documonster 0.20.2 → 0.21.0

package/README.md

@@ -211,7 +211,7 @@ const buffer = await Workbook.toBuffer(wb);
 
 ```html
 <!-- Script tag (no bundler) — one IIFE per module, each under the shared `Documonster` global -->
-<script src="https://unpkg.com/documonster@0.20.2/dist/iife/documonster.excel.iife.min.js"></script>
+<script src="https://unpkg.com/documonster@0.21.0/dist/iife/documonster.excel.iife.min.js"></script>
 <script>
   const { Workbook, Cell } = Documonster.Excel;
   const wb = Workbook.create();

package/README_zh.md

@@ -198,7 +198,7 @@ const buffer = await Workbook.toBuffer(wb);
 
 ```html
 <!-- Script 标签（无需打包工具）— 每个模块一个 IIFE，共享同一个 `Documonster` 全局 -->
-<script src="https://unpkg.com/documonster@0.20.2/dist/iife/documonster.excel.iife.min.js"></script>
+<script src="https://unpkg.com/documonster@0.21.0/dist/iife/documonster.excel.iife.min.js"></script>
 <script>
   const { Workbook, Cell } = Documonster.Excel;
   const wb = Workbook.create();

package/THIRD_PARTY_NOTICES.md

@@ -5,8 +5,8 @@ documonster as a whole is licensed under the Apache License, Version 2.0
 third-party components identified, and do not affect the licensing of the
 remainder of the project.
 
-The PDF, Word, Formula, CSV, Markdown, XML, Archive, and Stream modules, as
-well as the parts of the Excel module not listed below, are original works of
+The PDF, Word, Formula, CSV, Markdown, XML, and Archive modules, as well as the
+parts of the Excel and Stream modules not listed below, are original works of
 the documonster authors and are licensed under the Apache License, Version 2.0.
 
 ---
@@ -39,3 +39,35 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+## Node.js (Stream module kernel)
+
+The stream kernel in `src/modules/stream/kernel/` — the browser's stream classes,
+and the Web adapters and pipeline both entry points use — is a port of Node.js
+`lib/internal/streams/` and `lib/internal/webstreams/adapters.js`. That
+derivative code remains subject to the Node.js MIT License, reproduced below.
+The following copyright notice and permission notice are retained in
+compliance with that license.
+
+Copyright Joyent, Inc. and other Node contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/esm/modules/archive/core/byte-queue.js

@@ -21,7 +21,8 @@ export class ByteQueue {
         }
     }
     _dropHeadChunk() {
-        this._chunkHead++;
+        // Release the consumed chunk now rather than at the next compaction.
+        this._chunks[this._chunkHead++] = undefined;
         this._headOffset = 0;
         this._compactConsumedChunks();
     }

package/dist/esm/modules/archive/unzip/stream.browser.js

@@ -314,6 +314,8 @@ onmessage = async (ev) => {
 class WorkerInflateRaw extends Duplex {
     constructor(workerUrl) {
         super({
+            // Output is pushed as the worker replies, not on demand.
+            read() { },
             write: (chunk, _encoding, callback) => {
                 this._doWrite(chunk, callback);
             },
@@ -465,6 +467,8 @@ class FallbackInflateRaw extends Duplex {
         this.chunks = [];
         this._finished = false;
     }
+    // Output is pushed when decompression completes, not on demand.
+    _read() { }
     _decompress(callback) {
         try {
             // Combine all chunks
@@ -513,6 +517,8 @@ export function createParseClass(createInflateRawFn) {
         constructor(opts = {}) {
             super({
                 objectMode: true,
+                // Entries are pushed by the parse loop, not on demand.
+                read() { },
                 write: (chunk, _encoding, callback) => {
                     this._handleWrite(chunk, callback);
                 },

package/dist/esm/modules/csv/parse/async.js

@@ -21,7 +21,7 @@ import { getUtf8ByteLength } from "../constants.js";
 import { CsvError } from "../errors.js";
 import { parseCsv } from "./sync.js";
 import { CsvParserStream } from "../stream/parser.js";
-import { isReadableStreamLike, readableStreamToAsyncIterable } from "../../stream/utils.base.js";
+import { isReadableStreamLike, readableStreamToAsyncIterable } from "../../stream/core/stream-helpers.js";
 import { toError } from "../../../utils/errors.js";
 /**
  * Rows buffered for the generator's consumer before the parser is paused.
@@ -40,6 +40,7 @@ function normalizeAsyncInput(input) {
         return input;
     }
     if (isReadableStreamLike(input)) {
+        // The documented input: a Web stream of text or bytes, like any other source here.
         return readableStreamToAsyncIterable(input);
     }
     throw new TypeError("input must be an AsyncIterable or a ReadableStream");

package/dist/esm/modules/excel/bridge/csv-bridge.js

@@ -24,7 +24,7 @@ import { addWorksheet, getWorksheet } from "#platform/modules/excel/core/workboo
 import { addRow, eachRow } from "../core/worksheet.js";
 import { ExcelDownloadError } from "../errors.js";
 import { pipeline } from "#platform/modules/stream/index";
-import { readableStreamToAsyncIterable } from "../../stream/utils.base.js";
+import { readableStreamToAsyncIterable } from "../../stream/core/stream-helpers.js";
 import { createDateParser, createDateFormatter, createIsoDateFormatter } from "../../../utils/datetime.js";
 // =============================================================================
 // Constants

package/dist/esm/modules/excel/core/xlsx-io.browser.js

@@ -142,15 +142,11 @@ export async function writeStream(wb, stream, options) {
  *
  * ### Leaving `for await` early
  *
- * Breaking out of the loop destroys the stream with no error, so `errored` stays
- * `null` and no `'error'` listener fires. Use
- * `stream.iterator({ destroyOnReturn: false })` to keep the stream alive past the
- * loop — you then have to `destroy()` it yourself, or the serializer stays parked.
- *
- * Note this differs from the Node build, where Node's own async iterator destroys
- * the stream with an `AbortError` on early exit and sets `errored`. `errored` is
- * therefore not a portable way to distinguish "the consumer stopped" from
- * "serialization failed"; track that yourself if the same code runs on both.
+ * As in Node, breaking out of the loop destroys the stream with an `AbortError`:
+ * `errored` is set and an attached `'error'` listener receives it. To leave
+ * silently, `destroy()` the stream before `break`, or iterate
+ * `stream.iterator({ destroyOnReturn: false })` and `destroy()` it yourself
+ * afterwards — otherwise the serializer stays parked.
  */
 export function toStream(wb, options) {
     if (options?.format === "xlsb") {

package/dist/esm/modules/excel/core/xlsx-io.js

@@ -218,9 +218,7 @@ export async function writeStream(wb, stream, options) {
  * }
  * ```
  *
- * The browser build destroys silently on early exit instead, so `errored` is not
- * a portable way to tell "the consumer stopped" from "serialization failed" —
- * track that yourself if the same code runs on both platforms.
+ * The browser build behaves the same way: its stream kernel is a port of Node's.
  */
 export function toStream(wb, options) {
     if (options?.format === "xlsb") {

package/dist/esm/modules/excel/core/xlsx-stream.js

@@ -1,5 +1,7 @@
 import { createReadable } from "#platform/modules/stream/index";
 const textEncoder = new TextEncoder();
+/** 64 KB: the same threshold on Node (whose own default is 16 KB on Windows), Bun and browsers. */
+const DEFAULT_HIGH_WATER_MARK = 64 * 1024;
 /**
  * Wrap a push-shaped XLSX serializer in a demand-driven readable byte stream.
  *
@@ -8,7 +10,7 @@ const textEncoder = new TextEncoder();
  * the backpressure signal the writer parks on at its next ZIP-entry boundary.
  */
 export function createXlsxByteStream(serialize, options) {
-    const { highWaterMark, ...writeOptions } = options ?? {};
+    const { highWaterMark = DEFAULT_HIGH_WATER_MARK, ...writeOptions } = options ?? {};
     const listeners = new Map();
     let started = false;
     let ended = false;

package/dist/esm/modules/excel/stream/workbook-reader.browser.js

@@ -222,13 +222,11 @@ export class WorkbookReaderBase extends EventEmitter {
         }
         throw new ExcelFileError(String(input), "read", "Could not recognise input");
     }
-    _cleanupWaitingWorksheets(_waitingWorksheets) {
-        // Default: attempt best-effort cleanup if the stored object provides it.
-        for (const ws of _waitingWorksheets) {
-            if (ws && typeof ws.cleanup === "function") {
-                ws.cleanup();
-            }
-        }
+    /** Release every stored worksheet that provides a `cleanup`, and wait until each is gone. */
+    async _cleanupWaitingWorksheets(waitingWorksheets) {
+        await Promise.all(waitingWorksheets.map(async (ws) => {
+            await ws?.cleanup?.();
+        }));
     }
     // Unified implementations using passed-in classes
     _createWorksheetReader(params) {
@@ -302,9 +300,11 @@ export class WorkbookReaderBase extends EventEmitter {
             }
             yield* this._processWaitingWorksheets(waitingWorksheets);
         }
-        catch (error) {
-            this._cleanupWaitingWorksheets(waitingWorksheets);
-            throw error;
+        finally {
+            // On every way out — the end, an error, or a consumer leaving early,
+            // which returns the generator and runs no `catch` — so a sheet stored
+            // but never replayed does not leave its spool behind.
+            await this._cleanupWaitingWorksheets(waitingWorksheets);
         }
     }
     _emitEntry(payload) {

package/dist/esm/modules/excel/stream/workbook-reader.js

@@ -26,12 +26,13 @@ class WorkbookReader extends WorkbookReaderBase {
         // a leftover temporary file is self-describing rather than a lie.
         const isXlsb = /\.bin$/i.test(entry.path);
         const filePath = join(tmpDir, `sheet${sheetNo}.${isXlsb ? "bin" : "xml"}`);
-        const cleanup = () => {
-            remove(tmpDir).catch(() => { });
-        };
         const maxBytes = this._maxBufferedBytes;
+        const tempStream = createWriteStream(filePath);
+        // The file goes only once nothing has it open: removing a directory with
+        // an open file fails on Windows and leaves it behind.
+        let removed;
+        const cleanup = () => (removed ?? (removed = releaseFile(tempStream).then(() => remove(tmpDir))));
         const writePromise = new Promise((resolve, reject) => {
-            const tempStream = createWriteStream(filePath);
             tempStream.on("error", reject);
             tempStream.on("finish", resolve);
             // Track bytes written to detect oversized waiting worksheets.
@@ -65,6 +66,10 @@ class WorkbookReader extends WorkbookReaderBase {
             });
             entry.pipe(tempStream);
         });
+        // Awaited when the sheet is replayed; a sheet never replayed (the reader
+        // left early, or failed first) must not turn its failure into an
+        // unhandled rejection.
+        writePromise.catch(() => { });
         return { sheetNo, path: filePath, cleanup, writePromise, isXlsb };
     }
     async *_processWaitingWorksheets(waitingWorksheets) {
@@ -80,10 +85,29 @@ class WorkbookReader extends WorkbookReaderBase {
             finally {
                 // The file goes away now, so a reader not yet read must say so if it is read later rather than wait forever.
                 part.finish();
-                fileStream.close();
-                ws.cleanup();
+                // Remove the file only once the stream has let go of it. The open is
+                // asynchronous and may still be pending when a consumer stops early;
+                // removing first fails it with ENOENT on a stream nobody listens to
+                // any more (every time on Bun, by luck not on Node).
+                await releaseFile(fileStream);
+                await ws.cleanup();
             }
         }
     }
 }
+/**
+ * Destroy a file stream and wait until its descriptor is closed. Anything it
+ * reports from here on concerns a read or write that was abandoned, so it is
+ * dropped.
+ */
+function releaseFile(stream) {
+    if (stream.closed) {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        stream.on("error", () => { });
+        stream.once("close", () => resolve());
+        stream.destroy();
+    });
+}
 export { WorkbookReader, WorkbookReaderOptionsSchema };

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

@@ -1,9 +1,9 @@
 /**
  * Browser Stream - Collector
  */
-import { Writable } from "./writable.js";
 import { toBinaryChunk } from "../core/binary-chunk.js";
 import { StreamTypeError } from "../errors.js";
+import { Writable } from "../kernel/writable.js";
 import { concatUint8Arrays, chunksToString } from "../../../utils/binary.js";
 // =============================================================================
 // Collector Stream
@@ -13,10 +13,8 @@ import { concatUint8Arrays, chunksToString } from "../../../utils/binary.js";
  */
 export class Collector extends Writable {
     constructor(options) {
-        // The write handler collects into a closed-over array; it is exposed as
-        // `this.chunks` after construction. Using the `write` option (rather than a
-        // subclass `_write` method) keeps the synchronous direct-write path so
-        // chunks are collected before the caller's next synchronous statement.
+        // The write handler collects into a closed-over array exposed as
+        // `this.chunks` after construction, mirroring the Node Collector.
         const chunks = [];
         super({
             ...options,

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

@@ -1,233 +1,18 @@
 /**
- * Browser Stream - Compose
- *
- * Compose multiple transform streams into one.
- * Aligned with Node.js compose semantics:
- * - Backpressure: pauses `last` when composed buffer is full
- * - Flush: waits for `last` to emit "end" before signalling completion
- * - Error: destroys composed stream on any child error (not just emit)
- *
- * Uses Transform constructor options (write, final, destroy) instead of
- * post-construction method overrides, keeping all internal Writable state
- * (buffering, serialization, _writableLength, drain) properly tracked.
+ * Browser Stream - compose()
  */
-import { createListenerRegistry } from "./helpers.js";
-import { Transform } from "./transform.js";
-import { getDefaultHighWaterMark } from "../core/utils.js";
-// =============================================================================
-// Compose
-// =============================================================================
+import { kernel } from "../kernel/classes.js";
+import { composeImpl } from "../kernel/compose-impl.js";
 /**
- * Compose multiple transform streams into one
- * Data flows through each transform in sequence
+ * Combine stages into one Duplex: writes go into the first, reads come out of
+ * the last. Stages are what `pipeline` takes — streams, Web streams,
+ * generator functions, iterables — and the rules are Node's: no stage throws
+ * ERR_MISSING_ARGS, one stage is `Duplex.from(stage)`.
+ *
+ * `T` is what is written in and `R` what is read out. They are the caller's
+ * statement, like a type argument to `JSON.parse`: the stages are not checked
+ * against them, as Node's own `compose` checks nothing.
  */
-export function compose(...transforms) {
-    const len = transforms.length;
-    if (len === 0) {
-        // Boundary: an empty composition is a pure pass-through, so each input
-        // chunk (type T) is re-emitted unchanged as the declared output type R.
-        return new Transform({
-            objectMode: true,
-            transform: chunk => chunk
-        });
-    }
-    // Preserve identity: compose(single) returns the same transform.
-    if (len === 1) {
-        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]);
-    }
-    // Track whether last is paused due to backpressure from composed.
-    let lastPaused = false;
-    // Track whether flush is handling the end sequence.
-    let flushing = false;
-    // Use per-side objectMode matching Node.js compose behavior.
-    // When the property is missing, default to false (same as Node.js Transform).
-    const readableObjMode = last.readableObjectMode ?? false;
-    const writableObjMode = first.writableObjectMode ?? false;
-    const registry = createListenerRegistry();
-    const composed = new Transform({
-        readableHighWaterMark: getDefaultHighWaterMark(readableObjMode),
-        writableHighWaterMark: getDefaultHighWaterMark(writableObjMode),
-        readableObjectMode: readableObjMode,
-        writableObjectMode: writableObjMode,
-        // Write path: forward writes into the head of the chain.
-        // Using the `write` constructor option ensures all writes go through the
-        // Transform's internal Writable state machine (_writableLength tracking,
-        // write serialization via _writeQueue, cork buffering, drain signals).
-        write(chunk, encoding, callback) {
-            try {
-                first.write(chunk, encoding, callback);
-            }
-            catch (err) {
-                callback(err);
-            }
-        },
-        // Flush path: end the head of the chain, then wait for `last` to emit
-        // "end" (readable exhaustion) before completing the composed stream.
-        // This is the `final` handler — called after all pending writes complete,
-        // before "finish" is emitted. The Transform constructor wrapper will
-        // automatically push(null) on the readable side after our callback.
-        final(callback) {
-            flushing = true;
-            // If `last` already ended independently (e.g. a "take N" transform that
-            // pushed null on its own), complete immediately — the "end" event has
-            // already fired and a new once("end") listener would never trigger.
-            if (last.readableEnded) {
-                callback();
-                return;
-            }
-            const onEnd = () => {
-                cleanupFlush();
-                callback();
-            };
-            const onError = (err) => {
-                cleanupFlush();
-                callback(err);
-            };
-            const cleanupFlush = () => {
-                last.off?.("end", onEnd);
-                last.off?.("error", onError);
-            };
-            last.once?.("end", onEnd);
-            last.once?.("error", onError);
-            first.end();
-        },
-        // Destroy path: clean up all listeners and destroy all child transforms.
-        destroy(_error, callback) {
-            try {
-                registry.cleanup();
-                for (const t of transforms) {
-                    t.destroy(_error ?? undefined);
-                }
-            }
-            finally {
-                callback(_error);
-            }
-        }
-    });
-    // Hook into the internal _readable's _read method so that when the
-    // PipeManager (or any consumer) pulls data, we resume `last` if it was
-    // paused due to backpressure. This is the browser equivalent of Node.js
-    // compose's `read()` option which is called by the native pipe mechanism.
-    //
-    // Compose the new behavior with the Transform's existing _read patch
-    // (which releases _afterTransformCallback). Although _afterTransformCallback
-    // is not used when the `write` option is provided, preserving it is a
-    // defensive measure against future changes.
-    const composedReadable = composed._readable;
-    const origRead = composedReadable._read;
-    composedReadable._read = () => {
-        origRead?.call(composedReadable);
-        if (lastPaused) {
-            lastPaused = false;
-            last.resume?.();
-        }
-    };
-    // Forward errors from all transforms — destroy composed on error (matches Node.js).
-    for (const t of transforms) {
-        registry.add(t, "error", (err) => composed.destroy(err));
-    }
-    // Drain is handled by the internal Writable's own drain → Transform's
-    // _setupSideForwarding → composed.emit("drain"). No need to forward from
-    // `first` — that would cause double-drain when both buffers cross below HWM.
-    // Track whether both sides have completed so we can auto-destroy the composed
-    // stream (emitting 'close'), matching Node.js compose behavior.
-    let composedEndFired = false;
-    let composedFinishFired = false;
-    const maybeAutoDestroy = () => {
-        if (composedEndFired && composedFinishFired && !composed.destroyed) {
-            composed.destroy();
-        }
-    };
-    // Finish is handled by the internal Writable's own lifecycle: when the
-    // `final` handler calls callback(), the internal Writable emits "finish",
-    // which _setupSideForwarding propagates to composed.emit("finish").
-    // Forwarding finish from `last` would cause double-finish.
-    // Track the composed stream's own finish for auto-destroy.
-    composed.once("finish", () => {
-        composedFinishFired = true;
-        maybeAutoDestroy();
-    });
-    // Eagerly attach data/end forwarding from `last` to composed (matching Node.js).
-    // Node.js compose immediately attaches last.on("data") so data flows into
-    // composed's buffer right away, ensuring no data is missed.
-    registry.add(last, "data", (chunk) => {
-        if (!composed.push(chunk)) {
-            lastPaused = true;
-            last.pause?.();
-        }
-    });
-    registry.once(last, "end", () => {
-        // When flushing, the final handler + Transform wrapper handles stream
-        // termination (push(null)). Otherwise (e.g. last ended independently),
-        // we must push(null) ourselves.
-        if (!flushing) {
-            composed.push(null);
-        }
-    });
-    // Track when the composed stream's own 'end' fires (from push(null)).
-    composed.once("end", () => {
-        composedEndFired = true;
-        maybeAutoDestroy();
-    });
-    // Delegate cork/uncork to the head of the chain.
-    composed.cork = () => {
-        first.cork?.();
-    };
-    composed.uncork = () => {
-        first.uncork?.();
-    };
-    // Safety net: ensure listener cleanup even if close fires through an
-    // unexpected path (destroy option already calls registry.cleanup).
-    composed.once("close", () => {
-        registry.cleanup();
-    });
-    // Reflect underlying readability/writability like the previous duck-typed wrapper
-    Object.defineProperty(composed, "readable", {
-        get: () => last.readable
-    });
-    Object.defineProperty(composed, "writable", {
-        get: () => first.writable
-    });
-    // Proxy writable-side state to `first` so properties like writableEnded and
-    // writableFinished reflect the actual head-of-chain state, not the inner
-    // Transform wrapper which is never written to directly.
-    Object.defineProperty(composed, "writableEnded", {
-        get: () => first.writableEnded ?? false
-    });
-    Object.defineProperty(composed, "writableFinished", {
-        get: () => first.writableFinished ?? false
-    });
-    Object.defineProperty(composed, "writableLength", {
-        get: () => first.writableLength ?? 0
-    });
-    Object.defineProperty(composed, "writableHighWaterMark", {
-        get: () => first.writableHighWaterMark ?? getDefaultHighWaterMark(false)
-    });
-    Object.defineProperty(composed, "writableCorked", {
-        get: () => first.writableCorked ?? 0
-    });
-    Object.defineProperty(composed, "writableNeedDrain", {
-        get: () => first.writableNeedDrain ?? false
-    });
-    // Proxy readable-side state to `last`.
-    Object.defineProperty(composed, "readableEnded", {
-        get: () => last.readableEnded ?? false
-    });
-    Object.defineProperty(composed, "readableLength", {
-        get: () => last.readableLength ?? 0
-    });
-    Object.defineProperty(composed, "readableHighWaterMark", {
-        get: () => last.readableHighWaterMark ?? getDefaultHighWaterMark(false)
-    });
-    Object.defineProperty(composed, "readableFlowing", {
-        get: () => last.readableFlowing ?? null
-    });
-    return composed;
+export function compose(...stages) {
+    return composeImpl(kernel, ...stages);
 }

package/dist/esm/modules/stream/browser/duplex-pair.js

@@ -0,0 +1,71 @@
+/**
+ * Browser Stream - duplexPair()
+ *
+ * Its own module: `DuplexSide extends Duplex` is a top-level class, which a
+ * bundler keeps — with the whole Duplex chain behind it — whenever the module
+ * holding it is kept.
+ */
+import { Duplex } from "../kernel/classes.js";
+import { nextTick } from "../kernel/state.js";
+/**
+ * One end of a {@link duplexPair}: what is written here is pushed to the
+ * other end, and the write completes only when the other end reads it.
+ * Port of Node.js `lib/internal/streams/duplexpair.js`.
+ */
+class DuplexSide extends Duplex {
+    constructor() {
+        super(...arguments);
+        this._otherSide = null;
+        this._pendingCallback = null;
+    }
+    _initOtherSide(otherSide) {
+        this._otherSide = otherSide;
+    }
+    _read(_size) {
+        // The other side's write waits for this read; release it.
+        const callback = this._pendingCallback;
+        if (callback) {
+            this._pendingCallback = null;
+            callback();
+        }
+    }
+    _write(chunk, _encoding, callback) {
+        const other = this._otherSide;
+        if (chunk.length === 0) {
+            nextTick(callback);
+        }
+        else {
+            other.push(chunk);
+            other._pendingCallback = callback;
+        }
+    }
+    _final(callback) {
+        this._otherSide.on("end", callback);
+        this._otherSide.push(null);
+    }
+    _destroy(err, callback) {
+        const other = this._otherSide;
+        if (other !== null && !other.destroyed) {
+            nextTick(() => {
+                if (other.destroyed) {
+                    return;
+                }
+                if (err) {
+                    other.destroy();
+                }
+                else {
+                    other.push(null);
+                }
+            });
+        }
+        callback(err);
+    }
+}
+/** Two connected Duplex streams: each one reads what the other writes. */
+export function duplexPair(options) {
+    const side0 = new DuplexSide(options);
+    const side1 = new DuplexSide(options);
+    side0._initOtherSide(side1);
+    side1._initOtherSide(side0);
+    return [side0, side1];
+}