Upload Kmake

lib/internal/webstreams/compression.js

@@ -0,0 +1,173 @@
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  SymbolToStringTag,
+} = primordials;
+
+const {
+  newReadableWritablePairFromDuplex,
+} = require('internal/webstreams/adapters');
+
+const { customInspect } = require('internal/webstreams/util');
+
+const {
+  customInspectSymbol: kInspect,
+  kEnumerableProperty,
+} = require('internal/util');
+
+const { createEnumConverter } = require('internal/webidl');
+
+let zlib;
+function lazyZlib() {
+  zlib ??= require('zlib');
+  return zlib;
+}
+
+const formatConverter = createEnumConverter('CompressionFormat', [
+  'deflate',
+  'deflate-raw',
+  'gzip',
+]);
+
+/**
+ * @typedef {import('./readablestream').ReadableStream} ReadableStream
+ * @typedef {import('./writablestream').WritableStream} WritableStream
+ */
+
+class CompressionStream {
+  #handle;
+  #transform;
+
+  /**
+   * @param {'deflate'|'deflate-raw'|'gzip'} format
+   */
+  constructor(format) {
+    format = formatConverter(format, {
+      prefix: "Failed to construct 'CompressionStream'",
+      context: '1st argument',
+    });
+    switch (format) {
+      case 'deflate':
+        this.#handle = lazyZlib().createDeflate();
+        break;
+      case 'deflate-raw':
+        this.#handle = lazyZlib().createDeflateRaw();
+        break;
+      case 'gzip':
+        this.#handle = lazyZlib().createGzip();
+        break;
+    }
+    this.#transform = newReadableWritablePairFromDuplex(this.#handle);
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    return this.#transform.readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    return this.#transform.writable;
+  }
+
+  [kInspect](depth, options) {
+    return customInspect(depth, options, 'CompressionStream', {
+      readable: this.#transform.readable,
+      writable: this.#transform.writable,
+    });
+  }
+}
+
+class DecompressionStream {
+  #handle;
+  #transform;
+
+  /**
+   * @param {'deflate'|'deflate-raw'|'gzip'} format
+   */
+  constructor(format) {
+    format = formatConverter(format, {
+      prefix: "Failed to construct 'DecompressionStream'",
+      context: '1st argument',
+    });
+    switch (format) {
+      case 'deflate':
+        this.#handle = lazyZlib().createInflate({
+          rejectGarbageAfterEnd: true,
+        });
+        break;
+      case 'deflate-raw':
+        this.#handle = lazyZlib().createInflateRaw();
+        break;
+      case 'gzip':
+        this.#handle = lazyZlib().createGunzip({
+          rejectGarbageAfterEnd: true,
+        });
+        break;
+    }
+    this.#transform = newReadableWritablePairFromDuplex(this.#handle);
+
+    this.#handle.on('error', (err) => {
+      if (this.#transform?.writable &&
+        !this.#transform.writable.locked &&
+        typeof this.#transform.writable.abort === 'function') {
+        this.#transform.writable.abort(err);
+      }
+    });
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    return this.#transform.readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    return this.#transform.writable;
+  }
+
+  [kInspect](depth, options) {
+    return customInspect(depth, options, 'DecompressionStream', {
+      readable: this.#transform.readable,
+      writable: this.#transform.writable,
+    });
+  }
+}
+
+ObjectDefineProperties(CompressionStream.prototype, {
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'CompressionStream',
+  },
+});
+
+ObjectDefineProperties(DecompressionStream.prototype, {
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'DecompressionStream',
+  },
+});
+
+module.exports = {
+  CompressionStream,
+  DecompressionStream,
+};

lib/internal/webstreams/encoding.js

@@ -0,0 +1,223 @@
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  String,
+  StringPrototypeCharCodeAt,
+  Uint8Array,
+} = primordials;
+
+const {
+  TextDecoder,
+  TextEncoder,
+} = require('internal/encoding');
+
+const {
+  TransformStream,
+} = require('internal/webstreams/transformstream');
+
+const { customInspect } = require('internal/webstreams/util');
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_THIS,
+  },
+} = require('internal/errors');
+
+const {
+  customInspectSymbol: kInspect,
+  kEmptyObject,
+  kEnumerableProperty,
+} = require('internal/util');
+
+/**
+ * @typedef {import('./readablestream').ReadableStream} ReadableStream
+ * @typedef {import('./writablestream').WritableStream} WritableStream
+ */
+
+class TextEncoderStream {
+  #pendingHighSurrogate = null;
+  #handle;
+  #transform;
+
+  constructor() {
+    this.#handle = new TextEncoder();
+    this.#transform = new TransformStream({
+      transform: (chunk, controller) => {
+        // https://encoding.spec.whatwg.org/#encode-and-enqueue-a-chunk
+        chunk = String(chunk);
+        let finalChunk = '';
+        for (let i = 0; i < chunk.length; i++) {
+          const item = chunk[i];
+          const codeUnit = StringPrototypeCharCodeAt(item, 0);
+          if (this.#pendingHighSurrogate !== null) {
+            const highSurrogate = this.#pendingHighSurrogate;
+            this.#pendingHighSurrogate = null;
+            if (0xDC00 <= codeUnit && codeUnit <= 0xDFFF) {
+              finalChunk += highSurrogate + item;
+              continue;
+            }
+            finalChunk += '\uFFFD';
+          }
+          if (0xD800 <= codeUnit && codeUnit <= 0xDBFF) {
+            this.#pendingHighSurrogate = item;
+            continue;
+          }
+          if (0xDC00 <= codeUnit && codeUnit <= 0xDFFF) {
+            finalChunk += '\uFFFD';
+            continue;
+          }
+          finalChunk += item;
+        }
+        if (finalChunk) {
+          const value = this.#handle.encode(finalChunk);
+          controller.enqueue(value);
+        }
+      },
+      flush: (controller) => {
+        // https://encoding.spec.whatwg.org/#encode-and-flush
+        if (this.#pendingHighSurrogate !== null) {
+          controller.enqueue(new Uint8Array([0xEF, 0xBF, 0xBD]));
+        }
+      },
+    });
+  }
+
+  /**
+   * @readonly
+   * @type {string}
+   */
+  get encoding() {
+    return this.#handle.encoding;
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    return this.#transform.readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    return this.#transform.writable;
+  }
+
+  [kInspect](depth, options) {
+    if (this == null)
+      throw new ERR_INVALID_THIS('TextEncoderStream');
+    return customInspect(depth, options, 'TextEncoderStream', {
+      encoding: this.#handle.encoding,
+      readable: this.#transform.readable,
+      writable: this.#transform.writable,
+    });
+  }
+}
+
+class TextDecoderStream {
+  #handle;
+  #transform;
+
+  /**
+   * @param {string} [encoding]
+   * @param {{
+   *   fatal? : boolean,
+   *   ignoreBOM? : boolean,
+   * }} [options]
+   */
+  constructor(encoding = 'utf-8', options = kEmptyObject) {
+    this.#handle = new TextDecoder(encoding, options);
+    this.#transform = new TransformStream({
+      transform: (chunk, controller) => {
+        if (chunk === undefined) {
+          throw new ERR_INVALID_ARG_TYPE('chunk', 'string', chunk);
+        }
+        const value = this.#handle.decode(chunk, { stream: true });
+        if (value)
+          controller.enqueue(value);
+      },
+      flush: (controller) => {
+        const value = this.#handle.decode();
+        if (value)
+          controller.enqueue(value);
+        controller.terminate();
+      },
+    });
+  }
+
+  /**
+   * @readonly
+   * @type {string}
+   */
+  get encoding() {
+    return this.#handle.encoding;
+  }
+
+  /**
+   * @readonly
+   * @type {boolean}
+   */
+  get fatal() {
+    return this.#handle.fatal;
+  }
+
+  /**
+   * @readonly
+   * @type {boolean}
+   */
+  get ignoreBOM() {
+    return this.#handle.ignoreBOM;
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    return this.#transform.readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    return this.#transform.writable;
+  }
+
+  [kInspect](depth, options) {
+    if (this == null)
+      throw new ERR_INVALID_THIS('TextDecoderStream');
+    return customInspect(depth, options, 'TextDecoderStream', {
+      encoding: this.#handle.encoding,
+      fatal: this.#handle.fatal,
+      ignoreBOM: this.#handle.ignoreBOM,
+      readable: this.#transform.readable,
+      writable: this.#transform.writable,
+    });
+  }
+}
+
+ObjectDefineProperties(TextEncoderStream.prototype, {
+  encoding: kEnumerableProperty,
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+});
+
+ObjectDefineProperties(TextDecoderStream.prototype, {
+  encoding: kEnumerableProperty,
+  fatal: kEnumerableProperty,
+  ignoreBOM: kEnumerableProperty,
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+});
+
+module.exports = {
+  TextEncoderStream,
+  TextDecoderStream,
+};

lib/internal/webstreams/queuingstrategies.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  SymbolToStringTag,
+} = primordials;
+
+const {
+  codes: {
+    ERR_MISSING_OPTION,
+  },
+} = require('internal/errors');
+
+const {
+  customInspectSymbol: kInspect,
+  kEnumerableProperty,
+} = require('internal/util');
+
+const {
+  customInspect,
+} = require('internal/webstreams/util');
+
+const {
+  validateObject,
+} = require('internal/validators');
+
+/**
+ * @callback QueuingStrategySize
+ * @param {any} chunk
+ * @returns {number}
+ */
+
+/**
+ * @typedef {{
+ *   highWaterMark : number,
+ *   size? : QueuingStrategySize,
+ * }} QueuingStrategy
+ */
+
+const nameDescriptor = { __proto__: null, value: 'size' };
+const byteSizeFunction = ObjectDefineProperty(
+  (chunk) => chunk.byteLength,
+  'name',
+  nameDescriptor,
+);
+const countSizeFunction = ObjectDefineProperty(() => 1, 'name', nameDescriptor);
+
+const getNonWritablePropertyDescriptor = (value) => {
+  return {
+    __proto__: null,
+    configurable: true,
+    value,
+  };
+};
+
+/**
+ * @type {QueuingStrategy}
+ */
+class ByteLengthQueuingStrategy {
+  #state;
+  #byteSizeFunction = byteSizeFunction;
+
+  /**
+   * @param {{
+   *   highWaterMark : number
+   * }} init
+   */
+  constructor(init) {
+    validateObject(init, 'init');
+    if (init.highWaterMark === undefined)
+      throw new ERR_MISSING_OPTION('init.highWaterMark');
+
+    // The highWaterMark value is not checked until the strategy
+    // is actually used, per the spec.
+    this.#state = {
+      highWaterMark: +init.highWaterMark,
+    };
+  }
+
+  /**
+   * @readonly
+   * @type {number}
+   */
+  get highWaterMark() {
+    return this.#state.highWaterMark;
+  }
+
+  /**
+   * @type {QueuingStrategySize}
+   */
+  get size() {
+    return this.#byteSizeFunction;
+  }
+
+  [kInspect](depth, options) {
+    return customInspect(depth, options, 'ByteLengthQueuingStrategy', {
+      highWaterMark: this.highWaterMark,
+    });
+  }
+}
+
+ObjectDefineProperties(ByteLengthQueuingStrategy.prototype, {
+  highWaterMark: kEnumerableProperty,
+  size: kEnumerableProperty,
+  [SymbolToStringTag]: getNonWritablePropertyDescriptor(ByteLengthQueuingStrategy.name),
+});
+
+/**
+ * @type {QueuingStrategy}
+ */
+class CountQueuingStrategy {
+  #state;
+  #countSizeFunction = countSizeFunction;
+
+  /**
+   * @param {{
+   *   highWaterMark : number
+   * }} init
+   */
+  constructor(init) {
+    validateObject(init, 'init');
+    if (init.highWaterMark === undefined)
+      throw new ERR_MISSING_OPTION('init.highWaterMark');
+
+    // The highWaterMark value is not checked until the strategy
+    // is actually used, per the spec.
+    this.#state = {
+      highWaterMark: +init.highWaterMark,
+    };
+  }
+
+  /**
+   * @readonly
+   * @type {number}
+   */
+  get highWaterMark() {
+    return this.#state.highWaterMark;
+  }
+
+  /**
+   * @type {QueuingStrategySize}
+   */
+  get size() {
+    return this.#countSizeFunction;
+  }
+
+  [kInspect](depth, options) {
+    return customInspect(depth, options, 'CountQueuingStrategy', {
+      highWaterMark: this.highWaterMark,
+    });
+  }
+}
+
+ObjectDefineProperties(CountQueuingStrategy.prototype, {
+  highWaterMark: kEnumerableProperty,
+  size: kEnumerableProperty,
+  [SymbolToStringTag]: getNonWritablePropertyDescriptor(CountQueuingStrategy.name),
+});
+
+module.exports = {
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+};

lib/internal/webstreams/transfer.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  PromiseResolve,
+  PromiseWithResolvers,
+  ReflectConstruct,
+} = primordials;
+
+const {
+  kState,
+  setPromiseHandled,
+} = require('internal/webstreams/util');
+
+const {
+  DOMException,
+} = internalBinding('messaging');
+
+const {
+  ReadableStream,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerError,
+  readableStreamPipeTo,
+} = require('internal/webstreams/readablestream');
+
+const {
+  WritableStream,
+  writableStreamDefaultControllerErrorIfNeeded,
+} = require('internal/webstreams/writablestream');
+
+const assert = require('internal/assert');
+
+const {
+  markTransferMode,
+  kClone,
+  kDeserialize,
+} = require('internal/worker/js_transferable');
+
+// This class is a bit of a hack. The Node.js implementation of
+// DOMException is not transferable/cloneable. This provides us
+// with a variant that is. Unfortunately, it means playing around
+// a bit with the message, name, and code properties and the
+// prototype. We can revisit this if DOMException is ever made
+// properly cloneable.
+class CloneableDOMException extends DOMException {
+  constructor(message, name) {
+    super(message, name);
+    markTransferMode(this, true, false);
+    this[kDeserialize]({
+      message: this.message,
+      name: this.name,
+      code: this.code,
+    });
+  }
+
+  [kClone]() {
+    return {
+      data: {
+        message: this.message,
+        name: this.name,
+        code: this.code,
+      },
+      deserializeInfo:
+        'internal/webstreams/transfer:InternalCloneableDOMException',
+    };
+  }
+
+  [kDeserialize]({ message, name, code }) {
+    ObjectDefineProperties(this, {
+      message: {
+        __proto__: null,
+        configurable: true,
+        enumerable: true,
+        get() { return message; },
+      },
+      name: {
+        __proto__: null,
+        configurable: true,
+        enumerable: true,
+        get() { return name; },
+      },
+      code: {
+        __proto__: null,
+        configurable: true,
+        enumerable: true,
+        get() { return code; },
+      },
+    });
+  }
+}
+
+function InternalCloneableDOMException() {
+  return ReflectConstruct(
+    CloneableDOMException,
+    [],
+    DOMException);
+}
+InternalCloneableDOMException[kDeserialize] = () => {};
+
+class CrossRealmTransformReadableSource {
+  constructor(port, unref) {
+    this[kState] = {
+      port,
+      controller: undefined,
+      unref,
+    };
+
+    port.onmessage = ({ data }) => {
+      const {
+        controller,
+      } = this[kState];
+      const {
+        type,
+        value,
+      } = data;
+      switch (type) {
+        case 'chunk':
+          readableStreamDefaultControllerEnqueue(
+            controller,
+            value);
+          break;
+        case 'close':
+          readableStreamDefaultControllerClose(controller);
+          port.close();
+          break;
+        case 'error':
+          readableStreamDefaultControllerError(controller, value);
+          port.close();
+          break;
+      }
+    };
+
+    port.onmessageerror = () => {
+      const error = new CloneableDOMException(
+        'Internal transferred ReadableStream error',
+        'DataCloneError');
+      port.postMessage({ type: 'error', value: error });
+      readableStreamDefaultControllerError(
+        this[kState].controller,
+        error);
+      port.close();
+    };
+
+    port.unref();
+  }
+
+  start(controller) {
+    this[kState].controller = controller;
+  }
+
+  async pull() {
+    if (this[kState].unref) {
+      this[kState].unref = false;
+      this[kState].port.ref();
+    }
+    this[kState].port.postMessage({ type: 'pull' });
+  }
+
+  async cancel(reason) {
+    try {
+      this[kState].port.postMessage({ type: 'error', value: reason });
+    } catch (error) {
+      if (error instanceof DOMException) {
+        // eslint-disable-next-line no-ex-assign
+        error = new CloneableDOMException(error.message, error.name);
+      }
+      this[kState].port.postMessage({ type: 'error', value: error });
+      throw error;
+    } finally {
+      this[kState].port.close();
+    }
+  }
+}
+
+class CrossRealmTransformWritableSink {
+  constructor(port, unref) {
+    this[kState] = {
+      port,
+      controller: undefined,
+      backpressurePromise: PromiseWithResolvers(),
+      unref,
+    };
+
+    port.onmessage = ({ data }) => {
+      assert(typeof data === 'object');
+      const {
+        type,
+        value,
+      } = { ...data };
+      assert(typeof type === 'string');
+      switch (type) {
+        case 'pull':
+          if (this[kState].backpressurePromise !== undefined)
+            this[kState].backpressurePromise.resolve?.();
+          this[kState].backpressurePromise = undefined;
+          break;
+        case 'error':
+          writableStreamDefaultControllerErrorIfNeeded(
+            this[kState].controller,
+            value);
+          if (this[kState].backpressurePromise !== undefined)
+            this[kState].backpressurePromise.resolve?.();
+          this[kState].backpressurePromise = undefined;
+          break;
+      }
+    };
+    port.onmessageerror = () => {
+      const error = new CloneableDOMException(
+        'Internal transferred ReadableStream error',
+        'DataCloneError');
+      port.postMessage({ type: 'error', value: error });
+      writableStreamDefaultControllerErrorIfNeeded(
+        this[kState].controller,
+        error);
+      port.close();
+    };
+
+    port.unref();
+  }
+
+  start(controller) {
+    this[kState].controller = controller;
+  }
+
+  async write(chunk) {
+    if (this[kState].unref) {
+      this[kState].unref = false;
+      this[kState].port.ref();
+    }
+    if (this[kState].backpressurePromise === undefined) {
+      this[kState].backpressurePromise = {
+        promise: PromiseResolve(),
+        resolve: undefined,
+        reject: undefined,
+      };
+    }
+    await this[kState].backpressurePromise.promise;
+    this[kState].backpressurePromise = PromiseWithResolvers();
+    try {
+      this[kState].port.postMessage({ type: 'chunk', value: chunk });
+    } catch (error) {
+      if (error instanceof DOMException) {
+        // eslint-disable-next-line no-ex-assign
+        error = new CloneableDOMException(error.message, error.name);
+      }
+      this[kState].port.postMessage({ type: 'error', value: error });
+      this[kState].port.close();
+      throw error;
+    }
+  }
+
+  close() {
+    this[kState].port.postMessage({ type: 'close' });
+    this[kState].port.close();
+  }
+
+  abort(reason) {
+    try {
+      this[kState].port.postMessage({ type: 'error', value: reason });
+    } catch (error) {
+      if (error instanceof DOMException) {
+        // eslint-disable-next-line no-ex-assign
+        error = new CloneableDOMException(error.message, error.name);
+      }
+      this[kState].port.postMessage({ type: 'error', value: error });
+      throw error;
+    } finally {
+      this[kState].port.close();
+    }
+  }
+}
+
+function newCrossRealmReadableStream(writable, port) {
+  // MessagePort should always be unref.
+  // There is a problem with the process not terminating.
+  // https://github.com/nodejs/node/issues/44985
+  const readable = new ReadableStream(new CrossRealmTransformReadableSource(port, false));
+
+  const promise = readableStreamPipeTo(readable, writable, false, false, false);
+
+  setPromiseHandled(promise);
+
+  return {
+    readable,
+    promise,
+  };
+}
+
+function newCrossRealmWritableSink(readable, port) {
+  // MessagePort should always be unref.
+  // There is a problem with the process not terminating.
+  // https://github.com/nodejs/node/issues/44985
+  const writable = new WritableStream(new CrossRealmTransformWritableSink(port, false));
+
+  const promise = readableStreamPipeTo(readable, writable, false, false, false);
+
+  setPromiseHandled(promise);
+
+  return {
+    writable,
+    promise,
+  };
+}
+
+module.exports = {
+  newCrossRealmReadableStream,
+  newCrossRealmWritableSink,
+  CrossRealmTransformWritableSink,
+  CrossRealmTransformReadableSource,
+  CloneableDOMException,
+  InternalCloneableDOMException,
+};

lib/internal/webstreams/transformstream.js

@@ -0,0 +1,695 @@
+'use strict';
+
+const {
+  FunctionPrototypeCall,
+  ObjectDefineProperties,
+  ObjectSetPrototypeOf,
+  PromisePrototypeThen,
+  PromiseWithResolvers,
+  Symbol,
+  SymbolToStringTag,
+} = primordials;
+
+const {
+  codes: {
+    ERR_ILLEGAL_CONSTRUCTOR,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_STATE,
+    ERR_INVALID_THIS,
+  },
+} = require('internal/errors');
+
+const {
+  DOMException,
+} = internalBinding('messaging');
+
+const {
+  customInspectSymbol: kInspect,
+  kEmptyObject,
+  kEnumerableProperty,
+} = require('internal/util');
+
+const {
+  validateObject,
+  kValidateObjectAllowObjects,
+  kValidateObjectAllowObjectsAndNull,
+} = require('internal/validators');
+
+const {
+  kDeserialize,
+  kTransfer,
+  kTransferList,
+  markTransferMode,
+} = require('internal/worker/js_transferable');
+
+const {
+  createPromiseCallback,
+  customInspect,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  isBrandCheck,
+  nonOpFlush,
+  kType,
+  kState,
+  nonOpCancel,
+} = require('internal/webstreams/util');
+
+const {
+  createReadableStream,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerHasBackpressure,
+} = require('internal/webstreams/readablestream');
+
+const {
+  createWritableStream,
+  writableStreamDefaultControllerErrorIfNeeded,
+} = require('internal/webstreams/writablestream');
+
+const assert = require('internal/assert');
+
+const kSkipThrow = Symbol('kSkipThrow');
+
+const getNonWritablePropertyDescriptor = (value) => {
+  return {
+    __proto__: null,
+    configurable: true,
+    value,
+  };
+};
+
+/**
+ * @typedef {import('./queuingstrategies').QueuingStrategy
+ * } QueuingStrategy
+ * @typedef {import('./queuingstrategies').QueuingStrategySize
+ * } QueuingStrategySize
+ */
+
+/**
+ * @callback TransformerStartCallback
+ * @param {TransformStreamDefaultController} controller;
+ */
+
+/**
+ * @callback TransformerFlushCallback
+ * @param {TransformStreamDefaultController} controller;
+ * @returns {Promise<void>}
+ */
+
+/**
+ * @callback TransformerTransformCallback
+ * @param {any} chunk
+ * @param {TransformStreamDefaultController} controller
+ * @returns {Promise<void>}
+ */
+
+/**
+ * @typedef {{
+ *  start? : TransformerStartCallback,
+ *  transform? : TransformerTransformCallback,
+ *  flush? : TransformerFlushCallback,
+ *  readableType? : any,
+ *  writableType? : any,
+ * }} Transformer
+ */
+
+class TransformStream {
+  [kType] = 'TransformStream';
+
+  /**
+   * @param {Transformer} [transformer]
+   * @param {QueuingStrategy} [writableStrategy]
+   * @param {QueuingStrategy} [readableStrategy]
+   */
+  constructor(
+    transformer = kEmptyObject,
+    writableStrategy = kEmptyObject,
+    readableStrategy = kEmptyObject) {
+    markTransferMode(this, false, true);
+    validateObject(transformer, 'transformer', kValidateObjectAllowObjects);
+    validateObject(writableStrategy, 'writableStrategy', kValidateObjectAllowObjectsAndNull);
+    validateObject(readableStrategy, 'readableStrategy', kValidateObjectAllowObjectsAndNull);
+    const readableType = transformer?.readableType;
+    const writableType = transformer?.writableType;
+    const start = transformer?.start;
+
+    if (readableType !== undefined) {
+      throw new ERR_INVALID_ARG_VALUE.RangeError(
+        'transformer.readableType',
+        readableType);
+    }
+    if (writableType !== undefined) {
+      throw new ERR_INVALID_ARG_VALUE.RangeError(
+        'transformer.writableType',
+        writableType);
+    }
+
+    const readableHighWaterMark = readableStrategy?.highWaterMark;
+    const readableSize = readableStrategy?.size;
+
+    const writableHighWaterMark = writableStrategy?.highWaterMark;
+    const writableSize = writableStrategy?.size;
+
+    const actualReadableHighWaterMark =
+      extractHighWaterMark(readableHighWaterMark, 0);
+    const actualReadableSize = extractSizeAlgorithm(readableSize);
+
+    const actualWritableHighWaterMark =
+      extractHighWaterMark(writableHighWaterMark, 1);
+    const actualWritableSize = extractSizeAlgorithm(writableSize);
+
+    const startPromise = PromiseWithResolvers();
+
+    initializeTransformStream(
+      this,
+      startPromise,
+      actualWritableHighWaterMark,
+      actualWritableSize,
+      actualReadableHighWaterMark,
+      actualReadableSize);
+
+    setupTransformStreamDefaultControllerFromTransformer(this, transformer);
+
+    if (start !== undefined) {
+      startPromise.resolve(
+        FunctionPrototypeCall(
+          start,
+          transformer,
+          this[kState].controller));
+    } else {
+      startPromise.resolve();
+    }
+  }
+
+  /**
+   * @readonly
+   * @type {ReadableStream}
+   */
+  get readable() {
+    if (!isTransformStream(this))
+      throw new ERR_INVALID_THIS('TransformStream');
+    return this[kState].readable;
+  }
+
+  /**
+   * @readonly
+   * @type {WritableStream}
+   */
+  get writable() {
+    if (!isTransformStream(this))
+      throw new ERR_INVALID_THIS('TransformStream');
+    return this[kState].writable;
+  }
+
+  [kInspect](depth, options) {
+    return customInspect(depth, options, this[kType], {
+      readable: this.readable,
+      writable: this.writable,
+      backpressure: this[kState].backpressure,
+    });
+  }
+
+  [kTransfer]() {
+    if (!isTransformStream(this))
+      throw new ERR_INVALID_THIS('TransformStream');
+    const {
+      readable,
+      writable,
+    } = this[kState];
+    if (readable.locked) {
+      throw new DOMException(
+        'Cannot transfer a locked ReadableStream',
+        'DataCloneError');
+    }
+    if (writable.locked) {
+      throw new DOMException(
+        'Cannot transfer a locked WritableStream',
+        'DataCloneError');
+    }
+    return {
+      data: {
+        readable,
+        writable,
+      },
+      deserializeInfo:
+        'internal/webstreams/transformstream:TransferredTransformStream',
+    };
+  }
+
+  [kTransferList]() {
+    return [ this[kState].readable, this[kState].writable ];
+  }
+
+  [kDeserialize]({ readable, writable }) {
+    this[kState].readable = readable;
+    this[kState].writable = writable;
+  }
+}
+
+ObjectDefineProperties(TransformStream.prototype, {
+  readable: kEnumerableProperty,
+  writable: kEnumerableProperty,
+  [SymbolToStringTag]: getNonWritablePropertyDescriptor(TransformStream.name),
+});
+
+function InternalTransferredTransformStream() {
+  ObjectSetPrototypeOf(this, TransformStream.prototype);
+  markTransferMode(this, false, true);
+  this[kType] = 'TransformStream';
+  this[kState] = {
+    __proto__: null,
+    readable: undefined,
+    writable: undefined,
+    backpressure: undefined,
+    backpressureChange: {
+      __proto__: null,
+      promise: undefined,
+      resolve: undefined,
+      reject: undefined,
+    },
+    controller: undefined,
+  };
+}
+
+ObjectSetPrototypeOf(InternalTransferredTransformStream.prototype, TransformStream.prototype);
+ObjectSetPrototypeOf(InternalTransferredTransformStream, TransformStream);
+
+function TransferredTransformStream() {
+  const stream = new InternalTransferredTransformStream();
+
+  stream.constructor = TransformStream;
+
+  return stream;
+}
+
+TransferredTransformStream.prototype[kDeserialize] = () => {};
+
+class TransformStreamDefaultController {
+  [kType] = 'TransformStreamDefaultController';
+
+  constructor(skipThrowSymbol = undefined) {
+    if (skipThrowSymbol !== kSkipThrow) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+  }
+
+  /**
+   * @readonly
+   * @type {number}
+   */
+  get desiredSize() {
+    if (!isTransformStreamDefaultController(this))
+      throw new ERR_INVALID_THIS('TransformStreamDefaultController');
+    const {
+      stream,
+    } = this[kState];
+    const {
+      readable,
+    } = stream[kState];
+    const {
+      controller: readableController,
+    } = readable[kState];
+    return readableStreamDefaultControllerGetDesiredSize(readableController);
+  }
+
+  /**
+   * @param {any} [chunk]
+   */
+  enqueue(chunk = undefined) {
+    if (!isTransformStreamDefaultController(this))
+      throw new ERR_INVALID_THIS('TransformStreamDefaultController');
+    transformStreamDefaultControllerEnqueue(this, chunk);
+  }
+
+  /**
+   * @param {any} [reason]
+   */
+  error(reason = undefined) {
+    if (!isTransformStreamDefaultController(this))
+      throw new ERR_INVALID_THIS('TransformStreamDefaultController');
+    transformStreamDefaultControllerError(this, reason);
+  }
+
+  terminate() {
+    if (!isTransformStreamDefaultController(this))
+      throw new ERR_INVALID_THIS('TransformStreamDefaultController');
+    transformStreamDefaultControllerTerminate(this);
+  }
+
+  [kInspect](depth, options) {
+    return customInspect(depth, options, this[kType], {
+      stream: this[kState].stream,
+    });
+  }
+}
+
+ObjectDefineProperties(TransformStreamDefaultController.prototype, {
+  desiredSize: kEnumerableProperty,
+  enqueue: kEnumerableProperty,
+  error: kEnumerableProperty,
+  terminate: kEnumerableProperty,
+  [SymbolToStringTag]: getNonWritablePropertyDescriptor(TransformStreamDefaultController.name),
+});
+
+const isTransformStream =
+  isBrandCheck('TransformStream');
+const isTransformStreamDefaultController =
+  isBrandCheck('TransformStreamDefaultController');
+
+async function defaultTransformAlgorithm(chunk, controller) {
+  transformStreamDefaultControllerEnqueue(controller, chunk);
+}
+
+function initializeTransformStream(
+  stream,
+  startPromise,
+  writableHighWaterMark,
+  writableSizeAlgorithm,
+  readableHighWaterMark,
+  readableSizeAlgorithm) {
+
+  const startAlgorithm = () => startPromise.promise;
+
+  const writable = createWritableStream(
+    startAlgorithm,
+    (chunk) => transformStreamDefaultSinkWriteAlgorithm(stream, chunk),
+    () => transformStreamDefaultSinkCloseAlgorithm(stream),
+    (reason) => transformStreamDefaultSinkAbortAlgorithm(stream, reason),
+    writableHighWaterMark,
+    writableSizeAlgorithm,
+  );
+
+  const readable = createReadableStream(
+    startAlgorithm,
+    () => transformStreamDefaultSourcePullAlgorithm(stream),
+    (reason) => transformStreamDefaultSourceCancelAlgorithm(stream, reason),
+    readableHighWaterMark,
+    readableSizeAlgorithm,
+  );
+
+  stream[kState] = {
+    __proto__: null,
+    readable,
+    writable,
+    controller: undefined,
+    backpressure: undefined,
+    backpressureChange: {
+      __proto__: null,
+      promise: undefined,
+      resolve: undefined,
+      reject: undefined,
+    },
+  };
+
+  transformStreamSetBackpressure(stream, true);
+}
+
+function transformStreamError(stream, error) {
+  const {
+    readable,
+  } = stream[kState];
+  const {
+    controller,
+  } = readable[kState];
+  readableStreamDefaultControllerError(controller, error);
+  transformStreamErrorWritableAndUnblockWrite(stream, error);
+}
+
+function transformStreamErrorWritableAndUnblockWrite(stream, error) {
+  const {
+    controller,
+    writable,
+  } = stream[kState];
+  transformStreamDefaultControllerClearAlgorithms(controller);
+  writableStreamDefaultControllerErrorIfNeeded(
+    writable[kState].controller,
+    error);
+  transformStreamUnblockWrite(stream);
+}
+
+function transformStreamUnblockWrite(stream) {
+  if (stream[kState].backpressure)
+    transformStreamSetBackpressure(stream, false);
+}
+
+function transformStreamSetBackpressure(stream, backpressure) {
+  assert(stream[kState].backpressure !== backpressure);
+  if (stream[kState].backpressureChange.promise !== undefined)
+    stream[kState].backpressureChange.resolve?.();
+  stream[kState].backpressureChange = PromiseWithResolvers();
+  stream[kState].backpressure = backpressure;
+}
+
+function setupTransformStreamDefaultController(
+  stream,
+  controller,
+  transformAlgorithm,
+  flushAlgorithm,
+  cancelAlgorithm) {
+  assert(isTransformStream(stream));
+  assert(stream[kState].controller === undefined);
+  controller[kState] = {
+    __proto__: null,
+    stream,
+    transformAlgorithm,
+    flushAlgorithm,
+    cancelAlgorithm,
+  };
+  stream[kState].controller = controller;
+}
+
+function setupTransformStreamDefaultControllerFromTransformer(
+  stream,
+  transformer) {
+  const controller = new TransformStreamDefaultController(kSkipThrow);
+  const transform = transformer?.transform;
+  const flush = transformer?.flush;
+  const cancel = transformer?.cancel;
+  const transformAlgorithm = transform ?
+    createPromiseCallback('transformer.transform', transform, transformer) :
+    defaultTransformAlgorithm;
+  const flushAlgorithm = flush ?
+    createPromiseCallback('transformer.flush', flush, transformer) :
+    nonOpFlush;
+  const cancelAlgorithm = cancel ?
+    createPromiseCallback('transformer.cancel', cancel, transformer) :
+    nonOpCancel;
+
+  setupTransformStreamDefaultController(
+    stream,
+    controller,
+    transformAlgorithm,
+    flushAlgorithm,
+    cancelAlgorithm);
+}
+
+function transformStreamDefaultControllerClearAlgorithms(controller) {
+  controller[kState].transformAlgorithm = undefined;
+  controller[kState].flushAlgorithm = undefined;
+  controller[kState].cancelAlgorithm = undefined;
+}
+
+function transformStreamDefaultControllerEnqueue(controller, chunk) {
+  const {
+    stream,
+  } = controller[kState];
+  const {
+    readable,
+  } = stream[kState];
+  const {
+    controller: readableController,
+  } = readable[kState];
+  if (!readableStreamDefaultControllerCanCloseOrEnqueue(readableController))
+    throw new ERR_INVALID_STATE.TypeError('Unable to enqueue');
+  try {
+    readableStreamDefaultControllerEnqueue(readableController, chunk);
+  } catch (error) {
+    transformStreamErrorWritableAndUnblockWrite(stream, error);
+    throw readable[kState].storedError;
+  }
+  const backpressure =
+    readableStreamDefaultControllerHasBackpressure(readableController);
+  if (backpressure !== stream[kState].backpressure) {
+    assert(backpressure);
+    transformStreamSetBackpressure(stream, true);
+  }
+}
+
+function transformStreamDefaultControllerError(controller, error) {
+  transformStreamError(controller[kState].stream, error);
+}
+
+async function transformStreamDefaultControllerPerformTransform(controller, chunk) {
+  try {
+    return await controller[kState].transformAlgorithm(chunk, controller);
+  } catch (error) {
+    transformStreamError(controller[kState].stream, error);
+    throw error;
+  }
+}
+
+function transformStreamDefaultControllerTerminate(controller) {
+  const {
+    stream,
+  } = controller[kState];
+  const {
+    readable,
+  } = stream[kState];
+  assert(readable !== undefined);
+  const {
+    controller: readableController,
+  } = readable[kState];
+  readableStreamDefaultControllerClose(readableController);
+  transformStreamErrorWritableAndUnblockWrite(
+    stream,
+    new ERR_INVALID_STATE.TypeError('TransformStream has been terminated'));
+}
+
+function transformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
+  const {
+    writable,
+    controller,
+  } = stream[kState];
+  assert(writable[kState].state === 'writable');
+  if (stream[kState].backpressure) {
+    const backpressureChange = stream[kState].backpressureChange.promise;
+    return PromisePrototypeThen(
+      backpressureChange,
+      () => {
+        const {
+          writable,
+        } = stream[kState];
+        if (writable[kState].state === 'erroring')
+          throw writable[kState].storedError;
+        assert(writable[kState].state === 'writable');
+        return transformStreamDefaultControllerPerformTransform(
+          controller,
+          chunk);
+      });
+  }
+  return transformStreamDefaultControllerPerformTransform(controller, chunk);
+}
+
+async function transformStreamDefaultSinkAbortAlgorithm(stream, reason) {
+  const {
+    controller,
+    readable,
+  } = stream[kState];
+
+  if (controller[kState].finishPromise !== undefined) {
+    return controller[kState].finishPromise;
+  }
+
+  const { promise, resolve, reject } = PromiseWithResolvers();
+  controller[kState].finishPromise = promise;
+  const cancelPromise = controller[kState].cancelAlgorithm(reason);
+  transformStreamDefaultControllerClearAlgorithms(controller);
+
+  PromisePrototypeThen(
+    cancelPromise,
+    () => {
+      if (readable[kState].state === 'errored')
+        reject(readable[kState].storedError);
+      else {
+        readableStreamDefaultControllerError(readable[kState].controller, reason);
+        resolve();
+      }
+    },
+    (error) => {
+      readableStreamDefaultControllerError(readable[kState].controller, error);
+      reject(error);
+    },
+  );
+
+  return controller[kState].finishPromise;
+}
+
+function transformStreamDefaultSinkCloseAlgorithm(stream) {
+  const {
+    readable,
+    controller,
+  } = stream[kState];
+
+  if (controller[kState].finishPromise !== undefined) {
+    return controller[kState].finishPromise;
+  }
+  const { promise, resolve, reject } = PromiseWithResolvers();
+  controller[kState].finishPromise = promise;
+  const flushPromise = controller[kState].flushAlgorithm(controller);
+  transformStreamDefaultControllerClearAlgorithms(controller);
+  PromisePrototypeThen(
+    flushPromise,
+    () => {
+      if (readable[kState].state === 'errored')
+        reject(readable[kState].storedError);
+      else {
+        readableStreamDefaultControllerClose(readable[kState].controller);
+        resolve();
+      }
+    },
+    (error) => {
+      readableStreamDefaultControllerError(readable[kState].controller, error);
+      reject(error);
+    });
+  return controller[kState].finishPromise;
+}
+
+function transformStreamDefaultSourcePullAlgorithm(stream) {
+  assert(stream[kState].backpressure);
+  assert(stream[kState].backpressureChange.promise !== undefined);
+  transformStreamSetBackpressure(stream, false);
+  return stream[kState].backpressureChange.promise;
+}
+
+function transformStreamDefaultSourceCancelAlgorithm(stream, reason) {
+  const {
+    controller,
+    writable,
+  } = stream[kState];
+
+  if (controller[kState].finishPromise !== undefined) {
+    return controller[kState].finishPromise;
+  }
+
+  const { promise, resolve, reject } = PromiseWithResolvers();
+  controller[kState].finishPromise = promise;
+  const cancelPromise = controller[kState].cancelAlgorithm(reason);
+  transformStreamDefaultControllerClearAlgorithms(controller);
+
+  PromisePrototypeThen(
+    cancelPromise,
+    () => {
+      if (writable[kState].state === 'errored')
+        reject(writable[kState].storedError);
+      else {
+        writableStreamDefaultControllerErrorIfNeeded(
+          writable[kState].controller,
+          reason);
+        transformStreamUnblockWrite(stream);
+        resolve();
+      }
+    },
+    (error) => {
+      writableStreamDefaultControllerErrorIfNeeded(
+        writable[kState].controller,
+        error);
+      transformStreamUnblockWrite(stream);
+      reject(error);
+    },
+  );
+
+  return controller[kState].finishPromise;
+}
+
+module.exports = {
+  TransformStream,
+  TransformStreamDefaultController,
+  TransferredTransformStream,
+
+  // Exported Brand Checks
+  isTransformStream,
+  isTransformStreamDefaultController,
+};

lib/internal/webstreams/util.js

@@ -0,0 +1,299 @@
+'use strict';
+
+const {
+  ArrayBufferPrototypeGetByteLength,
+  ArrayBufferPrototypeGetDetached,
+  ArrayBufferPrototypeSlice,
+  ArrayPrototypePush,
+  ArrayPrototypeShift,
+  AsyncIteratorPrototype,
+  FunctionPrototypeCall,
+  MathMax,
+  NumberIsNaN,
+  PromisePrototypeThen,
+  ReflectGet,
+  Symbol,
+  SymbolAsyncIterator,
+  SymbolIterator,
+  Uint8Array,
+} = primordials;
+
+const {
+  codes: {
+    ERR_ARG_NOT_ITERABLE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_STATE,
+  },
+} = require('internal/errors');
+
+const {
+  copyArrayBuffer,
+} = internalBinding('buffer');
+
+const {
+  inspect,
+} = require('util');
+
+const {
+  constants: {
+    kPending,
+  },
+  getPromiseDetails,
+} = internalBinding('util');
+
+const assert = require('internal/assert');
+
+const {
+  validateFunction,
+} = require('internal/validators');
+
+const kState = Symbol('kState');
+const kType = Symbol('kType');
+
+const AsyncIterator = {
+  __proto__: AsyncIteratorPrototype,
+  next: undefined,
+  return: undefined,
+};
+
+function extractHighWaterMark(value, defaultHWM) {
+  if (value === undefined) return defaultHWM;
+  value = +value;
+  if (typeof value !== 'number' ||
+      NumberIsNaN(value) ||
+      value < 0)
+    throw new ERR_INVALID_ARG_VALUE.RangeError('strategy.highWaterMark', value);
+  return value;
+}
+
+function extractSizeAlgorithm(size) {
+  if (size === undefined) return () => 1;
+  validateFunction(size, 'strategy.size');
+  return size;
+}
+
+function customInspect(depth, options, name, data) {
+  if (depth < 0)
+    return this;
+
+  const opts = {
+    ...options,
+    depth: options.depth == null ? null : options.depth - 1,
+  };
+
+  return `${name} ${inspect(data, opts)}`;
+}
+
+// These are defensive to work around the possibility that
+// the buffer, byteLength, and byteOffset properties on
+// ArrayBuffer and ArrayBufferView's may have been tampered with.
+
+function ArrayBufferViewGetBuffer(view) {
+  return ReflectGet(view.constructor.prototype, 'buffer', view);
+}
+
+function ArrayBufferViewGetByteLength(view) {
+  return ReflectGet(view.constructor.prototype, 'byteLength', view);
+}
+
+function ArrayBufferViewGetByteOffset(view) {
+  return ReflectGet(view.constructor.prototype, 'byteOffset', view);
+}
+
+function cloneAsUint8Array(view) {
+  const buffer = ArrayBufferViewGetBuffer(view);
+  const byteOffset = ArrayBufferViewGetByteOffset(view);
+  const byteLength = ArrayBufferViewGetByteLength(view);
+  return new Uint8Array(
+    ArrayBufferPrototypeSlice(buffer, byteOffset, byteOffset + byteLength),
+  );
+}
+
+function canCopyArrayBuffer(toBuffer, toIndex, fromBuffer, fromIndex, count) {
+  return toBuffer !== fromBuffer &&
+    !ArrayBufferPrototypeGetDetached(toBuffer) &&
+    !ArrayBufferPrototypeGetDetached(fromBuffer) &&
+    toIndex + count <= ArrayBufferPrototypeGetByteLength(toBuffer) &&
+    fromIndex + count <= ArrayBufferPrototypeGetByteLength(fromBuffer);
+}
+
+function isBrandCheck(brand) {
+  return (value) => {
+    return value != null &&
+           value[kState] !== undefined &&
+           value[kType] === brand;
+  };
+}
+
+function dequeueValue(controller) {
+  assert(controller[kState].queue !== undefined);
+  assert(controller[kState].queueTotalSize !== undefined);
+  assert(controller[kState].queue.length);
+  const {
+    value,
+    size,
+  } = ArrayPrototypeShift(controller[kState].queue);
+  controller[kState].queueTotalSize =
+    MathMax(0, controller[kState].queueTotalSize - size);
+  return value;
+}
+
+function resetQueue(controller) {
+  assert(controller[kState].queue !== undefined);
+  assert(controller[kState].queueTotalSize !== undefined);
+  controller[kState].queue = [];
+  controller[kState].queueTotalSize = 0;
+}
+
+function peekQueueValue(controller) {
+  assert(controller[kState].queue !== undefined);
+  assert(controller[kState].queueTotalSize !== undefined);
+  assert(controller[kState].queue.length);
+  return controller[kState].queue[0].value;
+}
+
+function enqueueValueWithSize(controller, value, size) {
+  assert(controller[kState].queue !== undefined);
+  assert(controller[kState].queueTotalSize !== undefined);
+  size = +size;
+  if (typeof size !== 'number' ||
+      size < 0 ||
+      NumberIsNaN(size) ||
+      size === Infinity) {
+    throw new ERR_INVALID_ARG_VALUE.RangeError('size', size);
+  }
+  ArrayPrototypePush(controller[kState].queue, { value, size });
+  controller[kState].queueTotalSize += size;
+}
+
+// This implements "invoke a callback function type" for callback functions that return a promise.
+// See https://webidl.spec.whatwg.org/#es-invoking-callback-functions
+async function invokePromiseCallback(fn, thisArg, ...args) {
+  return FunctionPrototypeCall(fn, thisArg, ...args);
+}
+
+function createPromiseCallback(name, fn, thisArg) {
+  validateFunction(fn, name);
+  return (...args) => invokePromiseCallback(fn, thisArg, ...args);
+}
+
+function isPromisePending(promise) {
+  if (promise === undefined) return false;
+  const details = getPromiseDetails(promise);
+  return details?.[0] === kPending;
+}
+
+function setPromiseHandled(promise) {
+  // Alternatively, we could use the native API
+  // MarkAsHandled, but this avoids the extra boundary cross
+  // and is hopefully faster at the cost of an extra Promise
+  // allocation.
+  PromisePrototypeThen(promise, () => {}, () => {});
+}
+
+async function nonOpFlush() {}
+
+function nonOpStart() {}
+
+async function nonOpPull() {}
+
+async function nonOpCancel() {}
+
+async function nonOpWrite() {}
+
+let transfer;
+function lazyTransfer() {
+  if (transfer === undefined)
+    transfer = require('internal/webstreams/transfer');
+  return transfer;
+}
+
+function createAsyncFromSyncIterator(syncIteratorRecord) {
+  const syncIterable = {
+    [SymbolIterator]: () => syncIteratorRecord.iterator,
+  };
+
+  const asyncIterator = (async function* () {
+    return yield* syncIterable;
+  }());
+
+  const nextMethod = asyncIterator.next;
+  return { iterator: asyncIterator, nextMethod, done: false };
+}
+
+// Refs: https://tc39.es/ecma262/#sec-getiterator
+function getIterator(obj, kind = 'sync', method) {
+  if (method === undefined) {
+    if (kind === 'async') {
+      method = obj[SymbolAsyncIterator];
+      if (method == null) {
+        const syncMethod = obj[SymbolIterator];
+
+        if (syncMethod === undefined) {
+          throw new ERR_ARG_NOT_ITERABLE(obj);
+        }
+
+        const syncIteratorRecord = getIterator(obj, 'sync', syncMethod);
+        return createAsyncFromSyncIterator(syncIteratorRecord);
+      }
+    } else {
+      method = obj[SymbolIterator];
+    }
+  }
+
+  if (method === undefined) {
+    throw new ERR_ARG_NOT_ITERABLE(obj);
+  }
+
+  const iterator = FunctionPrototypeCall(method, obj);
+  if (typeof iterator !== 'object' || iterator === null) {
+    throw new ERR_INVALID_STATE.TypeError('The iterator method must return an object');
+  }
+  const nextMethod = iterator.next;
+  return { iterator, nextMethod, done: false };
+}
+
+function iteratorNext(iteratorRecord, value) {
+  let result;
+  if (value === undefined) {
+    result = FunctionPrototypeCall(iteratorRecord.nextMethod, iteratorRecord.iterator);
+  } else {
+    result = FunctionPrototypeCall(iteratorRecord.nextMethod, iteratorRecord.iterator, [value]);
+  }
+  if (typeof result !== 'object' || result === null) {
+    throw new ERR_INVALID_STATE.TypeError('The iterator.next() method must return an object');
+  }
+  return result;
+}
+
+module.exports = {
+  ArrayBufferViewGetBuffer,
+  ArrayBufferViewGetByteLength,
+  ArrayBufferViewGetByteOffset,
+  AsyncIterator,
+  canCopyArrayBuffer,
+  createPromiseCallback,
+  cloneAsUint8Array,
+  copyArrayBuffer,
+  customInspect,
+  dequeueValue,
+  enqueueValueWithSize,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  lazyTransfer,
+  invokePromiseCallback,
+  isBrandCheck,
+  isPromisePending,
+  peekQueueValue,
+  resetQueue,
+  setPromiseHandled,
+  nonOpCancel,
+  nonOpFlush,
+  nonOpPull,
+  nonOpStart,
+  nonOpWrite,
+  getIterator,
+  iteratorNext,
+  kType,
+  kState,
+};