documonster 0.20.2 → 0.21.0

package/dist/esm/modules/stream/core/end-args.js

@@ -1,24 +0,0 @@
-/**
- * Stream common - end() argument parsing
- *
- * Extracts the optional chunk and callback from the overloaded end() signature.
- * Shared by browser Writable, Transform, and Duplex.
- */
-/**
- * Parse the overloaded `end()` arguments into a normalised form.
- *
- * Supports the three standard overload shapes:
- *   end(callback?)
- *   end(chunk, callback?)
- *   end(chunk, encoding?, callback?)
- */
-export function parseEndArgs(chunkOrCallback, encodingOrCallback, callback) {
-    const chunk = typeof chunkOrCallback === "function" ? undefined : chunkOrCallback;
-    const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : undefined;
-    const cb = typeof chunkOrCallback === "function"
-        ? chunkOrCallback
-        : typeof encodingOrCallback === "function"
-            ? encodingOrCallback
-            : callback;
-    return { chunk, encoding, cb };
-}

package/dist/esm/modules/stream/node/writable.js

@@ -1,125 +0,0 @@
-/**
- * Node.js Stream - Writable
- *
- * Extended Writable class with browser-compatible API.
- */
-import { Writable as NodeWritable } from "stream";
-import { getDefaultHighWaterMark } from "../core/utils.js";
-/**
- * Unified Writable class - wraps Node.js Writable with browser-compatible API
- *
- * Supports the same `{ stream }` option as browser version for wrapping existing streams.
- */
-export class Writable extends NodeWritable {
-    /**
-     * Duck-typing check so that native Duplex/Transform (which extend native
-     * stream.Writable, not our wrapper) pass `instanceof Writable`.
-     */
-    static [Symbol.hasInstance](instance) {
-        return instance instanceof NodeWritable;
-    }
-    constructor(options) {
-        // If wrapping an existing stream, proxy to it
-        if (options?.stream) {
-            const underlying = options.stream;
-            // Create a pass-through wrapper that proxies to the underlying stream
-            super({
-                highWaterMark: options?.highWaterMark ?? getDefaultHighWaterMark(options?.objectMode ?? false),
-                objectMode: options?.objectMode,
-                autoDestroy: options?.autoDestroy,
-                emitClose: options?.emitClose,
-                decodeStrings: options?.decodeStrings,
-                defaultEncoding: options?.defaultEncoding,
-                signal: options?.signal,
-                write(chunk, encoding, callback) {
-                    underlying.write(chunk, encoding, callback);
-                },
-                final(callback) {
-                    underlying.end(callback);
-                }
-            });
-            // Proxy events from underlying stream, but ensure we clean up listeners so
-            // the underlying stream cannot retain this wrapper longer than necessary.
-            const onUnderlyingError = (err) => {
-                this.emit("error", err);
-            };
-            const onUnderlyingClose = () => {
-                this.emit("close");
-            };
-            const cleanup = () => {
-                underlying.off("error", onUnderlyingError);
-                underlying.off("close", onUnderlyingClose);
-            };
-            underlying.on("error", onUnderlyingError);
-            underlying.on("close", onUnderlyingClose);
-            this.once("close", cleanup);
-            this.once("finish", cleanup);
-        }
-        else {
-            super({
-                highWaterMark: options?.highWaterMark ?? getDefaultHighWaterMark(options?.objectMode ?? false),
-                objectMode: options?.objectMode,
-                autoDestroy: options?.autoDestroy,
-                emitClose: options?.emitClose,
-                decodeStrings: options?.decodeStrings,
-                defaultEncoding: options?.defaultEncoding,
-                signal: options?.signal,
-                write: options?.write,
-                writev: options?.writev,
-                final: options?.final,
-                destroy: options?.destroy,
-                construct: options?.construct
-            });
-        }
-    }
-}
-// =============================================================================
-// Cross-environment stream normalization
-// =============================================================================
-/**
- * Normalize a user-provided writable into a Node.js-compatible Writable.
- *
- * This keeps Web/Node branching at the stream-module boundary.
- *
- * A Node `Writable` is accepted (and fast-pathed below) — it satisfies the
- * structural {@link WritableLike}, so the signature does not name Node's class.
- * Naming it made the browser variant's declaration require `@types/node`, and
- * the two platforms' signatures must stay identical (see
- * `excel/__tests__/type/stream-api-parity.typecheck.ts`).
- */
-export function toWritable(stream) {
-    if (stream instanceof Writable) {
-        return stream;
-    }
-    // Node.js Writable: already compatible, avoid extra wrapper allocation.
-    if (stream instanceof NodeWritable) {
-        return stream;
-    }
-    // Web WritableStream: detect by getWriter() (avoid relying on global WritableStream).
-    // Avoid `Writable.fromWeb()` — it is buggy on some runtimes (e.g. Bun).
-    // Instead, wrap manually by piping through the WritableStream's writer.
-    if (stream.getWriter) {
-        const ws = stream;
-        let writer;
-        const getWriter = () => (writer ?? (writer = ws.getWriter()));
-        return new Writable({
-            write(_chunk, _encoding, callback) {
-                getWriter()
-                    .write(_chunk)
-                    .then(() => callback(null), callback);
-            },
-            final(callback) {
-                const w = getWriter();
-                w.close().then(() => {
-                    w.releaseLock();
-                    callback(null);
-                }, (err) => {
-                    w.releaseLock();
-                    callback(err);
-                });
-            }
-        });
-    }
-    // Assume it structurally matches Node's Writable.
-    return stream;
-}

package/dist/esm/modules/stream/utils.base.js

@@ -1,126 +0,0 @@
-/**
- * Stream Utilities (shared base)
- *
- * Platform-independent helpers re-exported by both `utils.ts` (Node) and
- * `utils.browser.ts`.  The two platform files supply the concrete
- * `createReadableFromArray`, `createTransform` and `consumers` bindings.
- */
-import { isReadableStream } from "./core/type-guards.js";
-import { stringToUint8Array as _stringToUint8Array } from "../../utils/binary.js";
-// =============================================================================
-// High-Level Stream Consumers
-// =============================================================================
-export async function collect(stream) {
-    const result = [];
-    for await (const chunk of stream) {
-        result.push(chunk);
-    }
-    return result;
-}
-export function createText(deps) {
-    return async function text(stream) {
-        return deps.consumers.text(stream);
-    };
-}
-export function createJson(deps) {
-    return async function json(stream) {
-        return deps.consumers.json(stream);
-    };
-}
-export function createBytes(deps) {
-    return async function bytes(stream) {
-        return deps.consumers.buffer(stream);
-    };
-}
-// =============================================================================
-// Stream Factory Helpers
-// =============================================================================
-export function createFromString(deps) {
-    return function fromString(str) {
-        return deps.createReadableFromArray([_stringToUint8Array(str)], {
-            objectMode: false
-        });
-    };
-}
-export function createFromJSON(deps) {
-    const fromString = createFromString(deps);
-    return function fromJSON(data) {
-        return fromString(JSON.stringify(data));
-    };
-}
-export function createFromBytes(deps) {
-    return function fromBytes(data) {
-        return deps.createReadableFromArray([data], { objectMode: false });
-    };
-}
-export function createTransformHelper(deps) {
-    return function transform(fn) {
-        return deps.createTransform(fn);
-    };
-}
-export function createFilter(deps) {
-    return function filter(predicate) {
-        return deps.createTransform(async (chunk) => {
-            if (await predicate(chunk)) {
-                return chunk;
-            }
-            return undefined;
-        }, { objectMode: true });
-    };
-}
-// =============================================================================
-// ReadableStream Conversion
-// =============================================================================
-/**
- * Type guard for browser ReadableStream-like objects.
- * Re-exported from internal/type-guards for public API compatibility.
- *
- * Boundary: the reader's chunk type is erased here — callers of
- * `readableStreamToAsyncIterable` re-assert the element type via its generic.
- */
-export const isReadableStreamLike = isReadableStream;
-/**
- * Convert a browser ReadableStream to an AsyncIterable.
- * This is useful for consuming fetch response bodies in a streaming fashion.
- *
- * @example
- * ```ts
- * const response = await fetch(url);
- * for await (const chunk of readableStreamToAsyncIterable(response.body)) {
- *   // process chunk
- * }
- * ```
- */
-export async function* readableStreamToAsyncIterable(stream) {
-    const reader = stream.getReader();
-    try {
-        while (true) {
-            const result = await reader.read();
-            if (result.done) {
-                return;
-            }
-            // Only yield defined, non-null values — avoids silently dropping
-            // falsy-but-valid values like 0 or "".
-            if (result.value !== undefined && result.value !== null) {
-                yield result.value;
-            }
-        }
-    }
-    finally {
-        // Cancel the reader before releasing the lock so the underlying stream
-        // can free resources (e.g. a fetch body).  Without cancel(), the stream
-        // stays in a "disturbed but not cancelled" state per the WHATWG spec.
-        try {
-            await reader.cancel?.();
-        }
-        catch {
-            // ignore
-        }
-        try {
-            reader.releaseLock?.();
-        }
-        catch {
-            // ignore
-        }
-    }
-}

package/dist/esm/modules/stream/utils.browser.js

@@ -1,80 +0,0 @@
-/**
- * Stream Utilities (browser)
- *
- * Browser counterpart of `utils.ts`, selected automatically
- * by the `preferBrowserFilesPlugin()` mechanism.
- *
- * All factory-produced helpers are lazily initialized on first call to avoid
- * eagerly pulling in heavy stream class dependencies at import time.
- */
-import { createReadableFromArray, createTransform } from "./browser/factories.js";
-import { consumers } from "./browser/utils.js";
-import { collect, createText, createJson, createBytes, createFromString, createFromJSON, createFromBytes, createTransformHelper, createFilter, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.base.js";
-let _deps = null;
-function getDeps() {
-    if (!_deps) {
-        _deps = {
-            createReadableFromArray,
-            createTransform: createTransform,
-            consumers
-        };
-    }
-    return _deps;
-}
-export { collect, isReadableStreamLike, readableStreamToAsyncIterable };
-let _text;
-export function text(stream) {
-    if (!_text) {
-        _text = createText(getDeps());
-    }
-    return _text(stream);
-}
-let _json;
-export function json(stream) {
-    if (!_json) {
-        _json = createJson(getDeps());
-    }
-    return _json(stream);
-}
-let _bytes;
-export function bytes(stream) {
-    if (!_bytes) {
-        _bytes = createBytes(getDeps());
-    }
-    return _bytes(stream);
-}
-let _fromString;
-export function fromString(str) {
-    if (!_fromString) {
-        _fromString = createFromString(getDeps());
-    }
-    return _fromString(str);
-}
-let _fromJSON;
-export function fromJSON(data) {
-    if (!_fromJSON) {
-        _fromJSON = createFromJSON(getDeps());
-    }
-    return _fromJSON(data);
-}
-let _fromBytes;
-export function fromBytes(data) {
-    if (!_fromBytes) {
-        _fromBytes = createFromBytes(getDeps());
-    }
-    return _fromBytes(data);
-}
-let _transform;
-export function transform(fn) {
-    if (!_transform) {
-        _transform = createTransformHelper(getDeps());
-    }
-    return _transform(fn);
-}
-let _filter;
-export function filter(predicate) {
-    if (!_filter) {
-        _filter = createFilter(getDeps());
-    }
-    return _filter(predicate);
-}

package/dist/esm/modules/stream/utils.js

@@ -1,81 +0,0 @@
-/**
- * Stream Utilities
- *
- * Small, cross-platform helpers built on top of the platform stream
- * implementation. This file is swapped for `utils.browser.ts` in browser
- * builds via the `preferBrowserFilesPlugin()` mechanism.
- *
- * All factory-produced helpers are lazily initialized on first call to avoid
- * eagerly pulling in heavy stream class dependencies at import time.
- */
-import { createReadableFromArray, createTransform } from "./node/factories.js";
-import { consumers } from "./node/utils.js";
-import { collect, createText, createJson, createBytes, createFromString, createFromJSON, createFromBytes, createTransformHelper, createFilter, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.base.js";
-let _deps = null;
-function getDeps() {
-    if (!_deps) {
-        _deps = {
-            createReadableFromArray,
-            createTransform: createTransform,
-            consumers
-        };
-    }
-    return _deps;
-}
-export { collect, isReadableStreamLike, readableStreamToAsyncIterable };
-let _text;
-export function text(stream) {
-    if (!_text) {
-        _text = createText(getDeps());
-    }
-    return _text(stream);
-}
-let _json;
-export function json(stream) {
-    if (!_json) {
-        _json = createJson(getDeps());
-    }
-    return _json(stream);
-}
-let _bytes;
-export function bytes(stream) {
-    if (!_bytes) {
-        _bytes = createBytes(getDeps());
-    }
-    return _bytes(stream);
-}
-let _fromString;
-export function fromString(str) {
-    if (!_fromString) {
-        _fromString = createFromString(getDeps());
-    }
-    return _fromString(str);
-}
-let _fromJSON;
-export function fromJSON(data) {
-    if (!_fromJSON) {
-        _fromJSON = createFromJSON(getDeps());
-    }
-    return _fromJSON(data);
-}
-let _fromBytes;
-export function fromBytes(data) {
-    if (!_fromBytes) {
-        _fromBytes = createFromBytes(getDeps());
-    }
-    return _fromBytes(data);
-}
-let _transform;
-export function transform(fn) {
-    if (!_transform) {
-        _transform = createTransformHelper(getDeps());
-    }
-    return _transform(fn);
-}
-let _filter;
-export function filter(predicate) {
-    if (!_filter) {
-        _filter = createFilter(getDeps());
-    }
-    return _filter(predicate);
-}

package/dist/types/modules/stream/browser/_lazy.d.ts

@@ -1,20 +0,0 @@
-/**
- * Lazy Duplex.from() registry
- *
- * Breaks the circular import between Readable and Duplex:
- *   readable.ts → duplex.ts → readable.ts (cycle!)
- *
- * This file has ZERO imports from the browser stream class files, so it
- * can be safely imported by readable.ts without creating a cycle.
- * The actual Duplex.from binding is registered at module load time by
- * index.browser.ts.
- *
- * @internal
- */
-type DuplexFromFn = (source: unknown) => IDuplex<unknown, unknown>;
-/**
- * Get the registered Duplex.from() factory.
- * Returns null if not yet registered (callers should handle gracefully).
- */
-export declare function getDuplexFrom(): DuplexFromFn | null;
-export {};

package/dist/types/modules/stream/browser/chunk-buffer.d.ts

@@ -1,61 +0,0 @@
-/**
- * Browser Stream - ChunkBuffer
- *
- * Encapsulates FIFO buffer management for Readable streams.
- * Tracks byte size internally so callers don't need manual bookkeeping.
- */
-/**
- * A FIFO buffer optimised for stream chunk management.
- *
- * - Uses an index-based ring on the main array to avoid O(n) `Array.shift()`.
- * - Maintains a small front-stack for `unshift()` to avoid O(n) `Array.unshift()`.
- * - Tracks cumulative byte size (binary mode) so backpressure checks are O(1).
- */
-export declare class ChunkBuffer<T> {
-    private _items;
-    private _index;
-    private _front;
-    private _byteSize;
-    private readonly _objectMode;
-    constructor(objectMode: boolean);
-    private _chunkSize;
-    /** Number of buffered items. */
-    get length(): number;
-    /**
-     * Tracked byte size (binary mode) or item count (object mode).
-     * Useful for O(1) backpressure checks without iterating.
-     */
-    get byteSize(): number;
-    /** Append a chunk to the back of the buffer. */
-    push(chunk: T): void;
-    /** Remove and return the front chunk. Caller must check `length > 0` first. */
-    shift(): T;
-    /** Push a chunk back to the front of the buffer. */
-    unshift(chunk: T): void;
-    /** Peek at the front chunk without removing it. Returns `null` if empty. */
-    peek(): T | null;
-    /** Return a snapshot array of all buffered chunks (front-stack first, then main ring). */
-    toArray(): T[];
-    /** Remove all buffered data. */
-    clear(): void;
-    /**
-     * Consume exactly `size` bytes from the buffer, splitting chunks as needed.
-     * Returns a single Uint8Array of exactly `size` bytes.
-     * Caller must ensure `byteSize >= size` before calling.
-     * Only valid in binary (non-object) mode.
-     */
-    consumeBytes(size: number): T;
-    /**
-     * Consume all buffered data and return as a single concatenated Uint8Array.
-     * Only valid in binary (non-object) mode.
-     * Optimised: iterates directly over internal arrays instead of per-element
-     * shift() to avoid redundant _byteSize arithmetic and compaction checks.
-     */
-    consumeAll(): T;
-    /**
-     * Remove and return the front chunk WITHOUT updating byteSize.
-     * Used by consumeBytes when we need to split a chunk.
-     * Actually, we just use shift() which handles byteSize — see consumeBytes.
-     */
-    private _shiftFrontChunk;
-}