@gjsify/web-streams 0.1.0

package/lib/esm/writable-stream.js

@@ -0,0 +1,676 @@
+import {
+  kState,
+  kType,
+  isBrandCheck,
+  createPromiseCallback,
+  dequeueValue,
+  enqueueValueWithSize,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  peekQueueValue,
+  resetQueue,
+  setPromiseHandled,
+  nonOpCancel,
+  nonOpStart,
+  nonOpWrite
+} from "./util.js";
+const _AbortController = typeof globalThis.AbortController === "function" ? globalThis.AbortController : class AbortControllerShim {
+  signal = { aborted: false, reason: void 0, addEventListener() {
+  }, removeEventListener() {
+  } };
+  abort(reason) {
+    this.signal.aborted = true;
+    this.signal.reason = reason;
+  }
+};
+const kAbort = /* @__PURE__ */ Symbol("kAbort");
+const kCloseSentinel = /* @__PURE__ */ Symbol("kCloseSentinel");
+const kError = /* @__PURE__ */ Symbol("kError");
+const kSkipThrow = /* @__PURE__ */ Symbol("kSkipThrow");
+class WritableStream {
+  [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 !== void 0) {
+      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";
+  }
+}
+class WritableStreamDefaultWriter {
+  [kType] = "WritableStreamDefaultWriter";
+  [kState];
+  constructor(stream) {
+    if (!isWritableStream(stream)) {
+      throw new TypeError("Expected a WritableStream");
+    }
+    this[kState] = {
+      stream: void 0,
+      close: { promise: void 0, resolve: void 0, reject: void 0 },
+      ready: { promise: void 0, resolve: void 0, reject: void 0 }
+    };
+    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 === void 0) {
+      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 === void 0) {
+      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 === void 0) {
+      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 === void 0) return;
+    writableStreamDefaultWriterRelease(this);
+  }
+  write(chunk) {
+    if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
+    if (this[kState].stream === void 0) {
+      return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
+    }
+    return writableStreamDefaultWriterWrite(this, chunk);
+  }
+  get [Symbol.toStringTag]() {
+    return "WritableStreamDefaultWriter";
+  }
+}
+class WritableStreamDefaultController {
+  [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: void 0, resolve: void 0, reject: void 0 };
+}
+function createWritableStreamState() {
+  return {
+    close: Promise.withResolvers(),
+    closeRequest: createEmptyPromiseRecord(),
+    inFlightWriteRequest: createEmptyPromiseRecord(),
+    inFlightCloseRequest: createEmptyPromiseRecord(),
+    pendingAbortRequest: {
+      abort: createEmptyPromiseRecord(),
+      reason: void 0,
+      wasAlreadyErroring: false
+    },
+    backpressure: false,
+    controller: void 0,
+    state: "writable",
+    storedError: void 0,
+    writeRequests: [],
+    writer: void 0
+  };
+}
+function isWritableStreamLocked(stream) {
+  return stream[kState].writer !== void 0;
+}
+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: void 0,
+          reject: void 0
+        };
+      }
+      writer[kState].close = Promise.withResolvers();
+      break;
+    case "erroring":
+      writer[kState].ready = {
+        promise: Promise.reject(stream[kState].storedError),
+        resolve: void 0,
+        reject: void 0
+      };
+      setPromiseHandled(writer[kState].ready.promise);
+      writer[kState].close = Promise.withResolvers();
+      break;
+    case "closed":
+      writer[kState].ready = {
+        promise: Promise.resolve(),
+        resolve: void 0,
+        reject: void 0
+      };
+      writer[kState].close = {
+        promise: Promise.resolve(),
+        resolve: void 0,
+        reject: void 0
+      };
+      break;
+    default:
+      writer[kState].ready = {
+        promise: Promise.reject(stream[kState].storedError),
+        resolve: void 0,
+        reject: void 0
+      };
+      writer[kState].close = {
+        promise: Promise.reject(stream[kState].storedError),
+        resolve: void 0,
+        reject: void 0
+      };
+      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 !== void 0) {
+    return stream[kState].pendingAbortRequest.abort.promise;
+  }
+  let wasAlreadyErroring = false;
+  if (state === "erroring") {
+    wasAlreadyErroring = true;
+    reason = void 0;
+  }
+  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 !== void 0 && backpressure && state === "writable") {
+    writer[kState].ready.resolve?.();
+  }
+  writableStreamDefaultControllerClose(controller);
+  return promise;
+}
+function writableStreamUpdateBackpressure(stream, backpressure) {
+  const { writer } = stream[kState];
+  if (writer !== void 0 && 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 !== void 0) {
+    writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
+  }
+  if (!writableStreamHasOperationMarkedInFlight(stream) && controller[kState].started) {
+    writableStreamFinishErroring(stream);
+  }
+}
+function writableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
+  if (stream[kState].closeRequest.promise !== void 0) {
+    stream[kState].closeRequest.reject?.(stream[kState].storedError);
+    stream[kState].closeRequest = { promise: void 0, resolve: void 0, reject: void 0 };
+  }
+  setPromiseHandled(stream[kState].close.promise);
+  stream[kState].close.reject?.(stream[kState].storedError);
+  const { writer } = stream[kState];
+  if (writer !== void 0) {
+    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: void 0, resolve: void 0, reject: void 0 };
+}
+function writableStreamHasOperationMarkedInFlight(stream) {
+  return stream[kState].inFlightWriteRequest.promise !== void 0 || stream[kState].inFlightCloseRequest.promise !== void 0;
+}
+function writableStreamFinishInFlightWriteWithError(stream, error) {
+  stream[kState].inFlightWriteRequest.reject?.(error);
+  stream[kState].inFlightWriteRequest = { promise: void 0, resolve: void 0, reject: void 0 };
+  writableStreamDealWithRejection(stream, error);
+}
+function writableStreamFinishInFlightWrite(stream) {
+  stream[kState].inFlightWriteRequest.resolve?.();
+  stream[kState].inFlightWriteRequest = { promise: void 0, resolve: void 0, reject: void 0 };
+}
+function writableStreamFinishInFlightCloseWithError(stream, error) {
+  stream[kState].inFlightCloseRequest.reject?.(error);
+  stream[kState].inFlightCloseRequest = { promise: void 0, resolve: void 0, reject: void 0 };
+  if (stream[kState].pendingAbortRequest.abort.promise !== void 0) {
+    stream[kState].pendingAbortRequest.abort.reject?.(error);
+    stream[kState].pendingAbortRequest = {
+      abort: { promise: void 0, resolve: void 0, reject: void 0 },
+      reason: void 0,
+      wasAlreadyErroring: false
+    };
+  }
+  writableStreamDealWithRejection(stream, error);
+}
+function writableStreamFinishInFlightClose(stream) {
+  stream[kState].inFlightCloseRequest.resolve?.();
+  stream[kState].inFlightCloseRequest = { promise: void 0, resolve: void 0, reject: void 0 };
+  if (stream[kState].state === "erroring") {
+    stream[kState].storedError = void 0;
+    if (stream[kState].pendingAbortRequest.abort.promise !== void 0) {
+      stream[kState].pendingAbortRequest.abort.resolve?.();
+      stream[kState].pendingAbortRequest = {
+        abort: { promise: void 0, resolve: void 0, reject: void 0 },
+        reason: void 0,
+        wasAlreadyErroring: false
+      };
+    }
+  }
+  stream[kState].state = "closed";
+  if (stream[kState].writer !== void 0) {
+    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 === void 0) {
+    writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+    return;
+  }
+  const abortRequest = stream[kState].pendingAbortRequest;
+  stream[kState].pendingAbortRequest = {
+    abort: { promise: void 0, resolve: void 0, reject: void 0 },
+    reason: void 0,
+    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 !== void 0 || stream[kState].inFlightCloseRequest.promise !== void 0;
+}
+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 = void 0;
+  writer[kState].stream = void 0;
+}
+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 = void 0;
+    writer[kState].ready.reject = void 0;
+  } else {
+    writer[kState].ready = {
+      promise: Promise.reject(error),
+      resolve: void 0,
+      reject: void 0
+    };
+  }
+  setPromiseHandled(writer[kState].ready.promise);
+}
+function writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
+  if (writer[kState].close.reject) {
+    writer[kState].close.reject(error);
+    writer[kState].close.resolve = void 0;
+    writer[kState].close.reject = void 0;
+  } else {
+    writer[kState].close = {
+      promise: Promise.reject(error),
+      resolve: void 0,
+      reject: void 0
+    };
+  }
+  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 === void 0) 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 = void 0;
+  controller[kState].closeAlgorithm = void 0;
+  controller[kState].abortAlgorithm = void 0;
+  controller[kState].sizeAlgorithm = void 0;
+}
+function writableStreamDefaultControllerGetBackpressure(controller) {
+  return writableStreamDefaultControllerGetDesiredSize(controller) <= 0;
+}
+function writableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
+  const { queue, started, stream } = controller[kState];
+  if (!started || stream[kState].inFlightWriteRequest.promise !== void 0) 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;
+}
+export {
+  WritableStream,
+  WritableStreamDefaultController,
+  WritableStreamDefaultWriter,
+  createWritableStream,
+  isWritableStream,
+  isWritableStreamDefaultController,
+  isWritableStreamDefaultWriter,
+  isWritableStreamLocked,
+  writableStreamAbort,
+  writableStreamClose,
+  writableStreamCloseQueuedOrInFlight,
+  writableStreamDefaultControllerErrorIfNeeded,
+  writableStreamDefaultWriterCloseWithErrorPropagation,
+  writableStreamDefaultWriterRelease,
+  writableStreamDefaultWriterWrite
+};