@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/cjs/modules/stream/streams.browser.js

@@ -1,3318 +0,0 @@
-"use strict";
-/**
- * Native Stream Implementation - Browser
- *
- * Uses Web Streams API (ReadableStream, WritableStream, TransformStream)
- * for true native streaming in browsers.
- *
- * Supported browsers:
- * - Chrome >= 89
- * - Firefox >= 102
- * - Safari >= 14.1
- * - Edge >= 89
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promises = exports.consumers = exports.streamToBuffer = exports.BufferedStream = exports.BufferChunk = exports.StringChunk = exports.PullStream = exports.Collector = exports.PassThrough = exports.Duplex = exports.Transform = exports.Writable = exports.Readable = void 0;
-exports.normalizeWritable = normalizeWritable;
-exports.createReadable = createReadable;
-exports.createReadableFromAsyncIterable = createReadableFromAsyncIterable;
-exports.createReadableFromArray = createReadableFromArray;
-exports.createWritable = createWritable;
-exports.createTransform = createTransform;
-exports.createCollector = createCollector;
-exports.createPassThrough = createPassThrough;
-exports.createPullStream = createPullStream;
-exports.createBufferedStream = createBufferedStream;
-exports.pipeline = pipeline;
-exports.finished = finished;
-exports.streamToPromise = streamToPromise;
-exports.streamToUint8Array = streamToUint8Array;
-exports.streamToString = streamToString;
-exports.drainStream = drainStream;
-exports.copyStream = copyStream;
-exports.isTransform = isTransform;
-exports.isDuplex = isDuplex;
-exports.isStream = isStream;
-exports.addAbortSignal = addAbortSignal;
-exports.createDuplex = createDuplex;
-exports.createReadableFromGenerator = createReadableFromGenerator;
-exports.createReadableFromPromise = createReadableFromPromise;
-exports.compose = compose;
-exports.finishedAll = finishedAll;
-exports.createEmptyReadable = createEmptyReadable;
-exports.createNullWritable = createNullWritable;
-exports.once = once;
-exports.promisify = promisify;
-exports.getDefaultHighWaterMark = getDefaultHighWaterMark;
-exports.setDefaultHighWaterMark = setDefaultHighWaterMark;
-exports.isDestroyed = isDestroyed;
-exports.isDisturbed = isDisturbed;
-exports.isErrored = isErrored;
-exports.isReadable = isReadable;
-exports.isWritable = isWritable;
-exports.duplexPair = duplexPair;
-const event_emitter_1 = require("@stream/event-emitter");
-const pull_stream_1 = require("@stream/pull-stream");
-const buffered_stream_1 = require("@stream/buffered-stream");
-const shared_1 = require("@stream/shared");
-// =============================================================================
-// Readable Stream Wrapper
-// =============================================================================
-/**
- * A wrapper around Web ReadableStream that provides Node.js-like API
- */
-class Readable extends event_emitter_1.EventEmitter {
-    constructor(options) {
-        super();
-        this._reader = null;
-        this._buffer = [];
-        this._bufferIndex = 0;
-        this._unshiftBuffer = [];
-        this._bufferSize = 0;
-        this._reading = false;
-        this._ended = false;
-        this._destroyed = false;
-        this._errored = null;
-        this._closed = false;
-        this._paused = true;
-        this._flowing = false;
-        this._pipeTo = [];
-        this._pipeListeners = new Map();
-        this._encoding = null;
-        this._decoder = null;
-        this._didRead = false;
-        this._aborted = false;
-        // Whether this stream uses push() mode (true) or Web Stream mode (false)
-        this._pushMode = false;
-        // Whether this stream was created from an external Web Stream (true) or is controllable (false)
-        this._webStreamMode = false;
-        this.objectMode = options?.objectMode ?? false;
-        this.readableHighWaterMark = options?.highWaterMark ?? 16384;
-        this.autoDestroy = options?.autoDestroy ?? true;
-        this.emitClose = options?.emitClose ?? true;
-        // Store user-provided read function
-        if (options?.read) {
-            this._read = options.read.bind(this);
-            this._pushMode = true; // User will call push()
-        }
-        if (options?.stream) {
-            this._stream = options.stream;
-            this._webStreamMode = true; // Created from external Web Stream
-        }
-        else {
-            // Create a controllable stream
-            let controller;
-            this._stream = new ReadableStream({
-                start: ctrl => {
-                    controller = ctrl;
-                },
-                pull: async () => {
-                    // Signal that more data can be pushed
-                    this.emit("drain");
-                },
-                cancel: reason => {
-                    this._ended = true;
-                    this._aborted = true;
-                    if (this.emitClose) {
-                        this.emit("close");
-                    }
-                }
-            });
-            // Expose controller for push/end
-            this._controller = controller;
-        }
-    }
-    /**
-     * Create a Readable from an iterable (static factory method)
-     */
-    static from(iterable, options) {
-        const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-        (async () => {
-            try {
-                for await (const chunk of iterable) {
-                    if (!readable.push(chunk)) {
-                        // Backpressure
-                        await new Promise(resolve => setTimeout(resolve, 0));
-                    }
-                }
-                readable.push(null);
-            }
-            catch (err) {
-                readable.destroy(err);
-            }
-        })();
-        return readable;
-    }
-    /**
-     * Check if a stream has been disturbed (read from)
-     */
-    static isDisturbed(stream) {
-        return stream._didRead || stream._ended || stream._destroyed;
-    }
-    /**
-     * Convert a Web ReadableStream to Node.js Readable
-     */
-    static fromWeb(webStream, options) {
-        return new Readable({ ...options, stream: webStream });
-    }
-    /**
-     * Convert a Node.js Readable to Web ReadableStream
-     */
-    static toWeb(nodeStream) {
-        return nodeStream.webStream;
-    }
-    /**
-     * Push data to the stream (when using controllable stream)
-     */
-    push(chunk) {
-        if (this._destroyed) {
-            return false;
-        }
-        // Mark as push mode when push() is called
-        this._pushMode = true;
-        const controller = this._controller;
-        if (chunk === null) {
-            // Prevent duplicate end handling
-            if (this._ended) {
-                return false;
-            }
-            this._ended = true;
-            if (controller) {
-                try {
-                    controller.close();
-                }
-                catch {
-                    // Controller may already be closed
-                }
-            }
-            this.emit("end");
-            // Note: Don't call destroy() here, let the stream be consumed naturally
-            // The reader will return done:true when it finishes reading
-            return false;
-        }
-        if (this._flowing) {
-            // In flowing mode, emit data directly without buffering or enqueueing
-            // const chunkStr = chunk instanceof Uint8Array ? new TextDecoder().decode(chunk.slice(0, 50)) : String(chunk).slice(0, 50);
-            // console.log(`[Readable#${this._id}.push FLOWING] emit data size:${(chunk as any).length || (chunk as any).byteLength} start:"${chunkStr}"`);
-            this.emit("data", chunk);
-            // Check if stream was paused during emit (backpressure from consumer)
-            if (!this._flowing) {
-                return false;
-            }
-            // After emitting data, call _read again if available (Node.js behavior)
-            if (this._read && !this._ended) {
-                queueMicrotask(() => {
-                    if (this._flowing && !this._ended && !this._destroyed) {
-                        this._read(this.readableHighWaterMark);
-                    }
-                });
-            }
-            // In flowing mode, return true (no backpressure since data is immediately consumed)
-            return true;
-        }
-        else {
-            // In paused mode, buffer for later
-            const wasEmpty = this._bufferedLength() === 0;
-            // const chunkStrBuf = chunk instanceof Uint8Array ? new TextDecoder().decode((chunk as Uint8Array).slice(0, 50)) : String(chunk).slice(0, 50);
-            // console.log(`[Readable#${this._id}.push PAUSED->BUFFER] buffer len:${this._buffer.length}->${this._buffer.length + 1} start:"${chunkStrBuf}"`);
-            this._buffer.push(chunk);
-            if (!this.objectMode) {
-                this._bufferSize += this._getChunkSize(chunk);
-            }
-            // NOTE: Do NOT enqueue to Web Stream controller here!
-            // In push mode, _buffer is the only source of data for data events.
-            // Web Stream is only used for async iteration when not in push mode.
-            // Enqueueing here would cause data duplication when _startReading is also running.
-            // Emit readable event when buffer goes from empty to having data
-            if (wasEmpty) {
-                queueMicrotask(() => this.emit("readable"));
-            }
-            // Return false if buffer exceeds high water mark (backpressure signal)
-            // Fast path for object mode - just count items
-            if (this.objectMode) {
-                return this._bufferedLength() < this.readableHighWaterMark;
-            }
-            // For binary mode, use tracked buffer size (O(1))
-            return this._bufferSize < this.readableHighWaterMark;
-        }
-    }
-    /**
-     * Put a chunk back at the front of the buffer
-     * Note: unshift is allowed even after end, as it's used to put back already read data
-     */
-    unshift(chunk) {
-        if (this._destroyed) {
-            return;
-        }
-        this._bufferUnshift(chunk);
-        if (!this.objectMode) {
-            this._bufferSize += this._getChunkSize(chunk);
-        }
-    }
-    /**
-     * Read data from the stream
-     */
-    read(size) {
-        this._didRead = true;
-        if (this._bufferedLength() > 0) {
-            if (this.objectMode || size === undefined) {
-                const chunk = this._bufferShift();
-                if (!this.objectMode) {
-                    this._bufferSize -= this._getChunkSize(chunk);
-                }
-                return this._applyEncoding(chunk);
-            }
-            // For binary mode, handle size
-            const chunk = this._bufferShift();
-            if (!this.objectMode) {
-                this._bufferSize -= this._getChunkSize(chunk);
-            }
-            return this._applyEncoding(chunk);
-        }
-        return null;
-    }
-    _bufferedLength() {
-        return this._unshiftBuffer.length + (this._buffer.length - this._bufferIndex);
-    }
-    _bufferPeek() {
-        const unshiftLen = this._unshiftBuffer.length;
-        if (unshiftLen > 0) {
-            return this._unshiftBuffer[unshiftLen - 1];
-        }
-        return this._bufferIndex < this._buffer.length ? this._buffer[this._bufferIndex] : null;
-    }
-    _bufferShift() {
-        if (this._unshiftBuffer.length > 0) {
-            return this._unshiftBuffer.pop();
-        }
-        const chunk = this._buffer[this._bufferIndex++];
-        // Fast reset when emptied
-        if (this._bufferIndex === this._buffer.length) {
-            this._buffer.length = 0;
-            this._bufferIndex = 0;
-            return chunk;
-        }
-        // Occasionally compact to avoid unbounded growth of the unused prefix
-        if (this._bufferIndex > 1024 && this._bufferIndex * 2 > this._buffer.length) {
-            this._buffer = this._buffer.slice(this._bufferIndex);
-            this._bufferIndex = 0;
-        }
-        return chunk;
-    }
-    _bufferUnshift(chunk) {
-        if (this._bufferIndex === 0) {
-            // Avoid O(n) Array.unshift() by using a small front stack.
-            // Semantics: last unshifted chunk is returned first.
-            this._unshiftBuffer.push(chunk);
-            return;
-        }
-        this._bufferIndex--;
-        this._buffer[this._bufferIndex] = chunk;
-    }
-    _getChunkSize(chunk) {
-        // Keep semantics aligned with previous implementation:
-        // - Uint8Array counts by byteLength
-        // - other types count as 1
-        return chunk instanceof Uint8Array ? chunk.byteLength : 1;
-    }
-    /**
-     * Set encoding for string output
-     */
-    setEncoding(encoding) {
-        this._encoding = encoding;
-        // Fast path: reuse cached utf-8 decoder; otherwise lazy-create on first decode.
-        if (encoding === "utf-8" || encoding === "utf8") {
-            this._decoder = shared_1.textDecoder;
-        }
-        else {
-            this._decoder = null;
-        }
-        return this;
-    }
-    _applyEncoding(chunk) {
-        if (this._encoding && chunk instanceof Uint8Array) {
-            // Use cached decoder instances (module-level for utf-8, cached per encoding otherwise).
-            if (!this._decoder) {
-                this._decoder = (0, shared_1.getTextDecoder)(this._encoding);
-            }
-            return this._decoder.decode(chunk);
-        }
-        return chunk;
-    }
-    /**
-     * Wrap an old-style stream
-     */
-    wrap(stream) {
-        stream.on("data", (chunk) => {
-            if (!this.push(chunk)) {
-                stream.pause();
-            }
-        });
-        stream.on("end", () => this.push(null));
-        stream.on("error", (err) => this.destroy(err));
-        stream.on("close", () => this.destroy());
-        return this;
-    }
-    /**
-     * Pause the stream
-     */
-    pause() {
-        this._paused = true;
-        this._flowing = false;
-        return this;
-    }
-    /**
-     * Resume the stream
-     */
-    resume() {
-        this._paused = false;
-        this._flowing = true;
-        // Emit any buffered data first
-        while (this._bufferedLength() > 0 && this._flowing) {
-            const chunk = this._bufferShift();
-            if (!this.objectMode) {
-                this._bufferSize -= this._getChunkSize(chunk);
-            }
-            this.emit("data", chunk);
-        }
-        // If already ended, emit end event
-        if (this._ended && this._bufferedLength() === 0) {
-            this.emit("end");
-        }
-        else if (this._read) {
-            // Call user-provided read function asynchronously
-            // This allows multiple pipe() calls to register before data flows
-            queueMicrotask(() => {
-                if (this._flowing && !this._ended && !this._destroyed) {
-                    this._read(this.readableHighWaterMark);
-                }
-            });
-        }
-        else if (this._webStreamMode && !this._pushMode) {
-            // Only start reading from underlying Web Stream if:
-            // 1. Stream was created from external Web Stream (_webStreamMode)
-            // 2. Not in push mode (no one called push() yet)
-            this._startReading();
-        }
-        return this;
-    }
-    /**
-     * Override on() to automatically resume when 'data' listener is added
-     * This matches Node.js behavior where adding a 'data' listener puts
-     * the stream into flowing mode.
-     */
-    on(event, listener) {
-        super.on(event, listener);
-        // When a 'data' listener is added, switch to flowing mode
-        if (event === "data") {
-            this.resume();
-        }
-        return this;
-    }
-    /**
-     * Check if paused
-     */
-    isPaused() {
-        return this._paused;
-    }
-    /**
-     * Pipe to a writable stream, transform stream, or duplex stream
-     */
-    pipe(destination) {
-        // IMPORTANT:
-        // Do not rely on `instanceof` here.
-        // In bundled/minified builds, multiple copies of this module can exist,
-        // causing `instanceof Transform/Writable/Duplex` to fail even when the object
-        // is a valid destination.
-        const dest = destination;
-        // Get the actual writable target.
-        // Prefer internal `_writable` (Transform/Duplex wrappers), else treat the destination as writable-like.
-        const candidate = dest?._writable ?? dest;
-        const hasWrite = typeof candidate?.write === "function";
-        const hasEnd = typeof candidate?.end === "function";
-        const hasOn = typeof candidate?.on === "function";
-        const hasOnce = typeof candidate?.once === "function";
-        const hasOff = typeof candidate?.off === "function";
-        if (!hasWrite || !hasEnd || (!hasOnce && !hasOn) || (!hasOff && !candidate?.removeListener)) {
-            throw new Error("Readable.pipe: invalid destination");
-        }
-        const target = candidate;
-        this._pipeTo.push(target);
-        // Create listeners that we can later remove
-        const dataListener = (chunk) => {
-            const canWrite = target.write(chunk);
-            if (!canWrite) {
-                this.pause();
-                if (typeof target.once === "function") {
-                    target.once("drain", () => this.resume());
-                }
-                else {
-                    const resumeOnce = () => {
-                        if (typeof target.off === "function") {
-                            target.off("drain", resumeOnce);
-                        }
-                        else if (typeof target.removeListener === "function") {
-                            target.removeListener("drain", resumeOnce);
-                        }
-                        this.resume();
-                    };
-                    target.on("drain", resumeOnce);
-                }
-            }
-        };
-        const endListener = () => {
-            target.end();
-        };
-        const errorListener = (err) => {
-            if (typeof target.destroy === "function") {
-                target.destroy(err);
-            }
-            else {
-                // Best-effort: forward error to the destination if it supports events.
-                target.emit?.("error", err);
-            }
-        };
-        // Store listeners for later removal in unpipe
-        this._pipeListeners.set(target, {
-            data: dataListener,
-            end: endListener,
-            error: errorListener
-        });
-        this.on("data", dataListener);
-        this.once("end", endListener);
-        this.once("error", errorListener);
-        this.resume();
-        return destination;
-    }
-    /**
-     * Unpipe from destination
-     */
-    unpipe(destination) {
-        if (destination) {
-            const idx = this._pipeTo.indexOf(destination);
-            if (idx !== -1) {
-                this._pipeTo.splice(idx, 1);
-            }
-            // Remove the listeners
-            const listeners = this._pipeListeners.get(destination);
-            if (listeners) {
-                this.off("data", listeners.data);
-                this.off("end", listeners.end);
-                this.off("error", listeners.error);
-                this._pipeListeners.delete(destination);
-            }
-        }
-        else {
-            // Unpipe all
-            for (const target of this._pipeTo) {
-                const listeners = this._pipeListeners.get(target);
-                if (listeners) {
-                    this.off("data", listeners.data);
-                    this.off("end", listeners.end);
-                    this.off("error", listeners.error);
-                    this._pipeListeners.delete(target);
-                }
-            }
-            this._pipeTo = [];
-        }
-        // Pause the stream after unpipe
-        this.pause();
-        return this;
-    }
-    /**
-     * Destroy the stream
-     */
-    destroy(error) {
-        if (this._destroyed) {
-            return this;
-        }
-        this._destroyed = true;
-        this._ended = true;
-        if (error) {
-            this._errored = error;
-            this.emit("error", error);
-        }
-        if (this._reader) {
-            this._reader.cancel().catch(() => { });
-        }
-        this._closed = true;
-        this.emit("close");
-        return this;
-    }
-    /**
-     * Get the underlying Web ReadableStream
-     */
-    get webStream() {
-        return this._stream;
-    }
-    get readable() {
-        return !this._destroyed && !this._ended;
-    }
-    get readableEnded() {
-        return this._ended;
-    }
-    get readableLength() {
-        return this._bufferedLength();
-    }
-    /** Whether the stream has been destroyed */
-    get destroyed() {
-        return this._destroyed;
-    }
-    /** The error that destroyed the stream, or null */
-    get errored() {
-        return this._errored;
-    }
-    /** Whether the stream has been closed */
-    get closed() {
-        return this._closed;
-    }
-    /** Whether the stream is in flowing mode */
-    get readableFlowing() {
-        if (!this._paused && !this._ended) {
-            return this._flowing;
-        }
-        return this._flowing ? true : null;
-    }
-    /** Whether the stream was aborted */
-    get readableAborted() {
-        return this._aborted;
-    }
-    /** Whether read() has ever been called */
-    get readableDidRead() {
-        return this._didRead;
-    }
-    /** Current encoding or null */
-    get readableEncoding() {
-        return this._encoding;
-    }
-    /** Returns array of objects containing info about buffered data */
-    get readableObjectMode() {
-        return this.objectMode;
-    }
-    /**
-     * Get the internal buffer state (for debugging)
-     * Returns array of objects with length and chunk info
-     */
-    get readableBuffer() {
-        return {
-            length: this._bufferedLength(),
-            head: this._bufferPeek()
-        };
-    }
-    async _startReading() {
-        if (this._reading || this._destroyed || !this._flowing) {
-            return;
-        }
-        this._reading = true;
-        try {
-            if (!this._reader) {
-                this._reader = this._stream.getReader();
-            }
-            while (this._flowing && !this._destroyed && !this._pushMode) {
-                const { done, value } = await this._reader.read();
-                // Check _pushMode again after async read - if push() was called, stop reading
-                if (this._pushMode) {
-                    break;
-                }
-                if (done) {
-                    this._ended = true;
-                    this.emit("end");
-                    break;
-                }
-                if (value !== undefined) {
-                    // In flowing mode, emit data directly without buffering
-                    // Only buffer if not flowing (paused mode)
-                    if (this._flowing) {
-                        this.emit("data", value);
-                    }
-                    else {
-                        this._buffer.push(value);
-                        if (!this.objectMode) {
-                            this._bufferSize += this._getChunkSize(value);
-                        }
-                    }
-                }
-            }
-        }
-        catch (err) {
-            this.emit("error", err);
-        }
-        finally {
-            this._reading = false;
-        }
-    }
-    /**
-     * Async iterator support
-     * Uses Web Stream reader for non-push mode, event-based for push mode
-     */
-    async *[Symbol.asyncIterator]() {
-        // First yield any buffered data
-        while (this._bufferedLength() > 0) {
-            const chunk = this._bufferShift();
-            if (!this.objectMode) {
-                this._bufferSize -= this._getChunkSize(chunk);
-            }
-            yield chunk;
-        }
-        // If already ended, we're done
-        if (this._ended) {
-            return;
-        }
-        // For controllable streams (not created from external Web Stream),
-        // use event-based iteration since data comes from push() calls
-        if (!this._webStreamMode) {
-            // Create a promise-based queue for incoming data
-            const dataQueue = [];
-            let resolveNext = null;
-            let rejectNext = null;
-            let done = false;
-            let streamError = null;
-            let dataQueueIndex = 0;
-            const dataHandler = (chunk) => {
-                if (resolveNext) {
-                    resolveNext(chunk);
-                    resolveNext = null;
-                    rejectNext = null;
-                }
-                else {
-                    dataQueue.push(chunk);
-                }
-            };
-            const endHandler = () => {
-                done = true;
-                if (resolveNext) {
-                    resolveNext(null);
-                    resolveNext = null;
-                    rejectNext = null;
-                }
-            };
-            const errorHandler = (err) => {
-                done = true;
-                streamError = err;
-                if (rejectNext) {
-                    rejectNext(err);
-                    resolveNext = null;
-                    rejectNext = null;
-                }
-            };
-            const closeHandler = () => {
-                // If stream closed without end event (e.g., after destroy()),
-                // treat it as done
-                done = true;
-                if (resolveNext) {
-                    resolveNext(null);
-                    resolveNext = null;
-                    rejectNext = null;
-                }
-            };
-            this.on("data", dataHandler);
-            this.on("end", endHandler);
-            this.on("error", errorHandler);
-            this.on("close", closeHandler);
-            try {
-                // Enter flowing mode
-                this.resume();
-                while (!done || dataQueueIndex < dataQueue.length) {
-                    // Check for error before processing
-                    if (streamError) {
-                        throw streamError;
-                    }
-                    if (dataQueueIndex < dataQueue.length) {
-                        const chunk = dataQueue[dataQueueIndex++];
-                        if (dataQueueIndex >= 1024 && dataQueueIndex * 2 >= dataQueue.length) {
-                            dataQueue.splice(0, dataQueueIndex);
-                            dataQueueIndex = 0;
-                        }
-                        yield chunk;
-                    }
-                    else if (!done) {
-                        const chunk = await new Promise((resolve, reject) => {
-                            resolveNext = resolve;
-                            rejectNext = reject;
-                        });
-                        if (chunk !== null) {
-                            yield chunk;
-                        }
-                    }
-                }
-                // Check for error after loop
-                if (streamError) {
-                    throw streamError;
-                }
-            }
-            finally {
-                this.off("data", dataHandler);
-                this.off("end", endHandler);
-                this.off("error", errorHandler);
-                this.off("close", closeHandler);
-            }
-            return;
-        }
-        // For Web Stream mode, use the underlying reader
-        if (!this._reader) {
-            this._reader = this._stream.getReader();
-        }
-        try {
-            while (true) {
-                const { done, value } = await this._reader.read();
-                if (done) {
-                    break;
-                }
-                yield value;
-            }
-        }
-        finally {
-            this._reader.releaseLock();
-        }
-    }
-    /**
-     * Explicit iterator method (same as Symbol.asyncIterator)
-     */
-    iterator(options) {
-        const destroyOnReturn = options?.destroyOnReturn ?? true;
-        const iterator = this[Symbol.asyncIterator]();
-        if (!destroyOnReturn) {
-            return iterator;
-        }
-        // Wrap to handle early return
-        return {
-            next: async () => {
-                return iterator.next();
-            },
-            return: async (value) => {
-                this.destroy();
-                return { done: true, value };
-            },
-            [Symbol.asyncIterator]() {
-                return this;
-            }
-        };
-    }
-    // =========================================================================
-    // Async Iterator Helper Methods (Node.js 16.6+)
-    // =========================================================================
-    /**
-     * Map each chunk through an async function
-     */
-    async *map(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            yield await fn(chunk, { signal });
-        }
-    }
-    /**
-     * Filter chunks through an async predicate
-     */
-    async *filter(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (await fn(chunk, { signal })) {
-                yield chunk;
-            }
-        }
-    }
-    /**
-     * FlatMap each chunk
-     */
-    async *flatMap(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            const result = await fn(chunk, { signal });
-            for await (const item of result) {
-                yield item;
-            }
-        }
-    }
-    /**
-     * Take the first n chunks
-     */
-    async *take(limit, options) {
-        const signal = options?.signal;
-        let count = 0;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (count >= limit) {
-                break;
-            }
-            yield chunk;
-            count++;
-        }
-    }
-    /**
-     * Drop the first n chunks
-     */
-    async *drop(limit, options) {
-        const signal = options?.signal;
-        let count = 0;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (count >= limit) {
-                yield chunk;
-            }
-            count++;
-        }
-    }
-    async reduce(fn, initial, options) {
-        const signal = options?.signal;
-        let accumulator = initial;
-        let first = true;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (first && accumulator === undefined) {
-                accumulator = chunk;
-                first = false;
-            }
-            else {
-                accumulator = await fn(accumulator, chunk, { signal });
-            }
-        }
-        if (accumulator === undefined) {
-            throw new TypeError("Reduce of empty stream with no initial value");
-        }
-        return accumulator;
-    }
-    /**
-     * Check if every chunk passes a predicate
-     */
-    async every(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (!(await fn(chunk, { signal }))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Check if some chunk passes a predicate
-     */
-    async some(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (await fn(chunk, { signal })) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Find first chunk that passes predicate
-     */
-    async find(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            if (await fn(chunk, { signal })) {
-                return chunk;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Execute function for each chunk (like forEach)
-     */
-    async forEach(fn, options) {
-        const signal = options?.signal;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            await fn(chunk, { signal });
-        }
-    }
-    /**
-     * Collect all chunks into an array
-     */
-    async toArray(options) {
-        const signal = options?.signal;
-        const result = [];
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            result.push(chunk);
-        }
-        return result;
-    }
-    /**
-     * Yield [index, value] pairs
-     */
-    async *asIndexedPairs(options) {
-        const signal = options?.signal;
-        let index = 0;
-        for await (const chunk of this) {
-            if (signal?.aborted) {
-                throw new Error("AbortError");
-            }
-            yield [index++, chunk];
-        }
-    }
-    compose(stream) {
-        if (typeof stream === "function") {
-            // It's an async generator function
-            const output = stream(this);
-            return Readable.from(output);
-        }
-        // It's a Duplex stream
-        this.pipe(stream);
-        return stream;
-    }
-}
-exports.Readable = Readable;
-// =============================================================================
-// Writable Stream Wrapper
-// =============================================================================
-/**
- * A wrapper around Web WritableStream that provides Node.js-like API
- */
-class Writable extends event_emitter_1.EventEmitter {
-    constructor(options) {
-        super();
-        this._writer = null;
-        this._ended = false;
-        this._finished = false;
-        this._destroyed = false;
-        this._errored = null;
-        this._closed = false;
-        this._pendingWrites = 0;
-        this._writableLength = 0;
-        this._corked = 0;
-        this._corkedChunks = [];
-        this._defaultEncoding = "utf8";
-        this._aborted = false;
-        this.objectMode = options?.objectMode ?? false;
-        this.writableHighWaterMark = options?.highWaterMark ?? 16384;
-        this.autoDestroy = options?.autoDestroy ?? true;
-        this.emitClose = options?.emitClose ?? true;
-        this._defaultEncoding = options?.defaultEncoding ?? "utf8";
-        // Store user-provided write function
-        if (options?.write) {
-            this._writeFunc = options.write.bind(this);
-        }
-        // Store user-provided final function
-        if (options?.final) {
-            this._finalFunc = options.final.bind(this);
-        }
-        if (options?.stream) {
-            this._stream = options.stream;
-        }
-        else {
-            // Create bound references to instance properties/methods for use in WritableStream callbacks
-            const getWriteFunc = () => this._writeFunc;
-            const getFinalFunc = () => this._finalFunc;
-            const getDefaultEncoding = () => this._defaultEncoding;
-            const setFinished = (value) => {
-                this._finished = value;
-            };
-            const setAborted = (value) => {
-                this._aborted = value;
-            };
-            const emitEvent = this.emit.bind(this);
-            const getEmitClose = () => this.emitClose;
-            const callWrite = (chunk) => this._write?.(chunk);
-            this._stream = new WritableStream({
-                write: async (chunk) => {
-                    // Use user-provided write function or default behavior
-                    const writeFunc = getWriteFunc();
-                    if (writeFunc) {
-                        await new Promise((resolve, reject) => {
-                            writeFunc(chunk, getDefaultEncoding(), err => {
-                                if (err) {
-                                    reject(err);
-                                }
-                                else {
-                                    resolve();
-                                }
-                            });
-                        });
-                    }
-                    else {
-                        // Override this in subclasses
-                        callWrite(chunk);
-                    }
-                },
-                close: async () => {
-                    // Call final function if provided
-                    const finalFunc = getFinalFunc();
-                    if (finalFunc) {
-                        await new Promise((resolve, reject) => {
-                            finalFunc(err => {
-                                if (err) {
-                                    reject(err);
-                                }
-                                else {
-                                    resolve();
-                                }
-                            });
-                        });
-                    }
-                    setFinished(true);
-                    emitEvent("finish");
-                    if (getEmitClose()) {
-                        emitEvent("close");
-                    }
-                },
-                abort: reason => {
-                    setAborted(true);
-                    emitEvent("error", reason);
-                }
-            });
-        }
-    }
-    /**
-     * Set default encoding for string writes
-     */
-    setDefaultEncoding(encoding) {
-        this._defaultEncoding = encoding;
-        return this;
-    }
-    /**
-     * Buffer writes until uncork() is called
-     */
-    cork() {
-        this._corked++;
-    }
-    /**
-     * Flush buffered writes from cork()
-     */
-    uncork() {
-        if (this._corked > 0) {
-            this._corked--;
-        }
-        if (this._corked === 0) {
-            // Flush all corked chunks
-            const chunks = this._corkedChunks;
-            this._corkedChunks = [];
-            for (const { chunk, callback } of chunks) {
-                this._doWrite(chunk, callback);
-            }
-        }
-    }
-    write(chunk, encodingOrCallback, callback) {
-        if (this._destroyed || this._ended) {
-            const err = new Error("Cannot write after stream destroyed/ended");
-            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-            cb?.(err);
-            return false;
-        }
-        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-        // If corked, buffer the write
-        if (this._corked > 0) {
-            this._corkedChunks.push({ chunk, callback: cb });
-            const chunkSize = this._getChunkSize(chunk);
-            this._writableLength += chunkSize;
-            return this._writableLength < this.writableHighWaterMark;
-        }
-        return this._doWrite(chunk, cb);
-    }
-    _doWrite(chunk, callback) {
-        // Track pending writes for writableLength
-        const chunkSize = this._getChunkSize(chunk);
-        this._pendingWrites++;
-        this._writableLength += chunkSize;
-        this._getWriter()
-            .write(chunk)
-            .then(() => {
-            this._pendingWrites--;
-            this._writableLength -= chunkSize;
-            this.emit("drain");
-            callback?.(null);
-        })
-            .catch(err => {
-            this._pendingWrites--;
-            this._writableLength -= chunkSize;
-            this.emit("error", err);
-            callback?.(err);
-        });
-        // Return false if we've exceeded high water mark (for backpressure)
-        return this._writableLength < this.writableHighWaterMark;
-    }
-    _getChunkSize(chunk) {
-        if (this.objectMode) {
-            return 1;
-        }
-        if (chunk instanceof Uint8Array) {
-            return chunk.byteLength;
-        }
-        if (typeof chunk === "string") {
-            return chunk.length;
-        }
-        return 0;
-    }
-    end(chunkOrCallback, encodingOrCallback, callback) {
-        if (this._ended) {
-            return this;
-        }
-        this._ended = true;
-        const chunk = typeof chunkOrCallback !== "function" ? chunkOrCallback : undefined;
-        const cb = typeof chunkOrCallback === "function"
-            ? chunkOrCallback
-            : typeof encodingOrCallback === "function"
-                ? encodingOrCallback
-                : callback;
-        const finish = async () => {
-            try {
-                if (chunk !== undefined) {
-                    await this._getWriter().write(chunk);
-                }
-                await this._getWriter().close();
-                this._finished = true;
-                this.emit("finish");
-                if (cb) {
-                    cb();
-                }
-            }
-            catch (err) {
-                this.emit("error", err);
-            }
-        };
-        finish();
-        return this;
-    }
-    /**
-     * Destroy the stream
-     */
-    destroy(error) {
-        if (this._destroyed) {
-            return this;
-        }
-        this._destroyed = true;
-        this._ended = true;
-        if (error) {
-            this._errored = error;
-            this.emit("error", error);
-        }
-        if (this._writer) {
-            this._writer.abort(error).catch(() => { });
-        }
-        this._closed = true;
-        this.emit("close");
-        return this;
-    }
-    /**
-     * Get the underlying Web WritableStream
-     */
-    get webStream() {
-        return this._stream;
-    }
-    get writable() {
-        return !this._destroyed && !this._ended;
-    }
-    get writableEnded() {
-        return this._ended;
-    }
-    get writableFinished() {
-        return this._finished;
-    }
-    get writableLength() {
-        return this._writableLength;
-    }
-    /** Whether the stream has been destroyed */
-    get destroyed() {
-        return this._destroyed;
-    }
-    /** The error that destroyed the stream, or null */
-    get errored() {
-        return this._errored;
-    }
-    /** Whether the stream has been closed */
-    get closed() {
-        return this._closed;
-    }
-    /** Whether the stream needs drain (writableLength exceeds high water mark) */
-    get writableNeedDrain() {
-        return this._writableLength >= this.writableHighWaterMark;
-    }
-    /** How many times cork() has been called without uncork() */
-    get writableCorked() {
-        return this._corked;
-    }
-    /** Whether the stream was aborted */
-    get writableAborted() {
-        return this._aborted;
-    }
-    /** Whether the stream is in object mode */
-    get writableObjectMode() {
-        return this.objectMode;
-    }
-    /** Get default encoding */
-    get defaultEncoding() {
-        return this._defaultEncoding;
-    }
-    /**
-     * Get the internal buffer state (for debugging)
-     * Returns array of objects with length and chunk info
-     */
-    get writableBuffer() {
-        return {
-            length: this._corkedChunks.length,
-            head: this._corkedChunks.length > 0 ? this._corkedChunks[0].chunk : null
-        };
-    }
-    /**
-     * Write multiple chunks at once (batch write).
-     * Override in subclass to implement custom batch write logic.
-     */
-    _writev(chunks, callback) {
-        // Default implementation: write each chunk individually
-        let i = 0;
-        const writeNext = () => {
-            if (i >= chunks.length) {
-                callback(null);
-                return;
-            }
-            const { chunk } = chunks[i++];
-            this._doWrite(chunk, err => {
-                if (err) {
-                    callback(err);
-                    return;
-                }
-                // Continue to next chunk
-                writeNext();
-            });
-        };
-        writeNext();
-    }
-    /**
-     * Batch write multiple chunks
-     */
-    writev(chunks, callback) {
-        if (this._destroyed || this._ended) {
-            const err = new Error("Cannot write after stream destroyed/ended");
-            callback?.(err);
-            return false;
-        }
-        this._writev(chunks, callback ?? (() => { }));
-        // Return backpressure indicator
-        return this._writableLength < this.writableHighWaterMark;
-    }
-    _getWriter() {
-        if (!this._writer) {
-            this._writer = this._stream.getWriter();
-        }
-        return this._writer;
-    }
-    // =========================================================================
-    // Static Methods (Node.js compatibility)
-    // =========================================================================
-    /**
-     * Convert a Web WritableStream to Node.js Writable
-     */
-    static fromWeb(webStream, options) {
-        return new Writable({ ...options, stream: webStream });
-    }
-    /**
-     * Convert a Node.js Writable to Web WritableStream
-     */
-    static toWeb(nodeStream) {
-        return nodeStream.webStream;
-    }
-}
-exports.Writable = Writable;
-// =============================================================================
-// Cross-environment stream normalization
-// =============================================================================
-/**
- * Normalize a user-provided writable into this module's Writable.
- * Keeps Web/Node branching at the stream-module boundary.
- */
-function normalizeWritable(stream) {
-    if (stream instanceof Writable) {
-        return stream;
-    }
-    // Web WritableStream
-    if (stream?.getWriter) {
-        return new Writable({ stream: stream });
-    }
-    // Already a Node-like writable (e.g. StreamBuf)
-    return stream;
-}
-// =============================================================================
-// Transform Stream Wrapper
-// =============================================================================
-/**
- * A wrapper around Web TransformStream that provides Node.js-like API
- */
-class Transform extends event_emitter_1.EventEmitter {
-    /**
-     * Push data to the readable side (Node.js compatibility)
-     * Can be called from within transform callback
-     */
-    push(chunk) {
-        if (chunk === null) {
-            return false;
-        }
-        if (this._transformController) {
-            // If we're in a transform callback, enqueue directly
-            this._transformController.enqueue(chunk);
-        }
-        else {
-            // Otherwise buffer for later
-            this._pushBuffer.push(chunk);
-        }
-        return true;
-    }
-    constructor(options) {
-        super();
-        this._ended = false;
-        this._destroyed = false;
-        this._errored = false;
-        // Buffer for Node.js style push() calls during transform
-        this._pushBuffer = [];
-        // Controller for enqueueing pushed data (set during transform execution)
-        this._transformController = null;
-        // Buffer for writes that occur after end() but before writable is closed
-        this._pendingEndWrites = [];
-        // Whether end() has been called but writable not yet closed
-        this._endPending = false;
-        // Track if we've already set up data forwarding
-        this._dataForwardingSetup = false;
-        /** @internal - whether we have a data event consumer */
-        this._hasDataConsumer = false;
-        /** @internal - whether we're auto-consuming the readable */
-        this._readableConsuming = false;
-        /** @internal - buffer for auto-consumed data */
-        this._autoConsumedBuffer = [];
-        this._autoConsumedBufferIndex = 0;
-        /** @internal - whether auto-consume has ended */
-        this._autoConsumeEnded = false;
-        /** @internal - promise that resolves when auto-consume finishes */
-        this._autoConsumePromise = null;
-        this.objectMode = options?.objectMode ?? false;
-        const userTransform = options?.transform;
-        const userFlush = options?.flush;
-        // Determine if transform function is Node.js style (has 3 params) or simple style
-        const isNodeStyleTransform = userTransform && userTransform.length >= 3;
-        const isNodeStyleFlush = userFlush && userFlush.length >= 1;
-        // Create bound references for use in TransformStream callbacks
-        const setController = (ctrl) => {
-            this._transformController = ctrl;
-        };
-        const emitEvent = (event, ...args) => {
-            if (event === "error") {
-                // Only emit error once to prevent duplicate events
-                if (this._errored) {
-                    return false;
-                }
-                this._errored = true;
-                // Also destroy the writable to prevent further writes
-                this._writable.destroy(args[0]);
-            }
-            return this.emit(event, ...args);
-        };
-        const getInstance = () => this;
-        // Check if subclass overrides _transform (for Node.js compatibility)
-        // We need to check this at runtime since the subclass constructor runs after super()
-        const hasSubclassTransform = () => {
-            // If userTransform was provided in options, use that
-            if (userTransform) {
-                return false;
-            }
-            // Check if _transform is overridden (not the base class no-op)
-            const proto = Object.getPrototypeOf(this);
-            return proto._transform !== Transform.prototype._transform;
-        };
-        const hasSubclassFlush = () => {
-            if (userFlush) {
-                return false;
-            }
-            const proto = Object.getPrototypeOf(this);
-            return proto._flush !== Transform.prototype._flush;
-        };
-        this._stream = new TransformStream({
-            transform: async (chunk, controller) => {
-                // Skip processing if already errored
-                if (this._errored) {
-                    return;
-                }
-                try {
-                    // Set controller for push() to use
-                    setController(controller);
-                    // Check for subclass _transform override first
-                    if (hasSubclassTransform()) {
-                        // Call subclass _transform method (Node.js style)
-                        await new Promise((resolve, reject) => {
-                            this._transform(chunk, "utf8", (err, data) => {
-                                if (err) {
-                                    reject(err);
-                                }
-                                else {
-                                    if (data !== undefined) {
-                                        controller.enqueue(data);
-                                    }
-                                    resolve();
-                                }
-                            });
-                        });
-                    }
-                    else if (userTransform) {
-                        if (isNodeStyleTransform) {
-                            // Node.js style: transform(chunk, encoding, callback)
-                            await new Promise((resolve, reject) => {
-                                userTransform.call(getInstance(), chunk, "utf8", (err, data) => {
-                                    if (err) {
-                                        reject(err);
-                                    }
-                                    else {
-                                        // If data provided via callback, enqueue it
-                                        if (data !== undefined) {
-                                            controller.enqueue(data);
-                                        }
-                                        resolve();
-                                    }
-                                });
-                            });
-                        }
-                        else {
-                            // Simple style: transform(chunk) => result
-                            const result = await userTransform(chunk);
-                            if (result !== undefined) {
-                                controller.enqueue(result);
-                            }
-                        }
-                    }
-                    else {
-                        // Default: pass through
-                        controller.enqueue(chunk);
-                    }
-                }
-                catch (err) {
-                    controller.error(err);
-                    emitEvent("error", err);
-                }
-                finally {
-                    setController(null);
-                }
-            },
-            flush: async (controller) => {
-                try {
-                    setController(controller);
-                    // Check for subclass _flush override first
-                    if (hasSubclassFlush()) {
-                        await new Promise((resolve, reject) => {
-                            this._flush((err, data) => {
-                                if (err) {
-                                    reject(err);
-                                }
-                                else {
-                                    if (data !== undefined) {
-                                        controller.enqueue(data);
-                                    }
-                                    resolve();
-                                }
-                            });
-                        });
-                    }
-                    else if (userFlush) {
-                        if (isNodeStyleFlush) {
-                            // Node.js style: flush(callback)
-                            await new Promise((resolve, reject) => {
-                                userFlush.call(getInstance(), (err, data) => {
-                                    if (err) {
-                                        reject(err);
-                                    }
-                                    else {
-                                        if (data !== undefined) {
-                                            controller.enqueue(data);
-                                        }
-                                        resolve();
-                                    }
-                                });
-                            });
-                        }
-                        else {
-                            // Simple style: flush() => result
-                            const result = await userFlush();
-                            if (result !== undefined && result !== null) {
-                                controller.enqueue(result);
-                            }
-                        }
-                    }
-                    // No flush defined - nothing to do
-                }
-                catch (err) {
-                    controller.error(err);
-                    emitEvent("error", err);
-                }
-                finally {
-                    setController(null);
-                }
-            }
-        });
-        this._readable = new Readable({
-            stream: this._stream.readable,
-            objectMode: this.objectMode
-        });
-        this._writable = new Writable({
-            stream: this._stream.writable,
-            objectMode: this.objectMode
-        });
-        // Forward non-data events (data forwarding is lazy to avoid premature flowing)
-        this._readable.on("end", () => this.emit("end"));
-        // Only forward errors if not already errored (to prevent duplicate events)
-        this._readable.on("error", err => {
-            if (!this._errored) {
-                this._errored = true;
-                this.emit("error", err);
-            }
-        });
-        this._writable.on("finish", () => this.emit("finish"));
-        this._writable.on("drain", () => this.emit("drain"));
-        // Only forward errors if not already errored (to prevent duplicate events)
-        this._writable.on("error", err => {
-            if (!this._errored) {
-                this._errored = true;
-                this.emit("error", err);
-            }
-        });
-    }
-    /**
-     * Override on to start flowing when data listener is added
-     */
-    on(event, listener) {
-        // Set up data forwarding when first external data listener is added
-        if (event === "data" && !this._dataForwardingSetup) {
-            this._dataForwardingSetup = true;
-            this._readable.on("data", data => this.emit("data", data));
-        }
-        super.on(event, listener);
-        // When data listener is added, mark as having consumer
-        // and start the readable in flowing mode
-        if (event === "data") {
-            this._hasDataConsumer = true;
-            this._readable.resume();
-        }
-        return this;
-    }
-    write(chunk, encodingOrCallback, callback) {
-        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-        if (this._destroyed || this._errored) {
-            const err = new Error(this._errored ? "Cannot write after stream errored" : "Cannot write after stream destroyed");
-            queueMicrotask(() => this.emit("error", err));
-            cb?.(err);
-            return false;
-        }
-        // Ensure readable is being consumed to allow transform to execute
-        // This matches Node.js behavior where transform executes immediately on write
-        // Only auto-consume if no explicit consumer (data listener or pipe)
-        if (!this._readableConsuming && !this._hasDataConsumer) {
-            this._readableConsuming = true;
-            this._startAutoConsume();
-        }
-        // If end() was called but writable not yet closed, buffer the write
-        // This allows writes during data event handlers to be processed
-        if (this._endPending) {
-            this._pendingEndWrites.push({ chunk, callback: cb });
-            return true;
-        }
-        return this._writable.write(chunk, cb);
-    }
-    /** @internal - auto-consume readable to allow transform to execute */
-    _startAutoConsume() {
-        this._autoConsumePromise = (async () => {
-            try {
-                for await (const chunk of this._readable) {
-                    // Buffer the data for later retrieval
-                    this._autoConsumedBuffer.push(chunk);
-                    // Also emit data event for listeners
-                    this.emit("data", chunk);
-                }
-                this._autoConsumeEnded = true;
-                this.emit("end");
-            }
-            catch (err) {
-                this.emit("error", err);
-            }
-        })();
-    }
-    end(chunkOrCallback, encodingOrCallback, callback) {
-        if (this._ended) {
-            return this;
-        }
-        this._ended = true;
-        this._endPending = true;
-        const chunk = typeof chunkOrCallback === "function" ? undefined : chunkOrCallback;
-        const cb = typeof chunkOrCallback === "function"
-            ? chunkOrCallback
-            : typeof encodingOrCallback === "function"
-                ? encodingOrCallback
-                : callback;
-        if (cb) {
-            this.once("finish", cb);
-        }
-        if (chunk !== undefined) {
-            this._writable.write(chunk);
-        }
-        // Use setTimeout(0) instead of queueMicrotask to ensure all transform
-        // processing and data events complete before we close the writable.
-        // Microtasks run before the TransformStream processes data.
-        setTimeout(() => {
-            // Process any writes that occurred during data events
-            for (const { chunk: pendingChunk, callback } of this._pendingEndWrites) {
-                this._writable.write(pendingChunk, callback);
-            }
-            this._pendingEndWrites = [];
-            this._endPending = false;
-            this._writable.end();
-        }, 0);
-        return this;
-    }
-    /**
-     * Read from the transform stream
-     */
-    read(size) {
-        return this._readable.read(size);
-    }
-    /**
-     * Pipe to another stream (writable, transform, or duplex)
-     */
-    pipe(destination) {
-        // Mark as having consumer to prevent auto-consume conflict
-        this._hasDataConsumer = true;
-        return this._readable.pipe(destination);
-    }
-    /**
-     * Unpipe from destination
-     */
-    unpipe(destination) {
-        this._readable.unpipe(destination);
-        return this;
-    }
-    /**
-     * Check if paused
-     */
-    isPaused() {
-        return this._readable.isPaused();
-    }
-    /**
-     * Resume reading from the readable side
-     */
-    resume() {
-        this._readable.resume();
-        return this;
-    }
-    /**
-     * Pause reading from the readable side
-     */
-    pause() {
-        this._readable.pause();
-        return this;
-    }
-    /**
-     * Destroy the stream
-     */
-    destroy(error) {
-        if (this._destroyed) {
-            return;
-        }
-        this._destroyed = true;
-        this._readable.destroy(error);
-        this._writable.destroy(error);
-        queueMicrotask(() => this.emit("close"));
-    }
-    /**
-     * Get the underlying Web TransformStream
-     */
-    get webStream() {
-        return this._stream;
-    }
-    get readable() {
-        return this._readable.readable;
-    }
-    get writable() {
-        return this._writable.writable;
-    }
-    get readableEnded() {
-        return this._readable.readableEnded;
-    }
-    get writableEnded() {
-        return this._writable.writableEnded;
-    }
-    get writableFinished() {
-        return this._writable.writableFinished;
-    }
-    get readableLength() {
-        return this._readable.readableLength;
-    }
-    get writableLength() {
-        return this._writable.writableLength;
-    }
-    get readableHighWaterMark() {
-        return this._readable.readableHighWaterMark;
-    }
-    get writableHighWaterMark() {
-        return this._writable.writableHighWaterMark;
-    }
-    get readableObjectMode() {
-        return this._readable.readableObjectMode ?? this._readable.objectMode;
-    }
-    get readableFlowing() {
-        return this._readable.readableFlowing;
-    }
-    get destroyed() {
-        return this._destroyed;
-    }
-    /**
-     * Async iterator support
-     */
-    async *[Symbol.asyncIterator]() {
-        // If auto-consume is running, wait for it to finish and use its buffer
-        if (this._autoConsumePromise) {
-            await this._autoConsumePromise;
-            // Yield all buffered data
-            while (this._autoConsumedBufferIndex < this._autoConsumedBuffer.length) {
-                yield this._autoConsumedBuffer[this._autoConsumedBufferIndex++];
-            }
-            // Reset when drained to avoid prefix growth
-            this._autoConsumedBuffer.length = 0;
-            this._autoConsumedBufferIndex = 0;
-            return;
-        }
-        // Otherwise delegate to readable's iterator
-        yield* this._readable[Symbol.asyncIterator]();
-    }
-    // =========================================================================
-    // Static Methods (Node.js compatibility)
-    // =========================================================================
-    /**
-     * Convert a Web TransformStream to Node.js Transform
-     */
-    static fromWeb(webStream, options) {
-        const transform = new Transform(options);
-        // Connect the web stream - set the internal _stream property
-        transform._stream = webStream;
-        // Replace internal streams with the ones from the web stream
-        const newReadable = Readable.fromWeb(webStream.readable, { objectMode: options?.objectMode });
-        const newWritable = Writable.fromWeb(webStream.writable, { objectMode: options?.objectMode });
-        // Remove old event listeners before replacing
-        transform._readable.removeAllListeners();
-        transform._writable.removeAllListeners();
-        transform._readable = newReadable;
-        transform._writable = newWritable;
-        // Re-connect event forwarding
-        newReadable.on("data", (data) => transform.emit("data", data));
-        newReadable.on("end", () => transform.emit("end"));
-        newReadable.on("error", (err) => transform.emit("error", err));
-        newWritable.on("finish", () => transform.emit("finish"));
-        newWritable.on("drain", () => transform.emit("drain"));
-        newWritable.on("error", (err) => transform.emit("error", err));
-        return transform;
-    }
-    /**
-     * Convert a Node.js Transform to Web TransformStream
-     */
-    static toWeb(nodeStream) {
-        return nodeStream.webStream;
-    }
-    // =========================================================================
-    // Base Class Methods (for subclass override detection)
-    // =========================================================================
-    /**
-     * Base transform method - can be overridden by subclasses.
-     * Default behavior: pass through chunk unchanged.
-     */
-    _transform(chunk, encoding, callback) {
-        // Default: pass through unchanged
-        callback(null, chunk);
-    }
-    /**
-     * Base flush method - can be overridden by subclasses.
-     * Called when the stream ends to allow final processing.
-     */
-    _flush(callback) {
-        // Default: no-op
-        callback();
-    }
-}
-exports.Transform = Transform;
-// =============================================================================
-// Duplex Stream
-// =============================================================================
-/**
- * A duplex stream that combines readable and writable
- */
-class Duplex extends event_emitter_1.EventEmitter {
-    /**
-     * Create a Duplex stream from various sources
-     */
-    static from(source) {
-        // If it's already a Duplex, return as-is
-        if (source instanceof Duplex) {
-            return source;
-        }
-        const forwardReadableToDuplex = (readable, duplex) => {
-            const sink = new Writable({
-                objectMode: duplex.readableObjectMode,
-                write(chunk, _encoding, callback) {
-                    duplex.push(chunk);
-                    callback();
-                },
-                final(callback) {
-                    duplex.push(null);
-                    callback();
-                }
-            });
-            readable.on("error", err => duplex.emit("error", err));
-            readable.pipe(sink);
-        };
-        // If it has readable and/or writable properties
-        if (typeof source === "object" &&
-            source !== null &&
-            "readable" in source &&
-            "writable" in source) {
-            const duplex = new Duplex();
-            const pair = source;
-            if (pair.readable) {
-                forwardReadableToDuplex(pair.readable, duplex);
-            }
-            if (pair.writable) {
-                return new Duplex({
-                    objectMode: duplex.writableObjectMode,
-                    write(chunk, encoding, callback) {
-                        pair.writable.write(chunk, encoding, callback);
-                    },
-                    final(callback) {
-                        pair.writable.end(callback);
-                    }
-                });
-            }
-            return duplex;
-        }
-        // If it's an iterable
-        if (typeof source === "object" &&
-            source !== null &&
-            (Symbol.asyncIterator in source || Symbol.iterator in source)) {
-            const readable = Readable.from(source);
-            const duplex = new Duplex();
-            forwardReadableToDuplex(readable, duplex);
-            return duplex;
-        }
-        // If it's a Readable
-        if (source instanceof Readable) {
-            const duplex = new Duplex();
-            forwardReadableToDuplex(source, duplex);
-            return duplex;
-        }
-        // If it's a Writable
-        if (source instanceof Writable) {
-            return new Duplex({
-                objectMode: true,
-                write(chunk, encoding, callback) {
-                    source.write(chunk, encoding, callback);
-                },
-                final(callback) {
-                    source.end(callback);
-                }
-            });
-        }
-        throw new Error("Duplex.from: unsupported source type");
-    }
-    /**
-     * Create a Duplex from a Web ReadableWritablePair
-     */
-    static fromWeb(pair, options) {
-        const duplex = new Duplex(options);
-        // Replace internal streams
-        duplex._readable = new Readable({ stream: pair.readable });
-        duplex._writable = new Writable({ stream: pair.writable });
-        return duplex;
-    }
-    /**
-     * Convert a Node.js Duplex to Web ReadableWritablePair
-     */
-    static toWeb(duplex) {
-        return {
-            readable: duplex._readable.webStream,
-            writable: duplex._writable.webStream
-        };
-    }
-    constructor(options) {
-        super();
-        // Track if we've already set up data forwarding
-        this._dataForwardingSetup = false;
-        this.allowHalfOpen = options?.allowHalfOpen ?? true;
-        // Support shorthand objectMode option
-        const objectMode = options?.objectMode ?? false;
-        this.readableObjectMode = options?.readableObjectMode ?? objectMode;
-        this.writableObjectMode = options?.writableObjectMode ?? objectMode;
-        this._readable = new Readable({
-            highWaterMark: options?.readableHighWaterMark,
-            objectMode: this.readableObjectMode,
-            read: options?.read?.bind(this)
-        });
-        this._writable = new Writable({
-            highWaterMark: options?.writableHighWaterMark,
-            objectMode: this.writableObjectMode,
-            write: options?.write?.bind(this),
-            final: options?.final?.bind(this)
-        });
-        // Forward non-data events (data forwarding is lazy to avoid premature flowing)
-        this._readable.on("end", () => {
-            this.emit("end");
-            // If not allowHalfOpen, end the writable side too
-            if (!this.allowHalfOpen) {
-                this._writable.end();
-            }
-        });
-        this._readable.on("error", err => this.emit("error", err));
-        this._writable.on("finish", () => this.emit("finish"));
-        this._writable.on("drain", () => this.emit("drain"));
-        this._writable.on("close", () => {
-            // If not allowHalfOpen, destroy the readable side too
-            if (!this.allowHalfOpen && !this._readable.destroyed) {
-                this._readable.destroy();
-            }
-        });
-    }
-    /**
-     * Override on() to set up data forwarding lazily
-     */
-    on(event, listener) {
-        // Set up data forwarding when first external data listener is added
-        if (event === "data" && !this._dataForwardingSetup) {
-            this._dataForwardingSetup = true;
-            this._readable.on("data", chunk => this.emit("data", chunk));
-        }
-        return super.on(event, listener);
-    }
-    /**
-     * Push data to readable side
-     */
-    push(chunk) {
-        return this._readable.push(chunk);
-    }
-    /**
-     * Put a chunk back at the front of the buffer (readable side)
-     */
-    unshift(chunk) {
-        this._readable.unshift(chunk);
-    }
-    /**
-     * Read from readable side
-     */
-    read(size) {
-        return this._readable.read(size);
-    }
-    write(chunk, encodingOrCallback, callback) {
-        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-        return this._writable.write(chunk, cb);
-    }
-    end(chunkOrCallback, encodingOrCallback, callback) {
-        const chunk = typeof chunkOrCallback === "function" ? undefined : chunkOrCallback;
-        const cb = typeof chunkOrCallback === "function"
-            ? chunkOrCallback
-            : typeof encodingOrCallback === "function"
-                ? encodingOrCallback
-                : callback;
-        if (cb) {
-            this.once("finish", cb);
-        }
-        if (chunk !== undefined) {
-            this._writable.write(chunk);
-        }
-        this._writable.end();
-        return this;
-    }
-    /**
-     * Cork the writable side
-     */
-    cork() {
-        this._writable.cork();
-    }
-    /**
-     * Uncork the writable side
-     */
-    uncork() {
-        this._writable.uncork();
-    }
-    /**
-     * Set encoding for readable side
-     */
-    setEncoding(encoding) {
-        this._readable.setEncoding(encoding);
-        return this;
-    }
-    /**
-     * Set default encoding for writable side
-     */
-    setDefaultEncoding(encoding) {
-        this._writable.setDefaultEncoding(encoding);
-        return this;
-    }
-    /**
-     * Pipe readable side to destination
-     */
-    pipe(destination) {
-        if (destination instanceof Transform) {
-            this._readable.pipe(destination._writable);
-            return destination;
-        }
-        this._readable.pipe(destination);
-        return destination;
-    }
-    /**
-     * Unpipe from destination
-     */
-    unpipe(destination) {
-        this._readable.unpipe(destination);
-        return this;
-    }
-    /**
-     * Pause the readable side
-     */
-    pause() {
-        this._readable.pause();
-        return this;
-    }
-    /**
-     * Resume the readable side
-     */
-    resume() {
-        this._readable.resume();
-        return this;
-    }
-    /**
-     * Check if paused
-     */
-    isPaused() {
-        return this._readable.isPaused();
-    }
-    /**
-     * Destroy both sides
-     */
-    destroy(error) {
-        this._readable.destroy(error);
-        this._writable.destroy(error);
-        return this;
-    }
-    get readable() {
-        return this._readable.readable;
-    }
-    get writable() {
-        return this._writable.writable;
-    }
-    get readableEnded() {
-        return this._readable.readableEnded;
-    }
-    get writableEnded() {
-        return this._writable.writableEnded;
-    }
-    get writableFinished() {
-        return this._writable.writableFinished;
-    }
-    get readableLength() {
-        return this._readable.readableLength;
-    }
-    get writableLength() {
-        return this._writable.writableLength;
-    }
-    get readableHighWaterMark() {
-        return this._readable.readableHighWaterMark;
-    }
-    get writableHighWaterMark() {
-        return this._writable.writableHighWaterMark;
-    }
-    get destroyed() {
-        return this._readable.destroyed && this._writable.destroyed;
-    }
-    get writableCorked() {
-        return this._writable.writableCorked;
-    }
-    get writableNeedDrain() {
-        return this._writable.writableNeedDrain;
-    }
-    /**
-     * Async iterator support
-     */
-    [Symbol.asyncIterator]() {
-        return this._readable[Symbol.asyncIterator]();
-    }
-}
-exports.Duplex = Duplex;
-// =============================================================================
-// PassThrough Stream
-// =============================================================================
-/**
- * A passthrough stream that passes data through unchanged
- */
-class PassThrough extends Transform {
-    constructor(options) {
-        super({
-            ...options,
-            transform: chunk => chunk
-        });
-    }
-}
-exports.PassThrough = PassThrough;
-// =============================================================================
-// Collector Stream
-// =============================================================================
-/**
- * A writable stream that collects all chunks
- */
-class Collector extends Writable {
-    constructor(options) {
-        const collectedChunks = [];
-        super({
-            ...options,
-            stream: new WritableStream({
-                write: chunk => {
-                    collectedChunks.push(chunk);
-                },
-                close: () => {
-                    // Finished
-                }
-            })
-        });
-        this.chunks = [];
-        this.chunks = collectedChunks;
-    }
-    write(chunk, encodingOrCallback, callback) {
-        if (this.writableEnded || this.writableFinished) {
-            const err = new Error("write after end");
-            this.emit("error", err);
-            return false;
-        }
-        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-        // Synchronously push to chunks
-        this.chunks.push(chunk);
-        cb?.(null);
-        return true;
-    }
-    /**
-     * Get all collected data as a single Uint8Array (for binary mode)
-     */
-    toUint8Array() {
-        const chunks = this.chunks;
-        const len = chunks.length;
-        if (len === 0) {
-            return new Uint8Array(0);
-        }
-        if (len === 1 && chunks[0] instanceof Uint8Array) {
-            return chunks[0];
-        }
-        // If chunks are Uint8Arrays, concatenate them
-        if (chunks[0] instanceof Uint8Array) {
-            return (0, shared_1.concatUint8Arrays)(chunks);
-        }
-        throw new Error("Collector contains non-binary data");
-    }
-    /**
-     * Get all collected data as a string
-     */
-    toString() {
-        const chunks = this.chunks;
-        const len = chunks.length;
-        if (len === 0) {
-            return "";
-        }
-        const first = chunks[0];
-        if (typeof first === "string") {
-            if (len === 1) {
-                return first;
-            }
-            return chunks.join("");
-        }
-        return shared_1.textDecoder.decode(this.toUint8Array());
-    }
-    get isFinished() {
-        // Use inherited writable property
-        return this.writableFinished;
-    }
-}
-exports.Collector = Collector;
-// =============================================================================
-// PullStream / BufferedStream / DataChunk helpers
-// =============================================================================
-class PullStream extends pull_stream_1.PullStream {
-    // Keep constructor signature aligned with streams.browser.ts public API
-    constructor(options) {
-        super(options);
-    }
-}
-exports.PullStream = PullStream;
-class StringChunk extends buffered_stream_1.StringChunk {
-}
-exports.StringChunk = StringChunk;
-class BufferChunk extends buffered_stream_1.BufferChunk {
-}
-exports.BufferChunk = BufferChunk;
-class BufferedStream extends buffered_stream_1.BufferedStream {
-    constructor(options) {
-        super(options);
-    }
-}
-exports.BufferedStream = BufferedStream;
-// =============================================================================
-// Stream Creation Functions
-// =============================================================================
-/**
- * Create a readable stream with custom read implementation
- */
-function createReadable(options) {
-    const readable = new Readable(options);
-    // Override read behavior if provided
-    if (options?.read) {
-        const originalRead = readable.read.bind(readable);
-        readable.read = function (size) {
-            options.read(size ?? 16384);
-            return originalRead(size);
-        };
-    }
-    return readable;
-}
-/**
- * Create a readable stream from an async iterable
- */
-function createReadableFromAsyncIterable(iterable, options) {
-    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    (async () => {
-        try {
-            for await (const chunk of iterable) {
-                if (!readable.push(chunk)) {
-                    // Backpressure - wait a bit
-                    await new Promise(resolve => setTimeout(resolve, 0));
-                }
-            }
-            readable.push(null);
-        }
-        catch (err) {
-            readable.destroy(err);
-        }
-    })();
-    return readable;
-}
-/**
- * Create a readable stream from an array
- */
-function createReadableFromArray(data, options) {
-    let index = 0;
-    const readable = new Readable({
-        ...options,
-        objectMode: options?.objectMode ?? true,
-        read() {
-            // Push data when read is called
-            while (index < data.length) {
-                if (!this.push(data[index++])) {
-                    // Backpressure - wait for next read
-                    return;
-                }
-            }
-            // All data pushed, end the stream
-            this.push(null);
-        }
-    });
-    return readable;
-}
-/**
- * Create a writable stream with custom write implementation
- */
-function createWritable(options) {
-    // Create a custom WritableStream with user's handlers
-    const stream = new WritableStream({
-        write: async (chunk) => {
-            if (options?.write) {
-                return new Promise((resolve, reject) => {
-                    options.write(chunk, "utf8", err => {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                });
-            }
-        },
-        close: async () => {
-            if (options?.final) {
-                return new Promise((resolve, reject) => {
-                    options.final(err => {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                });
-            }
-        }
-    });
-    return new Writable({ ...options, stream });
-}
-/**
- * Create a transform stream from a transform function
- */
-function createTransform(transformFn, options) {
-    return new Transform({
-        ...options,
-        transform: transformFn,
-        flush: options?.flush
-    });
-}
-/**
- * Create a collector stream
- */
-function createCollector(options) {
-    return new Collector(options);
-}
-/**
- * Create a passthrough stream
- */
-function createPassThrough(options) {
-    return new PassThrough(options);
-}
-/**
- * Create a pull stream
- */
-function createPullStream(options) {
-    return new PullStream(options);
-}
-/**
- * Create a buffered stream
- */
-function createBufferedStream(options) {
-    return new BufferedStream(options);
-}
-const isReadableStream = (value) => !!value && typeof value === "object" && typeof value.getReader === "function";
-const isAsyncIterable = (value) => {
-    if (!value || (typeof value !== "object" && typeof value !== "function")) {
-        return false;
-    }
-    return typeof value[Symbol.asyncIterator] === "function";
-};
-const isWritableStream = (value) => !!value && typeof value === "object" && typeof value.getWriter === "function";
-const isTransformStream = (value) => !!value &&
-    typeof value === "object" &&
-    !!value.readable &&
-    !!value.writable &&
-    isReadableStream(value.readable) &&
-    isWritableStream(value.writable);
-const isPipelineOptions = (value) => {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    // IMPORTANT:
-    // Do NOT use `"end" in obj` here because streams have `.end()` and would be
-    // misclassified as options, breaking argument parsing and potentially hanging.
-    if (typeof value.pipe === "function" ||
-        typeof value.write === "function" ||
-        typeof value.end === "function" ||
-        typeof value.getReader === "function" ||
-        typeof value.getWriter === "function") {
-        return false;
-    }
-    return (Object.prototype.hasOwnProperty.call(value, "signal") ||
-        Object.prototype.hasOwnProperty.call(value, "end"));
-};
-const toBrowserPipelineStream = (stream) => {
-    if (stream instanceof Readable ||
-        stream instanceof Writable ||
-        stream instanceof Transform ||
-        stream instanceof Duplex) {
-        return stream;
-    }
-    if (isTransformStream(stream)) {
-        return Transform.fromWeb(stream);
-    }
-    if (isReadableStream(stream)) {
-        return Readable.fromWeb(stream);
-    }
-    if (isWritableStream(stream)) {
-        return Writable.fromWeb(stream);
-    }
-    return stream;
-};
-/**
- * Pipeline streams together with proper error handling and cleanup.
- * Supports both callback and promise-based usage like Node.js.
- *
- * @example
- * // Promise usage
- * await pipeline(source, transform, destination);
- *
- * @example
- * // With options
- * await pipeline(source, transform, destination, { signal: controller.signal });
- *
- * @example
- * // Callback usage
- * pipeline(source, transform, destination, (err) => {
- *   if (err) console.error('Pipeline failed', err);
- * });
- */
-function pipeline(...args) {
-    // Parse arguments
-    let streams;
-    let options = {};
-    let callback;
-    const lastArg = args[args.length - 1];
-    if (typeof lastArg === "function") {
-        // Callback style: pipeline(s1, s2, s3, callback)
-        callback = lastArg;
-        streams = args.slice(0, -1);
-    }
-    else if (isPipelineOptions(lastArg)) {
-        // Options style: pipeline(s1, s2, s3, { signal })
-        options = lastArg;
-        streams = args.slice(0, -1);
-    }
-    else {
-        // No callback or options: pipeline(s1, s2, s3)
-        streams = args;
-    }
-    const promise = new Promise((resolve, reject) => {
-        if (streams.length < 2) {
-            const err = new Error("Pipeline requires at least 2 streams");
-            reject(err);
-            return;
-        }
-        const normalized = streams.map(toBrowserPipelineStream);
-        const source = normalized[0];
-        const destination = normalized[normalized.length - 1];
-        const transforms = normalized.slice(1, -1);
-        let completed = false;
-        const allStreams = [source, ...transforms, destination];
-        const cleanup = (error) => {
-            if (completed) {
-                return;
-            }
-            completed = true;
-            // Destroy all streams on error
-            if (error) {
-                for (const stream of allStreams) {
-                    if (typeof stream.destroy === "function") {
-                        stream.destroy(error);
-                    }
-                }
-                reject(error);
-            }
-            else {
-                resolve();
-            }
-        };
-        // Handle abort signal
-        if (options.signal) {
-            if (options.signal.aborted) {
-                cleanup(new Error("Pipeline aborted"));
-                return;
-            }
-            options.signal.addEventListener("abort", () => {
-                cleanup(new Error("Pipeline aborted"));
-            });
-        }
-        // Chain the streams
-        let current = source;
-        for (const transform of transforms) {
-            current.pipe(transform);
-            current = transform;
-        }
-        // Pipe to destination
-        if (options.end !== false) {
-            current.pipe(destination);
-        }
-        else {
-            // Don't end destination
-            current.on("data", chunk => destination.write(chunk));
-        }
-        // Handle completion
-        destination.on("finish", () => cleanup());
-        // Handle errors on all streams
-        for (const stream of allStreams) {
-            stream.on("error", (err) => cleanup(err));
-        }
-    });
-    // If callback provided, use it
-    if (callback) {
-        promise.then(() => callback(null)).catch(err => callback(err));
-    }
-    return promise;
-}
-/**
- * Wait for a stream to finish, close, or error.
- * Node.js compatible with support for options and callbacks.
- *
- * @example
- * // Promise usage
- * await finished(stream);
- *
- * @example
- * // With options
- * await finished(stream, { readable: false }); // Only wait for writable side
- *
- * @example
- * // Callback usage
- * finished(stream, (err) => {
- *   if (err) console.error('Stream error', err);
- * });
- */
-function finished(stream, optionsOrCallback, callback) {
-    let options = {};
-    let cb;
-    if (typeof optionsOrCallback === "function") {
-        cb = optionsOrCallback;
-    }
-    else if (optionsOrCallback) {
-        options = optionsOrCallback;
-        cb = callback;
-    }
-    const promise = new Promise((resolve, reject) => {
-        const normalizedStream = toBrowserPipelineStream(stream);
-        let resolved = false;
-        const done = (err) => {
-            if (resolved) {
-                return;
-            }
-            resolved = true;
-            if (err && !options.error) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
-        };
-        // Handle abort signal
-        if (options.signal) {
-            if (options.signal.aborted) {
-                done(new Error("Aborted"));
-                return;
-            }
-            options.signal.addEventListener("abort", () => {
-                done(new Error("Aborted"));
-            });
-        }
-        const checkReadable = options.readable !== false;
-        const checkWritable = options.writable !== false;
-        // Already finished?
-        if (checkReadable && normalizedStream.readableEnded) {
-            done();
-            return;
-        }
-        if (checkWritable && normalizedStream.writableFinished) {
-            done();
-            return;
-        }
-        // Listen for events
-        if (checkWritable) {
-            normalizedStream.on("finish", () => done());
-        }
-        if (checkReadable) {
-            normalizedStream.on("end", () => done());
-        }
-        normalizedStream.on("error", (err) => done(err));
-        normalizedStream.on("close", () => done());
-    });
-    // If callback provided, use it
-    if (cb) {
-        promise.then(() => cb(null)).catch(err => cb(err));
-    }
-    return promise;
-}
-// =============================================================================
-// Utility Functions
-// =============================================================================
-/**
- * Convert a stream to a promise that resolves when finished
- */
-async function streamToPromise(stream) {
-    return finished(stream);
-}
-/**
- * Collect all data from a readable stream into a Uint8Array
- * (Browser equivalent of Node.js streamToBuffer)
- */
-async function streamToUint8Array(stream) {
-    let iterable;
-    if (isReadableStream(stream)) {
-        iterable = Readable.fromWeb(stream);
-    }
-    else if (isAsyncIterable(stream)) {
-        iterable = stream;
-    }
-    else {
-        throw new Error("streamToUint8Array: unsupported stream type");
-    }
-    const chunks = [];
-    let totalLength = 0;
-    for await (const chunk of iterable) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
-    }
-    // Fast paths
-    const len = chunks.length;
-    if (len === 0) {
-        return new Uint8Array(0);
-    }
-    if (len === 1) {
-        return chunks[0];
-    }
-    // Use precalculated total length
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0; i < len; i++) {
-        result.set(chunks[i], offset);
-        offset += chunks[i].length;
-    }
-    return result;
-}
-/**
- * Alias for streamToUint8Array (Node.js compatibility)
- */
-exports.streamToBuffer = streamToUint8Array;
-/**
- * Collect all data from a readable stream into a string
- */
-async function streamToString(stream, encoding) {
-    const buffer = await streamToUint8Array(stream);
-    return (0, shared_1.getTextDecoder)(encoding).decode(buffer);
-}
-/**
- * Drain a stream (consume all data without processing)
- */
-async function drainStream(stream) {
-    let iterable;
-    if (isReadableStream(stream)) {
-        iterable = Readable.fromWeb(stream);
-    }
-    else if (isAsyncIterable(stream)) {
-        iterable = stream;
-    }
-    else {
-        throw new Error("drainStream: unsupported stream type");
-    }
-    for await (const _chunk of iterable) {
-        // Consume data
-    }
-}
-/**
- * Copy from a readable stream to a writable stream
- */
-async function copyStream(source, destination) {
-    return pipeline(source, destination);
-}
-// =============================================================================
-// Type Guards
-// =============================================================================
-/**
- * Check if an object is a transform stream
- */
-function isTransform(obj) {
-    if (obj == null) {
-        return false;
-    }
-    if (obj instanceof Transform) {
-        return true;
-    }
-    const o = obj;
-    return (typeof o.read === "function" &&
-        typeof o.pipe === "function" &&
-        typeof o.write === "function" &&
-        typeof o.end === "function" &&
-        typeof o._transform === "function");
-}
-/**
- * Check if an object is a duplex stream
- * Note: In Node.js, Transform extends Duplex, so Transform is also a Duplex
- */
-function isDuplex(obj) {
-    if (obj == null) {
-        return false;
-    }
-    if (obj instanceof Duplex || obj instanceof Transform) {
-        return true;
-    }
-    const o = obj;
-    return (typeof o.read === "function" &&
-        typeof o.pipe === "function" &&
-        typeof o.write === "function" &&
-        typeof o.end === "function");
-}
-/**
- * Check if an object is any kind of stream
- */
-function isStream(obj) {
-    if (obj == null) {
-        return false;
-    }
-    if (obj instanceof Readable || obj instanceof Writable) {
-        return true;
-    }
-    const o = obj;
-    return ((typeof o.read === "function" && typeof o.pipe === "function") ||
-        (typeof o.write === "function" && typeof o.end === "function"));
-}
-// =============================================================================
-// Additional Utility Functions (Node.js Compatibility)
-// =============================================================================
-/**
- * Add abort signal handling to any stream
- */
-function addAbortSignal(signal, stream) {
-    if (signal.aborted) {
-        stream.destroy(new Error("Aborted"));
-        return stream;
-    }
-    const onAbort = () => {
-        stream.destroy(new Error("Aborted"));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    // Clean up when stream is destroyed
-    stream.on("close", () => {
-        signal.removeEventListener("abort", onAbort);
-    });
-    return stream;
-}
-/**
- * Create a duplex stream from a pair of readable and writable streams
- */
-function createDuplex(options) {
-    const readableObjectMode = options?.readableObjectMode ?? options?.objectMode;
-    const writableObjectMode = options?.writableObjectMode ?? options?.objectMode;
-    const duplex = new Duplex({
-        allowHalfOpen: options?.allowHalfOpen,
-        readableHighWaterMark: options?.readableHighWaterMark,
-        writableHighWaterMark: options?.writableHighWaterMark,
-        readableObjectMode,
-        writableObjectMode
-    });
-    // If custom readable/writable provided, pipe them
-    if (options?.readable) {
-        const readable = options.readable;
-        readable.on?.("data", (chunk) => duplex.push(chunk));
-        readable.on?.("end", () => duplex.push(null));
-        readable.on?.("error", (err) => duplex.destroy(err));
-    }
-    if (options?.writable) {
-        const writable = options.writable;
-        duplex.on("data", (chunk) => writable.write?.(chunk));
-        duplex.on("finish", () => writable.end?.());
-    }
-    // If custom read/write/final provided, override methods
-    if (options?.write) {
-        const _originalWrite = duplex.write.bind(duplex); // Keep bound reference for potential future use
-        duplex.write = function (chunk, encodingOrCallback, callback) {
-            const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : "utf8";
-            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : (callback ?? (() => { }));
-            options.write.call(duplex, chunk, encoding, cb);
-            return true;
-        };
-    }
-    if (options?.final) {
-        const originalEnd = duplex.end.bind(duplex);
-        duplex.end = function (chunkOrCallback, encodingOrCallback, callback) {
-            const cb = typeof chunkOrCallback === "function"
-                ? chunkOrCallback
-                : typeof encodingOrCallback === "function"
-                    ? encodingOrCallback
-                    : (callback ?? (() => { }));
-            if (chunkOrCallback !== undefined && typeof chunkOrCallback !== "function") {
-                duplex.write(chunkOrCallback);
-            }
-            // Call custom final handler
-            options.final.call(duplex, (err) => {
-                if (err) {
-                    duplex.emit("error", err);
-                }
-                else {
-                    duplex.emit("finish");
-                }
-                // Call original end to properly close writable side
-                originalEnd();
-                cb();
-            });
-            return duplex;
-        };
-    }
-    if (options?.destroy) {
-        const originalDestroy = duplex.destroy.bind(duplex);
-        duplex.destroy = function (error) {
-            options.destroy.call(duplex, error ?? null, (err) => {
-                if (err) {
-                    duplex.emit("error", err);
-                    originalDestroy(err);
-                }
-                else {
-                    originalDestroy(error);
-                }
-            });
-            return duplex;
-        };
-    }
-    return duplex;
-}
-/**
- * Create a readable stream from a generator function
- */
-function createReadableFromGenerator(generator, options) {
-    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    (async () => {
-        try {
-            for await (const chunk of generator()) {
-                if (!readable.push(chunk)) {
-                    // Backpressure
-                    await new Promise(resolve => setTimeout(resolve, 0));
-                }
-            }
-            readable.push(null);
-        }
-        catch (err) {
-            readable.destroy(err);
-        }
-    })();
-    return readable;
-}
-/**
- * Create a readable stream from a Promise
- */
-function createReadableFromPromise(promise, options) {
-    const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
-    promise
-        .then(value => {
-        readable.push(value);
-        readable.push(null);
-    })
-        .catch(err => {
-        readable.destroy(err);
-    });
-    return readable;
-}
-/**
- * Compose multiple transform streams into one
- * Data flows through each transform in sequence
- */
-function compose(...transforms) {
-    const len = transforms.length;
-    if (len === 0) {
-        return new Transform({
-            objectMode: true,
-            transform: chunk => chunk
-        });
-    }
-    const isNativeTransform = (stream) => stream instanceof Transform;
-    if (len === 1 && isNativeTransform(transforms[0])) {
-        return transforms[0];
-    }
-    // Chain the transforms: first → second → ... → last
-    const first = transforms[0];
-    const last = transforms[len - 1];
-    // Pipe all transforms together
-    for (let i = 0; i < len - 1; i++) {
-        transforms[i].pipe(transforms[i + 1]);
-    }
-    class ComposedTransform extends Transform {
-        constructor() {
-            super(...arguments);
-            this._dataForwarding = false;
-            this._endForwarding = false;
-        }
-        on(event, listener) {
-            if (event === "data" && !this._dataForwarding) {
-                this._dataForwarding = true;
-                last.on("data", (chunk) => this.emit("data", chunk));
-            }
-            if (event === "end" && !this._endForwarding) {
-                this._endForwarding = true;
-                last.on("end", () => this.emit("end"));
-            }
-            return super.on(event, listener);
-        }
-        write(chunk, encodingOrCallback, callback) {
-            if (typeof encodingOrCallback === "function") {
-                return first.write(chunk, encodingOrCallback);
-            }
-            return first.write(chunk, encodingOrCallback, callback);
-        }
-        end(chunkOrCallback, encodingOrCallback, callback) {
-            if (typeof chunkOrCallback === "function") {
-                first.end(chunkOrCallback);
-                return this;
-            }
-            if (typeof encodingOrCallback === "function") {
-                first.end(chunkOrCallback, encodingOrCallback);
-                return this;
-            }
-            first.end(chunkOrCallback, encodingOrCallback, callback);
-            return this;
-        }
-        pipe(destination) {
-            return last.pipe(destination);
-        }
-        destroy(error) {
-            for (const t of transforms) {
-                t.destroy(error);
-            }
-            super.destroy(error);
-        }
-        read(size) {
-            return typeof last.read === "function" ? last.read(size) : null;
-        }
-        async *[Symbol.asyncIterator]() {
-            const it = last?.[Symbol.asyncIterator]?.();
-            if (it) {
-                for await (const chunk of it) {
-                    yield chunk;
-                }
-                return;
-            }
-            yield* super[Symbol.asyncIterator]();
-        }
-    }
-    const composed = new ComposedTransform({
-        objectMode: first?.objectMode ?? true,
-        transform: chunk => chunk
-    });
-    // Forward errors from any transform
-    for (const t of transforms) {
-        t.on("error", (err) => {
-            composed.emit("error", err);
-        });
-    }
-    // Reflect underlying readability/writability like the previous duck-typed wrapper
-    Object.defineProperty(composed, "readable", {
-        get: () => last.readable
-    });
-    Object.defineProperty(composed, "writable", {
-        get: () => first.writable
-    });
-    return composed;
-}
-/**
- * Wait for multiple streams to finish
- */
-async function finishedAll(streams) {
-    const len = streams.length;
-    if (len === 0) {
-        return;
-    }
-    if (len === 1) {
-        await finished(streams[0]);
-        return;
-    }
-    // Pre-allocate promise array
-    const promises = new Array(len);
-    for (let i = 0; i < len; i++) {
-        promises[i] = finished(streams[i]);
-    }
-    await Promise.all(promises);
-}
-// Reusable empty push callback for createEmptyReadable
-const pushNull = (readable) => {
-    readable.push(null);
-};
-/**
- * Create a readable stream that emits nothing and immediately ends
- */
-function createEmptyReadable(options) {
-    const readable = new Readable(options);
-    queueMicrotask(() => pushNull(readable));
-    return readable;
-}
-// Reusable null write handler
-const nullWriteHandler = {
-    write: () => {
-        // Discard
-    }
-};
-/**
- * Create a writable stream that discards all data (like /dev/null)
- */
-function createNullWritable(options) {
-    return new Writable({
-        ...options,
-        stream: new WritableStream(nullWriteHandler)
-    });
-}
-/**
- * Promisified version of once for events
- */
-function once(emitter, event, options) {
-    return new Promise((resolve, reject) => {
-        let onAbort;
-        let resolved = false;
-        const cleanup = () => {
-            if (resolved) {
-                return;
-            }
-            resolved = true;
-            emitter.off(event, onEvent);
-            emitter.off("error", onError);
-            if (onAbort && options?.signal) {
-                options.signal.removeEventListener("abort", onAbort);
-            }
-        };
-        const onEvent = (...args) => {
-            cleanup();
-            resolve(args);
-        };
-        const onError = (err) => {
-            cleanup();
-            reject(err);
-        };
-        emitter.once(event, onEvent);
-        emitter.once("error", onError);
-        if (options?.signal) {
-            if (options.signal.aborted) {
-                cleanup();
-                reject(new Error("Aborted"));
-                return;
-            }
-            onAbort = () => {
-                cleanup();
-                reject(new Error("Aborted"));
-            };
-            options.signal.addEventListener("abort", onAbort);
-        }
-    });
-}
-/**
- * Convert a callback-based stream operation to a promise
- */
-function promisify(fn) {
-    return new Promise((resolve, reject) => {
-        fn((error, result) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve(result);
-            }
-        });
-    });
-}
-// =============================================================================
-// Default High Water Mark Management
-// =============================================================================
-let _defaultHighWaterMark = 16384; // 16KB default
-let _defaultHighWaterMarkObjectMode = 16; // 16 objects default
-/**
- * Get the default high water mark for streams
- */
-function getDefaultHighWaterMark(objectMode) {
-    return objectMode ? _defaultHighWaterMarkObjectMode : _defaultHighWaterMark;
-}
-/**
- * Set the default high water mark for streams
- */
-function setDefaultHighWaterMark(objectMode, value) {
-    if (objectMode) {
-        _defaultHighWaterMarkObjectMode = value;
-    }
-    else {
-        _defaultHighWaterMark = value;
-    }
-}
-// =============================================================================
-// Stream State Inspection Functions
-// =============================================================================
-/**
- * Check if a stream has been destroyed
- */
-function isDestroyed(stream) {
-    return !!stream?.destroyed;
-}
-/**
- * Check if a readable stream has been disturbed (read from)
- */
-function isDisturbed(stream) {
-    if (stream instanceof Readable) {
-        return Readable.isDisturbed(stream);
-    }
-    if (stream instanceof Duplex) {
-        return Readable.isDisturbed(stream._readable);
-    }
-    const s = stream;
-    return (s?.readableDidRead === true ||
-        s?._didRead === true ||
-        s?._ended === true ||
-        s?._destroyed === true);
-}
-/**
- * Check if a stream has an error
- */
-function isErrored(stream) {
-    const err = stream?.errored;
-    return err !== null && err !== undefined;
-}
-/**
- * Check if a stream is readable
- */
-function isReadable(stream) {
-    if (stream == null) {
-        return false;
-    }
-    if (stream instanceof Readable || stream instanceof Transform) {
-        return true;
-    }
-    if (stream instanceof Duplex) {
-        return stream._readable instanceof Readable;
-    }
-    const o = stream;
-    return typeof o.read === "function" && typeof o.pipe === "function";
-}
-/**
- * Check if a stream is writable
- */
-function isWritable(stream) {
-    if (stream == null) {
-        return false;
-    }
-    if (stream instanceof Writable || stream instanceof Transform) {
-        return true;
-    }
-    if (stream instanceof Duplex) {
-        return stream._writable instanceof Writable;
-    }
-    const o = stream;
-    return typeof o.write === "function" && typeof o.end === "function";
-}
-// =============================================================================
-// Duplex Pair
-// =============================================================================
-/**
- * Create a pair of connected Duplex streams
- * Data written to one stream can be read from the other
- */
-function duplexPair(options) {
-    const stream1 = new Duplex(options);
-    const stream2 = new Duplex(options);
-    // Override write to push to the other stream's readable
-    stream1.write = function (chunk) {
-        // Push to stream2's readable side
-        stream2.push(chunk);
-        return true;
-    };
-    stream2.write = function (chunk) {
-        // Push to stream1's readable side
-        stream1.push(chunk);
-        return true;
-    };
-    // Override end to signal EOF to the other stream
-    const originalEnd1 = stream1.end.bind(stream1);
-    const originalEnd2 = stream2.end.bind(stream2);
-    stream1.end = function (chunk) {
-        if (chunk !== undefined && typeof chunk !== "function") {
-            stream2.push(chunk);
-        }
-        stream2.push(null);
-        return originalEnd1(typeof chunk === "function" ? chunk : undefined);
-    };
-    stream2.end = function (chunk) {
-        if (chunk !== undefined && typeof chunk !== "function") {
-            stream1.push(chunk);
-        }
-        stream1.push(null);
-        return originalEnd2(typeof chunk === "function" ? chunk : undefined);
-    };
-    return [stream1, stream2];
-}
-// =============================================================================
-// Stream Consumers (like stream.consumers in Node.js)
-// =============================================================================
-// Helper function to collect stream chunks with total length tracking
-async function collectStreamChunks(stream) {
-    const chunks = [];
-    let totalLength = 0;
-    let iterable;
-    if (isReadableStream(stream)) {
-        iterable = Readable.fromWeb(stream);
-    }
-    else if (isAsyncIterable(stream)) {
-        iterable = stream;
-    }
-    else {
-        throw new Error("collectStreamChunks: unsupported stream type");
-    }
-    for await (const chunk of iterable) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
-    }
-    return { chunks, totalLength };
-}
-// Helper to concatenate with known length (faster)
-function concatWithLength(chunks, totalLength) {
-    const len = chunks.length;
-    if (len === 0) {
-        return new Uint8Array(0);
-    }
-    if (len === 1) {
-        return chunks[0];
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0; i < len; i++) {
-        result.set(chunks[i], offset);
-        offset += chunks[i].length;
-    }
-    return result;
-}
-exports.consumers = {
-    /**
-     * Consume entire stream as ArrayBuffer
-     */
-    async arrayBuffer(stream) {
-        const { chunks, totalLength } = await collectStreamChunks(stream);
-        const combined = concatWithLength(chunks, totalLength);
-        return combined.buffer.slice(combined.byteOffset, combined.byteOffset + combined.byteLength);
-    },
-    /**
-     * Consume entire stream as Blob
-     */
-    async blob(stream, options) {
-        const { chunks } = await collectStreamChunks(stream);
-        return new Blob(chunks, options);
-    },
-    /**
-     * Consume entire stream as Buffer (Uint8Array in browser)
-     */
-    async buffer(stream) {
-        const { chunks, totalLength } = await collectStreamChunks(stream);
-        return concatWithLength(chunks, totalLength);
-    },
-    /**
-     * Consume entire stream as JSON
-     */
-    async json(stream) {
-        const text = await exports.consumers.text(stream);
-        return JSON.parse(text);
-    },
-    /**
-     * Consume entire stream as text
-     */
-    async text(stream, encoding) {
-        const { chunks, totalLength } = await collectStreamChunks(stream);
-        const combined = concatWithLength(chunks, totalLength);
-        const decoder = encoding ? (0, shared_1.getTextDecoder)(encoding) : shared_1.textDecoder;
-        return decoder.decode(combined);
-    }
-};
-// =============================================================================
-// Promises API (like stream/promises in Node.js)
-// =============================================================================
-exports.promises = {
-    pipeline,
-    finished
-};