chore: remove std directory (#9361)

This removes the std folder from the tree.

Various parts of the tests are pretty tightly dependent 
on std (47 direct imports and 75 indirect imports, not 
counting the cli tests that use them as fixtures) so I've 
added std as a submodule for now.

1 files changed, 0 insertions, 186 deletions

diff --git a/std/node/_crypto/pbkdf2.ts b/std/node/_crypto/pbkdf2.ts
deleted file mode 100644
index 2a63802e6..000000000
--- a/std/node/_crypto/pbkdf2.ts
+++ /dev/null
@@ -1,186 +0,0 @@
-import { createHash } from "../../hash/mod.ts";
-import { Buffer } from "../buffer.ts";
-import { MAX_ALLOC } from "./constants.ts";
-import { HASH_DATA } from "./types.ts";
-
-export type NormalizedAlgorithms =
-  | "md5"
-  | "ripemd160"
-  | "sha1"
-  | "sha224"
-  | "sha256"
-  | "sha384"
-  | "sha512";
-
-type Algorithms =
-  | "md5"
-  | "ripemd160"
-  | "rmd160"
-  | "sha1"
-  | "sha224"
-  | "sha256"
-  | "sha384"
-  | "sha512";
-
-function createHasher(alg: Algorithms) {
-  let normalizedAlg: NormalizedAlgorithms;
-  if (alg === "rmd160") {
-    normalizedAlg = "ripemd160";
-  } else {
-    normalizedAlg = alg;
-  }
-  return (value: Uint8Array) =>
-    Buffer.from(createHash(normalizedAlg).update(value).digest());
-}
-
-function getZeroes(zeros: number) {
-  return Buffer.alloc(zeros);
-}
-const sizes = {
-  md5: 16,
-  sha1: 20,
-  sha224: 28,
-  sha256: 32,
-  sha384: 48,
-  sha512: 64,
-  rmd160: 20,
-  ripemd160: 20,
-};
-
-function toBuffer(bufferable: HASH_DATA) {
-  if (bufferable instanceof Uint8Array || typeof bufferable === "string") {
-    return Buffer.from(bufferable as Uint8Array);
-  } else {
-    return Buffer.from(bufferable.buffer);
-  }
-}
-
-class Hmac {
-  hash: (value: Uint8Array) => Buffer;
-  ipad1: Buffer;
-  opad: Buffer;
-  alg: string;
-  blocksize: number;
-  size: number;
-  ipad2: Buffer;
-
-  constructor(alg: Algorithms, key: Buffer, saltLen: number) {
-    this.hash = createHasher(alg);
-
-    const blocksize = (alg === "sha512" || alg === "sha384") ? 128 : 64;
-
-    if (key.length > blocksize) {
-      key = this.hash(key);
-    } else if (key.length < blocksize) {
-      key = Buffer.concat([key, getZeroes(blocksize - key.length)], blocksize);
-    }
-
-    const ipad = Buffer.allocUnsafe(blocksize + sizes[alg]);
-    const opad = Buffer.allocUnsafe(blocksize + sizes[alg]);
-    for (let i = 0; i < blocksize; i++) {
-      ipad[i] = key[i] ^ 0x36;
-      opad[i] = key[i] ^ 0x5C;
-    }
-
-    const ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4);
-    ipad.copy(ipad1, 0, 0, blocksize);
-
-    this.ipad1 = ipad1;
-    this.ipad2 = ipad;
-    this.opad = opad;
-    this.alg = alg;
-    this.blocksize = blocksize;
-    this.size = sizes[alg];
-  }
-
-  run(data: Buffer, ipad: Buffer) {
-    data.copy(ipad, this.blocksize);
-    const h = this.hash(ipad);
-    h.copy(this.opad, this.blocksize);
-    return this.hash(this.opad);
-  }
-}
-
-/**
- * @param iterations Needs to be higher or equal than zero
- * @param keylen  Needs to be higher or equal than zero but less than max allocation size (2^30)
- * @param digest Algorithm to be used for encryption
- */
-export function pbkdf2Sync(
-  password: HASH_DATA,
-  salt: HASH_DATA,
-  iterations: number,
-  keylen: number,
-  digest: Algorithms = "sha1",
-): Buffer {
-  if (typeof iterations !== "number" || iterations < 0) {
-    throw new TypeError("Bad iterations");
-  }
-  if (typeof keylen !== "number" || keylen < 0 || keylen > MAX_ALLOC) {
-    throw new TypeError("Bad key length");
-  }
-
-  const bufferedPassword = toBuffer(password);
-  const bufferedSalt = toBuffer(salt);
-
-  const hmac = new Hmac(digest, bufferedPassword, bufferedSalt.length);
-
-  const DK = Buffer.allocUnsafe(keylen);
-  const block1 = Buffer.allocUnsafe(bufferedSalt.length + 4);
-  bufferedSalt.copy(block1, 0, 0, bufferedSalt.length);
-
-  let destPos = 0;
-  const hLen = sizes[digest];
-  const l = Math.ceil(keylen / hLen);
-
-  for (let i = 1; i <= l; i++) {
-    block1.writeUInt32BE(i, bufferedSalt.length);
-
-    const T = hmac.run(block1, hmac.ipad1);
-    let U = T;
-
-    for (let j = 1; j < iterations; j++) {
-      U = hmac.run(U, hmac.ipad2);
-      for (let k = 0; k < hLen; k++) T[k] ^= U[k];
-    }
-
-    T.copy(DK, destPos);
-    destPos += hLen;
-  }
-
-  return DK;
-}
-
-/**
- * @param iterations Needs to be higher or equal than zero
- * @param keylen  Needs to be higher or equal than zero but less than max allocation size (2^30)
- * @param digest Algorithm to be used for encryption
- */
-export function pbkdf2(
-  password: HASH_DATA,
-  salt: HASH_DATA,
-  iterations: number,
-  keylen: number,
-  digest: Algorithms = "sha1",
-  callback: ((err: Error | null, derivedKey?: Buffer) => void),
-): void {
-  setTimeout(() => {
-    let err = null, res;
-    try {
-      res = pbkdf2Sync(
-        password,
-        salt,
-        iterations,
-        keylen,
-        digest,
-      );
-    } catch (e) {
-      err = e;
-    }
-    if (err) {
-      callback(err);
-    } else {
-      callback(null, res);
-    }
-  }, 0);
-}