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, 190 deletions

diff --git a/std/bytes/mod.ts b/std/bytes/mod.ts
deleted file mode 100644
index bb2b7d46e..000000000
--- a/std/bytes/mod.ts
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-
-/** Find first index of binary pattern from source. If not found, then return -1
- * @param source source array
- * @param pat pattern to find in source array
- * @param start the index to start looking in the source
- */
-export function indexOf(
-  source: Uint8Array,
-  pat: Uint8Array,
-  start = 0,
-): number {
-  if (start >= source.length) {
-    return -1;
-  }
-  if (start < 0) {
-    start = 0;
-  }
-  const s = pat[0];
-  for (let i = start; i < source.length; i++) {
-    if (source[i] !== s) continue;
-    const pin = i;
-    let matched = 1;
-    let j = i;
-    while (matched < pat.length) {
-      j++;
-      if (source[j] !== pat[j - pin]) {
-        break;
-      }
-      matched++;
-    }
-    if (matched === pat.length) {
-      return pin;
-    }
-  }
-  return -1;
-}
-
-/** Find last index of binary pattern from source. If not found, then return -1.
- * @param source source array
- * @param pat pattern to find in source array
- * @param start the index to start looking in the source
- */
-export function lastIndexOf(
-  source: Uint8Array,
-  pat: Uint8Array,
-  start = source.length - 1,
-): number {
-  if (start < 0) {
-    return -1;
-  }
-  if (start >= source.length) {
-    start = source.length - 1;
-  }
-  const e = pat[pat.length - 1];
-  for (let i = start; i >= 0; i--) {
-    if (source[i] !== e) continue;
-    const pin = i;
-    let matched = 1;
-    let j = i;
-    while (matched < pat.length) {
-      j--;
-      if (source[j] !== pat[pat.length - 1 - (pin - j)]) {
-        break;
-      }
-      matched++;
-    }
-    if (matched === pat.length) {
-      return pin - pat.length + 1;
-    }
-  }
-  return -1;
-}
-
-/** Check whether binary arrays are equal to each other.
- * @param a first array to check equality
- * @param b second array to check equality
- */
-export function equals(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < b.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-
-/** Check whether binary array starts with prefix.
- * @param source source array
- * @param prefix prefix array to check in source
- */
-export function startsWith(source: Uint8Array, prefix: Uint8Array): boolean {
-  for (let i = 0, max = prefix.length; i < max; i++) {
-    if (source[i] !== prefix[i]) return false;
-  }
-  return true;
-}
-
-/** Check whether binary array ends with suffix.
- * @param source source array
- * @param suffix suffix array to check in source
- */
-export function endsWith(source: Uint8Array, suffix: Uint8Array): boolean {
-  for (
-    let srci = source.length - 1, sfxi = suffix.length - 1;
-    sfxi >= 0;
-    srci--, sfxi--
-  ) {
-    if (source[srci] !== suffix[sfxi]) return false;
-  }
-  return true;
-}
-
-/** Repeat bytes. returns a new byte slice consisting of `count` copies of `b`.
- * @param origin The origin bytes
- * @param count The count you want to repeat.
- * @throws `RangeError` When count is negative
- */
-export function repeat(origin: Uint8Array, count: number): Uint8Array {
-  if (count === 0) {
-    return new Uint8Array();
-  }
-
-  if (count < 0) {
-    throw new RangeError("bytes: negative repeat count");
-  } else if ((origin.length * count) / count !== origin.length) {
-    throw new Error("bytes: repeat count causes overflow");
-  }
-
-  const int = Math.floor(count);
-
-  if (int !== count) {
-    throw new Error("bytes: repeat count must be an integer");
-  }
-
-  const nb = new Uint8Array(origin.length * count);
-
-  let bp = copy(origin, nb);
-
-  for (; bp < nb.length; bp *= 2) {
-    copy(nb.slice(0, bp), nb, bp);
-  }
-
-  return nb;
-}
-
-/** Concatenate multiple binary arrays and return new one.
- * @param buf binary arrays to concatenate
- */
-export function concat(...buf: Uint8Array[]): Uint8Array {
-  let length = 0;
-  for (const b of buf) {
-    length += b.length;
-  }
-
-  const output = new Uint8Array(length);
-  let index = 0;
-  for (const b of buf) {
-    output.set(b, index);
-    index += b.length;
-  }
-
-  return output;
-}
-
-/** Check source array contains pattern array.
- * @param source source array
- * @param pat patter array
- */
-export function contains(source: Uint8Array, pat: Uint8Array): boolean {
-  return indexOf(source, pat) != -1;
-}
-
-/**
- * Copy bytes from one Uint8Array to another.  Bytes from `src` which don't fit
- * into `dst` will not be copied.
- *
- * @param src Source byte array
- * @param dst Destination byte array
- * @param off Offset into `dst` at which to begin writing values from `src`.
- * @return number of bytes copied
- */
-export function copy(src: Uint8Array, dst: Uint8Array, off = 0): number {
-  off = Math.max(0, Math.min(off, dst.byteLength));
-  const dstBytesAvailable = dst.byteLength - off;
-  if (src.byteLength > dstBytesAvailable) {
-    src = src.subarray(0, dstBytesAvailable);
-  }
-  dst.set(src, off);
-  return src.byteLength;
-}