@gjsify/web-streams 0.3.15 → 0.3.17

package/lib/esm/writable-stream.js

@@ -1,676 +1 @@
-import { createPromiseCallback, dequeueValue, enqueueValueWithSize, extractHighWaterMark, extractSizeAlgorithm, isBrandCheck, kState, kType, nonOpCancel, nonOpStart, nonOpWrite, peekQueueValue, resetQueue, setPromiseHandled } from "./util.js";
-
-//#region src/writable-stream.ts
-const _AbortController = typeof globalThis.AbortController === "function" ? globalThis.AbortController : class AbortControllerShim {
-	signal = {
-		aborted: false,
-		reason: undefined,
-		addEventListener() {},
-		removeEventListener() {}
-	};
-	abort(reason) {
-		this.signal.aborted = true;
-		this.signal.reason = reason;
-	}
-};
-const kAbort = Symbol("kAbort");
-const kCloseSentinel = Symbol("kCloseSentinel");
-const kError = Symbol("kError");
-const kSkipThrow = Symbol("kSkipThrow");
-var WritableStream = class {
-	[kType] = "WritableStream";
-	[kState];
-	constructor(sink = {}, strategy = {}) {
-		if (sink != null && typeof sink !== "object") {
-			throw new TypeError("sink must be an object");
-		}
-		if (strategy != null && typeof strategy !== "object") {
-			throw new TypeError("strategy must be an object");
-		}
-		const type = sink?.type;
-		if (type !== undefined) {
-			throw new RangeError(`Invalid type: ${type}`);
-		}
-		this[kState] = createWritableStreamState();
-		const size = extractSizeAlgorithm(strategy?.size);
-		const highWaterMark = extractHighWaterMark(strategy?.highWaterMark, 1);
-		setupWritableStreamDefaultControllerFromSink(this, sink, highWaterMark, size);
-	}
-	get locked() {
-		if (!isWritableStream(this)) throw new TypeError("Invalid this");
-		return isWritableStreamLocked(this);
-	}
-	abort(reason) {
-		if (!isWritableStream(this)) return Promise.reject(new TypeError("Invalid this"));
-		if (isWritableStreamLocked(this)) {
-			return Promise.reject(new TypeError("WritableStream is locked"));
-		}
-		return writableStreamAbort(this, reason);
-	}
-	close() {
-		if (!isWritableStream(this)) return Promise.reject(new TypeError("Invalid this"));
-		if (isWritableStreamLocked(this)) {
-			return Promise.reject(new TypeError("WritableStream is locked"));
-		}
-		if (writableStreamCloseQueuedOrInFlight(this)) {
-			return Promise.reject(new TypeError("Failure closing WritableStream"));
-		}
-		return writableStreamClose(this);
-	}
-	getWriter() {
-		if (!isWritableStream(this)) throw new TypeError("Invalid this");
-		return new WritableStreamDefaultWriter(this);
-	}
-	get [Symbol.toStringTag]() {
-		return "WritableStream";
-	}
-};
-var WritableStreamDefaultWriter = class {
-	[kType] = "WritableStreamDefaultWriter";
-	[kState];
-	constructor(stream) {
-		if (!isWritableStream(stream)) {
-			throw new TypeError("Expected a WritableStream");
-		}
-		this[kState] = {
-			stream: undefined,
-			close: {
-				promise: undefined,
-				resolve: undefined,
-				reject: undefined
-			},
-			ready: {
-				promise: undefined,
-				resolve: undefined,
-				reject: undefined
-			}
-		};
-		setupWritableStreamDefaultWriter(this, stream);
-	}
-	get closed() {
-		if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
-		return this[kState].close.promise;
-	}
-	get desiredSize() {
-		if (!isWritableStreamDefaultWriter(this)) throw new TypeError("Invalid this");
-		if (this[kState].stream === undefined) {
-			throw new TypeError("Writer is not bound to a WritableStream");
-		}
-		return writableStreamDefaultWriterGetDesiredSize(this);
-	}
-	get ready() {
-		if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
-		return this[kState].ready.promise;
-	}
-	abort(reason) {
-		if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
-		if (this[kState].stream === undefined) {
-			return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
-		}
-		return writableStreamDefaultWriterAbort(this, reason);
-	}
-	close() {
-		if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
-		const { stream } = this[kState];
-		if (stream === undefined) {
-			return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
-		}
-		if (writableStreamCloseQueuedOrInFlight(stream)) {
-			return Promise.reject(new TypeError("Failure to close WritableStream"));
-		}
-		return writableStreamDefaultWriterClose(this);
-	}
-	releaseLock() {
-		if (!isWritableStreamDefaultWriter(this)) throw new TypeError("Invalid this");
-		const { stream } = this[kState];
-		if (stream === undefined) return;
-		writableStreamDefaultWriterRelease(this);
-	}
-	write(chunk) {
-		if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
-		if (this[kState].stream === undefined) {
-			return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
-		}
-		return writableStreamDefaultWriterWrite(this, chunk);
-	}
-	get [Symbol.toStringTag]() {
-		return "WritableStreamDefaultWriter";
-	}
-};
-var WritableStreamDefaultController = class {
-	[kType] = "WritableStreamDefaultController";
-	[kState];
-	constructor(skipThrowSymbol) {
-		if (skipThrowSymbol !== kSkipThrow) {
-			throw new TypeError("Illegal constructor");
-		}
-	}
-	[kAbort](reason) {
-		const result = this[kState].abortAlgorithm(reason);
-		writableStreamDefaultControllerClearAlgorithms(this);
-		return result;
-	}
-	[kError]() {
-		resetQueue(this);
-	}
-	get signal() {
-		if (!isWritableStreamDefaultController(this)) throw new TypeError("Invalid this");
-		return this[kState].abortController.signal;
-	}
-	error(error) {
-		if (!isWritableStreamDefaultController(this)) throw new TypeError("Invalid this");
-		if (this[kState].stream[kState].state !== "writable") return;
-		writableStreamDefaultControllerError(this, error);
-	}
-	get [Symbol.toStringTag]() {
-		return "WritableStreamDefaultController";
-	}
-};
-const isWritableStream = isBrandCheck("WritableStream");
-const isWritableStreamDefaultWriter = isBrandCheck("WritableStreamDefaultWriter");
-const isWritableStreamDefaultController = isBrandCheck("WritableStreamDefaultController");
-function createEmptyPromiseRecord() {
-	return {
-		promise: undefined,
-		resolve: undefined,
-		reject: undefined
-	};
-}
-function createWritableStreamState() {
-	return {
-		close: Promise.withResolvers(),
-		closeRequest: createEmptyPromiseRecord(),
-		inFlightWriteRequest: createEmptyPromiseRecord(),
-		inFlightCloseRequest: createEmptyPromiseRecord(),
-		pendingAbortRequest: {
-			abort: createEmptyPromiseRecord(),
-			reason: undefined,
-			wasAlreadyErroring: false
-		},
-		backpressure: false,
-		controller: undefined,
-		state: "writable",
-		storedError: undefined,
-		writeRequests: [],
-		writer: undefined
-	};
-}
-function isWritableStreamLocked(stream) {
-	return stream[kState].writer !== undefined;
-}
-function setupWritableStreamDefaultWriter(writer, stream) {
-	if (isWritableStreamLocked(stream)) {
-		throw new TypeError("WritableStream is locked");
-	}
-	writer[kState].stream = stream;
-	stream[kState].writer = writer;
-	switch (stream[kState].state) {
-		case "writable":
-			if (!writableStreamCloseQueuedOrInFlight(stream) && stream[kState].backpressure) {
-				writer[kState].ready = Promise.withResolvers();
-			} else {
-				writer[kState].ready = {
-					promise: Promise.resolve(),
-					resolve: undefined,
-					reject: undefined
-				};
-			}
-			writer[kState].close = Promise.withResolvers();
-			break;
-		case "erroring":
-			writer[kState].ready = {
-				promise: Promise.reject(stream[kState].storedError),
-				resolve: undefined,
-				reject: undefined
-			};
-			setPromiseHandled(writer[kState].ready.promise);
-			writer[kState].close = Promise.withResolvers();
-			break;
-		case "closed":
-			writer[kState].ready = {
-				promise: Promise.resolve(),
-				resolve: undefined,
-				reject: undefined
-			};
-			writer[kState].close = {
-				promise: Promise.resolve(),
-				resolve: undefined,
-				reject: undefined
-			};
-			break;
-		default:
-			writer[kState].ready = {
-				promise: Promise.reject(stream[kState].storedError),
-				resolve: undefined,
-				reject: undefined
-			};
-			writer[kState].close = {
-				promise: Promise.reject(stream[kState].storedError),
-				resolve: undefined,
-				reject: undefined
-			};
-			setPromiseHandled(writer[kState].ready.promise);
-			setPromiseHandled(writer[kState].close.promise);
-	}
-}
-function writableStreamAbort(stream, reason) {
-	const { state, controller } = stream[kState];
-	if (state === "closed" || state === "errored") return Promise.resolve();
-	controller[kState].abortController.abort(reason);
-	if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
-		return stream[kState].pendingAbortRequest.abort.promise;
-	}
-	let wasAlreadyErroring = false;
-	if (state === "erroring") {
-		wasAlreadyErroring = true;
-		reason = undefined;
-	}
-	const abort = Promise.withResolvers();
-	stream[kState].pendingAbortRequest = {
-		abort,
-		reason,
-		wasAlreadyErroring
-	};
-	if (!wasAlreadyErroring) writableStreamStartErroring(stream, reason);
-	return abort.promise;
-}
-function writableStreamClose(stream) {
-	const { state, writer, backpressure, controller } = stream[kState];
-	if (state === "closed" || state === "errored") {
-		return Promise.reject(new TypeError("WritableStream is closed"));
-	}
-	stream[kState].closeRequest = Promise.withResolvers();
-	const { promise } = stream[kState].closeRequest;
-	if (writer !== undefined && backpressure && state === "writable") {
-		writer[kState].ready.resolve?.();
-	}
-	writableStreamDefaultControllerClose(controller);
-	return promise;
-}
-function writableStreamUpdateBackpressure(stream, backpressure) {
-	const { writer } = stream[kState];
-	if (writer !== undefined && stream[kState].backpressure !== backpressure) {
-		if (backpressure) {
-			writer[kState].ready = Promise.withResolvers();
-		} else {
-			writer[kState].ready.resolve?.();
-		}
-	}
-	stream[kState].backpressure = backpressure;
-}
-function writableStreamStartErroring(stream, reason) {
-	const { controller, writer } = stream[kState];
-	stream[kState].state = "erroring";
-	stream[kState].storedError = reason;
-	if (writer !== undefined) {
-		writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
-	}
-	if (!writableStreamHasOperationMarkedInFlight(stream) && controller[kState].started) {
-		writableStreamFinishErroring(stream);
-	}
-}
-function writableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
-	if (stream[kState].closeRequest.promise !== undefined) {
-		stream[kState].closeRequest.reject?.(stream[kState].storedError);
-		stream[kState].closeRequest = {
-			promise: undefined,
-			resolve: undefined,
-			reject: undefined
-		};
-	}
-	setPromiseHandled(stream[kState].close.promise);
-	stream[kState].close.reject?.(stream[kState].storedError);
-	const { writer } = stream[kState];
-	if (writer !== undefined) {
-		setPromiseHandled(writer[kState].close.promise);
-		writer[kState].close.reject?.(stream[kState].storedError);
-	}
-}
-function writableStreamMarkFirstWriteRequestInFlight(stream) {
-	const writeRequest = stream[kState].writeRequests.shift();
-	stream[kState].inFlightWriteRequest = writeRequest;
-}
-function writableStreamMarkCloseRequestInFlight(stream) {
-	stream[kState].inFlightCloseRequest = stream[kState].closeRequest;
-	stream[kState].closeRequest = {
-		promise: undefined,
-		resolve: undefined,
-		reject: undefined
-	};
-}
-function writableStreamHasOperationMarkedInFlight(stream) {
-	return stream[kState].inFlightWriteRequest.promise !== undefined || stream[kState].inFlightCloseRequest.promise !== undefined;
-}
-function writableStreamFinishInFlightWriteWithError(stream, error) {
-	stream[kState].inFlightWriteRequest.reject?.(error);
-	stream[kState].inFlightWriteRequest = {
-		promise: undefined,
-		resolve: undefined,
-		reject: undefined
-	};
-	writableStreamDealWithRejection(stream, error);
-}
-function writableStreamFinishInFlightWrite(stream) {
-	stream[kState].inFlightWriteRequest.resolve?.();
-	stream[kState].inFlightWriteRequest = {
-		promise: undefined,
-		resolve: undefined,
-		reject: undefined
-	};
-}
-function writableStreamFinishInFlightCloseWithError(stream, error) {
-	stream[kState].inFlightCloseRequest.reject?.(error);
-	stream[kState].inFlightCloseRequest = {
-		promise: undefined,
-		resolve: undefined,
-		reject: undefined
-	};
-	if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
-		stream[kState].pendingAbortRequest.abort.reject?.(error);
-		stream[kState].pendingAbortRequest = {
-			abort: {
-				promise: undefined,
-				resolve: undefined,
-				reject: undefined
-			},
-			reason: undefined,
-			wasAlreadyErroring: false
-		};
-	}
-	writableStreamDealWithRejection(stream, error);
-}
-function writableStreamFinishInFlightClose(stream) {
-	stream[kState].inFlightCloseRequest.resolve?.();
-	stream[kState].inFlightCloseRequest = {
-		promise: undefined,
-		resolve: undefined,
-		reject: undefined
-	};
-	if (stream[kState].state === "erroring") {
-		stream[kState].storedError = undefined;
-		if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
-			stream[kState].pendingAbortRequest.abort.resolve?.();
-			stream[kState].pendingAbortRequest = {
-				abort: {
-					promise: undefined,
-					resolve: undefined,
-					reject: undefined
-				},
-				reason: undefined,
-				wasAlreadyErroring: false
-			};
-		}
-	}
-	stream[kState].state = "closed";
-	if (stream[kState].writer !== undefined) {
-		stream[kState].writer[kState].close.resolve?.();
-	}
-	stream[kState].close.resolve?.();
-}
-function writableStreamFinishErroring(stream) {
-	stream[kState].state = "errored";
-	stream[kState].controller[kError]();
-	const storedError = stream[kState].storedError;
-	for (const req of stream[kState].writeRequests) {
-		req.reject?.(storedError);
-	}
-	stream[kState].writeRequests = [];
-	if (stream[kState].pendingAbortRequest.abort.promise === undefined) {
-		writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-		return;
-	}
-	const abortRequest = stream[kState].pendingAbortRequest;
-	stream[kState].pendingAbortRequest = {
-		abort: {
-			promise: undefined,
-			resolve: undefined,
-			reject: undefined
-		},
-		reason: undefined,
-		wasAlreadyErroring: false
-	};
-	if (abortRequest.wasAlreadyErroring) {
-		abortRequest.abort.reject?.(storedError);
-		writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-		return;
-	}
-	stream[kState].controller[kAbort](abortRequest.reason).then(() => {
-		abortRequest.abort.resolve?.();
-		writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-	}, (error) => {
-		abortRequest.abort.reject?.(error);
-		writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-	});
-}
-function writableStreamDealWithRejection(stream, error) {
-	if (stream[kState].state === "writable") {
-		writableStreamStartErroring(stream, error);
-		return;
-	}
-	writableStreamFinishErroring(stream);
-}
-function writableStreamCloseQueuedOrInFlight(stream) {
-	return stream[kState].closeRequest.promise !== undefined || stream[kState].inFlightCloseRequest.promise !== undefined;
-}
-function writableStreamAddWriteRequest(stream) {
-	const { promise, resolve, reject } = Promise.withResolvers();
-	stream[kState].writeRequests.push({
-		promise,
-		resolve,
-		reject
-	});
-	return promise;
-}
-function writableStreamDefaultWriterWrite(writer, chunk) {
-	const { stream } = writer[kState];
-	const { controller } = stream[kState];
-	const chunkSize = writableStreamDefaultControllerGetChunkSize(controller, chunk);
-	if (stream !== writer[kState].stream) {
-		return Promise.reject(new TypeError("Mismatched WritableStreams"));
-	}
-	const { state } = stream[kState];
-	if (state === "errored") return Promise.reject(stream[kState].storedError);
-	if (writableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
-		return Promise.reject(new TypeError("WritableStream is closed"));
-	}
-	if (state === "erroring") return Promise.reject(stream[kState].storedError);
-	const promise = writableStreamAddWriteRequest(stream);
-	writableStreamDefaultControllerWrite(controller, chunk, chunkSize);
-	return promise;
-}
-function writableStreamDefaultWriterRelease(writer) {
-	const { stream } = writer[kState];
-	const releasedError = new TypeError("Writer has been released");
-	writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
-	writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
-	stream[kState].writer = undefined;
-	writer[kState].stream = undefined;
-}
-function writableStreamDefaultWriterGetDesiredSize(writer) {
-	const { stream } = writer[kState];
-	switch (stream[kState].state) {
-		case "errored":
-		case "erroring": return null;
-		case "closed": return 0;
-	}
-	return writableStreamDefaultControllerGetDesiredSize(stream[kState].controller);
-}
-function writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
-	if (writer[kState].ready.reject) {
-		writer[kState].ready.reject(error);
-		writer[kState].ready.resolve = undefined;
-		writer[kState].ready.reject = undefined;
-	} else {
-		writer[kState].ready = {
-			promise: Promise.reject(error),
-			resolve: undefined,
-			reject: undefined
-		};
-	}
-	setPromiseHandled(writer[kState].ready.promise);
-}
-function writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
-	if (writer[kState].close.reject) {
-		writer[kState].close.reject(error);
-		writer[kState].close.resolve = undefined;
-		writer[kState].close.reject = undefined;
-	} else {
-		writer[kState].close = {
-			promise: Promise.reject(error),
-			resolve: undefined,
-			reject: undefined
-		};
-	}
-	setPromiseHandled(writer[kState].close.promise);
-}
-function writableStreamDefaultWriterCloseWithErrorPropagation(writer) {
-	const { stream } = writer[kState];
-	const { state } = stream[kState];
-	if (writableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
-		return Promise.resolve();
-	}
-	if (state === "errored") return Promise.reject(stream[kState].storedError);
-	return writableStreamDefaultWriterClose(writer);
-}
-function writableStreamDefaultWriterClose(writer) {
-	return writableStreamClose(writer[kState].stream);
-}
-function writableStreamDefaultWriterAbort(writer, reason) {
-	return writableStreamAbort(writer[kState].stream, reason);
-}
-function writableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
-	try {
-		enqueueValueWithSize(controller, chunk, chunkSize);
-	} catch (error) {
-		writableStreamDefaultControllerErrorIfNeeded(controller, error);
-		return;
-	}
-	const { stream } = controller[kState];
-	if (!writableStreamCloseQueuedOrInFlight(stream) && stream[kState].state === "writable") {
-		writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
-	}
-	writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-}
-function writableStreamDefaultControllerProcessWrite(controller, chunk) {
-	const { stream, writeAlgorithm } = controller[kState];
-	writableStreamMarkFirstWriteRequestInFlight(stream);
-	writeAlgorithm(chunk, controller).then(() => {
-		writableStreamFinishInFlightWrite(stream);
-		const { state } = stream[kState];
-		dequeueValue(controller);
-		if (!writableStreamCloseQueuedOrInFlight(stream) && state === "writable") {
-			writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
-		}
-		writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-	}, (error) => {
-		if (stream[kState].state === "writable") {
-			writableStreamDefaultControllerClearAlgorithms(controller);
-		}
-		writableStreamFinishInFlightWriteWithError(stream, error);
-	});
-}
-function writableStreamDefaultControllerProcessClose(controller) {
-	const { closeAlgorithm, queue, stream } = controller[kState];
-	writableStreamMarkCloseRequestInFlight(stream);
-	dequeueValue(controller);
-	const sinkClosePromise = closeAlgorithm();
-	writableStreamDefaultControllerClearAlgorithms(controller);
-	sinkClosePromise.then(() => writableStreamFinishInFlightClose(stream), (error) => writableStreamFinishInFlightCloseWithError(stream, error));
-}
-function writableStreamDefaultControllerGetDesiredSize(controller) {
-	return controller[kState].highWaterMark - controller[kState].queueTotalSize;
-}
-function writableStreamDefaultControllerGetChunkSize(controller, chunk) {
-	const { stream, sizeAlgorithm } = controller[kState];
-	if (sizeAlgorithm === undefined) return 1;
-	try {
-		return sizeAlgorithm(chunk);
-	} catch (error) {
-		writableStreamDefaultControllerErrorIfNeeded(controller, error);
-		return 1;
-	}
-}
-function writableStreamDefaultControllerErrorIfNeeded(controller, error) {
-	if (controller[kState].stream[kState].state === "writable") {
-		writableStreamDefaultControllerError(controller, error);
-	}
-}
-function writableStreamDefaultControllerError(controller, error) {
-	writableStreamDefaultControllerClearAlgorithms(controller);
-	writableStreamStartErroring(controller[kState].stream, error);
-}
-function writableStreamDefaultControllerClose(controller) {
-	enqueueValueWithSize(controller, kCloseSentinel, 0);
-	writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-}
-function writableStreamDefaultControllerClearAlgorithms(controller) {
-	controller[kState].writeAlgorithm = undefined;
-	controller[kState].closeAlgorithm = undefined;
-	controller[kState].abortAlgorithm = undefined;
-	controller[kState].sizeAlgorithm = undefined;
-}
-function writableStreamDefaultControllerGetBackpressure(controller) {
-	return writableStreamDefaultControllerGetDesiredSize(controller) <= 0;
-}
-function writableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
-	const { queue, started, stream } = controller[kState];
-	if (!started || stream[kState].inFlightWriteRequest.promise !== undefined) return;
-	if (stream[kState].state === "erroring") {
-		writableStreamFinishErroring(stream);
-		return;
-	}
-	if (!queue.length) return;
-	const value = peekQueueValue(controller);
-	if (value === kCloseSentinel) {
-		writableStreamDefaultControllerProcessClose(controller);
-	} else {
-		writableStreamDefaultControllerProcessWrite(controller, value);
-	}
-}
-function setupWritableStreamDefaultControllerFromSink(stream, sink, highWaterMark, sizeAlgorithm) {
-	const controller = new WritableStreamDefaultController(kSkipThrow);
-	const start = sink?.start;
-	const write = sink?.write;
-	const close = sink?.close;
-	const abort = sink?.abort;
-	const startAlgorithm = start ? start.bind(sink, controller) : nonOpStart;
-	const writeAlgorithm = write ? createPromiseCallback("sink.write", write, sink) : nonOpWrite;
-	const closeAlgorithm = close ? createPromiseCallback("sink.close", close, sink) : nonOpCancel;
-	const abortAlgorithm = abort ? createPromiseCallback("sink.abort", abort, sink) : nonOpCancel;
-	setupWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
-}
-function setupWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
-	controller[kState] = {
-		abortAlgorithm,
-		closeAlgorithm,
-		highWaterMark,
-		queue: [],
-		queueTotalSize: 0,
-		abortController: new _AbortController(),
-		sizeAlgorithm,
-		started: false,
-		stream,
-		writeAlgorithm
-	};
-	stream[kState].controller = controller;
-	writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
-	const startResult = startAlgorithm();
-	new Promise((r) => r(startResult)).then(() => {
-		controller[kState].started = true;
-		writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-	}, (error) => {
-		controller[kState].started = true;
-		writableStreamDealWithRejection(stream, error);
-	});
-}
-function createWritableStream(start, write, close, abort, highWaterMark = 1, size = () => 1) {
-	const stream = Object.create(WritableStream.prototype);
-	stream[kType] = "WritableStream";
-	stream[kState] = createWritableStreamState();
-	const controller = new WritableStreamDefaultController(kSkipThrow);
-	setupWritableStreamDefaultController(stream, controller, start, write, close, abort, highWaterMark, size);
-	return stream;
-}
-
-//#endregion
-export { WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter, createWritableStream, isWritableStream, isWritableStreamDefaultController, isWritableStreamDefaultWriter, isWritableStreamLocked, writableStreamAbort, writableStreamClose, writableStreamCloseQueuedOrInFlight, writableStreamDefaultControllerErrorIfNeeded, writableStreamDefaultWriterCloseWithErrorPropagation, writableStreamDefaultWriterRelease, writableStreamDefaultWriterWrite };
+import{createPromiseCallback as e,dequeueValue as t,enqueueValueWithSize as n,extractHighWaterMark as r,extractSizeAlgorithm as i,isBrandCheck as a,kState as o,kType as s,nonOpCancel as c,nonOpStart as l,nonOpWrite as ee,peekQueueValue as u,resetQueue as d,setPromiseHandled as f}from"./util.js";const te=typeof globalThis.AbortController==`function`?globalThis.AbortController:class{signal={aborted:!1,reason:void 0,addEventListener(){},removeEventListener(){}};abort(e){this.signal.aborted=!0,this.signal.reason=e}},p=Symbol(`kAbort`),m=Symbol(`kCloseSentinel`),h=Symbol(`kError`),g=Symbol(`kSkipThrow`);var _=class{[s]=`WritableStream`;[o];constructor(e={},t={}){if(e!=null&&typeof e!=`object`)throw TypeError(`sink must be an object`);if(t!=null&&typeof t!=`object`)throw TypeError(`strategy must be an object`);let n=e?.type;if(n!==void 0)throw RangeError(`Invalid type: ${n}`);this[o]=w();let a=i(t?.size),s=r(t?.highWaterMark,1);de(this,e,s,a)}get locked(){if(!b(this))throw TypeError(`Invalid this`);return T(this)}abort(e){return b(this)?T(this)?Promise.reject(TypeError(`WritableStream is locked`)):E(this,e):Promise.reject(TypeError(`Invalid this`))}close(){return b(this)?T(this)?Promise.reject(TypeError(`WritableStream is locked`)):I(this)?Promise.reject(TypeError(`Failure closing WritableStream`)):D(this):Promise.reject(TypeError(`Invalid this`))}getWriter(){if(!b(this))throw TypeError(`Invalid this`);return new v(this)}get[Symbol.toStringTag](){return`WritableStream`}},v=class{[s]=`WritableStreamDefaultWriter`;[o];constructor(e){if(!b(e))throw TypeError(`Expected a WritableStream`);this[o]={stream:void 0,close:{promise:void 0,resolve:void 0,reject:void 0},ready:{promise:void 0,resolve:void 0,reject:void 0}},ne(this,e)}get closed(){return x(this)?this[o].close.promise:Promise.reject(TypeError(`Invalid this`))}get desiredSize(){if(!x(this))throw TypeError(`Invalid this`);if(this[o].stream===void 0)throw TypeError(`Writer is not bound to a WritableStream`);return z(this)}get ready(){return x(this)?this[o].ready.promise:Promise.reject(TypeError(`Invalid this`))}abort(e){return x(this)?this[o].stream===void 0?Promise.reject(TypeError(`Writer is not bound to a WritableStream`)):W(this,e):Promise.reject(TypeError(`Invalid this`))}close(){if(!x(this))return Promise.reject(TypeError(`Invalid this`));let{stream:e}=this[o];return e===void 0?Promise.reject(TypeError(`Writer is not bound to a WritableStream`)):I(e)?Promise.reject(TypeError(`Failure to close WritableStream`)):U(this)}releaseLock(){if(!x(this))throw TypeError(`Invalid this`);let{stream:e}=this[o];e!==void 0&&R(this)}write(e){return x(this)?this[o].stream===void 0?Promise.reject(TypeError(`Writer is not bound to a WritableStream`)):L(this,e):Promise.reject(TypeError(`Invalid this`))}get[Symbol.toStringTag](){return`WritableStreamDefaultWriter`}},y=class{[s]=`WritableStreamDefaultController`;[o];constructor(e){if(e!==g)throw TypeError(`Illegal constructor`)}[p](e){let t=this[o].abortAlgorithm(e);return X(this),t}[h](){d(this)}get signal(){if(!S(this))throw TypeError(`Invalid this`);return this[o].abortController.signal}error(e){if(!S(this))throw TypeError(`Invalid this`);this[o].stream[o].state===`writable`&&J(this,e)}get[Symbol.toStringTag](){return`WritableStreamDefaultController`}};const b=a(`WritableStream`),x=a(`WritableStreamDefaultWriter`),S=a(`WritableStreamDefaultController`);function C(){return{promise:void 0,resolve:void 0,reject:void 0}}function w(){return{close:Promise.withResolvers(),closeRequest:C(),inFlightWriteRequest:C(),inFlightCloseRequest:C(),pendingAbortRequest:{abort:C(),reason:void 0,wasAlreadyErroring:!1},backpressure:!1,controller:void 0,state:`writable`,storedError:void 0,writeRequests:[],writer:void 0}}function T(e){return e[o].writer!==void 0}function ne(e,t){if(T(t))throw TypeError(`WritableStream is locked`);switch(e[o].stream=t,t[o].writer=e,t[o].state){case`writable`:!I(t)&&t[o].backpressure?e[o].ready=Promise.withResolvers():e[o].ready={promise:Promise.resolve(),resolve:void 0,reject:void 0},e[o].close=Promise.withResolvers();break;case`erroring`:e[o].ready={promise:Promise.reject(t[o].storedError),resolve:void 0,reject:void 0},f(e[o].ready.promise),e[o].close=Promise.withResolvers();break;case`closed`:e[o].ready={promise:Promise.resolve(),resolve:void 0,reject:void 0},e[o].close={promise:Promise.resolve(),resolve:void 0,reject:void 0};break;default:e[o].ready={promise:Promise.reject(t[o].storedError),resolve:void 0,reject:void 0},e[o].close={promise:Promise.reject(t[o].storedError),resolve:void 0,reject:void 0},f(e[o].ready.promise),f(e[o].close.promise)}}function E(e,t){let{state:n,controller:r}=e[o];if(n===`closed`||n===`errored`)return Promise.resolve();if(r[o].abortController.abort(t),e[o].pendingAbortRequest.abort.promise!==void 0)return e[o].pendingAbortRequest.abort.promise;let i=!1;n===`erroring`&&(i=!0,t=void 0);let a=Promise.withResolvers();return e[o].pendingAbortRequest={abort:a,reason:t,wasAlreadyErroring:i},i||k(e,t),a.promise}function D(e){let{state:t,writer:n,backpressure:r,controller:i}=e[o];if(t===`closed`||t===`errored`)return Promise.reject(TypeError(`WritableStream is closed`));e[o].closeRequest=Promise.withResolvers();let{promise:a}=e[o].closeRequest;return n!==void 0&&r&&t===`writable`&&n[o].ready.resolve?.(),Y(i),a}function O(e,t){let{writer:n}=e[o];n!==void 0&&e[o].backpressure!==t&&(t?n[o].ready=Promise.withResolvers():n[o].ready.resolve?.()),e[o].backpressure=t}function k(e,t){let{controller:n,writer:r}=e[o];e[o].state=`erroring`,e[o].storedError=t,r!==void 0&&B(r,t),!ae(e)&&n[o].started&&P(e)}function A(e){e[o].closeRequest.promise!==void 0&&(e[o].closeRequest.reject?.(e[o].storedError),e[o].closeRequest={promise:void 0,resolve:void 0,reject:void 0}),f(e[o].close.promise),e[o].close.reject?.(e[o].storedError);let{writer:t}=e[o];t!==void 0&&(f(t[o].close.promise),t[o].close.reject?.(e[o].storedError))}function re(e){let t=e[o].writeRequests.shift();e[o].inFlightWriteRequest=t}function ie(e){e[o].inFlightCloseRequest=e[o].closeRequest,e[o].closeRequest={promise:void 0,resolve:void 0,reject:void 0}}function ae(e){return e[o].inFlightWriteRequest.promise!==void 0||e[o].inFlightCloseRequest.promise!==void 0}function oe(e,t){e[o].inFlightWriteRequest.reject?.(t),e[o].inFlightWriteRequest={promise:void 0,resolve:void 0,reject:void 0},F(e,t)}function j(e){e[o].inFlightWriteRequest.resolve?.(),e[o].inFlightWriteRequest={promise:void 0,resolve:void 0,reject:void 0}}function M(e,t){e[o].inFlightCloseRequest.reject?.(t),e[o].inFlightCloseRequest={promise:void 0,resolve:void 0,reject:void 0},e[o].pendingAbortRequest.abort.promise!==void 0&&(e[o].pendingAbortRequest.abort.reject?.(t),e[o].pendingAbortRequest={abort:{promise:void 0,resolve:void 0,reject:void 0},reason:void 0,wasAlreadyErroring:!1}),F(e,t)}function N(e){e[o].inFlightCloseRequest.resolve?.(),e[o].inFlightCloseRequest={promise:void 0,resolve:void 0,reject:void 0},e[o].state===`erroring`&&(e[o].storedError=void 0,e[o].pendingAbortRequest.abort.promise!==void 0&&(e[o].pendingAbortRequest.abort.resolve?.(),e[o].pendingAbortRequest={abort:{promise:void 0,resolve:void 0,reject:void 0},reason:void 0,wasAlreadyErroring:!1})),e[o].state=`closed`,e[o].writer!==void 0&&e[o].writer[o].close.resolve?.(),e[o].close.resolve?.()}function P(e){e[o].state=`errored`,e[o].controller[h]();let t=e[o].storedError;for(let n of e[o].writeRequests)n.reject?.(t);if(e[o].writeRequests=[],e[o].pendingAbortRequest.abort.promise===void 0){A(e);return}let n=e[o].pendingAbortRequest;if(e[o].pendingAbortRequest={abort:{promise:void 0,resolve:void 0,reject:void 0},reason:void 0,wasAlreadyErroring:!1},n.wasAlreadyErroring){n.abort.reject?.(t),A(e);return}e[o].controller[p](n.reason).then(()=>{n.abort.resolve?.(),A(e)},t=>{n.abort.reject?.(t),A(e)})}function F(e,t){if(e[o].state===`writable`){k(e,t);return}P(e)}function I(e){return e[o].closeRequest.promise!==void 0||e[o].inFlightCloseRequest.promise!==void 0}function se(e){let{promise:t,resolve:n,reject:r}=Promise.withResolvers();return e[o].writeRequests.push({promise:t,resolve:n,reject:r}),t}function L(e,t){let{stream:n}=e[o],{controller:r}=n[o],i=ue(r,t);if(n!==e[o].stream)return Promise.reject(TypeError(`Mismatched WritableStreams`));let{state:a}=n[o];if(a===`errored`)return Promise.reject(n[o].storedError);if(I(n)||a===`closed`)return Promise.reject(TypeError(`WritableStream is closed`));if(a===`erroring`)return Promise.reject(n[o].storedError);let s=se(n);return G(r,t,i),s}function R(e){let{stream:t}=e[o],n=TypeError(`Writer has been released`);B(e,n),V(e,n),t[o].writer=void 0,e[o].stream=void 0}function z(e){let{stream:t}=e[o];switch(t[o].state){case`errored`:case`erroring`:return null;case`closed`:return 0}return K(t[o].controller)}function B(e,t){e[o].ready.reject?(e[o].ready.reject(t),e[o].ready.resolve=void 0,e[o].ready.reject=void 0):e[o].ready={promise:Promise.reject(t),resolve:void 0,reject:void 0},f(e[o].ready.promise)}function V(e,t){e[o].close.reject?(e[o].close.reject(t),e[o].close.resolve=void 0,e[o].close.reject=void 0):e[o].close={promise:Promise.reject(t),resolve:void 0,reject:void 0},f(e[o].close.promise)}function H(e){let{stream:t}=e[o],{state:n}=t[o];return I(t)||n===`closed`?Promise.resolve():n===`errored`?Promise.reject(t[o].storedError):U(e)}function U(e){return D(e[o].stream)}function W(e,t){return E(e[o].stream,t)}function G(e,t,r){try{n(e,t,r)}catch(t){q(e,t);return}let{stream:i}=e[o];!I(i)&&i[o].state===`writable`&&O(i,Z(e)),Q(e)}function ce(e,n){let{stream:r,writeAlgorithm:i}=e[o];re(r),i(n,e).then(()=>{j(r);let{state:n}=r[o];t(e),!I(r)&&n===`writable`&&O(r,Z(e)),Q(e)},t=>{r[o].state===`writable`&&X(e),oe(r,t)})}function le(e){let{closeAlgorithm:n,queue:r,stream:i}=e[o];ie(i),t(e);let a=n();X(e),a.then(()=>N(i),e=>M(i,e))}function K(e){return e[o].highWaterMark-e[o].queueTotalSize}function ue(e,t){let{stream:n,sizeAlgorithm:r}=e[o];if(r===void 0)return 1;try{return r(t)}catch(t){return q(e,t),1}}function q(e,t){e[o].stream[o].state===`writable`&&J(e,t)}function J(e,t){X(e),k(e[o].stream,t)}function Y(e){n(e,m,0),Q(e)}function X(e){e[o].writeAlgorithm=void 0,e[o].closeAlgorithm=void 0,e[o].abortAlgorithm=void 0,e[o].sizeAlgorithm=void 0}function Z(e){return K(e)<=0}function Q(e){let{queue:t,started:n,stream:r}=e[o];if(!n||r[o].inFlightWriteRequest.promise!==void 0)return;if(r[o].state===`erroring`){P(r);return}if(!t.length)return;let i=u(e);i===m?le(e):ce(e,i)}function de(t,n,r,i){let a=new y(g),o=n?.start,s=n?.write,u=n?.close,d=n?.abort;$(t,a,o?o.bind(n,a):l,s?e(`sink.write`,s,n):ee,u?e(`sink.close`,u,n):c,d?e(`sink.abort`,d,n):c,r,i)}function $(e,t,n,r,i,a,s,c){t[o]={abortAlgorithm:a,closeAlgorithm:i,highWaterMark:s,queue:[],queueTotalSize:0,abortController:new te,sizeAlgorithm:c,started:!1,stream:e,writeAlgorithm:r},e[o].controller=t,O(e,Z(t));let l=n();new Promise(e=>e(l)).then(()=>{t[o].started=!0,Q(t)},n=>{t[o].started=!0,F(e,n)})}function fe(e,t,n,r,i=1,a=()=>1){let c=Object.create(_.prototype);return c[s]=`WritableStream`,c[o]=w(),$(c,new y(g),e,t,n,r,i,a),c}export{_ as WritableStream,y as WritableStreamDefaultController,v as WritableStreamDefaultWriter,fe as createWritableStream,b as isWritableStream,S as isWritableStreamDefaultController,x as isWritableStreamDefaultWriter,T as isWritableStreamLocked,E as writableStreamAbort,D as writableStreamClose,I as writableStreamCloseQueuedOrInFlight,q as writableStreamDefaultControllerErrorIfNeeded,H as writableStreamDefaultWriterCloseWithErrorPropagation,R as writableStreamDefaultWriterRelease,L as writableStreamDefaultWriterWrite};