@gjsify/web-streams 0.1.0

package/lib/esm/readable-stream.js

@@ -0,0 +1,1064 @@
+import {
+  kState,
+  kType,
+  isBrandCheck,
+  createPromiseCallback,
+  dequeueValue,
+  enqueueValueWithSize,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  resetQueue,
+  setPromiseHandled,
+  nonOpCancel,
+  nonOpPull,
+  nonOpStart,
+  getIterator,
+  iteratorNext,
+  AsyncIterator
+} from "./util.js";
+import {
+  WritableStreamDefaultWriter,
+  isWritableStream,
+  isWritableStreamLocked,
+  writableStreamAbort,
+  writableStreamCloseQueuedOrInFlight,
+  writableStreamDefaultWriterCloseWithErrorPropagation,
+  writableStreamDefaultWriterRelease,
+  writableStreamDefaultWriterWrite
+} from "./writable-stream.js";
+const kCancel = /* @__PURE__ */ Symbol("kCancel");
+const kClose = /* @__PURE__ */ Symbol("kClose");
+const kChunk = /* @__PURE__ */ Symbol("kChunk");
+const kError = /* @__PURE__ */ Symbol("kError");
+const kPull = /* @__PURE__ */ Symbol("kPull");
+const kRelease = /* @__PURE__ */ Symbol("kRelease");
+const kSkipThrow = /* @__PURE__ */ Symbol("kSkipThrow");
+let releasedError;
+let releasingError;
+function lazyReadableReleasedError() {
+  if (releasedError) return releasedError;
+  releasedError = new TypeError("Reader released");
+  return releasedError;
+}
+function lazyReadableReleasingError() {
+  if (releasingError) return releasingError;
+  releasingError = new TypeError("Releasing reader");
+  return releasingError;
+}
+function createAbortError() {
+  if (typeof globalThis.DOMException === "function") {
+    return new DOMException("The operation was aborted", "AbortError");
+  }
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  return err;
+}
+import { nextTick as _queueMicrotask } from "@gjsify/utils";
+function createReadableStreamState() {
+  return {
+    disturbed: false,
+    reader: void 0,
+    state: "readable",
+    storedError: void 0,
+    controller: void 0,
+    // closedPromise tracks stream-level close for watchers (pipeTo, etc.)
+    closedPromise: Promise.withResolvers()
+  };
+}
+class ReadableStream {
+  [kType] = "ReadableStream";
+  [kState];
+  constructor(source = {}, strategy = {}) {
+    if (source != null && typeof source !== "object") {
+      throw new TypeError("source must be an object");
+    }
+    if (strategy != null && typeof strategy !== "object") {
+      throw new TypeError("strategy must be an object");
+    }
+    this[kState] = createReadableStreamState();
+    const size = strategy?.size;
+    const highWaterMark = strategy?.highWaterMark;
+    const type = source?.type;
+    if (type !== void 0) {
+      if (`${type}` === "bytes") {
+        throw new RangeError("Byte streams not yet supported (use default controller)");
+      }
+      throw new RangeError(`Invalid type: ${type}`);
+    }
+    setupReadableStreamDefaultControllerFromSource(
+      this,
+      source,
+      extractHighWaterMark(highWaterMark, 1),
+      extractSizeAlgorithm(size)
+    );
+  }
+  get locked() {
+    if (!isReadableStream(this)) throw new TypeError("Invalid this");
+    return isReadableStreamLocked(this);
+  }
+  static from(iterable) {
+    return readableStreamFromIterable(iterable);
+  }
+  cancel(reason = void 0) {
+    if (!isReadableStream(this))
+      return Promise.reject(new TypeError("Invalid this"));
+    if (isReadableStreamLocked(this))
+      return Promise.reject(new TypeError("ReadableStream is locked"));
+    return readableStreamCancel(this, reason);
+  }
+  getReader(options = {}) {
+    if (!isReadableStream(this)) throw new TypeError("Invalid this");
+    if (options != null && typeof options !== "object") {
+      throw new TypeError("options must be an object");
+    }
+    const mode = options?.mode;
+    if (mode === void 0)
+      return new ReadableStreamDefaultReader(this);
+    if (`${mode}` === "byob")
+      throw new RangeError("BYOB readers not yet supported");
+    throw new RangeError(`Invalid mode: ${mode}`);
+  }
+  pipeThrough(transform, options = {}) {
+    if (!isReadableStream(this)) throw new TypeError("Invalid this");
+    const readable = transform?.readable;
+    if (!isReadableStream(readable)) {
+      throw new TypeError("transform.readable must be a ReadableStream");
+    }
+    const writable = transform?.writable;
+    if (!isWritableStream(writable)) {
+      throw new TypeError("transform.writable must be a WritableStream");
+    }
+    if (options != null && typeof options !== "object") {
+      throw new TypeError("options must be an object");
+    }
+    const preventAbort = options?.preventAbort;
+    const preventCancel = options?.preventCancel;
+    const preventClose = options?.preventClose;
+    const signal = options?.signal;
+    if (signal !== void 0 && !(signal instanceof Object && "aborted" in signal)) {
+      throw new TypeError("options.signal must be an AbortSignal");
+    }
+    if (isReadableStreamLocked(this))
+      throw new TypeError("The ReadableStream is locked");
+    if (isWritableStreamLocked(writable))
+      throw new TypeError("The WritableStream is locked");
+    const promise = readableStreamPipeTo(
+      this,
+      writable,
+      !!preventClose,
+      !!preventAbort,
+      !!preventCancel,
+      signal
+    );
+    setPromiseHandled(promise);
+    return readable;
+  }
+  pipeTo(destination, options = {}) {
+    try {
+      if (!isReadableStream(this)) throw new TypeError("Invalid this");
+      if (!isWritableStream(destination)) {
+        throw new TypeError("destination must be a WritableStream");
+      }
+      if (options != null && typeof options !== "object") {
+        throw new TypeError("options must be an object");
+      }
+      const preventAbort = options?.preventAbort;
+      const preventCancel = options?.preventCancel;
+      const preventClose = options?.preventClose;
+      const signal = options?.signal;
+      if (signal !== void 0 && !(signal instanceof Object && "aborted" in signal)) {
+        throw new TypeError("options.signal must be an AbortSignal");
+      }
+      if (isReadableStreamLocked(this))
+        throw new TypeError("The ReadableStream is locked");
+      if (isWritableStreamLocked(destination))
+        throw new TypeError("The WritableStream is locked");
+      return readableStreamPipeTo(
+        this,
+        destination,
+        !!preventClose,
+        !!preventAbort,
+        !!preventCancel,
+        signal
+      );
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  tee() {
+    if (!isReadableStream(this)) throw new TypeError("Invalid this");
+    return readableStreamDefaultTee(this, false);
+  }
+  values(options = {}) {
+    if (!isReadableStream(this)) throw new TypeError("Invalid this");
+    if (options != null && typeof options !== "object") {
+      throw new TypeError("options must be an object");
+    }
+    const preventCancel = !!options?.preventCancel;
+    const reader = new ReadableStreamDefaultReader(this);
+    const state = {
+      done: false,
+      current: void 0
+    };
+    let started = false;
+    function nextSteps() {
+      if (state.done)
+        return Promise.resolve({ done: true, value: void 0 });
+      if (reader[kState].stream === void 0) {
+        return Promise.reject(
+          new TypeError("The reader is not bound to a ReadableStream")
+        );
+      }
+      const { promise, resolve, reject } = Promise.withResolvers();
+      readableStreamDefaultReaderRead(reader, {
+        [kChunk](chunk) {
+          state.current = void 0;
+          resolve({ value: chunk, done: false });
+        },
+        [kClose]() {
+          state.current = void 0;
+          state.done = true;
+          readableStreamReaderGenericRelease(reader);
+          resolve({ done: true, value: void 0 });
+        },
+        [kError](error) {
+          state.current = void 0;
+          state.done = true;
+          readableStreamReaderGenericRelease(reader);
+          reject(error);
+        }
+      });
+      return promise;
+    }
+    async function returnSteps(value) {
+      if (state.done)
+        return { done: true, value };
+      state.done = true;
+      if (reader[kState].stream === void 0) {
+        throw new TypeError("The reader is not bound to a ReadableStream");
+      }
+      if (!preventCancel) {
+        const result = readableStreamReaderGenericCancel(reader, value);
+        readableStreamReaderGenericRelease(reader);
+        await result;
+        return { done: true, value };
+      }
+      readableStreamReaderGenericRelease(reader);
+      return { done: true, value };
+    }
+    return Object.setPrototypeOf({
+      next() {
+        if (!started) {
+          state.current = Promise.resolve();
+          started = true;
+        }
+        state.current = state.current !== void 0 ? state.current.then(nextSteps, nextSteps) : nextSteps();
+        return state.current;
+      },
+      return(error) {
+        started = true;
+        state.current = state.current !== void 0 ? state.current.then(
+          () => returnSteps(error),
+          () => returnSteps(error)
+        ) : returnSteps(error);
+        return state.current;
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    }, AsyncIterator);
+  }
+  [Symbol.asyncIterator]() {
+    return this.values();
+  }
+  get [Symbol.toStringTag]() {
+    return "ReadableStream";
+  }
+}
+class DefaultReadRequest {
+  [kState];
+  constructor() {
+    this[kState] = Promise.withResolvers();
+  }
+  [kChunk](value) {
+    this[kState].resolve?.({ value, done: false });
+  }
+  [kClose]() {
+    this[kState].resolve?.({ value: void 0, done: true });
+  }
+  [kError](error) {
+    this[kState].reject?.(error);
+  }
+  get promise() {
+    return this[kState].promise;
+  }
+}
+class ReadableStreamDefaultReader {
+  [kType] = "ReadableStreamDefaultReader";
+  [kState];
+  constructor(stream) {
+    if (!isReadableStream(stream))
+      throw new TypeError("Expected a ReadableStream");
+    this[kState] = {
+      readRequests: [],
+      stream: void 0,
+      close: {
+        promise: void 0,
+        resolve: void 0,
+        reject: void 0
+      }
+    };
+    setupReadableStreamDefaultReader(this, stream);
+  }
+  read() {
+    if (!isReadableStreamDefaultReader(this))
+      return Promise.reject(new TypeError("Invalid this"));
+    if (this[kState].stream === void 0) {
+      return Promise.reject(
+        new TypeError("The reader is not attached to a stream")
+      );
+    }
+    const stream = this[kState].stream;
+    const controller = stream[kState].controller;
+    if (stream[kState].state === "readable" && isReadableStreamDefaultController(controller) && controller[kState].queue.length > 0) {
+      stream[kState].disturbed = true;
+      const chunk = dequeueValue(controller);
+      if (controller[kState].closeRequested && !controller[kState].queue.length) {
+        readableStreamDefaultControllerClearAlgorithms(controller);
+        readableStreamClose(stream);
+      } else {
+        readableStreamDefaultControllerCallPullIfNeeded(controller);
+      }
+      return Promise.resolve({ value: chunk, done: false });
+    }
+    const readRequest = new DefaultReadRequest();
+    readableStreamDefaultReaderRead(this, readRequest);
+    return readRequest.promise;
+  }
+  releaseLock() {
+    if (!isReadableStreamDefaultReader(this))
+      throw new TypeError("Invalid this");
+    if (this[kState].stream === void 0)
+      return;
+    readableStreamDefaultReaderRelease(this);
+  }
+  get closed() {
+    if (!isReadableStreamDefaultReader(this))
+      return Promise.reject(new TypeError("Invalid this"));
+    return this[kState].close.promise;
+  }
+  cancel(reason = void 0) {
+    if (!isReadableStreamDefaultReader(this))
+      return Promise.reject(new TypeError("Invalid this"));
+    if (this[kState].stream === void 0) {
+      return Promise.reject(new TypeError("The reader is not attached to a stream"));
+    }
+    return readableStreamReaderGenericCancel(this, reason);
+  }
+  get [Symbol.toStringTag]() {
+    return "ReadableStreamDefaultReader";
+  }
+}
+class ReadableStreamDefaultController {
+  [kType] = "ReadableStreamDefaultController";
+  [kState] = {};
+  constructor(skipThrowSymbol) {
+    if (skipThrowSymbol !== kSkipThrow) {
+      throw new TypeError("Illegal constructor");
+    }
+  }
+  get desiredSize() {
+    return readableStreamDefaultControllerGetDesiredSize(this);
+  }
+  close() {
+    if (!readableStreamDefaultControllerCanCloseOrEnqueue(this))
+      throw new TypeError("Controller is already closed");
+    readableStreamDefaultControllerClose(this);
+  }
+  enqueue(chunk = void 0) {
+    if (!readableStreamDefaultControllerCanCloseOrEnqueue(this))
+      throw new TypeError("Controller is already closed");
+    readableStreamDefaultControllerEnqueue(this, chunk);
+  }
+  error(error = void 0) {
+    readableStreamDefaultControllerError(this, error);
+  }
+  [kCancel](reason) {
+    return readableStreamDefaultControllerCancelSteps(this, reason);
+  }
+  [kPull](readRequest) {
+    readableStreamDefaultControllerPullSteps(this, readRequest);
+  }
+  [kRelease]() {
+  }
+  get [Symbol.toStringTag]() {
+    return "ReadableStreamDefaultController";
+  }
+}
+const isReadableStream = isBrandCheck("ReadableStream");
+const isReadableStreamDefaultController = isBrandCheck("ReadableStreamDefaultController");
+const isReadableStreamDefaultReader = isBrandCheck("ReadableStreamDefaultReader");
+function isReadableStreamLocked(stream) {
+  return stream[kState].reader !== void 0;
+}
+function readableStreamCancel(stream, reason) {
+  stream[kState].disturbed = true;
+  switch (stream[kState].state) {
+    case "closed":
+      return Promise.resolve();
+    case "errored":
+      return Promise.reject(stream[kState].storedError);
+  }
+  readableStreamClose(stream);
+  return stream[kState].controller[kCancel](reason).then(() => {
+  });
+}
+function readableStreamClose(stream) {
+  stream[kState].state = "closed";
+  stream[kState].closedPromise.resolve();
+  const { reader } = stream[kState];
+  if (reader === void 0) return;
+  reader[kState].close.resolve?.();
+  if (readableStreamHasDefaultReader(stream)) {
+    for (let n = 0; n < reader[kState].readRequests.length; n++)
+      reader[kState].readRequests[n][kClose]();
+    reader[kState].readRequests = [];
+  }
+}
+function readableStreamError(stream, error) {
+  stream[kState].state = "errored";
+  stream[kState].storedError = error;
+  setPromiseHandled(stream[kState].closedPromise.promise);
+  stream[kState].closedPromise.reject(error);
+  const { reader } = stream[kState];
+  if (reader === void 0) return;
+  setPromiseHandled(reader[kState].close.promise);
+  reader[kState].close.reject?.(error);
+  if (readableStreamHasDefaultReader(stream)) {
+    for (let n = 0; n < reader[kState].readRequests.length; n++)
+      reader[kState].readRequests[n][kError](error);
+    reader[kState].readRequests = [];
+  }
+}
+function readableStreamHasDefaultReader(stream) {
+  const { reader } = stream[kState];
+  if (reader === void 0) return false;
+  return reader[kState] !== void 0 && reader[kType] === "ReadableStreamDefaultReader";
+}
+function readableStreamGetNumReadRequests(stream) {
+  return stream[kState].reader[kState].readRequests.length;
+}
+function readableStreamFulfillReadRequest(stream, chunk, done) {
+  const { reader } = stream[kState];
+  const readRequest = reader[kState].readRequests.shift();
+  if (done)
+    readRequest[kClose]();
+  else
+    readRequest[kChunk](chunk);
+}
+function readableStreamAddReadRequest(stream, readRequest) {
+  stream[kState].reader[kState].readRequests.push(readRequest);
+}
+function readableStreamReaderGenericCancel(reader, reason) {
+  const { stream } = reader[kState];
+  return readableStreamCancel(stream, reason);
+}
+function readableStreamReaderGenericInitialize(reader, stream) {
+  reader[kState].stream = stream;
+  stream[kState].reader = reader;
+  switch (stream[kState].state) {
+    case "readable":
+      reader[kState].close = Promise.withResolvers();
+      break;
+    case "closed":
+      reader[kState].close = {
+        promise: Promise.resolve(),
+        resolve: void 0,
+        reject: void 0
+      };
+      break;
+    case "errored":
+      reader[kState].close = {
+        promise: Promise.reject(stream[kState].storedError),
+        resolve: void 0,
+        reject: void 0
+      };
+      setPromiseHandled(reader[kState].close.promise);
+      break;
+  }
+}
+function readableStreamReaderGenericRelease(reader) {
+  const { stream } = reader[kState];
+  const releasedStateError = lazyReadableReleasedError();
+  if (stream[kState].state === "readable") {
+    reader[kState].close.reject?.(releasedStateError);
+  } else {
+    reader[kState].close = {
+      promise: Promise.reject(releasedStateError),
+      resolve: void 0,
+      reject: void 0
+    };
+  }
+  setPromiseHandled(reader[kState].close.promise);
+  stream[kState].controller[kRelease]();
+  stream[kState].reader = void 0;
+  reader[kState].stream = void 0;
+}
+function readableStreamDefaultReaderRelease(reader) {
+  readableStreamReaderGenericRelease(reader);
+  readableStreamDefaultReaderErrorReadRequests(reader, lazyReadableReleasingError());
+}
+function readableStreamDefaultReaderErrorReadRequests(reader, e) {
+  for (let n = 0; n < reader[kState].readRequests.length; ++n) {
+    reader[kState].readRequests[n][kError](e);
+  }
+  reader[kState].readRequests = [];
+}
+function readableStreamDefaultReaderRead(reader, readRequest) {
+  const { stream } = reader[kState];
+  stream[kState].disturbed = true;
+  switch (stream[kState].state) {
+    case "closed":
+      readRequest[kClose]();
+      break;
+    case "errored":
+      readRequest[kError](stream[kState].storedError);
+      break;
+    case "readable":
+      stream[kState].controller[kPull](readRequest);
+      break;
+  }
+}
+function setupReadableStreamDefaultReader(reader, stream) {
+  if (isReadableStreamLocked(stream))
+    throw new TypeError("ReadableStream is locked");
+  readableStreamReaderGenericInitialize(reader, stream);
+  reader[kState].readRequests = [];
+}
+function readableStreamDefaultControllerClose(controller) {
+  if (!readableStreamDefaultControllerCanCloseOrEnqueue(controller))
+    return;
+  controller[kState].closeRequested = true;
+  if (!controller[kState].queue.length) {
+    readableStreamDefaultControllerClearAlgorithms(controller);
+    readableStreamClose(controller[kState].stream);
+  }
+}
+function readableStreamDefaultControllerEnqueue(controller, chunk) {
+  if (!readableStreamDefaultControllerCanCloseOrEnqueue(controller))
+    return;
+  const { stream } = controller[kState];
+  if (isReadableStreamLocked(stream) && readableStreamGetNumReadRequests(stream)) {
+    readableStreamFulfillReadRequest(stream, chunk, false);
+  } else {
+    try {
+      const chunkSize = controller[kState].sizeAlgorithm(chunk);
+      enqueueValueWithSize(controller, chunk, chunkSize);
+    } catch (error) {
+      readableStreamDefaultControllerError(controller, error);
+      throw error;
+    }
+  }
+  readableStreamDefaultControllerCallPullIfNeeded(controller);
+}
+function readableStreamDefaultControllerCanCloseOrEnqueue(controller) {
+  const { stream } = controller[kState];
+  return !controller[kState].closeRequested && stream[kState].state === "readable";
+}
+function readableStreamDefaultControllerGetDesiredSize(controller) {
+  const { stream, highWaterMark, queueTotalSize } = controller[kState];
+  switch (stream[kState].state) {
+    case "errored":
+      return null;
+    case "closed":
+      return 0;
+    default:
+      return highWaterMark - queueTotalSize;
+  }
+}
+function readableStreamDefaultControllerHasBackpressure(controller) {
+  return !readableStreamDefaultControllerShouldCallPull(controller);
+}
+function readableStreamDefaultControllerShouldCallPull(controller) {
+  const { stream } = controller[kState];
+  if (!readableStreamDefaultControllerCanCloseOrEnqueue(controller) || !controller[kState].started)
+    return false;
+  if (isReadableStreamLocked(stream) && readableStreamGetNumReadRequests(stream)) {
+    return true;
+  }
+  const desiredSize = readableStreamDefaultControllerGetDesiredSize(controller);
+  return desiredSize !== null && desiredSize > 0;
+}
+function readableStreamDefaultControllerCallPullIfNeeded(controller) {
+  if (!readableStreamDefaultControllerShouldCallPull(controller))
+    return;
+  if (controller[kState].pulling) {
+    controller[kState].pullAgain = true;
+    return;
+  }
+  controller[kState].pulling = true;
+  controller[kState].pullAlgorithm(controller).then(
+    () => {
+      controller[kState].pulling = false;
+      if (controller[kState].pullAgain) {
+        controller[kState].pullAgain = false;
+        readableStreamDefaultControllerCallPullIfNeeded(controller);
+      }
+    },
+    (error) => readableStreamDefaultControllerError(controller, error)
+  );
+}
+function readableStreamDefaultControllerClearAlgorithms(controller) {
+  controller[kState].pullAlgorithm = void 0;
+  controller[kState].cancelAlgorithm = void 0;
+  controller[kState].sizeAlgorithm = void 0;
+}
+function readableStreamDefaultControllerError(controller, error) {
+  const { stream } = controller[kState];
+  if (stream[kState].state === "readable") {
+    resetQueue(controller);
+    readableStreamDefaultControllerClearAlgorithms(controller);
+    readableStreamError(stream, error);
+  }
+}
+function readableStreamDefaultControllerCancelSteps(controller, reason) {
+  resetQueue(controller);
+  const result = controller[kState].cancelAlgorithm(reason);
+  readableStreamDefaultControllerClearAlgorithms(controller);
+  return result;
+}
+function readableStreamDefaultControllerPullSteps(controller, readRequest) {
+  const { stream, queue } = controller[kState];
+  if (queue.length) {
+    const chunk = dequeueValue(controller);
+    if (controller[kState].closeRequested && !queue.length) {
+      readableStreamDefaultControllerClearAlgorithms(controller);
+      readableStreamClose(stream);
+    } else {
+      readableStreamDefaultControllerCallPullIfNeeded(controller);
+    }
+    readRequest[kChunk](chunk);
+    return;
+  }
+  readableStreamAddReadRequest(stream, readRequest);
+  readableStreamDefaultControllerCallPullIfNeeded(controller);
+}
+function setupReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
+  controller[kState] = {
+    cancelAlgorithm,
+    closeRequested: false,
+    highWaterMark,
+    pullAgain: false,
+    pullAlgorithm,
+    pulling: false,
+    queue: [],
+    queueTotalSize: 0,
+    started: false,
+    sizeAlgorithm,
+    stream
+  };
+  stream[kState].controller = controller;
+  const startResult = startAlgorithm();
+  new Promise((r) => r(startResult)).then(
+    () => {
+      controller[kState].started = true;
+      readableStreamDefaultControllerCallPullIfNeeded(controller);
+    },
+    (error) => readableStreamDefaultControllerError(controller, error)
+  );
+}
+function setupReadableStreamDefaultControllerFromSource(stream, source, highWaterMark, sizeAlgorithm) {
+  const controller = new ReadableStreamDefaultController(kSkipThrow);
+  const start = source?.start;
+  const pull = source?.pull;
+  const cancel = source?.cancel;
+  const startAlgorithm = start ? start.bind(source, controller) : nonOpStart;
+  const pullAlgorithm = pull ? createPromiseCallback("source.pull", pull, source) : nonOpPull;
+  const cancelAlgorithm = cancel ? createPromiseCallback("source.cancel", cancel, source) : nonOpCancel;
+  setupReadableStreamDefaultController(
+    stream,
+    controller,
+    startAlgorithm,
+    pullAlgorithm,
+    cancelAlgorithm,
+    highWaterMark,
+    sizeAlgorithm
+  );
+}
+function createReadableStream(start, pull, cancel, highWaterMark = 1, size = () => 1) {
+  const stream = Object.create(ReadableStream.prototype);
+  stream[kType] = "ReadableStream";
+  stream[kState] = createReadableStreamState();
+  const controller = new ReadableStreamDefaultController(kSkipThrow);
+  setupReadableStreamDefaultController(
+    stream,
+    controller,
+    start,
+    pull,
+    cancel,
+    highWaterMark,
+    size
+  );
+  return stream;
+}
+function readableStreamFromIterable(iterable) {
+  let stream;
+  const iteratorRecord = getIterator(iterable, "async");
+  const startAlgorithm = nonOpStart;
+  async function pullAlgorithm() {
+    const nextResult = iteratorNext(iteratorRecord);
+    const nextPromise = Promise.resolve(nextResult);
+    return nextPromise.then((iterResult) => {
+      if (typeof iterResult !== "object" || iterResult === null) {
+        throw new TypeError(
+          "The promise returned by the iterator.next() method must fulfill with an object"
+        );
+      }
+      if (iterResult.done) {
+        readableStreamDefaultControllerClose(stream[kState].controller);
+      } else {
+        readableStreamDefaultControllerEnqueue(stream[kState].controller, iterResult.value);
+      }
+    });
+  }
+  async function cancelAlgorithm(reason) {
+    const iterator = iteratorRecord.iterator;
+    const returnMethod = iterator.return;
+    if (returnMethod === void 0) {
+      return Promise.resolve();
+    }
+    const returnResult = returnMethod.call(iterator, reason);
+    const returnPromise = Promise.resolve(returnResult);
+    return returnPromise.then((iterResult) => {
+      if (typeof iterResult !== "object" || iterResult === null) {
+        throw new TypeError(
+          "The promise returned by the iterator.return() method must fulfill with an object"
+        );
+      }
+      return void 0;
+    });
+  }
+  stream = createReadableStream(
+    startAlgorithm,
+    pullAlgorithm,
+    cancelAlgorithm,
+    0
+  );
+  return stream;
+}
+function readableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
+  let reader;
+  let writer;
+  try {
+    reader = new ReadableStreamDefaultReader(source);
+    writer = new WritableStreamDefaultWriter(dest);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  source[kState].disturbed = true;
+  let shuttingDown = false;
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const state = {
+    currentWrite: Promise.resolve()
+  };
+  let abortListener;
+  function finalize(rejected, error) {
+    writableStreamDefaultWriterRelease(writer);
+    readableStreamReaderGenericRelease(reader);
+    if (signal !== void 0 && abortListener) {
+      signal.removeEventListener("abort", abortListener);
+      abortListener = void 0;
+    }
+    if (rejected)
+      reject(error);
+    else
+      resolve();
+  }
+  async function waitForCurrentWrite() {
+    const write = state.currentWrite;
+    await write;
+    if (write !== state.currentWrite)
+      await waitForCurrentWrite();
+  }
+  function shutdownWithAnAction(action, rejected, originalError) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (dest[kState].state === "writable" && !writableStreamCloseQueuedOrInFlight(dest)) {
+      waitForCurrentWrite().then(complete, (error) => finalize(true, error));
+      return;
+    }
+    complete();
+    function complete() {
+      action().then(
+        () => finalize(!!rejected, originalError),
+        (error) => finalize(true, error)
+      );
+    }
+  }
+  function shutdown(rejected, error) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (dest[kState].state === "writable" && !writableStreamCloseQueuedOrInFlight(dest)) {
+      waitForCurrentWrite().then(
+        () => finalize(!!rejected, error),
+        (err) => finalize(true, err)
+      );
+      return;
+    }
+    finalize(!!rejected, error);
+  }
+  function abortAlgorithm() {
+    let error;
+    if (signal.reason && signal.reason.name === "AbortError") {
+      error = createAbortError();
+    } else {
+      error = signal.reason;
+    }
+    const actions = [];
+    if (!preventAbort) {
+      actions.push(() => {
+        if (dest[kState].state === "writable")
+          return writableStreamAbort(dest, error);
+        return Promise.resolve();
+      });
+    }
+    if (!preventCancel) {
+      actions.push(() => {
+        if (source[kState].state === "readable")
+          return readableStreamCancel(source, error);
+        return Promise.resolve();
+      });
+    }
+    shutdownWithAnAction(
+      () => Promise.all(actions.map((action) => action())).then(() => void 0),
+      true,
+      error
+    );
+  }
+  function watchErrored(stream, watchPromise, action) {
+    if (stream[kState].state === "errored")
+      action(stream[kState].storedError);
+    else
+      watchPromise.then(void 0, action);
+  }
+  function watchClosed(stream, watchPromise, action) {
+    if (stream[kState].state === "closed")
+      action();
+    else
+      watchPromise.then(action, () => {
+      });
+  }
+  class PipeToReadRequest {
+    [kChunk](chunk) {
+      _queueMicrotask(() => {
+        state.currentWrite = writableStreamDefaultWriterWrite(writer, chunk);
+        setPromiseHandled(state.currentWrite);
+        stepPromise.resolve(false);
+      });
+    }
+    [kClose]() {
+      stepPromise.resolve(true);
+    }
+    [kError](error) {
+      stepPromise.reject(error);
+    }
+  }
+  let stepPromise = {
+    resolve: null,
+    reject: null
+  };
+  async function step() {
+    if (shuttingDown) return true;
+    if (dest[kState].backpressure) {
+      await writer[kState].ready.promise;
+      if (shuttingDown) return true;
+    }
+    const controller = source[kState].controller;
+    if (source[kState].state === "readable" && isReadableStreamDefaultController(controller) && controller[kState].queue.length > 0) {
+      while (controller[kState].queue.length > 0) {
+        if (shuttingDown) return true;
+        const chunk = dequeueValue(controller);
+        if (controller[kState].closeRequested && !controller[kState].queue.length) {
+          readableStreamDefaultControllerClearAlgorithms(controller);
+          readableStreamClose(source);
+        }
+        state.currentWrite = writableStreamDefaultWriterWrite(writer, chunk);
+        setPromiseHandled(state.currentWrite);
+        if (dest[kState].backpressure) {
+          break;
+        } else if (dest[kState].state !== "writable" || writableStreamCloseQueuedOrInFlight(dest)) {
+          break;
+        }
+      }
+      readableStreamDefaultControllerCallPullIfNeeded(controller);
+      if (source[kState].state === "closed") {
+        return true;
+      }
+      return false;
+    }
+    const { promise: readPromise, resolve: readResolve, reject: readReject } = Promise.withResolvers();
+    stepPromise = { resolve: readResolve, reject: readReject };
+    readableStreamDefaultReaderRead(reader, new PipeToReadRequest());
+    return readPromise;
+  }
+  async function run() {
+    while (!await step()) ;
+  }
+  if (signal !== void 0) {
+    if (signal.aborted) {
+      abortAlgorithm();
+      return promise;
+    }
+    abortListener = abortAlgorithm;
+    signal.addEventListener("abort", abortListener, { once: true });
+  }
+  setPromiseHandled(run());
+  watchErrored(source, reader[kState].close.promise, (error) => {
+    if (!preventAbort) {
+      return shutdownWithAnAction(
+        () => writableStreamAbort(dest, error),
+        true,
+        error
+      );
+    }
+    shutdown(true, error);
+  });
+  watchErrored(dest, writer[kState].close.promise, (error) => {
+    if (!preventCancel) {
+      return shutdownWithAnAction(
+        () => readableStreamCancel(source, error),
+        true,
+        error
+      );
+    }
+    shutdown(true, error);
+  });
+  watchClosed(source, reader[kState].close.promise, () => {
+    if (!preventClose) {
+      return shutdownWithAnAction(
+        () => writableStreamDefaultWriterCloseWithErrorPropagation(writer)
+      );
+    }
+    shutdown();
+  });
+  if (writableStreamCloseQueuedOrInFlight(dest) || dest[kState].state === "closed") {
+    const error = new TypeError("Destination WritableStream is closed");
+    if (!preventCancel) {
+      shutdownWithAnAction(
+        () => readableStreamCancel(source, error),
+        true,
+        error
+      );
+    } else {
+      shutdown(true, error);
+    }
+  }
+  return promise;
+}
+function readableStreamDefaultTee(stream, cloneForBranch2) {
+  const reader = new ReadableStreamDefaultReader(stream);
+  let reading = false;
+  let canceled1 = false;
+  let canceled2 = false;
+  let reason1;
+  let reason2;
+  let branch1;
+  let branch2;
+  const cancelPromise = Promise.withResolvers();
+  async function pullAlgorithm() {
+    if (reading) return;
+    reading = true;
+    const readRequest = {
+      [kChunk](value) {
+        _queueMicrotask(() => {
+          reading = false;
+          const value1 = value;
+          let value2 = value;
+          if (!canceled2 && cloneForBranch2) {
+            try {
+              value2 = structuredClone(value2);
+            } catch {
+            }
+          }
+          if (!canceled1) {
+            readableStreamDefaultControllerEnqueue(
+              branch1[kState].controller,
+              value1
+            );
+          }
+          if (!canceled2) {
+            readableStreamDefaultControllerEnqueue(
+              branch2[kState].controller,
+              value2
+            );
+          }
+        });
+      },
+      [kClose]() {
+        _queueMicrotask(() => {
+          reading = false;
+          if (!canceled1)
+            readableStreamDefaultControllerClose(branch1[kState].controller);
+          if (!canceled2)
+            readableStreamDefaultControllerClose(branch2[kState].controller);
+          if (!canceled1 || !canceled2)
+            cancelPromise.resolve(void 0);
+        });
+      },
+      [kError]() {
+        reading = false;
+      }
+    };
+    readableStreamDefaultReaderRead(reader, readRequest);
+  }
+  function cancel1Algorithm(reason) {
+    canceled1 = true;
+    reason1 = reason;
+    if (canceled2) {
+      const compositeReason = [reason1, reason2];
+      cancelPromise.resolve(readableStreamCancel(stream, compositeReason));
+    }
+    return cancelPromise.promise;
+  }
+  function cancel2Algorithm(reason) {
+    canceled2 = true;
+    reason2 = reason;
+    if (canceled1) {
+      const compositeReason = [reason1, reason2];
+      cancelPromise.resolve(readableStreamCancel(stream, compositeReason));
+    }
+    return cancelPromise.promise;
+  }
+  branch1 = createReadableStream(nonOpStart, pullAlgorithm, cancel1Algorithm);
+  branch2 = createReadableStream(nonOpStart, pullAlgorithm, cancel2Algorithm);
+  reader[kState].close.promise.then(
+    void 0,
+    (error) => {
+      readableStreamDefaultControllerError(branch1[kState].controller, error);
+      readableStreamDefaultControllerError(branch2[kState].controller, error);
+      if (!canceled1 || !canceled2)
+        cancelPromise.resolve(void 0);
+    }
+  );
+  return [branch1, branch2];
+}
+export {
+  ReadableStream,
+  ReadableStreamDefaultController,
+  ReadableStreamDefaultReader,
+  createReadableStream,
+  isReadableStream,
+  isReadableStreamDefaultController,
+  isReadableStreamDefaultReader,
+  isReadableStreamLocked,
+  readableStreamCancel,
+  readableStreamClose,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerHasBackpressure,
+  readableStreamError,
+  setupReadableStreamDefaultController
+};