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

diff --git a/std/node/_stream/async_iterator_test.ts b/std/node/_stream/async_iterator_test.ts
deleted file mode 100644
index 17698e0fd..000000000
--- a/std/node/_stream/async_iterator_test.ts
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright Node.js contributors. All rights reserved. MIT License.
-import Readable from "./readable.ts";
-import Stream from "./stream.ts";
-import toReadableAsyncIterator from "./async_iterator.ts";
-import { deferred } from "../../async/mod.ts";
-import { assertEquals, assertThrowsAsync } from "../../testing/asserts.ts";
-
-Deno.test("Stream to async iterator", async () => {
-  let destroyExecuted = 0;
-  const destroyExecutedExpected = 1;
-  const destroyExpectedExecutions = deferred();
-
-  class AsyncIteratorStream extends Stream {
-    constructor() {
-      super();
-    }
-
-    destroy() {
-      destroyExecuted++;
-      if (destroyExecuted == destroyExecutedExpected) {
-        destroyExpectedExecutions.resolve();
-      }
-    }
-
-    [Symbol.asyncIterator] = Readable.prototype[Symbol.asyncIterator];
-  }
-
-  const stream = new AsyncIteratorStream();
-
-  queueMicrotask(() => {
-    stream.emit("data", "hello");
-    stream.emit("data", "world");
-    stream.emit("end");
-  });
-
-  let res = "";
-
-  for await (const d of stream) {
-    res += d;
-  }
-  assertEquals(res, "helloworld");
-
-  const destroyTimeout = setTimeout(
-    () => destroyExpectedExecutions.reject(),
-    1000,
-  );
-  await destroyExpectedExecutions;
-  clearTimeout(destroyTimeout);
-  assertEquals(destroyExecuted, destroyExecutedExpected);
-});
-
-Deno.test("Stream to async iterator throws on 'error' emitted", async () => {
-  let closeExecuted = 0;
-  const closeExecutedExpected = 1;
-  const closeExpectedExecutions = deferred();
-
-  let errorExecuted = 0;
-  const errorExecutedExpected = 1;
-  const errorExpectedExecutions = deferred();
-
-  class StreamImplementation extends Stream {
-    close() {
-      closeExecuted++;
-      if (closeExecuted == closeExecutedExpected) {
-        closeExpectedExecutions.resolve();
-      }
-    }
-  }
-
-  const stream = new StreamImplementation();
-  queueMicrotask(() => {
-    stream.emit("data", 0);
-    stream.emit("data", 1);
-    stream.emit("error", new Error("asd"));
-  });
-
-  toReadableAsyncIterator(stream)
-    .next()
-    .catch((err) => {
-      errorExecuted++;
-      if (errorExecuted == errorExecutedExpected) {
-        errorExpectedExecutions.resolve();
-      }
-      assertEquals(err.message, "asd");
-    });
-
-  const closeTimeout = setTimeout(
-    () => closeExpectedExecutions.reject(),
-    1000,
-  );
-  const errorTimeout = setTimeout(
-    () => errorExpectedExecutions.reject(),
-    1000,
-  );
-  await closeExpectedExecutions;
-  await errorExpectedExecutions;
-  clearTimeout(closeTimeout);
-  clearTimeout(errorTimeout);
-  assertEquals(closeExecuted, closeExecutedExpected);
-  assertEquals(errorExecuted, errorExecutedExpected);
-});
-
-Deno.test("Async iterator matches values of Readable", async () => {
-  const readable = new Readable({
-    objectMode: true,
-    read() {},
-  });
-  readable.push(0);
-  readable.push(1);
-  readable.push(null);
-
-  const iter = readable[Symbol.asyncIterator]();
-
-  assertEquals(
-    await iter.next().then(({ value }) => value),
-    0,
-  );
-  for await (const d of iter) {
-    assertEquals(d, 1);
-  }
-});
-
-Deno.test("Async iterator throws on Readable destroyed sync", async () => {
-  const message = "kaboom from read";
-
-  const readable = new Readable({
-    objectMode: true,
-    read() {
-      this.destroy(new Error(message));
-    },
-  });
-
-  await assertThrowsAsync(
-    async () => {
-      // deno-lint-ignore no-empty
-      for await (const k of readable) {}
-    },
-    Error,
-    message,
-  );
-});
-
-Deno.test("Async iterator throws on Readable destroyed async", async () => {
-  const message = "kaboom";
-  const readable = new Readable({
-    read() {},
-  });
-  const iterator = readable[Symbol.asyncIterator]();
-
-  readable.destroy(new Error(message));
-
-  await assertThrowsAsync(
-    iterator.next.bind(iterator),
-    Error,
-    message,
-  );
-});
-
-Deno.test("Async iterator finishes the iterator when Readable destroyed", async () => {
-  const readable = new Readable({
-    read() {},
-  });
-
-  readable.destroy();
-
-  const { done } = await readable[Symbol.asyncIterator]().next();
-  assertEquals(done, true);
-});
-
-Deno.test("Async iterator finishes all item promises when Readable destroyed", async () => {
-  const r = new Readable({
-    objectMode: true,
-    read() {
-    },
-  });
-
-  const b = r[Symbol.asyncIterator]();
-  const c = b.next();
-  const d = b.next();
-  r.destroy();
-  assertEquals(await c, { done: true, value: undefined });
-  assertEquals(await d, { done: true, value: undefined });
-});
-
-Deno.test("Async iterator: 'next' is triggered by Readable push", async () => {
-  const max = 42;
-  let readed = 0;
-  let received = 0;
-  const readable = new Readable({
-    objectMode: true,
-    read() {
-      this.push("hello");
-      if (++readed === max) {
-        this.push(null);
-      }
-    },
-  });
-
-  for await (const k of readable) {
-    received++;
-    assertEquals(k, "hello");
-  }
-
-  assertEquals(readed, received);
-});
-
-Deno.test("Async iterator: 'close' called on forced iteration end", async () => {
-  let closeExecuted = 0;
-  const closeExecutedExpected = 1;
-  const closeExpectedExecutions = deferred();
-
-  class IndestructibleReadable extends Readable {
-    constructor() {
-      super({
-        autoDestroy: false,
-        read() {},
-      });
-    }
-
-    close() {
-      closeExecuted++;
-      if (closeExecuted == closeExecutedExpected) {
-        closeExpectedExecutions.resolve();
-      }
-      readable.emit("close");
-    }
-
-    // deno-lint-ignore ban-ts-comment
-    //@ts-ignore
-    destroy = null;
-  }
-
-  const readable = new IndestructibleReadable();
-  readable.push("asd");
-  readable.push("asd");
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  for await (const d of readable) {
-    break;
-  }
-
-  const closeTimeout = setTimeout(
-    () => closeExpectedExecutions.reject(),
-    1000,
-  );
-  await closeExpectedExecutions;
-  clearTimeout(closeTimeout);
-  assertEquals(closeExecuted, closeExecutedExpected);
-});