@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/browser/modules/stream/browser/duplex.js

@@ -0,0 +1,966 @@
+/**
+ * Browser Stream - Duplex
+ */
+import { StreamTypeError } from "../errors.js";
+import { EventEmitter } from "../../../utils/event-emitter.js";
+import { createAbortError } from "../../../utils/errors.js";
+import { parseEndArgs } from "../common/end-args.js";
+import { Readable } from "./readable.js";
+import { Writable } from "./writable.js";
+import { addEmitterListener, createListenerRegistry } from "./helpers.js";
+import { deferTask, inDeferredContext } from "./microtask-context.js";
+// =============================================================================
+// Duplex Stream
+// =============================================================================
+/**
+ * A duplex stream that combines readable and writable
+ */
+export class Duplex extends EventEmitter {
+    /**
+     * Allow duck-typed instanceof checks.
+     * Browser Duplex composes Readable + Writable, so we use Symbol.hasInstance
+     * to check for key Duplex-like methods/properties (both readable and writable).
+     * This makes `transform instanceof Duplex` return true.
+     */
+    static [Symbol.hasInstance](instance) {
+        if (instance == null || typeof instance !== "object") {
+            return false;
+        }
+        // Fast path: actual Duplex prototype
+        if (Object.prototype.isPrototypeOf.call(Duplex.prototype, instance)) {
+            return true;
+        }
+        // Duck-type: must have both Readable and Writable characteristics + stream brand
+        return (instance.__excelts_stream === true &&
+            typeof instance.read === "function" &&
+            typeof instance.pipe === "function" &&
+            typeof instance.write === "function" &&
+            typeof instance.end === "function" &&
+            typeof instance.on === "function" &&
+            "readableFlowing" in instance &&
+            "writableFinished" in instance);
+    }
+    /**
+     * Check if a stream has been disturbed (data read or piped).
+     * Delegates to Readable.isDisturbed, checking internal _readable for Duplex/Transform.
+     */
+    static isDisturbed(stream) {
+        if (stream && stream._readable instanceof Readable) {
+            return Readable.isDisturbed(stream._readable);
+        }
+        return Readable.isDisturbed(stream);
+    }
+    /**
+     * 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();
+                }
+            });
+            const onError = (err) => {
+                duplex.emit("error", err);
+            };
+            const cleanupError = addEmitterListener(readable, "error", onError);
+            addEmitterListener(readable, "end", cleanupError, { once: true });
+            addEmitterListener(readable, "close", cleanupError, { once: true });
+            addEmitterListener(sink, "finish", cleanupError, { once: true });
+            readable.pipe(sink);
+        };
+        // Promise source — resolve and recursively call from()
+        if (source instanceof Promise) {
+            const duplex = new Duplex({ objectMode: true });
+            source
+                .then(value => {
+                const inner = Duplex.from(value);
+                forwardReadableToDuplex(inner, duplex);
+            })
+                .catch(err => {
+                duplex.destroy(err instanceof Error ? err : new Error(String(err)));
+            });
+            return duplex;
+        }
+        // String source — wrap as a single-chunk readable
+        if (typeof source === "string") {
+            const readable = Readable.from([source]);
+            const duplex = new Duplex({ objectMode: true });
+            forwardReadableToDuplex(readable, duplex);
+            return duplex;
+        }
+        // Blob source — convert to ReadableStream then to Readable
+        if (typeof Blob !== "undefined" && source instanceof Blob) {
+            const readable = Readable.fromWeb(source.stream());
+            const duplex = new Duplex();
+            forwardReadableToDuplex(readable, duplex);
+            return duplex;
+        }
+        // If it has readable and/or writable properties
+        if (typeof source === "object" &&
+            source !== null &&
+            "readable" in source &&
+            "writable" in source) {
+            const pair = source;
+            // Create one duplex that can bridge both sides.
+            // (Previous behavior returned a new writable-only Duplex and dropped the readable side.)
+            const duplex = new Duplex({
+                readableObjectMode: pair.readable?.readableObjectMode,
+                writableObjectMode: pair.writable?.writableObjectMode,
+                write: pair.writable
+                    ? (chunk, encoding, callback) => {
+                        pair.writable.write(chunk, encoding, callback);
+                    }
+                    : undefined,
+                final: pair.writable
+                    ? callback => {
+                        pair.writable.end(callback);
+                    }
+                    : undefined,
+                destroy: (error, callback) => {
+                    // Propagate destroy to the original source streams so they are cleaned
+                    // up when the wrapping Duplex is destroyed. Node.js does this too.
+                    if (pair.readable && !pair.readable.destroyed) {
+                        pair.readable.destroy(error ?? undefined);
+                    }
+                    if (pair.writable && !pair.writable.destroyed) {
+                        pair.writable.destroy(error ?? undefined);
+                    }
+                    callback(error);
+                }
+            });
+            if (pair.readable) {
+                forwardReadableToDuplex(pair.readable, duplex);
+            }
+            return duplex;
+        }
+        // Web ReadableStream — wrap as readable-only Duplex (matches Node.js Duplex.from(ReadableStream))
+        if (typeof source === "object" &&
+            source !== null &&
+            typeof source.getReader === "function" &&
+            typeof source.cancel === "function") {
+            const readable = Readable.fromWeb(source);
+            const duplex = new Duplex({
+                objectMode: readable.readableObjectMode
+            });
+            forwardReadableToDuplex(readable, duplex);
+            return duplex;
+        }
+        // Web WritableStream — wrap as writable-only Duplex (matches Node.js Duplex.from(WritableStream))
+        if (typeof source === "object" &&
+            source !== null &&
+            typeof source.getWriter === "function" &&
+            typeof source.close === "function") {
+            const writable = Writable.fromWeb(source);
+            return new Duplex({
+                objectMode: writable.writableObjectMode,
+                write(chunk, encoding, callback) {
+                    writable.write(chunk, encoding, callback);
+                },
+                final(callback) {
+                    writable.end(callback);
+                },
+                destroy(error, callback) {
+                    if (!writable.destroyed) {
+                        writable.destroy(error ?? undefined);
+                    }
+                    callback(error);
+                }
+            });
+        }
+        // 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({
+                objectMode: readable.readableObjectMode
+            });
+            forwardReadableToDuplex(readable, duplex);
+            return duplex;
+        }
+        // If it's a Readable
+        if (source instanceof Readable) {
+            const duplex = new Duplex({
+                objectMode: source.readableObjectMode
+            });
+            forwardReadableToDuplex(source, duplex);
+            return duplex;
+        }
+        // If it's a Writable
+        if (source instanceof Writable) {
+            return new Duplex({
+                objectMode: source.writableObjectMode,
+                write(chunk, encoding, callback) {
+                    source.write(chunk, encoding, callback);
+                },
+                final(callback) {
+                    source.end(callback);
+                }
+            });
+        }
+        throw new StreamTypeError("Duplex-compatible source", typeof source);
+    }
+    /**
+     * Create a Duplex from a Web ReadableWritablePair
+     */
+    static fromWeb(pair, options) {
+        const duplex = new Duplex(options);
+        const newReadable = new Readable({
+            stream: pair.readable,
+            objectMode: duplex.readableObjectMode
+        });
+        const newWritable = new Writable({
+            stream: pair.writable,
+            objectMode: duplex.writableObjectMode
+        });
+        if (duplex._sideForwardingCleanup) {
+            duplex._sideForwardingCleanup();
+            duplex._sideForwardingCleanup = null;
+        }
+        duplex._readable = newReadable;
+        duplex._writable = newWritable;
+        // Re-wire event forwarding (data forwarding remains lazy via Duplex.on)
+        duplex._setupSideForwarding();
+        return duplex;
+    }
+    /**
+     * Convert a Node.js Duplex to Web ReadableWritablePair
+     */
+    static toWeb(duplex) {
+        return {
+            readable: Readable.toWeb(duplex._readable),
+            writable: Writable.toWeb(duplex._writable)
+        };
+    }
+    /**
+     * Detect a subclass-defined implementation hook (e.g. _read/_write/_writev/_final).
+     *
+     * Node.js allows implementing Duplex by subclassing and defining _read/_write on the
+     * subclass prototype. Since the browser Duplex composes internal Readable/Writable
+     * instances, we must explicitly forward these prototype hooks.
+     */
+    _getSubclassHook(name) {
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Duplex.prototype && proto !== Object.prototype) {
+            if (Object.prototype.hasOwnProperty.call(proto, name)) {
+                const fn = this[name];
+                if (typeof fn === "function") {
+                    return fn.bind(this);
+                }
+                return undefined;
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return undefined;
+    }
+    constructor(options) {
+        super();
+        // Track if we've already set up data forwarding
+        this._dataForwardingSetup = false;
+        this._destroyed = false;
+        this._errored = null;
+        this._closed = false;
+        this._sideForwardingCleanup = null;
+        this._constructed = true;
+        this.__excelts_stream = true;
+        this.allowHalfOpen = options?.allowHalfOpen ?? true;
+        this._emitClose = options?.emitClose ?? true;
+        this._autoDestroy = options?.autoDestroy ?? true;
+        // Support shorthand objectMode option
+        const objectMode = options?.objectMode ?? false;
+        const readableObjMode = options?.readableObjectMode ?? objectMode;
+        const writableObjMode = options?.writableObjectMode ?? objectMode;
+        // HWM: if highWaterMark is explicitly provided it overrides per-side (matching Node)
+        const hasGeneralHwm = options != null && Object.prototype.hasOwnProperty.call(options, "highWaterMark");
+        const readableHwm = hasGeneralHwm ? options.highWaterMark : options?.readableHighWaterMark;
+        const writableHwm = hasGeneralHwm ? options.highWaterMark : options?.writableHighWaterMark;
+        // Store user-provided destroy function
+        if (options?.destroy) {
+            this._destroy = options.destroy.bind(this);
+        }
+        // Store user-provided construct function
+        if (options?.construct) {
+            this._constructFunc = options.construct.bind(this);
+        }
+        // When Duplex has a construct hook, propagate delay to child streams
+        // so that reads/writes are queued until the Duplex-level construct fires.
+        let readableConstructCb;
+        let writableConstructCb;
+        const hasConstruct = this._hasConstructHook();
+        const readHook = options?.read ? options.read.bind(this) : this._getSubclassHook("_read");
+        // Prefer constructor options over subclass hooks (matches Node's behavior where
+        // options.{read,write,final,writev} override prototype hooks).
+        const writeHook = options?.write
+            ? options.write.bind(this)
+            : this._getSubclassHook("_write");
+        const writevHook = options?.writev
+            ? options.writev.bind(this)
+            : this._getSubclassHook("_writev");
+        const finalHook = options?.final
+            ? options.final.bind(this)
+            : this._getSubclassHook("_final");
+        this._readable = new Readable({
+            highWaterMark: readableHwm,
+            objectMode: readableObjMode,
+            read: readHook,
+            encoding: options?.encoding,
+            // Suppress child-level close/error — Duplex itself is the authority
+            emitClose: false,
+            autoDestroy: false,
+            // Propagate construct delay to child readable
+            construct: hasConstruct
+                ? cb => {
+                    readableConstructCb = cb;
+                }
+                : undefined
+        });
+        this._writable = new Writable({
+            highWaterMark: writableHwm,
+            objectMode: writableObjMode,
+            write: writeHook,
+            writev: writevHook,
+            final: finalHook,
+            decodeStrings: options?.decodeStrings,
+            defaultEncoding: options?.defaultEncoding,
+            // Suppress child-level close/error — Duplex itself is the authority
+            emitClose: false,
+            autoDestroy: false,
+            // Propagate construct delay to child writable
+            construct: hasConstruct
+                ? cb => {
+                    writableConstructCb = cb;
+                }
+                : undefined
+        });
+        // Prevent unhandled error throws on child streams.
+        // Errors are forwarded to the Duplex via _setupSideForwarding; these
+        // noop listeners act as safety nets after forwarding cleanup.
+        const noop = () => { };
+        this._readable.on("error", noop);
+        this._writable.on("error", noop);
+        this._setupSideForwarding();
+        // signal option — destroy the Duplex when signal aborts (matching Node)
+        if (options?.signal) {
+            this._setupAbortSignal(options.signal);
+        }
+        // R5-1: _construct hook — if provided, delay reads/writes until constructed
+        if (hasConstruct) {
+            this._constructed = false;
+            deferTask(() => {
+                const fn = this._constructFunc ?? this._construct.bind(this);
+                fn(err => {
+                    if (err) {
+                        readableConstructCb?.(err);
+                        writableConstructCb?.(err);
+                        this.destroy(err);
+                        return;
+                    }
+                    this._constructed = true;
+                    // Unblock child streams by firing their construct callbacks
+                    readableConstructCb?.();
+                    writableConstructCb?.();
+                });
+            });
+        }
+    }
+    _setupAbortSignal(signal) {
+        if (signal.aborted) {
+            this.destroy(createAbortError(signal.reason));
+            return;
+        }
+        const onAbort = () => {
+            this.destroy(createAbortError(signal.reason));
+        };
+        const cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.once("close", cleanup);
+    }
+    _setupSideForwarding() {
+        if (this._sideForwardingCleanup) {
+            this._sideForwardingCleanup();
+            this._sideForwardingCleanup = null;
+        }
+        // Ensure the pipe source identity is always the outer Duplex,
+        // including after fromWeb() replaces the internal _readable.
+        this._readable._pipes?.setSource(this);
+        const registry = createListenerRegistry();
+        // Deduplicate error forwarding: when destroy(err) tears down both sides,
+        // both _readable and _writable emit "error". Node.js Duplex only emits
+        // one "error" event, so we guard against duplicate forwarding.
+        let errorForwarded = false;
+        const forwardError = (err) => {
+            if (errorForwarded) {
+                return;
+            }
+            errorForwarded = true;
+            this.emit("error", err);
+        };
+        // Auto-destroy: when both sides finish, destroy the Duplex (matching Node.js).
+        let readableEnded = false;
+        let writableFinished = false;
+        const maybeAutoDestroy = () => {
+            if (this._autoDestroy && readableEnded && writableFinished && !this._destroyed) {
+                this.destroy();
+            }
+        };
+        // Forward non-data events (data forwarding is lazy to avoid premature flowing)
+        registry.once(this._readable, "end", () => {
+            this.emit("end");
+            readableEnded = true;
+            if (!this.allowHalfOpen) {
+                this._writable.end();
+            }
+            maybeAutoDestroy();
+        });
+        registry.add(this._readable, "error", forwardError);
+        // Use EventEmitter.prototype.on directly to register "readable" forwarding,
+        // bypassing Readable's on() override which sets readableFlowing = false.
+        const readableForwarder = () => {
+            this.emit("readable");
+        };
+        EventEmitter.prototype.on.call(this._readable, "readable", readableForwarder);
+        registry.add(this._readable, "pause", () => this.emit("pause"));
+        registry.add(this._readable, "resume", () => this.emit("resume"));
+        registry.add(this._writable, "error", forwardError);
+        registry.once(this._writable, "prefinish", () => this.emit("prefinish"));
+        registry.once(this._writable, "finish", () => {
+            this.emit("finish");
+            writableFinished = true;
+            maybeAutoDestroy();
+        });
+        registry.add(this._writable, "drain", () => this.emit("drain"));
+        // Forward "pipe"/"unpipe" from the internal writable so that
+        // source.pipe(duplex) triggers "pipe" on the Duplex itself.
+        registry.add(this._writable, "pipe", source => this.emit("pipe", source));
+        registry.add(this._writable, "unpipe", source => this.emit("unpipe", source));
+        // Node.js: when allowHalfOpen is false and the writable side finishes,
+        // gracefully end the readable side with push(null) — NOT destroy().
+        // The check is dynamic (inside the handler) so runtime changes to
+        // allowHalfOpen are respected, matching Node.js behaviour.
+        registry.once(this._writable, "finish", () => {
+            if (!this.allowHalfOpen && !this._readable.readableEnded) {
+                this._readable.push(null);
+            }
+        });
+        // Node.js parity: when the internal _readable is destroyed independently
+        // (e.g. by a higher-order method like map/filter/forEach that uses the
+        // async iterator and calls _readable.destroy() on error or early exit),
+        // propagate the destruction to the outer Duplex.  Without this, only the
+        // readable side would be torn down, leaving the writable side open — a
+        // resource leak that doesn't happen in Node.js where Duplex IS the
+        // Readable (same object, so destroy() hits both sides).
+        const origReadableDestroy = this._readable.destroy.bind(this._readable);
+        this._readable.destroy = (err) => {
+            const result = origReadableDestroy(err);
+            if (!this._destroyed) {
+                this.destroy(err);
+            }
+            return result;
+        };
+        this._sideForwardingCleanup = () => {
+            registry.cleanup();
+            this._readable.off("readable", readableForwarder);
+            // Restore original destroy to avoid leaking the closure after cleanup.
+            this._readable.destroy = origReadableDestroy;
+        };
+    }
+    /**
+     * Override on() to set up data forwarding lazily
+     */
+    on(event, listener) {
+        // Register the listener FIRST so that when _readable.on("data") triggers
+        // resume() and synchronously drains buffered data, the forwarding handler
+        // can find the listener already in place on this Duplex.
+        super.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));
+        }
+        else if (event === "readable") {
+            // Node.js: adding a 'readable' listener sets readableFlowing to false
+            this._readable._setReadableFlowing(false);
+        }
+        return this;
+    }
+    /**
+     * Push data to readable side
+     */
+    push(chunk, encoding) {
+        return this._readable.push(chunk, encoding);
+    }
+    /**
+     * Put a chunk back at the front of the buffer (readable side)
+     */
+    unshift(chunk, encoding) {
+        this._readable.unshift(chunk, encoding);
+    }
+    /**
+     * Read from readable side
+     */
+    read(size) {
+        return this._readable.read(size);
+    }
+    write(chunk, encodingOrCallback, callback) {
+        const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : undefined;
+        const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        return encoding !== undefined
+            ? this._writable.write(chunk, encoding, cb)
+            : this._writable.write(chunk, cb);
+    }
+    end(chunkOrCallback, encodingOrCallback, callback) {
+        const { chunk, encoding, cb } = parseEndArgs(chunkOrCallback, encodingOrCallback, callback);
+        // Repeated end() protection (matches Node.js Writable.end() behavior)
+        if (this._writable.writableEnded) {
+            // If a chunk was provided, this is a write-after-end error.
+            if (chunk !== undefined) {
+                this.write(chunk, encoding, err => {
+                    cb?.(err ?? null);
+                });
+                return this;
+            }
+            // If we've already finished, callback receives ERR_STREAM_ALREADY_FINISHED.
+            if (this.writableFinished && cb) {
+                const err = new Error("Cannot call end after a stream was finished");
+                err.code = "ERR_STREAM_ALREADY_FINISHED";
+                deferTask(() => cb(err));
+            }
+            else if (cb) {
+                // Redundant end() is a no-op; callback called with no error.
+                deferTask(() => cb(null));
+            }
+            return this;
+        }
+        if (cb) {
+            // Node.js fires the end() callback on 'finish', but also on 'close'
+            // (which is emitted after destroy). This ensures the callback fires
+            // even when the stream is destroyed before finishing.
+            let called = false;
+            const onceCb = () => {
+                if (!called) {
+                    called = true;
+                    cb();
+                }
+            };
+            this.once("finish", onceCb);
+            this.once("close", onceCb);
+        }
+        if (chunk !== undefined) {
+            // Propagate write errors through destroy (matching Node.js)
+            const onWriteError = (err) => {
+                if (err && !this.destroyed) {
+                    this.destroy(err);
+                }
+            };
+            if (encoding !== undefined) {
+                this._writable.write(chunk, encoding, onWriteError);
+            }
+            else {
+                this._writable.write(chunk, onWriteError);
+            }
+        }
+        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.
+     * Accepts any writable-like object (duck-typed, matching Node.js behavior).
+     */
+    pipe(destination, options) {
+        this._readable.pipe(destination, options);
+        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) {
+        if (this._destroyed) {
+            return this;
+        }
+        this._destroyed = true;
+        if (this._sideForwardingCleanup) {
+            this._sideForwardingCleanup();
+            this._sideForwardingCleanup = null;
+        }
+        const afterDestroy = (finalError) => {
+            // Node.js: _destroy's callback determines whether an error is emitted.
+            // cb(null)/cb()/cb(undefined) all suppress the original error.
+            // Only cb(new Error(...)) replaces and emits the error.
+            const err = finalError || null;
+            if (err) {
+                this._errored = err;
+            }
+            this._closed = true;
+            // Destroy internal streams without their own error/close emission — the
+            // Duplex itself is the authority for those events.
+            this._readable.destroy();
+            this._writable.destroy();
+            const doEmit = () => {
+                if (err) {
+                    this.emit("error", err);
+                }
+                if (this._emitClose) {
+                    this.emit("close");
+                }
+            };
+            if (inDeferredContext() &&
+                !this._hasDestroyHook() &&
+                this.readableEnded &&
+                this.writableFinished) {
+                doEmit();
+            }
+            else {
+                deferTask(doEmit);
+            }
+        };
+        if (this._hasDestroyHook()) {
+            try {
+                this._destroy(error ?? null, afterDestroy);
+            }
+            catch (err) {
+                afterDestroy(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        else {
+            afterDestroy(error);
+        }
+        return this;
+    }
+    /**
+     * Override in subclass to customise destroy behaviour.
+     * Call `callback(err)` when cleanup is complete.
+     */
+    _destroy(error, callback) {
+        callback(error);
+    }
+    /**
+     * Reverse the effects of destroy() so the stream can potentially be reused.
+     * Matches Node.js _undestroy() which resets destroyed and closed flags.
+     */
+    _undestroy() {
+        this._readable._undestroy();
+        this._writable._undestroy();
+        this._destroyed = false;
+        this._closed = false;
+        this._errored = null;
+        this._setupSideForwarding();
+    }
+    /** Check if _destroy has been overridden by a subclass or constructor option. */
+    _hasDestroyHook() {
+        return (Object.prototype.hasOwnProperty.call(this, "_destroy") ||
+            Object.getPrototypeOf(this)._destroy !== Duplex.prototype._destroy);
+    }
+    /**
+     * Check if a subclass defines _construct on its own prototype.
+     * Node.js does NOT have _construct on any stream prototype — it only exists
+     * when provided via constructor options or defined by a subclass.
+     */
+    _hasConstructHook() {
+        if (this._constructFunc) {
+            return true;
+        }
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Duplex.prototype && proto !== Object.prototype) {
+            if (Object.prototype.hasOwnProperty.call(proto, "_construct")) {
+                return true;
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return false;
+    }
+    /**
+     * Synchronous dispose — destroys the stream.
+     * Matches Node.js Symbol.dispose support (v20+, experimental).
+     */
+    [Symbol.dispose]() {
+        if (!this._destroyed) {
+            this.destroy();
+        }
+    }
+    /**
+     * Async dispose support (using await).
+     * Destroys the stream and resolves after the 'close' event.
+     */
+    async [Symbol.asyncDispose]() {
+        // Match Node.js behavior:
+        // 1. If not yet destroyed, destroy the stream (always resolves)
+        // 2. If already destroyed by someone else, reject with "Premature close"
+        //    unless the stream ended gracefully (writableFinished)
+        const selfInitiated = !this._destroyed;
+        if (selfInitiated) {
+            this.destroy();
+        }
+        return new Promise((resolve, reject) => {
+            const settle = () => {
+                if (selfInitiated || this.writableFinished) {
+                    resolve();
+                }
+                else {
+                    reject(new Error("Premature close"));
+                }
+            };
+            if (this._closed) {
+                settle();
+            }
+            else {
+                this.once("close", settle);
+            }
+        });
+    }
+    get readable() {
+        return this._readable.readable;
+    }
+    set readable(val) {
+        this._readable.readable = val;
+    }
+    get writable() {
+        return this._writable.writable;
+    }
+    set writable(val) {
+        this._writable.writable = val;
+    }
+    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._destroyed;
+    }
+    set destroyed(val) {
+        this._destroyed = val;
+        // Propagate to internal streams so their state stays consistent with
+        // the Duplex — matches Node.js where Duplex/Readable/Writable share
+        // a single destroyed flag via the prototype chain.
+        this._readable.destroyed = val;
+        this._writable.destroyed = val;
+    }
+    get writableCorked() {
+        return this._writable.writableCorked;
+    }
+    get writableNeedDrain() {
+        return this._writable.writableNeedDrain;
+    }
+    get readableObjectMode() {
+        return this._readable.readableObjectMode;
+    }
+    get writableObjectMode() {
+        return this._writable.writableObjectMode;
+    }
+    get readableFlowing() {
+        return this._readable.readableFlowing;
+    }
+    get readableAborted() {
+        return this._readable.readableAborted;
+    }
+    get readableDidRead() {
+        return this._readable.readableDidRead;
+    }
+    get readableEncoding() {
+        return this._readable.readableEncoding;
+    }
+    get errored() {
+        return this._errored ?? this._readable.errored ?? this._writable.errored;
+    }
+    get closed() {
+        return this._closed;
+    }
+    get readableBuffer() {
+        return this._readable.readableBuffer;
+    }
+    get writableBuffer() {
+        return this._writable.writableBuffer;
+    }
+    /**
+     * Wrap a legacy stream
+     */
+    wrap(stream) {
+        this._readable.wrap(stream);
+        return this;
+    }
+    /**
+     * Create an async iterator with options.
+     *
+     * Node.js parity: when `destroyOnReturn` is true (the default) and the
+     * iterator exits early (break/return), the entire Duplex is destroyed —
+     * not just the readable side.  The inner `_readable`'s iterator would only
+     * destroy `_readable` (which has `autoDestroy: false`, `emitClose: false`),
+     * leaving the writable side open.  We wrap the iterator so that `return()`
+     * propagates destruction to the outer Duplex.
+     */
+    iterator(options) {
+        const destroyOnReturn = options?.destroyOnReturn !== false;
+        if (!destroyOnReturn) {
+            // No destruction needed on return — delegate directly.
+            return this._readable.iterator(options);
+        }
+        return this._wrapAsyncIterator(this._readable[Symbol.asyncIterator]());
+    }
+    /**
+     * Async iterator support.
+     * Wraps the inner readable's iterator so that early exit destroys the
+     * entire Duplex (both readable and writable sides), matching Node.js.
+     */
+    [Symbol.asyncIterator]() {
+        return this._wrapAsyncIterator(this._readable[Symbol.asyncIterator]());
+    }
+    /**
+     * Wrap an inner readable iterator so that return()/throw() destroy the
+     * outer Duplex, not just the inner readable.
+     */
+    _wrapAsyncIterator(inner) {
+        // oxlint-disable-next-line no-this-alias -- needed for object literal method closures
+        const duplex = this;
+        return {
+            next() {
+                return inner.next();
+            },
+            async return() {
+                const result = await inner.return?.();
+                if (!duplex.destroyed) {
+                    duplex.destroy();
+                }
+                return result ?? { value: undefined, done: true };
+            },
+            async throw(err) {
+                const result = await inner.throw?.(err);
+                if (!duplex.destroyed) {
+                    duplex.destroy(err instanceof Error ? err : undefined);
+                }
+                return result ?? { value: undefined, done: true };
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            }
+        };
+    }
+    // =============================================================================
+    // Functional / Higher-order Methods (forwarded to readable side)
+    // =============================================================================
+    map(fn, options) {
+        return this._readable.map(fn, options);
+    }
+    filter(fn, options) {
+        return this._readable.filter(fn, options);
+    }
+    async forEach(fn, options) {
+        return this._readable.forEach(fn, options);
+    }
+    async toArray(options) {
+        return this._readable.toArray(options);
+    }
+    async some(fn, options) {
+        return this._readable.some(fn, options);
+    }
+    async find(fn, options) {
+        return this._readable.find(fn, options);
+    }
+    async every(fn, options) {
+        return this._readable.every(fn, options);
+    }
+    flatMap(fn, options) {
+        return this._readable.flatMap(fn, options);
+    }
+    drop(limit, options) {
+        return this._readable.drop(limit, options);
+    }
+    take(limit, options) {
+        return this._readable.take(limit, options);
+    }
+    async reduce(fn, initial, options) {
+        if (arguments.length >= 2) {
+            return this._readable.reduce(fn, initial, options);
+        }
+        return this._readable.reduce(fn);
+    }
+    compose(stream, options) {
+        return this._readable.compose(stream, options);
+    }
+}
+// Node.js: `Duplex.prototype.addListener === Duplex.prototype.on` (same function).
+// Duplex overrides `on` from EventEmitter, so we must re-alias `addListener`.
+Duplex.prototype.addListener = Duplex.prototype.on;
+// Node.js: Duplex.prototype._writev === null (copied from Writable).
+Duplex.prototype._writev = null;