@gjsify/web-streams 0.3.12 → 0.3.14

package/lib/esm/readable-stream.js

@@ -1,1064 +1,911 @@
-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");
+import { AsyncIterator, createPromiseCallback, dequeueValue, enqueueValueWithSize, extractHighWaterMark, extractSizeAlgorithm, getIterator, isBrandCheck, iteratorNext, kState, kType, nonOpCancel, nonOpPull, nonOpStart, resetQueue, setPromiseHandled } from "./util.js";
+import { WritableStreamDefaultWriter, isWritableStream, isWritableStreamLocked, writableStreamAbort, writableStreamCloseQueuedOrInFlight, writableStreamDefaultWriterCloseWithErrorPropagation, writableStreamDefaultWriterRelease, writableStreamDefaultWriterWrite } from "./writable-stream.js";
+import { queueMicrotask } from "@gjsify/utils";
+
+//#region src/readable-stream.ts
+const kCancel = Symbol("kCancel");
+const kClose = Symbol("kClose");
+const kChunk = Symbol("kChunk");
+const kError = Symbol("kError");
+const kPull = Symbol("kPull");
+const kRelease = Symbol("kRelease");
+const kSkipThrow = Symbol("kSkipThrow");
 let releasedError;
 let releasingError;
 function lazyReadableReleasedError() {
-  if (releasedError) return releasedError;
-  releasedError = new TypeError("Reader released");
-  return releasedError;
+	if (releasedError) return releasedError;
+	releasedError = new TypeError("Reader released");
+	return releasedError;
 }
 function lazyReadableReleasingError() {
-  if (releasingError) return releasingError;
-  releasingError = new TypeError("Releasing reader");
-  return releasingError;
+	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;
+	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 { queueMicrotask 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";
-  }
-}
+	return {
+		disturbed: false,
+		reader: undefined,
+		state: "readable",
+		storedError: undefined,
+		controller: undefined,
+		closedPromise: Promise.withResolvers()
+	};
+}
+var ReadableStream = class {
+	[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 !== undefined) {
+			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 = undefined) {
+		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 === undefined) 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 !== undefined && !(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 !== undefined && !(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: undefined
+		};
+		let started = false;
+		function nextSteps() {
+			if (state.done) return Promise.resolve({
+				done: true,
+				value: undefined
+			});
+			if (reader[kState].stream === undefined) {
+				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 = undefined;
+					resolve({
+						value: chunk,
+						done: false
+					});
+				},
+				[kClose]() {
+					state.current = undefined;
+					state.done = true;
+					readableStreamReaderGenericRelease(reader);
+					resolve({
+						done: true,
+						value: undefined
+					});
+				},
+				[kError](error) {
+					state.current = undefined;
+					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 === undefined) {
+				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 !== undefined ? state.current.then(nextSteps, nextSteps) : nextSteps();
+				return state.current;
+			},
+			return(error) {
+				started = true;
+				state.current = state.current !== undefined ? 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";
+	}
+};
+var DefaultReadRequest = class {
+	[kState];
+	constructor() {
+		this[kState] = Promise.withResolvers();
+	}
+	[kChunk](value) {
+		this[kState].resolve?.({
+			value,
+			done: false
+		});
+	}
+	[kClose]() {
+		this[kState].resolve?.({
+			value: undefined,
+			done: true
+		});
+	}
+	[kError](error) {
+		this[kState].reject?.(error);
+	}
+	get promise() {
+		return this[kState].promise;
+	}
+};
+var ReadableStreamDefaultReader = class {
+	[kType] = "ReadableStreamDefaultReader";
+	[kState];
+	constructor(stream) {
+		if (!isReadableStream(stream)) throw new TypeError("Expected a ReadableStream");
+		this[kState] = {
+			readRequests: [],
+			stream: undefined,
+			close: {
+				promise: undefined,
+				resolve: undefined,
+				reject: undefined
+			}
+		};
+		setupReadableStreamDefaultReader(this, stream);
+	}
+	read() {
+		if (!isReadableStreamDefaultReader(this)) return Promise.reject(new TypeError("Invalid this"));
+		if (this[kState].stream === undefined) {
+			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 === undefined) return;
+		readableStreamDefaultReaderRelease(this);
+	}
+	get closed() {
+		if (!isReadableStreamDefaultReader(this)) return Promise.reject(new TypeError("Invalid this"));
+		return this[kState].close.promise;
+	}
+	cancel(reason = undefined) {
+		if (!isReadableStreamDefaultReader(this)) return Promise.reject(new TypeError("Invalid this"));
+		if (this[kState].stream === undefined) {
+			return Promise.reject(new TypeError("The reader is not attached to a stream"));
+		}
+		return readableStreamReaderGenericCancel(this, reason);
+	}
+	get [Symbol.toStringTag]() {
+		return "ReadableStreamDefaultReader";
+	}
+};
+var ReadableStreamDefaultController = class {
+	[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 = undefined) {
+		if (!readableStreamDefaultControllerCanCloseOrEnqueue(this)) throw new TypeError("Controller is already closed");
+		readableStreamDefaultControllerEnqueue(this, chunk);
+	}
+	error(error = undefined) {
+		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;
+	return stream[kState].reader !== undefined;
 }
 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(() => {
-  });
+	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 = [];
-  }
+	stream[kState].state = "closed";
+	stream[kState].closedPromise.resolve();
+	const { reader } = stream[kState];
+	if (reader === undefined) 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 = [];
-  }
+	stream[kState].state = "errored";
+	stream[kState].storedError = error;
+	setPromiseHandled(stream[kState].closedPromise.promise);
+	stream[kState].closedPromise.reject(error);
+	const { reader } = stream[kState];
+	if (reader === undefined) 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";
+	const { reader } = stream[kState];
+	if (reader === undefined) return false;
+	return reader[kState] !== undefined && reader[kType] === "ReadableStreamDefaultReader";
 }
 function readableStreamGetNumReadRequests(stream) {
-  return stream[kState].reader[kState].readRequests.length;
+	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);
+	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);
+	stream[kState].reader[kState].readRequests.push(readRequest);
 }
 function readableStreamReaderGenericCancel(reader, reason) {
-  const { stream } = reader[kState];
-  return readableStreamCancel(stream, 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;
-  }
+	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: undefined,
+				reject: undefined
+			};
+			break;
+		case "errored":
+			reader[kState].close = {
+				promise: Promise.reject(stream[kState].storedError),
+				resolve: undefined,
+				reject: undefined
+			};
+			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;
+	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: undefined,
+			reject: undefined
+		};
+	}
+	setPromiseHandled(reader[kState].close.promise);
+	stream[kState].controller[kRelease]();
+	stream[kState].reader = undefined;
+	reader[kState].stream = undefined;
 }
 function readableStreamDefaultReaderRelease(reader) {
-  readableStreamReaderGenericRelease(reader);
-  readableStreamDefaultReaderErrorReadRequests(reader, lazyReadableReleasingError());
+	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 = [];
+	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;
-  }
+	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 = [];
+	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);
-  }
+	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);
+	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";
+	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;
-  }
+	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);
+	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;
+	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)
-  );
+	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;
+	controller[kState].pullAlgorithm = undefined;
+	controller[kState].cancelAlgorithm = undefined;
+	controller[kState].sizeAlgorithm = undefined;
 }
 function readableStreamDefaultControllerError(controller, error) {
-  const { stream } = controller[kState];
-  if (stream[kState].state === "readable") {
-    resetQueue(controller);
-    readableStreamDefaultControllerClearAlgorithms(controller);
-    readableStreamError(stream, 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;
+	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);
+	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)
-  );
+	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
-  );
+	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;
+	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;
+	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 === undefined) {
+			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 undefined;
+		});
+	}
+	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;
+	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 !== undefined && abortListener) {
+			signal.removeEventListener("abort", abortListener);
+			abortListener = undefined;
+		}
+		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(() => undefined), true, error);
+	}
+	function watchErrored(stream, watchPromise, action) {
+		if (stream[kState].state === "errored") action(stream[kState].storedError);
+		else watchPromise.then(undefined, 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 !== undefined) {
+		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
-};
+	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(undefined);
+				});
+			},
+			[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(undefined, (error) => {
+		readableStreamDefaultControllerError(branch1[kState].controller, error);
+		readableStreamDefaultControllerError(branch2[kState].controller, error);
+		if (!canceled1 || !canceled2) cancelPromise.resolve(undefined);
+	});
+	return [branch1, branch2];
+}
+
+//#endregion
+export { ReadableStream, ReadableStreamDefaultController, ReadableStreamDefaultReader, createReadableStream, isReadableStream, isReadableStreamDefaultController, isReadableStreamDefaultReader, isReadableStreamLocked, readableStreamCancel, readableStreamClose, readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamDefaultControllerClose, readableStreamDefaultControllerEnqueue, readableStreamDefaultControllerError, readableStreamDefaultControllerGetDesiredSize, readableStreamDefaultControllerHasBackpressure, readableStreamError, setupReadableStreamDefaultController };