@gjsify/web-streams 0.3.13 → 0.3.14

package/lib/esm/register/queuing.js

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

package/lib/esm/register/readable.js

@@ -1,12 +1,16 @@
-import { ReadableStream } from "../index.js";
+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;
-  }
+	try {
+		if (typeof Ctor !== "function") return false;
+		return typeof Ctor.prototype[method] === "function";
+	} catch {
+		return false;
+	}
 }
 if (!isNativeStreamUsable(globalThis.ReadableStream, "getReader")) {
-  globalThis.ReadableStream = ReadableStream;
+	globalThis.ReadableStream = _ReadableStream;
 }
+
+//#endregion

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

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

package/lib/esm/register/transform.js

@@ -1,12 +1,16 @@
-import { TransformStream } from "../index.js";
+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;
-  }
+	try {
+		if (typeof Ctor !== "function") return false;
+		return typeof Ctor.prototype[method] === "function";
+	} catch {
+		return false;
+	}
 }
 if (!isNativeStreamUsable(globalThis.TransformStream, "readable")) {
-  globalThis.TransformStream = TransformStream;
+	globalThis.TransformStream = _TransformStream;
 }
+
+//#endregion

package/lib/esm/register/writable.js

@@ -1,12 +1,16 @@
-import { WritableStream } from "../index.js";
+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;
-  }
+	try {
+		if (typeof Ctor !== "function") return false;
+		return typeof Ctor.prototype[method] === "function";
+	} catch {
+		return false;
+	}
 }
 if (!isNativeStreamUsable(globalThis.WritableStream, "getWriter")) {
-  globalThis.WritableStream = WritableStream;
+	globalThis.WritableStream = _WritableStream;
 }
+
+//#endregion

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

@@ -1,126 +1,141 @@
 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;
-  }
+	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;
-}
-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;
-  }
+	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");
+	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
-};
+
+//#endregion
+export { TextDecoderStream };

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

@@ -1,46 +1,60 @@
 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
+
+//#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 };