@cj-tech-master/excelts 4.2.1 → 4.2.2-canary.20260115044841.88820eb

package/dist/esm/modules/excel/xlsx/xform/strings/text-xform.js

@@ -13,14 +13,12 @@ class TextXform extends BaseXform {
         xmlStream.closeNode();
     }
     parseOpen(node) {
-        switch (node.name) {
-            case "t":
-                this._text = [];
-                this.model = ""; // Initialize model to empty string
-                return true;
-            default:
-                return false;
+        if (node.name === "t") {
+            this._text = [];
+            this.model = "";
+            return true;
         }
+        return false;
     }
     parseText(text) {
         this._text.push(text);

package/dist/esm/modules/excel/xlsx/xlsx.browser.js

@@ -30,8 +30,8 @@ import { theme1Xml } from "./xml/theme1.js";
 import { RelType } from "./rel-type.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { bufferToString, base64ToUint8Array } from "../../../utils/utils.js";
-import { StreamingZip, ZipDeflateFile } from "../../archive/streaming-zip.js";
-import { ZipParser } from "../../archive/index.js";
+import { StreamingZip, ZipDeflateFile } from "../../archive/zip/stream.js";
+import { ZipParser } from "../../archive/unzip/zip-parser.js";
 import { PassThrough, concatUint8Arrays } from "../../stream/index.js";
 import { commentsPath, commentsRelTargetFromWorksheetName, ctrlPropPath, drawingPath, drawingRelsPath, OOXML_REL_TARGETS, pivotTableRelTargetFromWorksheetName, pivotCacheDefinitionRelTargetFromWorkbook, getCommentsIndexFromPath, getDrawingNameFromPath, getDrawingNameFromRelsPath, getMediaFilenameFromPath, mediaPath, getPivotCacheDefinitionNameFromPath, getPivotCacheDefinitionNameFromRelsPath, getPivotCacheRecordsNameFromPath, getPivotTableNameFromPath, getPivotTableNameFromRelsPath, pivotCacheDefinitionPath, pivotCacheDefinitionRelsPath, pivotCacheDefinitionRelTargetFromPivotTable, pivotCacheRecordsPath, pivotCacheRecordsRelTarget, pivotTablePath, pivotTableRelsPath, getTableNameFromPath, tablePath, tableRelTargetFromWorksheetName, themePath, getThemeNameFromPath, getVmlDrawingNameFromPath, getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, isBinaryEntryPath, normalizeZipPath, OOXML_PATHS, vmlDrawingRelTargetFromWorksheetName, vmlDrawingPath, worksheetPath, worksheetRelsPath } from "../utils/ooxml-paths.js";
 class StreamingZipWriterAdapter {
@@ -126,10 +126,7 @@ class StreamingZipWriterAdapter {
             timestamps: this.timestamps
         });
         this.zip.add(file);
-        const pushResult = file.push(buffer, true);
-        if (pushResult && typeof pushResult.catch === "function") {
-            pushResult.catch((err) => this._emit("error", err));
-        }
+        file.push(buffer, true);
     }
     finalize() {
         if (this.finalized) {
@@ -367,8 +364,10 @@ class XLSX {
                     case OOXML_PATHS.docPropsApp: {
                         const appXform = new AppXform();
                         const appProperties = await appXform.parseStream(stream);
-                        model.company = appProperties.company;
-                        model.manager = appProperties.manager;
+                        if (appProperties) {
+                            model.company = appProperties.company;
+                            model.manager = appProperties.manager;
+                        }
                         break;
                     }
                     case OOXML_PATHS.docPropsCore: {
@@ -830,8 +829,10 @@ class XLSX {
                         case OOXML_PATHS.docPropsApp: {
                             const appXform = new AppXform();
                             const appProperties = await appXform.parseStream(stream);
-                            model.company = appProperties.company;
-                            model.manager = appProperties.manager;
+                            if (appProperties) {
+                                model.company = appProperties.company;
+                                model.manager = appProperties.manager;
+                            }
                             break;
                         }
                         case OOXML_PATHS.docPropsCore: {

package/dist/esm/modules/excel/xlsx/xlsx.js

@@ -16,7 +16,7 @@
 import fs from "fs";
 import { fileExists } from "../../../utils/utils.js";
 import { XLSX as XLSXBase } from "./xlsx.browser.js";
-import { Parse } from "../../archive/index.js";
+import { Parse } from "../../archive/unzip/stream.js";
 import { Writable, pipeline } from "../../stream/index.js";
 class XLSX extends XLSXBase {
     constructor(workbook) {

package/dist/esm/modules/stream/base-transform.js

@@ -17,6 +17,8 @@ export class BaseTransform extends EventEmitter {
         this._isDestroyed = false;
         this._isFinished = false;
         this._errorEmitted = false;
+        this._ending = false;
+        this._flushInProgress = false;
         this._objectMode = options.objectMode ?? false;
         this._highWaterMark = options.highWaterMark ?? 16384;
     }
@@ -45,26 +47,8 @@ export class BaseTransform extends EventEmitter {
         if (chunk !== undefined) {
             this.write(chunk);
         }
-        // Wait for buffer to drain, then flush
-        const checkAndFlush = () => {
-            if (this._buffer.length === this._bufferIndex && !this._isProcessing) {
-                this.processFlush((err, data) => {
-                    if (err) {
-                        this._emitError(err);
-                    }
-                    else if (data !== undefined) {
-                        this.emit("data", data);
-                    }
-                    this._isFinished = true;
-                    this.emit("finish");
-                    this.emit("end");
-                });
-            }
-            else {
-                setTimeout(checkAndFlush, 0);
-            }
-        };
-        checkAndFlush();
+        this._ending = true;
+        this._maybeFlush();
     }
     /**
      * Destroy the stream
@@ -113,13 +97,43 @@ export class BaseTransform extends EventEmitter {
                     }
                     // Process next chunk
                     this._processNext();
+                    this._maybeFlush();
                 }
             });
         }
         catch (err) {
             this._isProcessing = false;
             this._emitError(err);
+            this._maybeFlush();
+        }
+    }
+    _maybeFlush() {
+        if (!this._ending || this._isDestroyed || this._isFinished || this._flushInProgress) {
+            return;
         }
+        // If an error was emitted, stop flushing to avoid hanging end().
+        if (this._errorEmitted) {
+            this._isFinished = true;
+            this.emit("finish");
+            this.emit("end");
+            return;
+        }
+        if (this._isProcessing || this._bufferIndex < this._buffer.length) {
+            return;
+        }
+        this._flushInProgress = true;
+        this.processFlush((err, data) => {
+            this._flushInProgress = false;
+            if (err) {
+                this._emitError(err);
+            }
+            else if (data !== undefined) {
+                this.emit("data", data);
+            }
+            this._isFinished = true;
+            this.emit("finish");
+            this.emit("end");
+        });
     }
     /**
      * Emit error only once

package/dist/esm/modules/stream/chunked-builder.js

@@ -45,7 +45,7 @@ export class ChunkedBuilder {
     _consolidate() {
         if (this._pieces.length > 0) {
             this._chunks.push(this._pieces.join(""));
-            this._pieces = [];
+            this._pieces.length = 0;
         }
     }
     /**
@@ -76,8 +76,8 @@ export class ChunkedBuilder {
      * Clear all content
      */
     clear() {
-        this._pieces = [];
-        this._chunks = [];
+        this._pieces.length = 0;
+        this._chunks.length = 0;
         this._totalLength = 0;
     }
     /**
@@ -99,7 +99,7 @@ export class ChunkedBuilder {
         // Has chunks - consolidate and join
         if (piecesLen > 0) {
             this._chunks.push(this._pieces.join(""));
-            this._pieces = [];
+            this._pieces.length = 0;
         }
         if (this._chunks.length === 1) {
             return this._chunks[0];

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

@@ -1,25 +1,13 @@
 /**
- * Stream Module (browser type surface)
+ * Stream Module (browser entry)
  *
- * Mirrors [src/modules/stream/index.ts] but explicitly re-exports from
- * ./streams.browser so we can enforce index export-surface parity.
+ * Mirrors the public surface of `./index.ts`, but exports the browser
+ * implementation from `./streams.browser`.
+ *
+ * This file is intentionally export-only (tree-shaking friendly).
  */
-// =============================================================================
-// Native Stream Classes and Functions (browser)
-// =============================================================================
-import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.browser.js";
-export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
-import { EventEmitter } from "./event-emitter.js";
-export { EventEmitter };
-// =============================================================================
-// ChunkedBuilder (platform-independent)
-// =============================================================================
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-// =============================================================================
-// Utility Functions (platform-independent)
-// =============================================================================
-import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
-export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
-import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
-export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.browser.js";
+export { EventEmitter } from "./event-emitter.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";

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

@@ -1,52 +1,23 @@
 /**
- * Stream Module
+ * Stream Module (Node.js entry)
  *
- * Native stream implementations for Node.js and Browser.
+ * Public entrypoint for stream utilities and classes.
  *
- * - Node.js: Uses native `stream` module (Readable, Writable, Transform, Duplex, PassThrough)
- * - Browser: Uses Web Streams API (ReadableStream, WritableStream, TransformStream)
- *
- * Both implementations provide the same API for cross-platform compatibility.
+ * Notes:
+ * - This file is intentionally export-only (tree-shaking friendly).
+ * - Browser builds should import from `@stream/index.browser`.
  *
  * @example
- * ```typescript
- * import {
- *   Readable,
- *   Writable,
- *   Transform,
- *   Duplex,
- *   PassThrough,
- *   pipeline,
- *   createTransform,
- *   streamToUint8Array
- * } from './modules/stream.js';
- *
- * // Create a transform stream
- * const uppercase = createTransform<Uint8Array, Uint8Array>(chunk => {
- *   const text = new TextDecoder().decode(chunk);
- *   return new TextEncoder().encode(text.toUpperCase());
- * });
+ * ```ts
+ * import { pipeline, createTransform, createCollector } from "./index.js";
  *
- * // Use pipeline for clean stream composition
- * await pipeline(readable, uppercase, writable);
+ * const upper = createTransform<Uint8Array, Uint8Array>(chunk => chunk);
+ * const out = createCollector<Uint8Array>();
+ * await pipeline(source, upper, out);
  * ```
  */
-// =============================================================================
-// Native Stream Classes and Functions (platform-specific)
-// =============================================================================
-import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.js";
-export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
-import { EventEmitter } from "./event-emitter.js";
-export { EventEmitter };
-// =============================================================================
-// ChunkedBuilder (platform-independent)
-// =============================================================================
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-// =============================================================================
-// Utility Functions (platform-independent)
-// =============================================================================
-import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
-export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
-import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
-export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "./streams.js";
+export { EventEmitter } from "./event-emitter.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";

package/dist/esm/modules/stream/internal/event-utils.js

@@ -0,0 +1,40 @@
+/**
+ * Small event utilities for Node-style emitters.
+ *
+ * Prefer keeping this separate from the main stream implementation so other
+ * modules (e.g. archive) can reuse it without pulling in the whole stream API.
+ */
+function off(emitter, event, listener) {
+    if (typeof emitter.off === "function") {
+        emitter.off(event, listener);
+    }
+    else if (typeof emitter.removeListener === "function") {
+        emitter.removeListener(event, listener);
+    }
+}
+/**
+ * Resolve when an emitter fires `event`, reject on `error`.
+ */
+export function onceEvent(emitter, event) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const onDone = () => {
+            cleanup();
+            resolve();
+        };
+        const cleanup = () => {
+            off(emitter, "error", onError);
+            off(emitter, event, onDone);
+        };
+        if (typeof emitter.once === "function") {
+            emitter.once("error", onError);
+            emitter.once(event, onDone);
+            return;
+        }
+        emitter.on?.("error", onError);
+        emitter.on?.(event, onDone);
+    });
+}

package/dist/esm/modules/stream/internal/type-guards.js

@@ -0,0 +1,24 @@
+/**
+ * Lightweight runtime type guards shared across modules.
+ *
+ * Keep this file dependency-free to maximize deduping in bundled builds.
+ */
+export function isReadableStream(value) {
+    return !!value && typeof value === "object" && typeof value.getReader === "function";
+}
+export function isWritableStream(value) {
+    return !!value && typeof value === "object" && typeof value.getWriter === "function";
+}
+export function isAsyncIterable(value) {
+    return (!!value &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[Symbol.asyncIterator] === "function");
+}
+export function isTransformStream(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        !!value.readable &&
+        !!value.writable &&
+        isReadableStream(value.readable) &&
+        isWritableStream(value.writable));
+}

package/dist/esm/modules/stream/pull-stream.js

@@ -5,36 +5,41 @@
  * Works identically in both browser and Node.js environments.
  */
 import { EventEmitter } from "./event-emitter.js";
-import { concatUint8Arrays } from "./shared.js";
+const EMPTY_U8 = new Uint8Array(0);
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
  */
 export class PullStream extends EventEmitter {
     constructor(_options = {}) {
         super();
-        // Use chunked buffer storage to avoid repeated concat
-        this._bufferChunks = [];
-        this._totalLength = 0;
+        // Single growable buffer with read/write cursors.
+        // IMPORTANT: never mutate bytes that have already been returned via subarray
+        // (to keep views stable). When we need to reclaim prefix space, we allocate
+        // a new buffer and copy the remaining bytes.
+        this._buffer = new Uint8Array(0);
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
         this.finished = false;
         this._destroyed = false;
     }
-    // Consolidate chunks into single buffer when needed
+    // Maintain legacy protected accessor for subclasses.
+    // Returned value is a view of the readable region.
     get buffer() {
-        const len = this._bufferChunks.length;
-        if (len === 0) {
-            return new Uint8Array(0);
+        if (this._bufferReadIndex === this._bufferWriteIndex) {
+            return EMPTY_U8;
         }
-        if (len === 1) {
-            return this._bufferChunks[0];
-        }
-        // Consolidate multiple chunks
-        const buf = concatUint8Arrays(this._bufferChunks);
-        this._bufferChunks = [buf];
-        return buf;
+        return this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
     }
     set buffer(buf) {
-        this._bufferChunks = buf.length > 0 ? [buf] : [];
-        this._totalLength = buf.length;
+        if (buf.length === 0) {
+            this._buffer = EMPTY_U8;
+            this._bufferReadIndex = 0;
+            this._bufferWriteIndex = 0;
+            return;
+        }
+        this._buffer = buf;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = buf.length;
     }
     /**
      * Write data to the stream
@@ -44,8 +49,38 @@ export class PullStream extends EventEmitter {
             this.emit("error", new Error("Cannot write to destroyed stream"));
             return false;
         }
-        this._bufferChunks.push(chunk);
-        this._totalLength += chunk.length;
+        const chunkLen = chunk.length;
+        if (chunkLen === 0) {
+            this.emit("chunk");
+            return true;
+        }
+        // Fast path: first write can reuse caller buffer without copy.
+        if (this._buffer.length === 0) {
+            this._buffer = chunk;
+            this._bufferReadIndex = 0;
+            this._bufferWriteIndex = chunkLen;
+            this.emit("chunk");
+            return true;
+        }
+        const required = this._bufferWriteIndex + chunkLen;
+        if (required <= this._buffer.length) {
+            this._buffer.set(chunk, this._bufferWriteIndex);
+            this._bufferWriteIndex += chunkLen;
+            this.emit("chunk");
+            return true;
+        }
+        // Need a new buffer. We keep previously returned views stable by allocating.
+        const remaining = this._bufferWriteIndex - this._bufferReadIndex;
+        const nextLength = remaining + chunkLen;
+        const prevCap = this._buffer.length;
+        // Grow exponentially to avoid O(n^2) copying on many small writes.
+        const nextCap = Math.max(nextLength, prevCap > 0 ? prevCap * 2 : 1024);
+        const next = new Uint8Array(nextCap);
+        next.set(this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex), 0);
+        next.set(chunk, remaining);
+        this._buffer = next;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = nextLength;
         this.emit("chunk");
         return true;
     }
@@ -69,8 +104,9 @@ export class PullStream extends EventEmitter {
             return;
         }
         this._destroyed = true;
-        this._bufferChunks = [];
-        this._totalLength = 0;
+        this._buffer = EMPTY_U8;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
         if (error) {
             this.emit("error", error);
         }
@@ -95,19 +131,32 @@ export class PullStream extends EventEmitter {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
-                // Use _totalLength for fast check before consolidating
-                if (this._totalLength >= size) {
-                    const buf = this.buffer;
-                    const result = buf.subarray(0, size);
-                    this.buffer = buf.subarray(size);
+                if (size === 0) {
+                    resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
+                    return;
+                }
+                const available = this._bufferWriteIndex - this._bufferReadIndex;
+                if (available >= size) {
+                    const start = this._bufferReadIndex;
+                    const end = start + size;
+                    const result = this._buffer.subarray(start, end);
+                    this._bufferReadIndex = end;
+                    if (this._bufferReadIndex === this._bufferWriteIndex) {
+                        this._buffer = EMPTY_U8;
+                        this._bufferReadIndex = 0;
+                        this._bufferWriteIndex = 0;
+                    }
                     resolve(result);
                     return;
                 }
                 if (this.finished) {
                     // Return whatever we have
-                    const result = this.buffer;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
+                    const result = this._bufferReadIndex === this._bufferWriteIndex
+                        ? EMPTY_U8
+                        : this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
+                    this._buffer = EMPTY_U8;
+                    this._bufferReadIndex = 0;
+                    this._bufferWriteIndex = 0;
                     resolve(result);
                     return;
                 }
@@ -124,21 +173,36 @@ export class PullStream extends EventEmitter {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
-                const buf = this.buffer;
-                const matchIndex = this._indexOf(buf, pattern);
-                if (matchIndex !== -1) {
-                    this._match = matchIndex;
-                    const endIndex = includePattern ? matchIndex + pattern.length : matchIndex;
-                    const result = buf.subarray(0, endIndex);
-                    this.buffer = buf.subarray(includePattern ? endIndex : matchIndex + pattern.length);
+                // Match empty pattern without consuming anything.
+                if (pattern.length === 0) {
+                    this._match = 0;
+                    resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
+                    return;
+                }
+                const matchIndexAbs = this._indexOf(this._buffer, this._bufferReadIndex, this._bufferWriteIndex, pattern);
+                if (matchIndexAbs !== -1) {
+                    this._match = matchIndexAbs - this._bufferReadIndex;
+                    const patternLen = pattern.length;
+                    const resultEndAbs = includePattern ? matchIndexAbs + patternLen : matchIndexAbs;
+                    const consumeTo = matchIndexAbs + patternLen;
+                    const result = this._buffer.subarray(this._bufferReadIndex, resultEndAbs);
+                    this._bufferReadIndex = consumeTo;
+                    if (this._bufferReadIndex === this._bufferWriteIndex) {
+                        this._buffer = EMPTY_U8;
+                        this._bufferReadIndex = 0;
+                        this._bufferWriteIndex = 0;
+                    }
                     resolve(result);
                     return;
                 }
                 if (this.finished) {
                     // Pattern not found, return everything
-                    const result = buf;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
+                    const result = this._bufferReadIndex === this._bufferWriteIndex
+                        ? EMPTY_U8
+                        : this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
+                    this._buffer = EMPTY_U8;
+                    this._bufferReadIndex = 0;
+                    this._bufferWriteIndex = 0;
                     resolve(result);
                     return;
                 }
@@ -158,7 +222,7 @@ export class PullStream extends EventEmitter {
      * Get remaining buffer length
      */
     get length() {
-        return this._totalLength;
+        return this._bufferWriteIndex - this._bufferReadIndex;
     }
     /**
      * Check if stream is finished
@@ -175,13 +239,13 @@ export class PullStream extends EventEmitter {
     /**
      * Find pattern in Uint8Array (like Buffer.indexOf)
      */
-    _indexOf(haystack, needle, start = 0) {
+    _indexOf(haystack, start, end, needle) {
         const needleLen = needle.length;
         if (needleLen === 0) {
             return start;
         }
-        const haystackLen = haystack.length;
-        if (needleLen > haystackLen) {
+        const haystackLen = end;
+        if (needleLen > haystackLen - start) {
             return -1;
         }
         const first = needle[0];

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

@@ -54,7 +54,7 @@ export function uint8ArrayToString(arr, encoding) {
 /**
  * Concatenate multiple Uint8Arrays efficiently
  */
-export function concatUint8Arrays(arrays) {
+export function concatUint8Arrays(arrays, totalLength) {
     const len = arrays.length;
     if (len === 0) {
         return new Uint8Array(0);
@@ -63,9 +63,12 @@ export function concatUint8Arrays(arrays) {
         return arrays[0];
     }
     // Calculate total length with for loop for better performance
-    let totalLength = 0;
-    for (let i = 0; i < len; i++) {
-        totalLength += arrays[i].length;
+    if (totalLength === undefined) {
+        let sum = 0;
+        for (let i = 0; i < len; i++) {
+            sum += arrays[i].length;
+        }
+        totalLength = sum;
     }
     const result = new Uint8Array(totalLength);
     let offset = 0;