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

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

@@ -5,13 +5,14 @@
  * 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 { 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;
+import { Duplex, PassThrough, concatUint8Arrays } from "../stream/index.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";
 // =============================================================================
 // Browser InflateRaw using DecompressionStream
 // =============================================================================
@@ -28,9 +29,6 @@ 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);
             },
@@ -139,6 +137,47 @@ 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(() => {
@@ -166,6 +205,7 @@ class BrowserInflateRaw extends Duplex {
                 if (callback) {
                     callback();
                 }
+                this.emit("finish");
             });
         });
     }
@@ -178,225 +218,6 @@ 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
 // =============================================================================
 /**
@@ -456,7 +277,7 @@ function createInflateRaw() {
 // =============================================================================
 // Utilities
 // =============================================================================
-const dataDescriptorSignature = DATA_DESCRIPTOR_SIGNATURE_BYTES;
+const dataDescriptorSignature = writeUint32LE(DATA_DESCRIPTOR_SIG);
 export function createParseClass(createInflateRawFn) {
     /**
      * ZIP Stream Parser for browsers.
@@ -470,11 +291,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);
@@ -486,12 +307,6 @@ 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),
@@ -519,12 +334,6 @@ 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: () => {
@@ -535,22 +344,7 @@ export function createParseClass(createInflateRawFn) {
                 // 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
+                this._parsingDone = runParseLoop(this._opts, io, emitter, () => createInflateRawFn(), this._driverState
                 // No inflateRawSync - always use streaming DecompressionStream in browser
                 );
                 this._parsingDone.catch((e) => {
@@ -562,16 +356,8 @@ export function createParseClass(createInflateRawFn) {
                 });
             });
         }
-        _handleWrite(chunk, callback) {
+        _handleWrite(chunk) {
             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");
@@ -582,6 +368,13 @@ 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;
@@ -589,17 +382,6 @@ 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;
@@ -613,76 +395,60 @@ 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();
             }
-            const out = this._buffer.read(length);
-            this._maybeReleaseWriteCallback();
-            return out;
+            return this._buffer.read(length);
         }
         async _pullUntilInternal(pattern, includeEof = false) {
             const chunks = [];
-            const scanner = new PatternScanner(pattern);
+            let searchFrom = 0;
+            const overlap = Math.max(0, pattern.length - 1);
             while (true) {
-                const bufLen = this._buffer.length;
-                const match = scanner.find(this._buffer);
+                const view = this._buffer.view();
+                const match = indexOfUint8ArrayPattern(view, pattern, searchFrom);
                 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 chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks);
+                    return concatUint8Arrays(chunks);
                 }
                 // No match yet. Avoid rescanning bytes that can't start a match.
-                scanner.onNoMatch(bufLen);
+                searchFrom = Math.max(searchFrom, Math.max(0, view.length - overlap));
                 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));
-                    scanner.onConsume(safeLen);
-                    this._maybeReleaseWriteCallback();
+                    searchFrom = Math.max(0, searchFrom - safeLen);
                 }
                 await this._waitForData();
             }
         }
         _streamFixedLength(length) {
-            const output = new PassThrough({ highWaterMark: DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK });
+            const output = new PassThrough();
             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;
-                    const ok = output.write(chunk);
-                    this._maybeReleaseWriteCallback();
-                    if (!ok) {
-                        waitingDrain = true;
-                        output.once("drain", () => {
-                            waitingDrain = false;
-                            pull();
-                        });
-                        return;
-                    }
+                    output.write(chunk);
                 }
                 if (remaining === 0) {
                     done = true;
                     this.removeListener("data-available", pull);
+                    this._maybeReleaseWriteCallback();
                     output.end();
                 }
                 else if (this.finished) {
@@ -696,69 +462,42 @@ export function createParseClass(createInflateRawFn) {
             return output;
         }
         _streamUntilPattern(pattern, includeEof = false) {
-            const output = new PassThrough({ highWaterMark: DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK });
+            const output = new PassThrough();
             let done = false;
-            const patternLen = pattern.length;
-            const scanner = new PatternScanner(pattern);
-            let waitingDrain = false;
+            let searchFrom = 0;
+            const overlap = Math.max(0, pattern.length - 1);
             const pull = () => {
-                if (done || waitingDrain) {
+                if (done) {
                     return;
                 }
-                while (true) {
-                    if (this._buffer.length <= 0) {
-                        break;
-                    }
-                    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 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));
                     }
-                    const ok = output.write(this._buffer.read(safeLen));
-                    scanner.onConsume(safeLen);
+                    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);
                     this._maybeReleaseWriteCallback();
-                    if (!ok) {
-                        waitingDrain = true;
-                        output.once("drain", () => {
-                            waitingDrain = false;
-                            pull();
-                        });
-                        return;
-                    }
                 }
             };
             this.on("data-available", pull);
@@ -781,7 +520,11 @@ export function createParseClass(createInflateRawFn) {
                     return Promise.reject(new Error("FILE_ENDED"));
                 }
                 if (this._buffer.length >= eof) {
-                    return Promise.resolve(this._buffer.read(eof));
+                    const data = this._buffer.read(eof);
+                    if (this._buffer.length === 0) {
+                        this._maybeReleaseWriteCallback();
+                    }
+                    return Promise.resolve(data);
                 }
                 return this._pullInternal(eof);
             }
@@ -797,18 +540,14 @@ 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/unzip/stream.js → esm/modules/archive/parse.js}

@@ -1,12 +1,14 @@
 import zlib from "zlib";
-import { DATA_DESCRIPTOR_SIGNATURE_BYTES, PullStream, runParseLoop, streamUntilValidatedDataDescriptor } from "./stream.base.js";
+import { writeUint32LE } from "./utils/binary.js";
+import { PullStream, runParseLoop, streamUntilValidatedDataDescriptor } from "./parse.base.js";
+import { DATA_DESCRIPTOR_SIG } from "./zip-constants.js";
 /**
  * Creates an InflateRaw stream using Node.js native zlib.
  */
 function createInflateRaw() {
     return zlib.createInflateRaw();
 }
-const dataDescriptorSignature = DATA_DESCRIPTOR_SIGNATURE_BYTES;
+const dataDescriptorSignature = writeUint32LE(DATA_DESCRIPTOR_SIG);
 export function createParseClass(createInflateRawFn) {
     return class Parse extends PullStream {
         constructor(opts = {}) {
@@ -61,12 +63,9 @@ export function createParseClass(createInflateRawFn) {
         _streamUntilValidatedDataDescriptor() {
             return streamUntilValidatedDataDescriptor({
                 source: {
+                    getView: () => this._queue.view(),
                     getLength: () => this._queue.length,
                     read: (length) => this._queue.read(length),
-                    peekChunks: (length) => this._queue.peekChunks(length),
-                    discard: (length) => this._queue.discard(length),
-                    indexOfPattern: (pattern, startIndex) => this._queue.indexOfPattern(pattern, startIndex),
-                    peekUint32LE: (offset) => this._queue.peekUint32LE(offset),
                     isFinished: () => this.finished,
                     onDataAvailable: (cb) => {
                         this.on("chunk", cb);