feat(ext/node): embed std/node into the snapshot (#17724)

This commit moves "deno_std/node" in "ext/node" crate. The code is
transpiled and snapshotted during the build process.

During the first pass a minimal amount of work was done to create the
snapshot, a lot of code in "ext/node" depends on presence of "Deno"
global. This code will be gradually fixed in the follow up PRs to migrate
it to import relevant APIs from "internal:" modules.

Currently the code from snapshot is not used in any way, and all
Node/npm compatibility still uses code from 
"https://deno.land/std/node" (or from the location specified by 
"DENO_NODE_COMPAT_URL"). This will also be handled in a follow 
up PRs.

---------

Co-authored-by: crowlkats <crowlkats@toaxl.com>
Co-authored-by: Divy Srivastava <dj.srivastava23@gmail.com>
Co-authored-by: Yoshiya Hinosawa <stibium121@gmail.com>

1 files changed, 188 insertions, 0 deletions

diff --git a/ext/node/polyfills/internal/streams/buffer_list.mjs b/ext/node/polyfills/internal/streams/buffer_list.mjs
new file mode 100644
index 000000000..3016ffba5
--- /dev/null
+++ b/ext/node/polyfills/internal/streams/buffer_list.mjs
@@ -0,0 +1,188 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// deno-lint-ignore-file
+
+import { Buffer } from "internal:deno_node/polyfills/buffer.ts";
+import { inspect } from "internal:deno_node/polyfills/internal/util/inspect.mjs";
+
+class BufferList {
+  constructor() {
+    this.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+
+  push(v) {
+    const entry = { data: v, next: null };
+    if (this.length > 0) {
+      this.tail.next = entry;
+    } else {
+      this.head = entry;
+    }
+    this.tail = entry;
+    ++this.length;
+  }
+
+  unshift(v) {
+    const entry = { data: v, next: this.head };
+    if (this.length === 0) {
+      this.tail = entry;
+    }
+    this.head = entry;
+    ++this.length;
+  }
+
+  shift() {
+    if (this.length === 0) {
+      return;
+    }
+    const ret = this.head.data;
+    if (this.length === 1) {
+      this.head = this.tail = null;
+    } else {
+      this.head = this.head.next;
+    }
+    --this.length;
+    return ret;
+  }
+
+  clear() {
+    this.head = this.tail = null;
+    this.length = 0;
+  }
+
+  join(s) {
+    if (this.length === 0) {
+      return "";
+    }
+    let p = this.head;
+    let ret = "" + p.data;
+    while (p = p.next) {
+      ret += s + p.data;
+    }
+    return ret;
+  }
+
+  concat(n) {
+    if (this.length === 0) {
+      return Buffer.alloc(0);
+    }
+    const ret = Buffer.allocUnsafe(n >>> 0);
+    let p = this.head;
+    let i = 0;
+    while (p) {
+      ret.set(p.data, i);
+      i += p.data.length;
+      p = p.next;
+    }
+    return ret;
+  }
+
+  // Consumes a specified amount of bytes or characters from the buffered data.
+  consume(n, hasStrings) {
+    const data = this.head.data;
+    if (n < data.length) {
+      // `slice` is the same for buffers and strings.
+      const slice = data.slice(0, n);
+      this.head.data = data.slice(n);
+      return slice;
+    }
+    if (n === data.length) {
+      // First chunk is a perfect match.
+      return this.shift();
+    }
+    // Result spans more than one buffer.
+    return hasStrings ? this._getString(n) : this._getBuffer(n);
+  }
+
+  first() {
+    return this.head.data;
+  }
+
+  *[Symbol.iterator]() {
+    for (let p = this.head; p; p = p.next) {
+      yield p.data;
+    }
+  }
+
+  // Consumes a specified amount of characters from the buffered data.
+  _getString(n) {
+    let ret = "";
+    let p = this.head;
+    let c = 0;
+    do {
+      const str = p.data;
+      if (n > str.length) {
+        ret += str;
+        n -= str.length;
+      } else {
+        if (n === str.length) {
+          ret += str;
+          ++c;
+          if (p.next) {
+            this.head = p.next;
+          } else {
+            this.head = this.tail = null;
+          }
+        } else {
+          ret += str.slice(0, n);
+          this.head = p;
+          p.data = str.slice(n);
+        }
+        break;
+      }
+      ++c;
+    } while (p = p.next);
+    this.length -= c;
+    return ret;
+  }
+
+  // Consumes a specified amount of bytes from the buffered data.
+  _getBuffer(n) {
+    const ret = Buffer.allocUnsafe(n);
+    const retLen = n;
+    let p = this.head;
+    let c = 0;
+    do {
+      const buf = p.data;
+      if (n > buf.length) {
+        ret.set(buf, retLen - n);
+        n -= buf.length;
+      } else {
+        if (n === buf.length) {
+          ret.set(buf, retLen - n);
+          ++c;
+          if (p.next) {
+            this.head = p.next;
+          } else {
+            this.head = this.tail = null;
+          }
+        } else {
+          ret.set(
+            new Uint8Array(buf.buffer, buf.byteOffset, n),
+            retLen - n,
+          );
+          this.head = p;
+          p.data = buf.slice(n);
+        }
+        break;
+      }
+      ++c;
+    } while (p = p.next);
+    this.length -= c;
+    return ret;
+  }
+
+  // Make sure the linked list only shows the minimal necessary information.
+  [inspect.custom](_, options) {
+    return inspect(this, {
+      ...options,
+      // Only inspect one level.
+      depth: 0,
+      // It should not recurse.
+      customInspect: false,
+    });
+  }
+}
+
+export default BufferList;