@cj-tech-master/excelts 4.2.0 → 4.2.1-canary.20260111102127.f808a37

package/dist/browser/modules/archive/{parse.browser.d.ts → unzip/stream.browser.d.ts}

@@ -6,7 +6,7 @@
  * Uses the browser Duplex stream implementation for compatibility.
  */
 import { Duplex } from "@stream";
-import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "@archive/parse.base";
+import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "@archive/unzip/stream.base";
 export type { CrxHeader, EntryProps, EntryVars, ParseOptions, ZipEntry };
 export type ParseStream = Duplex & {
     promise(): Promise<void>;

package/dist/browser/modules/archive/{parse.browser.js → unzip/stream.browser.js}

@@ -5,14 +5,13 @@
  * Falls back to pure JavaScript implementation for older browsers.
  * Uses the browser Duplex stream implementation for compatibility.
  */
-import { Duplex, PassThrough, concatUint8Arrays } from "../stream/index.browser.js";
-import { writeUint32LE } from "./utils/binary.js";
-import { indexOfUint8ArrayPattern } from "./utils/bytes.js";
-import { runParseLoop, streamUntilValidatedDataDescriptor } from "./parse.base.js";
-import { inflateRaw as fallbackInflateRaw } from "./deflate-fallback.js";
-import { ByteQueue } from "./byte-queue.js";
-import { DATA_DESCRIPTOR_SIG } from "./zip-constants.js";
-import { hasDeflateRawDecompressionStream } from "./compress.base.js";
+import { Duplex, PassThrough, concatUint8Arrays } from "../../stream/index.browser.js";
+import { DATA_DESCRIPTOR_SIGNATURE_BYTES, runParseLoop, streamUntilValidatedDataDescriptor } from "./stream.base.js";
+import { PatternScanner } from "../utils/pattern-scanner.js";
+import { inflateRaw as fallbackInflateRaw } from "../compression/deflate-fallback.js";
+import { ByteQueue } from "../internal/byte-queue.js";
+import { hasDeflateRawDecompressionStream } from "../compression/compress.base.js";
+const DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK = 256 * 1024;
 // =============================================================================
 // Browser InflateRaw using DecompressionStream
 // =============================================================================
@@ -29,6 +28,9 @@ class BrowserInflateRaw extends Duplex {
         // Pass write handler to Duplex so pipe() calls our write method
         // Also pass final handler to close the DecompressionStream when _writable ends
         super({
+            // Keep the internal buffer bounded; this stream is used in tight parse loops.
+            writableHighWaterMark: 512 * 1024,
+            readableHighWaterMark: 512 * 1024,
             write: (chunk, _encoding, callback) => {
                 this._doWrite(chunk, callback);
             },
@@ -137,47 +139,6 @@ class BrowserInflateRaw extends Duplex {
             this.push(null);
         }
     }
-    // Override write to feed data into DecompressionStream
-    write(chunk, encodingOrCallback, callback) {
-        // Handle overload
-        let cb;
-        if (typeof encodingOrCallback === "function") {
-            cb = encodingOrCallback;
-        }
-        else {
-            cb = callback;
-        }
-        this._doWrite(chunk, cb);
-        return true;
-    }
-    // Override end to close the DecompressionStream writer
-    end(chunkOrCallback, encodingOrCallback, callback) {
-        // Handle overloads
-        let chunk;
-        let cb;
-        if (typeof chunkOrCallback === "function") {
-            cb = chunkOrCallback;
-        }
-        else if (chunkOrCallback !== undefined) {
-            chunk = chunkOrCallback;
-            if (typeof encodingOrCallback === "function") {
-                cb = encodingOrCallback;
-            }
-            else {
-                cb = callback;
-            }
-        }
-        // Write final chunk if provided
-        if (chunk) {
-            this.write(chunk, () => {
-                this._closeWriter(cb);
-            });
-        }
-        else {
-            this._closeWriter(cb);
-        }
-        return this;
-    }
     _closeWriter(callback) {
         if (this.writeClosed) {
             this._readingDonePromise.then(() => {
@@ -205,7 +166,6 @@ class BrowserInflateRaw extends Duplex {
                 if (callback) {
                     callback();
                 }
-                this.emit("finish");
             });
         });
     }
@@ -218,6 +178,225 @@ class BrowserInflateRaw extends Duplex {
     }
 }
 // =============================================================================
+// Worker-based InflateRaw (optional)
+// =============================================================================
+let _inflateWorkerUrl = null;
+function getInflateWorkerUrl(customUrl) {
+    if (typeof customUrl === "string" && customUrl.length > 0) {
+        return customUrl;
+    }
+    if (_inflateWorkerUrl) {
+        return _inflateWorkerUrl;
+    }
+    // Inline worker to avoid bundler-specific worker loaders.
+    // It streams deflate-raw through DecompressionStream and posts decompressed chunks back.
+    const code = `
+let ds;
+let writer;
+let reader;
+let junkError = false;
+let pendingWrites = 0;
+
+function isJunkErrorMessage(msg) {
+  return typeof msg === 'string' && (msg.includes('Junk') || msg.includes('junk'));
+}
+
+async function ensureStarted() {
+  if (ds) return;
+  ds = new DecompressionStream('deflate-raw');
+  writer = ds.writable.getWriter();
+  reader = ds.readable.getReader();
+
+  (async () => {
+    try {
+      while (true) {
+        const r = await reader.read();
+        if (r.done) break;
+        const chunk = r.value;
+        postMessage({ t: 'data', chunk }, [chunk.buffer]);
+      }
+      postMessage({ t: 'end' });
+    } catch (e) {
+      const msg = e && e.message ? e.message : String(e);
+      if (isJunkErrorMessage(msg)) {
+        junkError = true;
+        postMessage({ t: 'end' });
+      } else {
+        postMessage({ t: 'error', message: msg });
+      }
+    }
+  })();
+}
+
+onmessage = async (ev) => {
+  const msg = ev.data;
+  try {
+    await ensureStarted();
+    if (msg.t === 'write') {
+      if (junkError) {
+        postMessage({ t: 'ack', id: msg.id });
+        return;
+      }
+      pendingWrites++;
+      await writer.write(msg.chunk);
+      pendingWrites--;
+      postMessage({ t: 'ack', id: msg.id });
+      return;
+    }
+    if (msg.t === 'close') {
+      // Wait for in-flight writes to finish (best-effort).
+      while (pendingWrites > 0) {
+        await new Promise(r => setTimeout(r, 0));
+      }
+      try { await writer.close(); } catch (_) {}
+      postMessage({ t: 'closed' });
+      return;
+    }
+    if (msg.t === 'abort') {
+      try { await writer.abort(); } catch (_) {}
+      postMessage({ t: 'aborted' });
+      return;
+    }
+  } catch (e) {
+    const m = e && e.message ? e.message : String(e);
+    postMessage({ t: 'error', message: m, id: msg && msg.id });
+  }
+};
+`;
+    const blob = new Blob([code], { type: "text/javascript" });
+    _inflateWorkerUrl = URL.createObjectURL(blob);
+    return _inflateWorkerUrl;
+}
+class WorkerInflateRaw extends Duplex {
+    constructor(workerUrl) {
+        super({
+            write: (chunk, _encoding, callback) => {
+                this._doWrite(chunk, callback);
+            },
+            final: (callback) => {
+                this._doClose(callback);
+            }
+        });
+        this._nextId = 1;
+        this._pendingAcks = new Map();
+        this._closed = false;
+        this._junkError = false;
+        this._terminated = false;
+        const url = getInflateWorkerUrl(workerUrl);
+        this.worker = new Worker(url);
+        this.worker.onmessage = (ev) => {
+            const msg = ev.data;
+            if (!msg || typeof msg.t !== "string") {
+                return;
+            }
+            if (msg.t === "data") {
+                const chunk = msg.chunk;
+                this.push(chunk);
+                return;
+            }
+            if (msg.t === "end") {
+                this.push(null);
+                this._terminateWorker();
+                return;
+            }
+            if (msg.t === "aborted") {
+                this._terminateWorker();
+                return;
+            }
+            if (msg.t === "ack") {
+                const id = msg.id;
+                const cb = this._pendingAcks.get(id);
+                if (cb) {
+                    this._pendingAcks.delete(id);
+                    cb();
+                }
+                return;
+            }
+            if (msg.t === "error") {
+                const message = typeof msg.message === "string" ? msg.message : "Worker inflate error";
+                if (message.includes("Junk") || message.includes("junk")) {
+                    this._junkError = true;
+                    // Treat as end-of-stream.
+                    this.push(null);
+                    this._terminateWorker();
+                    // Resolve any pending writes.
+                    for (const cb of this._pendingAcks.values()) {
+                        cb();
+                    }
+                    this._pendingAcks.clear();
+                    return;
+                }
+                const err = new Error(message);
+                // Fail any pending writes.
+                for (const cb of this._pendingAcks.values()) {
+                    cb(err);
+                }
+                this._pendingAcks.clear();
+                this.emit("error", err);
+                this._terminateWorker();
+                return;
+            }
+        };
+        this.worker.onerror = (e) => {
+            const err = new Error(e.message || "Worker error");
+            for (const cb of this._pendingAcks.values()) {
+                cb(err);
+            }
+            this._pendingAcks.clear();
+            this.emit("error", err);
+            this._terminateWorker();
+        };
+    }
+    _terminateWorker() {
+        if (this._terminated) {
+            return;
+        }
+        this._terminated = true;
+        try {
+            this.worker.terminate();
+        }
+        catch {
+            // ignore
+        }
+    }
+    _doWrite(chunk, callback) {
+        if (this._closed || this._junkError) {
+            callback();
+            return;
+        }
+        const id = this._nextId++;
+        this._pendingAcks.set(id, callback);
+        // Transfer the underlying ArrayBuffer to reduce copies.
+        // If chunk is a view into a larger buffer, slice to avoid transferring unrelated bytes.
+        const transferable = chunk.byteOffset === 0 && chunk.byteLength === chunk.buffer.byteLength
+            ? chunk
+            : chunk.slice();
+        this.worker.postMessage({ t: "write", id, chunk: transferable }, [transferable.buffer]);
+    }
+    _doClose(callback) {
+        if (this._closed) {
+            callback();
+            return;
+        }
+        this._closed = true;
+        this.worker.postMessage({ t: "close" });
+        callback();
+    }
+    destroy(error) {
+        if (!this._closed) {
+            this._closed = true;
+            try {
+                this.worker.postMessage({ t: "abort" });
+            }
+            catch {
+                // ignore
+            }
+        }
+        this._terminateWorker();
+        return super.destroy(error);
+    }
+}
+// =============================================================================
 // Fallback InflateRaw for browsers without DecompressionStream
 // =============================================================================
 /**
@@ -277,7 +456,7 @@ function createInflateRaw() {
 // =============================================================================
 // Utilities
 // =============================================================================
-const dataDescriptorSignature = writeUint32LE(DATA_DESCRIPTOR_SIG);
+const dataDescriptorSignature = DATA_DESCRIPTOR_SIGNATURE_BYTES;
 export function createParseClass(createInflateRawFn) {
     /**
      * ZIP Stream Parser for browsers.
@@ -291,11 +470,11 @@ export function createParseClass(createInflateRawFn) {
             super({
                 objectMode: true,
                 write: (chunk, _encoding, callback) => {
-                    this._handleWrite(chunk);
-                    callback();
+                    this._handleWrite(chunk, callback);
                 },
                 final: (callback) => {
                     this.finished = true;
+                    this._maybeReleaseWriteCallback();
                     this._wakeUp();
                     this.emit("data-available");
                     this.emit("chunk", false);
@@ -307,6 +486,12 @@ export function createParseClass(createInflateRawFn) {
             this._driverState = {};
             this._parsingDone = Promise.resolve();
             this._opts = opts;
+            // Default values are intentionally conservative to avoid memory spikes
+            // when parsing large archives under slow consumers.
+            const hi = Math.max(64 * 1024, opts.inputHighWaterMarkBytes ?? 2 * 1024 * 1024);
+            const lo = Math.max(32 * 1024, opts.inputLowWaterMarkBytes ?? Math.floor(hi / 4));
+            this._inputHighWaterMarkBytes = hi;
+            this._inputLowWaterMarkBytes = Math.min(lo, hi);
             const io = {
                 pull: (length) => this.pull(length),
                 pullUntil: (pattern, includeEof) => this.pullUntil(pattern, includeEof),
@@ -334,6 +519,12 @@ export function createParseClass(createInflateRawFn) {
                 },
                 emitError: (err) => {
                     this.__emittedError = err;
+                    // Ensure upstream writers don't hang waiting for a deferred write callback.
+                    if (this._writeCb) {
+                        const cb = this._writeCb;
+                        this._writeCb = undefined;
+                        cb(err);
+                    }
                     this.emit("error", err);
                 },
                 emitClose: () => {
@@ -341,7 +532,27 @@ export function createParseClass(createInflateRawFn) {
                 }
             };
             queueMicrotask(() => {
-                this._parsingDone = runParseLoop(this._opts, io, emitter, () => createInflateRawFn(), this._driverState);
+                // NOTE: We intentionally do NOT pass inflateRawSync to runParseLoop in browser.
+                // Browser's native DecompressionStream is faster than our pure-JS fallback,
+                // so we always use the streaming path for decompression in browsers.
+                const inflateFactory = () => {
+                    if (this._opts.useWorkerInflate && typeof Worker !== "undefined") {
+                        // Worker path requires DecompressionStream support.
+                        if (hasDeflateRawDecompressionStream()) {
+                            try {
+                                return new WorkerInflateRaw(this._opts.workerInflateUrl);
+                            }
+                            catch {
+                                // If Worker construction fails (e.g. CSP/CORS), fall back.
+                                return createInflateRawFn();
+                            }
+                        }
+                    }
+                    return createInflateRawFn();
+                };
+                this._parsingDone = runParseLoop(this._opts, io, emitter, inflateFactory, this._driverState
+                // No inflateRawSync - always use streaming DecompressionStream in browser
+                );
                 this._parsingDone.catch((e) => {
                     if (!this.__emittedError || this.__emittedError !== e) {
                         this.__emittedError = e;
@@ -351,8 +562,16 @@ export function createParseClass(createInflateRawFn) {
                 });
             });
         }
-        _handleWrite(chunk) {
+        _handleWrite(chunk, callback) {
             this._buffer.append(chunk);
+            // Apply writable backpressure by deferring the callback when the input buffer is large.
+            // The callback will be released once the parser drains the buffer.
+            if (this._buffer.length >= this._inputHighWaterMarkBytes) {
+                this._writeCb = callback;
+            }
+            else {
+                callback();
+            }
             this._wakeUp();
             this.emit("data-available");
             this.emit("chunk");
@@ -363,13 +582,6 @@ export function createParseClass(createInflateRawFn) {
         set buffer(value) {
             this._buffer.reset(value);
         }
-        _maybeReleaseWriteCallback() {
-            if (typeof this.cb === "function") {
-                const callback = this.cb;
-                this.cb = undefined;
-                callback();
-            }
-        }
         _wakeUp() {
             if (this._pendingResolve) {
                 const resolve = this._pendingResolve;
@@ -377,6 +589,17 @@ export function createParseClass(createInflateRawFn) {
                 resolve();
             }
         }
+        _maybeReleaseWriteCallback() {
+            if (!this._writeCb) {
+                return;
+            }
+            if (this._buffer.length > this._inputLowWaterMarkBytes) {
+                return;
+            }
+            const cb = this._writeCb;
+            this._writeCb = undefined;
+            cb();
+        }
         _waitForData() {
             return new Promise(resolve => {
                 this._pendingResolve = resolve;
@@ -390,60 +613,76 @@ export function createParseClass(createInflateRawFn) {
                 if (this.finished) {
                     if (this._buffer.length > 0) {
                         const data = this._buffer.read(this._buffer.length);
+                        this._maybeReleaseWriteCallback();
                         return data;
                     }
                     throw new Error("FILE_ENDED");
                 }
                 await this._waitForData();
             }
-            return this._buffer.read(length);
+            const out = this._buffer.read(length);
+            this._maybeReleaseWriteCallback();
+            return out;
         }
         async _pullUntilInternal(pattern, includeEof = false) {
             const chunks = [];
-            let searchFrom = 0;
-            const overlap = Math.max(0, pattern.length - 1);
+            const scanner = new PatternScanner(pattern);
             while (true) {
-                const view = this._buffer.view();
-                const match = indexOfUint8ArrayPattern(view, pattern, searchFrom);
+                const bufLen = this._buffer.length;
+                const match = scanner.find(this._buffer);
                 if (match !== -1) {
                     this.match = match;
                     const toRead = match + (includeEof ? pattern.length : 0);
                     if (toRead > 0) {
                         chunks.push(this._buffer.read(toRead));
+                        this._maybeReleaseWriteCallback();
                     }
-                    return concatUint8Arrays(chunks);
+                    return chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks);
                 }
                 // No match yet. Avoid rescanning bytes that can't start a match.
-                searchFrom = Math.max(searchFrom, Math.max(0, view.length - overlap));
+                scanner.onNoMatch(bufLen);
                 if (this.finished) {
                     throw new Error("FILE_ENDED");
                 }
                 const safeLen = Math.max(0, this._buffer.length - pattern.length);
                 if (safeLen > 0) {
                     chunks.push(this._buffer.read(safeLen));
-                    searchFrom = Math.max(0, searchFrom - safeLen);
+                    scanner.onConsume(safeLen);
+                    this._maybeReleaseWriteCallback();
                 }
                 await this._waitForData();
             }
         }
         _streamFixedLength(length) {
-            const output = new PassThrough();
+            const output = new PassThrough({ highWaterMark: DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK });
             let remaining = length;
             let done = false;
+            let waitingDrain = false;
             const pull = () => {
                 if (done) {
                     return;
                 }
+                if (waitingDrain) {
+                    return;
+                }
                 while (remaining > 0 && this._buffer.length > 0) {
                     const toRead = Math.min(remaining, this._buffer.length);
                     const chunk = this._buffer.read(toRead);
                     remaining -= toRead;
-                    output.write(chunk);
+                    const ok = output.write(chunk);
+                    this._maybeReleaseWriteCallback();
+                    if (!ok) {
+                        waitingDrain = true;
+                        output.once("drain", () => {
+                            waitingDrain = false;
+                            pull();
+                        });
+                        return;
+                    }
                 }
                 if (remaining === 0) {
                     done = true;
                     this.removeListener("data-available", pull);
-                    this._maybeReleaseWriteCallback();
                     output.end();
                 }
                 else if (this.finished) {
@@ -457,42 +696,69 @@ export function createParseClass(createInflateRawFn) {
             return output;
         }
         _streamUntilPattern(pattern, includeEof = false) {
-            const output = new PassThrough();
+            const output = new PassThrough({ highWaterMark: DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK });
             let done = false;
-            let searchFrom = 0;
-            const overlap = Math.max(0, pattern.length - 1);
+            const patternLen = pattern.length;
+            const scanner = new PatternScanner(pattern);
+            let waitingDrain = false;
             const pull = () => {
-                if (done) {
+                if (done || waitingDrain) {
                     return;
                 }
-                const view = this._buffer.view();
-                const match = indexOfUint8ArrayPattern(view, pattern, searchFrom);
-                if (match !== -1) {
-                    this.match = match;
-                    const endIndex = includeEof ? match + pattern.length : match;
-                    if (endIndex > 0) {
-                        output.write(this._buffer.read(endIndex));
+                while (true) {
+                    if (this._buffer.length <= 0) {
+                        break;
                     }
-                    done = true;
-                    this.removeListener("data-available", pull);
-                    this._maybeReleaseWriteCallback();
-                    output.end();
-                    return;
-                }
-                // No match yet. Avoid rescanning bytes that can't start a match.
-                searchFrom = Math.max(searchFrom, Math.max(0, view.length - overlap));
-                if (this.finished) {
-                    done = true;
-                    this.removeListener("data-available", pull);
-                    this._maybeReleaseWriteCallback();
-                    output.destroy(new Error("FILE_ENDED"));
-                    return;
-                }
-                const safeLen = Math.max(0, this._buffer.length - pattern.length);
-                if (safeLen > 0) {
-                    output.write(this._buffer.read(safeLen));
-                    searchFrom = Math.max(0, searchFrom - safeLen);
+                    const bufLen = this._buffer.length;
+                    const match = scanner.find(this._buffer);
+                    if (match !== -1) {
+                        this.match = match;
+                        const endIndex = includeEof ? match + patternLen : match;
+                        if (endIndex > 0) {
+                            const ok = output.write(this._buffer.read(endIndex));
+                            scanner.onConsume(endIndex);
+                            this._maybeReleaseWriteCallback();
+                            if (!ok) {
+                                waitingDrain = true;
+                                output.once("drain", () => {
+                                    waitingDrain = false;
+                                    pull();
+                                });
+                                return;
+                            }
+                        }
+                        done = true;
+                        this.removeListener("data-available", pull);
+                        output.end();
+                        return;
+                    }
+                    // No match yet. Avoid rescanning bytes that can't start a match.
+                    scanner.onNoMatch(bufLen);
+                    if (this.finished) {
+                        done = true;
+                        this.removeListener("data-available", pull);
+                        output.destroy(new Error("FILE_ENDED"));
+                        return;
+                    }
+                    const safeLen = bufLen - patternLen;
+                    if (safeLen <= 0) {
+                        // Keep enough bytes to detect a split signature.
+                        if (this._buffer.length <= patternLen) {
+                            this._maybeReleaseWriteCallback();
+                        }
+                        break;
+                    }
+                    const ok = output.write(this._buffer.read(safeLen));
+                    scanner.onConsume(safeLen);
                     this._maybeReleaseWriteCallback();
+                    if (!ok) {
+                        waitingDrain = true;
+                        output.once("drain", () => {
+                            waitingDrain = false;
+                            pull();
+                        });
+                        return;
+                    }
                 }
             };
             this.on("data-available", pull);
@@ -515,11 +781,7 @@ export function createParseClass(createInflateRawFn) {
                     return Promise.reject(new Error("FILE_ENDED"));
                 }
                 if (this._buffer.length >= eof) {
-                    const data = this._buffer.read(eof);
-                    if (this._buffer.length === 0) {
-                        this._maybeReleaseWriteCallback();
-                    }
-                    return Promise.resolve(data);
+                    return Promise.resolve(this._buffer.read(eof));
                 }
                 return this._pullInternal(eof);
             }
@@ -535,14 +797,18 @@ export function createParseClass(createInflateRawFn) {
         _streamUntilDataDescriptor() {
             return streamUntilValidatedDataDescriptor({
                 source: {
-                    getView: () => this._buffer.view(),
                     getLength: () => this._buffer.length,
                     read: (length) => this._buffer.read(length),
+                    peekChunks: (length) => this._buffer.peekChunks(length),
+                    discard: (length) => this._buffer.discard(length),
+                    indexOfPattern: (pattern, startIndex) => this._buffer.indexOfPattern(pattern, startIndex),
+                    peekUint32LE: (offset) => this._buffer.peekUint32LE(offset),
                     isFinished: () => this.finished,
                     onDataAvailable: (cb) => {
                         this.on("data-available", cb);
                         return () => this.removeListener("data-available", cb);
-                    }
+                    },
+                    maybeReleaseWriteCallback: () => this._maybeReleaseWriteCallback()
                 },
                 dataDescriptorSignature
             });

package/dist/browser/modules/archive/{parse.d.ts → unzip/stream.d.ts}

@@ -1,6 +1,6 @@
 import type { Duplex } from "@stream";
-import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "@archive/parse.base";
-export type { CrxHeader } from "@archive/parse.base";
+import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "@archive/unzip/stream.base";
+export type { CrxHeader } from "@archive/unzip/stream.base";
 export type { EntryProps, EntryVars, ParseOptions, ZipEntry };
 export type ParseStream = Duplex & {
     promise(): Promise<void>;