@gjsify/web-streams 0.1.0

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

@@ -0,0 +1,126 @@
+import { TransformStream } from "./transform-stream.js";
+function hasStreamingSupport() {
+  try {
+    const td = new TextDecoder();
+    td.decode(new Uint8Array([195]), { stream: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+const supportsStreaming = hasStreamingSupport();
+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;
+}
+class TextDecoderStream {
+  #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");
+}
+export {
+  TextDecoderStream
+};

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

@@ -0,0 +1,46 @@
+import { TransformStream } from "./transform-stream.js";
+class TextEncoderStream {
+  #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;
+  }
+}
+export {
+  TextEncoderStream
+};

package/lib/esm/transform-stream.js

@@ -0,0 +1,336 @@
+import {
+  kState,
+  kType,
+  isBrandCheck,
+  createPromiseCallback,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  nonOpFlush,
+  nonOpCancel
+} from "./util.js";
+import {
+  createReadableStream,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerHasBackpressure
+} from "./readable-stream.js";
+import {
+  createWritableStream,
+  writableStreamDefaultControllerErrorIfNeeded
+} from "./writable-stream.js";
+const kSkipThrow = /* @__PURE__ */ Symbol("kSkipThrow");
+class TransformStream {
+  [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 !== void 0) {
+      throw new RangeError(`Invalid readableType: ${readableType}`);
+    }
+    if (writableType !== void 0) {
+      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 !== void 0) {
+      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";
+  }
+}
+class TransformStreamDefaultController {
+  [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: void 0,
+    backpressure: void 0,
+    backpressureChange: {
+      promise: void 0,
+      resolve: void 0,
+      reject: void 0
+    }
+  };
+  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 !== void 0) {
+    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: void 0
+  };
+  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 = void 0;
+  controller[kState].flushAlgorithm = void 0;
+  controller[kState].cancelAlgorithm = void 0;
+}
+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 === void 0) 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 !== void 0) {
+    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 !== void 0) {
+    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 !== void 0) {
+    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;
+}
+export {
+  TransformStream,
+  TransformStreamDefaultController,
+  isTransformStream,
+  isTransformStreamDefaultController
+};

package/lib/esm/util.js

@@ -0,0 +1,161 @@
+const kState = /* @__PURE__ */ Symbol("kState");
+const kType = /* @__PURE__ */ Symbol("kType");
+function isBrandCheck(brand) {
+  return (value) => {
+    return value != null && typeof value === "object" && value[kState] !== void 0 && value[kType] === brand;
+  };
+}
+function dequeueValue(controller) {
+  const { value, size } = controller[kState].queue.shift();
+  controller[kState].queueTotalSize = Math.max(0, controller[kState].queueTotalSize - size);
+  return value;
+}
+function resetQueue(controller) {
+  controller[kState].queue = [];
+  controller[kState].queueTotalSize = 0;
+}
+function peekQueueValue(controller) {
+  return controller[kState].queue[0].value;
+}
+function enqueueValueWithSize(controller, value, size) {
+  size = +size;
+  if (typeof size !== "number" || size < 0 || Number.isNaN(size) || size === Infinity) {
+    throw new RangeError(`Invalid size: ${size}`);
+  }
+  controller[kState].queue.push({ value, size });
+  controller[kState].queueTotalSize += size;
+}
+function extractHighWaterMark(value, defaultHWM) {
+  if (value === void 0) return defaultHWM;
+  value = +value;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+    throw new RangeError(`Invalid highWaterMark: ${value}`);
+  }
+  return value;
+}
+function extractSizeAlgorithm(size) {
+  if (size === void 0) return () => 1;
+  if (typeof size !== "function") {
+    throw new TypeError("strategy.size must be a function");
+  }
+  return size;
+}
+function cloneAsUint8Array(view) {
+  const buffer = view.buffer;
+  const byteOffset = view.byteOffset;
+  const byteLength = view.byteLength;
+  return new Uint8Array(buffer.slice(byteOffset, byteOffset + byteLength));
+}
+function ArrayBufferViewGetBuffer(view) {
+  return view.buffer;
+}
+function ArrayBufferViewGetByteLength(view) {
+  return view.byteLength;
+}
+function ArrayBufferViewGetByteOffset(view) {
+  return view.byteOffset;
+}
+function setPromiseHandled(promise) {
+  promise.then(() => {
+  }, () => {
+  });
+}
+function createPromiseCallback(name, fn, thisArg) {
+  if (typeof fn !== "function") {
+    throw new TypeError(`${name} must be a function`);
+  }
+  return async (...args) => fn.call(thisArg, ...args);
+}
+async function nonOpFlush() {
+}
+function nonOpStart() {
+}
+async function nonOpPull() {
+}
+async function nonOpCancel() {
+}
+async function nonOpWrite() {
+}
+const AsyncIteratorPrototype = Object.getPrototypeOf(
+  Object.getPrototypeOf(async function* () {
+  }).prototype
+);
+const AsyncIterator = {
+  __proto__: AsyncIteratorPrototype,
+  next: void 0,
+  return: void 0
+};
+function createAsyncFromSyncIterator(syncIteratorRecord) {
+  const syncIterable = {
+    [Symbol.iterator]: () => syncIteratorRecord.iterator
+  };
+  const asyncIterator = (async function* () {
+    return yield* syncIterable;
+  })();
+  const nextMethod = asyncIterator.next;
+  return { iterator: asyncIterator, nextMethod, done: false };
+}
+function getIterator(obj, kind = "sync", method) {
+  if (method === void 0) {
+    if (kind === "async") {
+      method = obj[Symbol.asyncIterator];
+      if (method == null) {
+        const syncMethod = obj[Symbol.iterator];
+        if (syncMethod === void 0) {
+          throw new TypeError("Object is not iterable");
+        }
+        const syncIteratorRecord = getIterator(obj, "sync", syncMethod);
+        return createAsyncFromSyncIterator(syncIteratorRecord);
+      }
+    } else {
+      method = obj[Symbol.iterator];
+    }
+  }
+  if (method === void 0) {
+    throw new TypeError("Object is not iterable");
+  }
+  const iterator = method.call(obj);
+  if (typeof iterator !== "object" || iterator === null) {
+    throw new TypeError("The iterator method must return an object");
+  }
+  const nextMethod = iterator.next;
+  return { iterator, nextMethod, done: false };
+}
+function iteratorNext(iteratorRecord, value) {
+  let result;
+  if (value === void 0) {
+    result = iteratorRecord.nextMethod.call(iteratorRecord.iterator);
+  } else {
+    result = iteratorRecord.nextMethod.call(iteratorRecord.iterator, value);
+  }
+  if (typeof result !== "object" || result === null) {
+    throw new TypeError("The iterator.next() method must return an object");
+  }
+  return result;
+}
+export {
+  ArrayBufferViewGetBuffer,
+  ArrayBufferViewGetByteLength,
+  ArrayBufferViewGetByteOffset,
+  AsyncIterator,
+  cloneAsUint8Array,
+  createAsyncFromSyncIterator,
+  createPromiseCallback,
+  dequeueValue,
+  enqueueValueWithSize,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  getIterator,
+  isBrandCheck,
+  iteratorNext,
+  kState,
+  kType,
+  nonOpCancel,
+  nonOpFlush,
+  nonOpPull,
+  nonOpStart,
+  nonOpWrite,
+  peekQueueValue,
+  resetQueue,
+  setPromiseHandled
+};