@gjsify/web-streams 0.3.16 → 0.3.18

package/lib/esm/register/queuing.js

@@ -1,11 +1 @@
-import { ByteLengthQueuingStrategy as _ByteLengthQueuingStrategy, CountQueuingStrategy as _CountQueuingStrategy } from "../index.js";
-
-//#region src/register/queuing.ts
-if (typeof globalThis.ByteLengthQueuingStrategy === "undefined") {
-	globalThis.ByteLengthQueuingStrategy = _ByteLengthQueuingStrategy;
-}
-if (typeof globalThis.CountQueuingStrategy === "undefined") {
-	globalThis.CountQueuingStrategy = _CountQueuingStrategy;
-}
-
-//#endregion
+import{ByteLengthQueuingStrategy as e,CountQueuingStrategy as t}from"../index.js";globalThis.ByteLengthQueuingStrategy===void 0&&(globalThis.ByteLengthQueuingStrategy=e),globalThis.CountQueuingStrategy===void 0&&(globalThis.CountQueuingStrategy=t);

package/lib/esm/register/readable.js

@@ -1,16 +1 @@
-import { ReadableStream as _ReadableStream } from "../index.js";
-
-//#region src/register/readable.ts
-function isNativeStreamUsable(Ctor, method) {
-	try {
-		if (typeof Ctor !== "function") return false;
-		return typeof Ctor.prototype[method] === "function";
-	} catch {
-		return false;
-	}
-}
-if (!isNativeStreamUsable(globalThis.ReadableStream, "getReader")) {
-	globalThis.ReadableStream = _ReadableStream;
-}
-
-//#endregion
+import{ReadableStream as e}from"../index.js";function t(e,t){try{return typeof e==`function`?typeof e.prototype[t]==`function`:!1}catch{return!1}}t(globalThis.ReadableStream,`getReader`)||(globalThis.ReadableStream=e);

package/lib/esm/register/text-streams.js

@@ -1,11 +1 @@
-import { TextDecoderStream as _TextDecoderStream, TextEncoderStream as _TextEncoderStream } from "../index.js";
-
-//#region src/register/text-streams.ts
-if (typeof globalThis.TextEncoderStream === "undefined") {
-	globalThis.TextEncoderStream = _TextEncoderStream;
-}
-if (typeof globalThis.TextDecoderStream === "undefined") {
-	globalThis.TextDecoderStream = _TextDecoderStream;
-}
-
-//#endregion
+import{TextDecoderStream as e,TextEncoderStream as t}from"../index.js";globalThis.TextEncoderStream===void 0&&(globalThis.TextEncoderStream=t),globalThis.TextDecoderStream===void 0&&(globalThis.TextDecoderStream=e);

package/lib/esm/register/transform.js

@@ -1,16 +1 @@
-import { TransformStream as _TransformStream } from "../index.js";
-
-//#region src/register/transform.ts
-function isNativeStreamUsable(Ctor, method) {
-	try {
-		if (typeof Ctor !== "function") return false;
-		return typeof Ctor.prototype[method] === "function";
-	} catch {
-		return false;
-	}
-}
-if (!isNativeStreamUsable(globalThis.TransformStream, "readable")) {
-	globalThis.TransformStream = _TransformStream;
-}
-
-//#endregion
+import{TransformStream as e}from"../index.js";function t(e,t){try{return typeof e==`function`?typeof e.prototype[t]==`function`:!1}catch{return!1}}t(globalThis.TransformStream,`readable`)||(globalThis.TransformStream=e);

package/lib/esm/register/writable.js

@@ -1,16 +1 @@
-import { WritableStream as _WritableStream } from "../index.js";
-
-//#region src/register/writable.ts
-function isNativeStreamUsable(Ctor, method) {
-	try {
-		if (typeof Ctor !== "function") return false;
-		return typeof Ctor.prototype[method] === "function";
-	} catch {
-		return false;
-	}
-}
-if (!isNativeStreamUsable(globalThis.WritableStream, "getWriter")) {
-	globalThis.WritableStream = _WritableStream;
-}
-
-//#endregion
+import{WritableStream as e}from"../index.js";function t(e,t){try{return typeof e==`function`?typeof e.prototype[t]==`function`:!1}catch{return!1}}t(globalThis.WritableStream,`getWriter`)||(globalThis.WritableStream=e);

package/lib/esm/register.js

@@ -1,5 +1 @@
-import "./register/readable.js";
-import "./register/writable.js";
-import "./register/transform.js";
-import "./register/text-streams.js";
-import "./register/queuing.js";
+import"./register/readable.js";import"./register/writable.js";import"./register/transform.js";import"./register/text-streams.js";import"./register/queuing.js";

package/lib/esm/text-decoder-stream.js

@@ -1,141 +1 @@
-import { TransformStream } from "./transform-stream.js";
-
-//#region src/text-decoder-stream.ts
-/** Check if TextDecoder supports the `stream` option */
-function hasStreamingSupport() {
-	try {
-		const td = new TextDecoder();
-		td.decode(new Uint8Array([195]), { stream: true });
-		return true;
-	} catch {
-		return false;
-	}
-}
-const supportsStreaming = hasStreamingSupport();
-/**
-* For UTF-8 without streaming TextDecoder support:
-* Determine how many bytes at the end of `buf` form an incomplete
-* multi-byte sequence. Returns 0 if the buffer ends on a complete character.
-*/
-function incompleteUtf8Tail(buf) {
-	const len = buf.length;
-	if (len === 0) return 0;
-	for (let i = 1; i <= Math.min(3, len); i++) {
-		const b = buf[len - i];
-		if ((b & 128) === 0) {
-			return 0;
-		}
-		if ((b & 192) !== 128) {
-			let expectedLen;
-			if ((b & 224) === 192) expectedLen = 2;
-			else if ((b & 240) === 224) expectedLen = 3;
-			else if ((b & 248) === 240) expectedLen = 4;
-			else return 0;
-			if (i < expectedLen) {
-				return i;
-			}
-			return 0;
-		}
-	}
-	return 0;
-}
-/**
-* TextDecoderStream decodes a stream of bytes into strings.
-*
-* Uses TextDecoder with `stream: true` when available (Node.js, browsers).
-* On GJS where `stream` option is not supported, manually buffers incomplete
-* multi-byte UTF-8 sequences across chunks.
-*/
-var TextDecoderStream = class {
-	#decoder;
-	#transform;
-	constructor(label, options) {
-		this.#decoder = new TextDecoder(label, options);
-		if (supportsStreaming) {
-			this.#transform = new TransformStream({
-				transform: (chunk, controller) => {
-					const bytes = toUint8Array(chunk);
-					const decoded = this.#decoder.decode(bytes, { stream: true });
-					if (decoded) {
-						controller.enqueue(decoded);
-					}
-				},
-				flush: (controller) => {
-					const final = this.#decoder.decode();
-					if (final) {
-						controller.enqueue(final);
-					}
-				},
-				cancel: () => {
-					this.#decoder.decode();
-				}
-			});
-		} else {
-			let pendingBytes = new Uint8Array(0);
-			this.#transform = new TransformStream({
-				transform: (chunk, controller) => {
-					const incoming = toUint8Array(chunk);
-					let combined;
-					if (pendingBytes.length > 0) {
-						combined = new Uint8Array(pendingBytes.length + incoming.length);
-						combined.set(pendingBytes, 0);
-						combined.set(incoming, pendingBytes.length);
-					} else {
-						combined = incoming;
-					}
-					const tail = incompleteUtf8Tail(combined);
-					let decodable;
-					if (tail > 0) {
-						decodable = combined.slice(0, combined.length - tail);
-						pendingBytes = combined.slice(combined.length - tail);
-					} else {
-						decodable = combined;
-						pendingBytes = new Uint8Array(0);
-					}
-					if (decodable.length > 0) {
-						const decoded = this.#decoder.decode(decodable);
-						if (decoded) {
-							controller.enqueue(decoded);
-						}
-					}
-				},
-				flush: (controller) => {
-					if (pendingBytes.length > 0) {
-						const decoded = this.#decoder.decode(pendingBytes);
-						if (decoded) {
-							controller.enqueue(decoded);
-						}
-						pendingBytes = new Uint8Array(0);
-					}
-				},
-				cancel: () => {
-					pendingBytes = new Uint8Array(0);
-				}
-			});
-		}
-	}
-	get encoding() {
-		return this.#decoder.encoding;
-	}
-	get fatal() {
-		return this.#decoder.fatal;
-	}
-	get ignoreBOM() {
-		return this.#decoder.ignoreBOM;
-	}
-	get readable() {
-		return this.#transform.readable;
-	}
-	get writable() {
-		return this.#transform.writable;
-	}
-};
-function toUint8Array(chunk) {
-	if (chunk instanceof Uint8Array) return chunk;
-	if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
-	if (ArrayBuffer.isView(chunk)) return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-	throw new TypeError("chunk must be a BufferSource");
-}
-
-//#endregion
-export { TextDecoderStream };
+import{TransformStream as e}from"./transform-stream.js";function t(){try{return new TextDecoder().decode(new Uint8Array([195]),{stream:!0}),!0}catch{return!1}}const n=t();function r(e){let t=e.length;if(t===0)return 0;for(let n=1;n<=Math.min(3,t);n++){let r=e[t-n];if(!(r&128))return 0;if((r&192)!=128){let e;if((r&224)==192)e=2;else if((r&240)==224)e=3;else if((r&248)==240)e=4;else return 0;return n<e?n:0}}return 0}var i=class{#e;#t;constructor(t,i){if(this.#e=new TextDecoder(t,i),n)this.#t=new e({transform:(e,t)=>{let n=a(e),r=this.#e.decode(n,{stream:!0});r&&t.enqueue(r)},flush:e=>{let t=this.#e.decode();t&&e.enqueue(t)},cancel:()=>{this.#e.decode()}});else{let t=new Uint8Array;this.#t=new e({transform:(e,n)=>{let i=a(e),o;t.length>0?(o=new Uint8Array(t.length+i.length),o.set(t,0),o.set(i,t.length)):o=i;let s=r(o),c;if(s>0?(c=o.slice(0,o.length-s),t=o.slice(o.length-s)):(c=o,t=new Uint8Array),c.length>0){let e=this.#e.decode(c);e&&n.enqueue(e)}},flush:e=>{if(t.length>0){let n=this.#e.decode(t);n&&e.enqueue(n),t=new Uint8Array}},cancel:()=>{t=new Uint8Array}})}}get encoding(){return this.#e.encoding}get fatal(){return this.#e.fatal}get ignoreBOM(){return this.#e.ignoreBOM}get readable(){return this.#t.readable}get writable(){return this.#t.writable}};function a(e){if(e instanceof Uint8Array)return e;if(e instanceof ArrayBuffer)return new Uint8Array(e);if(ArrayBuffer.isView(e))return new Uint8Array(e.buffer,e.byteOffset,e.byteLength);throw TypeError(`chunk must be a BufferSource`)}export{i as TextDecoderStream};

package/lib/esm/text-encoder-stream.js

@@ -1,60 +1 @@
-import { TransformStream } from "./transform-stream.js";
-
-//#region src/text-encoder-stream.ts
-/**
-* TextEncoderStream encodes a stream of strings into UTF-8 encoded bytes.
-*
-* Handles surrogate pairs split across chunks: if the last code unit of a
-* chunk is a high surrogate (0xD800–0xDBFF), it is held until the next chunk.
-* If the stream ends with a pending high surrogate, U+FFFD replacement bytes
-* are emitted.
-*/
-var TextEncoderStream = class {
-	#pendingHighSurrogate = null;
-	#encoder = new TextEncoder();
-	#transform;
-	constructor() {
-		this.#transform = new TransformStream({
-			transform: (chunk, controller) => {
-				chunk = String(chunk);
-				if (chunk === "") {
-					return;
-				}
-				if (this.#pendingHighSurrogate !== null) {
-					chunk = this.#pendingHighSurrogate + chunk;
-				}
-				const lastCodeUnit = chunk.charCodeAt(chunk.length - 1);
-				if (55296 <= lastCodeUnit && lastCodeUnit <= 56319) {
-					this.#pendingHighSurrogate = chunk.slice(-1);
-					chunk = chunk.slice(0, -1);
-				} else {
-					this.#pendingHighSurrogate = null;
-				}
-				if (chunk) {
-					controller.enqueue(this.#encoder.encode(chunk));
-				}
-			},
-			flush: (controller) => {
-				if (this.#pendingHighSurrogate !== null) {
-					controller.enqueue(new Uint8Array([
-						239,
-						191,
-						189
-					]));
-				}
-			}
-		});
-	}
-	get encoding() {
-		return "utf-8";
-	}
-	get readable() {
-		return this.#transform.readable;
-	}
-	get writable() {
-		return this.#transform.writable;
-	}
-};
-
-//#endregion
-export { TextEncoderStream };
+import{TransformStream as e}from"./transform-stream.js";var t=class{#e=null;#t=new TextEncoder;#n;constructor(){this.#n=new e({transform:(e,t)=>{if(e=String(e),e===``)return;this.#e!==null&&(e=this.#e+e);let n=e.charCodeAt(e.length-1);55296<=n&&n<=56319?(this.#e=e.slice(-1),e=e.slice(0,-1)):this.#e=null,e&&t.enqueue(this.#t.encode(e))},flush:e=>{this.#e!==null&&e.enqueue(new Uint8Array([239,191,189]))}})}get encoding(){return`utf-8`}get readable(){return this.#n.readable}get writable(){return this.#n.writable}};export{t as TextEncoderStream};

package/lib/esm/transform-stream.js

@@ -1,280 +1 @@
-import { createPromiseCallback, extractHighWaterMark, extractSizeAlgorithm, isBrandCheck, kState, kType, nonOpCancel, nonOpFlush } from "./util.js";
-import { createWritableStream, writableStreamDefaultControllerErrorIfNeeded } from "./writable-stream.js";
-import { createReadableStream, readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamDefaultControllerClose, readableStreamDefaultControllerEnqueue, readableStreamDefaultControllerError, readableStreamDefaultControllerGetDesiredSize, readableStreamDefaultControllerHasBackpressure } from "./readable-stream.js";
-
-//#region src/transform-stream.ts
-const kSkipThrow = Symbol("kSkipThrow");
-var TransformStream = class {
-	[kType] = "TransformStream";
-	[kState];
-	constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) {
-		if (transformer != null && typeof transformer !== "object") {
-			throw new TypeError("transformer must be an object");
-		}
-		if (writableStrategy != null && typeof writableStrategy !== "object") {
-			throw new TypeError("writableStrategy must be an object");
-		}
-		if (readableStrategy != null && typeof readableStrategy !== "object") {
-			throw new TypeError("readableStrategy must be an object");
-		}
-		const readableType = transformer?.readableType;
-		const writableType = transformer?.writableType;
-		const start = transformer?.start;
-		if (readableType !== undefined) {
-			throw new RangeError(`Invalid readableType: ${readableType}`);
-		}
-		if (writableType !== undefined) {
-			throw new RangeError(`Invalid writableType: ${writableType}`);
-		}
-		const readableHighWaterMark = extractHighWaterMark(readableStrategy?.highWaterMark, 0);
-		const readableSize = extractSizeAlgorithm(readableStrategy?.size);
-		const writableHighWaterMark = extractHighWaterMark(writableStrategy?.highWaterMark, 1);
-		const writableSize = extractSizeAlgorithm(writableStrategy?.size);
-		const startPromise = Promise.withResolvers();
-		initializeTransformStream(this, startPromise, writableHighWaterMark, writableSize, readableHighWaterMark, readableSize);
-		setupTransformStreamDefaultControllerFromTransformer(this, transformer);
-		if (start !== undefined) {
-			startPromise.resolve(start.call(transformer, this[kState].controller));
-		} else {
-			startPromise.resolve();
-		}
-	}
-	get readable() {
-		if (!isTransformStream(this)) throw new TypeError("Invalid this");
-		return this[kState].readable;
-	}
-	get writable() {
-		if (!isTransformStream(this)) throw new TypeError("Invalid this");
-		return this[kState].writable;
-	}
-	get [Symbol.toStringTag]() {
-		return "TransformStream";
-	}
-};
-var TransformStreamDefaultController = class {
-	[kType] = "TransformStreamDefaultController";
-	[kState];
-	constructor(skipThrowSymbol) {
-		if (skipThrowSymbol !== kSkipThrow) {
-			throw new TypeError("Illegal constructor");
-		}
-	}
-	get desiredSize() {
-		if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
-		const { stream } = this[kState];
-		const { readable } = stream[kState];
-		const readableController = readable[kState].controller;
-		return readableStreamDefaultControllerGetDesiredSize(readableController);
-	}
-	enqueue(chunk) {
-		if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
-		transformStreamDefaultControllerEnqueue(this, chunk);
-	}
-	error(reason) {
-		if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
-		transformStreamDefaultControllerError(this, reason);
-	}
-	terminate() {
-		if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
-		transformStreamDefaultControllerTerminate(this);
-	}
-	get [Symbol.toStringTag]() {
-		return "TransformStreamDefaultController";
-	}
-};
-const isTransformStream = isBrandCheck("TransformStream");
-const isTransformStreamDefaultController = isBrandCheck("TransformStreamDefaultController");
-async function defaultTransformAlgorithm(chunk, controller) {
-	transformStreamDefaultControllerEnqueue(controller, chunk);
-}
-function initializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
-	const startAlgorithm = () => startPromise.promise;
-	const writable = createWritableStream(startAlgorithm, (chunk) => transformStreamDefaultSinkWriteAlgorithm(stream, chunk), () => transformStreamDefaultSinkCloseAlgorithm(stream), (reason) => transformStreamDefaultSinkAbortAlgorithm(stream, reason), writableHighWaterMark, writableSizeAlgorithm);
-	const readable = createReadableStream(startAlgorithm, () => transformStreamDefaultSourcePullAlgorithm(stream), (reason) => transformStreamDefaultSourceCancelAlgorithm(stream, reason), readableHighWaterMark, readableSizeAlgorithm);
-	stream[kState] = {
-		readable,
-		writable,
-		controller: undefined,
-		backpressure: undefined,
-		backpressureChange: {
-			promise: undefined,
-			resolve: undefined,
-			reject: undefined
-		}
-	};
-	transformStreamSetBackpressure(stream, true);
-}
-function transformStreamError(stream, error) {
-	const { readable } = stream[kState];
-	readableStreamDefaultControllerError(readable[kState].controller, error);
-	transformStreamErrorWritableAndUnblockWrite(stream, error);
-}
-function transformStreamErrorWritableAndUnblockWrite(stream, error) {
-	const { controller, writable } = stream[kState];
-	transformStreamDefaultControllerClearAlgorithms(controller);
-	writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
-	transformStreamUnblockWrite(stream);
-}
-function transformStreamUnblockWrite(stream) {
-	if (stream[kState].backpressure) {
-		transformStreamSetBackpressure(stream, false);
-	}
-}
-function transformStreamSetBackpressure(stream, backpressure) {
-	if (stream[kState].backpressureChange.promise !== undefined) {
-		stream[kState].backpressureChange.resolve?.();
-	}
-	stream[kState].backpressureChange = Promise.withResolvers();
-	stream[kState].backpressure = backpressure;
-}
-function setupTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
-	controller[kState] = {
-		stream,
-		transformAlgorithm,
-		flushAlgorithm,
-		cancelAlgorithm,
-		finishPromise: undefined
-	};
-	stream[kState].controller = controller;
-}
-function setupTransformStreamDefaultControllerFromTransformer(stream, transformer) {
-	const controller = new TransformStreamDefaultController(kSkipThrow);
-	const transform = transformer?.transform;
-	const flush = transformer?.flush;
-	const cancel = transformer?.cancel;
-	const transformAlgorithm = transform ? createPromiseCallback("transformer.transform", transform, transformer) : defaultTransformAlgorithm;
-	const flushAlgorithm = flush ? createPromiseCallback("transformer.flush", flush, transformer) : nonOpFlush;
-	const cancelAlgorithm = cancel ? createPromiseCallback("transformer.cancel", cancel, transformer) : nonOpCancel;
-	setupTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
-}
-function transformStreamDefaultControllerClearAlgorithms(controller) {
-	controller[kState].transformAlgorithm = undefined;
-	controller[kState].flushAlgorithm = undefined;
-	controller[kState].cancelAlgorithm = undefined;
-}
-function transformStreamDefaultControllerEnqueue(controller, chunk) {
-	const { stream } = controller[kState];
-	const { readable } = stream[kState];
-	const readableController = readable[kState].controller;
-	if (!readableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
-		throw new TypeError("Unable to enqueue");
-	}
-	try {
-		readableStreamDefaultControllerEnqueue(readableController, chunk);
-	} catch (error) {
-		transformStreamErrorWritableAndUnblockWrite(stream, error);
-		throw readable[kState].storedError;
-	}
-	const backpressure = readableStreamDefaultControllerHasBackpressure(readableController);
-	if (backpressure !== stream[kState].backpressure) {
-		transformStreamSetBackpressure(stream, true);
-	}
-}
-function transformStreamDefaultControllerError(controller, error) {
-	transformStreamError(controller[kState].stream, error);
-}
-async function transformStreamDefaultControllerPerformTransform(controller, chunk) {
-	try {
-		const transformAlgorithm = controller[kState].transformAlgorithm;
-		if (transformAlgorithm === undefined) return;
-		return await transformAlgorithm(chunk, controller);
-	} catch (error) {
-		transformStreamError(controller[kState].stream, error);
-		throw error;
-	}
-}
-function transformStreamDefaultControllerTerminate(controller) {
-	const { stream } = controller[kState];
-	const { readable } = stream[kState];
-	readableStreamDefaultControllerClose(readable[kState].controller);
-	transformStreamErrorWritableAndUnblockWrite(stream, new TypeError("TransformStream has been terminated"));
-}
-function transformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
-	const { controller } = stream[kState];
-	if (stream[kState].backpressure) {
-		const backpressureChange = stream[kState].backpressureChange.promise;
-		return backpressureChange.then(() => {
-			const { writable } = stream[kState];
-			if (writable[kState].state === "erroring") {
-				throw writable[kState].storedError;
-			}
-			return transformStreamDefaultControllerPerformTransform(controller, chunk);
-		});
-	}
-	return transformStreamDefaultControllerPerformTransform(controller, chunk);
-}
-async function transformStreamDefaultSinkAbortAlgorithm(stream, reason) {
-	const { controller, readable } = stream[kState];
-	if (controller[kState].finishPromise !== undefined) {
-		return controller[kState].finishPromise;
-	}
-	const { promise, resolve, reject } = Promise.withResolvers();
-	controller[kState].finishPromise = promise;
-	const cancelPromise = controller[kState].cancelAlgorithm(reason);
-	transformStreamDefaultControllerClearAlgorithms(controller);
-	cancelPromise.then(() => {
-		if (readable[kState].state === "errored") {
-			reject(readable[kState].storedError);
-		} else {
-			readableStreamDefaultControllerError(readable[kState].controller, reason);
-			resolve();
-		}
-	}, (error) => {
-		readableStreamDefaultControllerError(readable[kState].controller, error);
-		reject(error);
-	});
-	return controller[kState].finishPromise;
-}
-function transformStreamDefaultSinkCloseAlgorithm(stream) {
-	const { readable, controller } = stream[kState];
-	if (controller[kState].finishPromise !== undefined) {
-		return controller[kState].finishPromise;
-	}
-	const { promise, resolve, reject } = Promise.withResolvers();
-	controller[kState].finishPromise = promise;
-	const flushPromise = controller[kState].flushAlgorithm(controller);
-	transformStreamDefaultControllerClearAlgorithms(controller);
-	flushPromise.then(() => {
-		if (readable[kState].state === "errored") {
-			reject(readable[kState].storedError);
-		} else {
-			readableStreamDefaultControllerClose(readable[kState].controller);
-			resolve();
-		}
-	}, (error) => {
-		readableStreamDefaultControllerError(readable[kState].controller, error);
-		reject(error);
-	});
-	return controller[kState].finishPromise;
-}
-function transformStreamDefaultSourcePullAlgorithm(stream) {
-	transformStreamSetBackpressure(stream, false);
-	return stream[kState].backpressureChange.promise;
-}
-function transformStreamDefaultSourceCancelAlgorithm(stream, reason) {
-	const { controller, writable } = stream[kState];
-	if (controller[kState].finishPromise !== undefined) {
-		return controller[kState].finishPromise;
-	}
-	const { promise, resolve, reject } = Promise.withResolvers();
-	controller[kState].finishPromise = promise;
-	const cancelPromise = controller[kState].cancelAlgorithm(reason);
-	transformStreamDefaultControllerClearAlgorithms(controller);
-	cancelPromise.then(() => {
-		if (writable[kState].state === "errored") {
-			reject(writable[kState].storedError);
-		} else {
-			writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, reason);
-			transformStreamUnblockWrite(stream);
-			resolve();
-		}
-	}, (error) => {
-		writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
-		transformStreamUnblockWrite(stream);
-		reject(error);
-	});
-	return controller[kState].finishPromise;
-}
-
-//#endregion
-export { TransformStream, TransformStreamDefaultController, isTransformStream, isTransformStreamDefaultController };
+import{createPromiseCallback as e,extractHighWaterMark as t,extractSizeAlgorithm as n,isBrandCheck as r,kState as i,kType as a,nonOpCancel as o,nonOpFlush as s}from"./util.js";import{createWritableStream as c,writableStreamDefaultControllerErrorIfNeeded as l}from"./writable-stream.js";import{createReadableStream as u,readableStreamDefaultControllerCanCloseOrEnqueue as d,readableStreamDefaultControllerClose as f,readableStreamDefaultControllerEnqueue as p,readableStreamDefaultControllerError as m,readableStreamDefaultControllerGetDesiredSize as h,readableStreamDefaultControllerHasBackpressure as g}from"./readable-stream.js";const _=Symbol(`kSkipThrow`);var v=class{[a]=`TransformStream`;[i];constructor(e={},r={},a={}){if(e!=null&&typeof e!=`object`)throw TypeError(`transformer must be an object`);if(r!=null&&typeof r!=`object`)throw TypeError(`writableStrategy must be an object`);if(a!=null&&typeof a!=`object`)throw TypeError(`readableStrategy must be an object`);let o=e?.readableType,s=e?.writableType,c=e?.start;if(o!==void 0)throw RangeError(`Invalid readableType: ${o}`);if(s!==void 0)throw RangeError(`Invalid writableType: ${s}`);let l=t(a?.highWaterMark,0),u=n(a?.size),d=t(r?.highWaterMark,1),f=n(r?.size),p=Promise.withResolvers();C(this,p,d,f,l,u),k(this,e),c===void 0?p.resolve():p.resolve(c.call(e,this[i].controller))}get readable(){if(!b(this))throw TypeError(`Invalid this`);return this[i].readable}get writable(){if(!b(this))throw TypeError(`Invalid this`);return this[i].writable}get[Symbol.toStringTag](){return`TransformStream`}},y=class{[a]=`TransformStreamDefaultController`;[i];constructor(e){if(e!==_)throw TypeError(`Illegal constructor`)}get desiredSize(){if(!x(this))throw TypeError(`Invalid this`);let{stream:e}=this[i],{readable:t}=e[i],n=t[i].controller;return h(n)}enqueue(e){if(!x(this))throw TypeError(`Invalid this`);j(this,e)}error(e){if(!x(this))throw TypeError(`Invalid this`);M(this,e)}terminate(){if(!x(this))throw TypeError(`Invalid this`);P(this)}get[Symbol.toStringTag](){return`TransformStreamDefaultController`}};const b=r(`TransformStream`),x=r(`TransformStreamDefaultController`);async function S(e,t){j(t,e)}function C(e,t,n,r,a,o){let s=()=>t.promise,l=c(s,t=>F(e,t),()=>L(e),t=>I(e,t),n,r);e[i]={readable:u(s,()=>R(e),t=>z(e,t),a,o),writable:l,controller:void 0,backpressure:void 0,backpressureChange:{promise:void 0,resolve:void 0,reject:void 0}},D(e,!0)}function w(e,t){let{readable:n}=e[i];m(n[i].controller,t),T(e,t)}function T(e,t){let{controller:n,writable:r}=e[i];A(n),l(r[i].controller,t),E(e)}function E(e){e[i].backpressure&&D(e,!1)}function D(e,t){e[i].backpressureChange.promise!==void 0&&e[i].backpressureChange.resolve?.(),e[i].backpressureChange=Promise.withResolvers(),e[i].backpressure=t}function O(e,t,n,r,a){t[i]={stream:e,transformAlgorithm:n,flushAlgorithm:r,cancelAlgorithm:a,finishPromise:void 0},e[i].controller=t}function k(t,n){let r=new y(_),i=n?.transform,a=n?.flush,c=n?.cancel;O(t,r,i?e(`transformer.transform`,i,n):S,a?e(`transformer.flush`,a,n):s,c?e(`transformer.cancel`,c,n):o)}function A(e){e[i].transformAlgorithm=void 0,e[i].flushAlgorithm=void 0,e[i].cancelAlgorithm=void 0}function j(e,t){let{stream:n}=e[i],{readable:r}=n[i],a=r[i].controller;if(!d(a))throw TypeError(`Unable to enqueue`);try{p(a,t)}catch(e){throw T(n,e),r[i].storedError}g(a)!==n[i].backpressure&&D(n,!0)}function M(e,t){w(e[i].stream,t)}async function N(e,t){try{let n=e[i].transformAlgorithm;return n===void 0?void 0:await n(t,e)}catch(t){throw w(e[i].stream,t),t}}function P(e){let{stream:t}=e[i],{readable:n}=t[i];f(n[i].controller),T(t,TypeError(`TransformStream has been terminated`))}function F(e,t){let{controller:n}=e[i];return e[i].backpressure?e[i].backpressureChange.promise.then(()=>{let{writable:r}=e[i];if(r[i].state===`erroring`)throw r[i].storedError;return N(n,t)}):N(n,t)}async function I(e,t){let{controller:n,readable:r}=e[i];if(n[i].finishPromise!==void 0)return n[i].finishPromise;let{promise:a,resolve:o,reject:s}=Promise.withResolvers();n[i].finishPromise=a;let c=n[i].cancelAlgorithm(t);return A(n),c.then(()=>{r[i].state===`errored`?s(r[i].storedError):(m(r[i].controller,t),o())},e=>{m(r[i].controller,e),s(e)}),n[i].finishPromise}function L(e){let{readable:t,controller:n}=e[i];if(n[i].finishPromise!==void 0)return n[i].finishPromise;let{promise:r,resolve:a,reject:o}=Promise.withResolvers();n[i].finishPromise=r;let s=n[i].flushAlgorithm(n);return A(n),s.then(()=>{t[i].state===`errored`?o(t[i].storedError):(f(t[i].controller),a())},e=>{m(t[i].controller,e),o(e)}),n[i].finishPromise}function R(e){return D(e,!1),e[i].backpressureChange.promise}function z(e,t){let{controller:n,writable:r}=e[i];if(n[i].finishPromise!==void 0)return n[i].finishPromise;let{promise:a,resolve:o,reject:s}=Promise.withResolvers();n[i].finishPromise=a;let c=n[i].cancelAlgorithm(t);return A(n),c.then(()=>{r[i].state===`errored`?s(r[i].storedError):(l(r[i].controller,t),E(e),o())},t=>{l(r[i].controller,t),E(e),s(t)}),n[i].finishPromise}export{v as TransformStream,y as TransformStreamDefaultController,b as isTransformStream,x as isTransformStreamDefaultController};