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

package/dist/browser/modules/archive/unzip/index.js

@@ -0,0 +1,164 @@
+import { ZipParser } from "./zip-parser.js";
+import { createParse } from "./stream.browser.js";
+import { pipeIterableToSink } from "../io/archive-sink.js";
+import { toAsyncIterable, toUint8Array } from "../io/archive-source.js";
+const textDecoderCache = new Map();
+function getTextDecoder(encoding) {
+    const key = encoding ?? "utf-8";
+    const cached = textDecoderCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const decoder = new TextDecoder(key);
+    textDecoderCache.set(key, decoder);
+    return decoder;
+}
+export class UnzipEntry {
+    constructor(args) {
+        if (args.kind === "buffer") {
+            this._parser = args.parser;
+            this._info = args.info;
+            this.path = args.info.path;
+            this.isDirectory = args.info.isDirectory;
+        }
+        else {
+            this._parseEntry = args.entry;
+            this.path = args.entry.path;
+            this.isDirectory = args.entry.type === "Directory";
+        }
+    }
+    async bytes() {
+        if (this._parser && this._info) {
+            const out = await this._parser.extract(this._info.path);
+            return out ?? new Uint8Array(0);
+        }
+        if (this._parseEntry) {
+            const data = await this._parseEntry.buffer();
+            // In Node.js, `entry.buffer()` may return a Buffer, which causes
+            // deep-equality mismatches against Uint8Array in tests.
+            if (typeof Buffer !== "undefined" && data instanceof Buffer) {
+                return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+            }
+            return data;
+        }
+        return new Uint8Array(0);
+    }
+    async *stream() {
+        if (this._parser && this._info) {
+            const data = await this.bytes();
+            if (data.length) {
+                yield data;
+            }
+            return;
+        }
+        if (this._parseEntry) {
+            for await (const chunk of this._parseEntry) {
+                yield chunk;
+            }
+        }
+    }
+    async pipeTo(sink) {
+        await pipeIterableToSink(this.stream(), sink);
+    }
+    async text(encoding) {
+        const bytes = await this.bytes();
+        return getTextDecoder(encoding).decode(bytes);
+    }
+    discard() {
+        if (this._parseEntry) {
+            this._parseEntry.autodrain();
+        }
+    }
+}
+export class ZipReader {
+    constructor(source, options = {}) {
+        this._bufferParser = null;
+        this._source = source;
+        this._options = options;
+    }
+    async _ensureBufferParser() {
+        if (this._bufferParser) {
+            return this._bufferParser;
+        }
+        if (this._source instanceof Uint8Array ||
+            this._source instanceof ArrayBuffer ||
+            typeof this._source === "string" ||
+            (typeof Blob !== "undefined" && this._source instanceof Blob)) {
+            const bytes = await toUint8Array(this._source);
+            this._bufferParser = new ZipParser(bytes, {
+                decodeStrings: this._options.decodeStrings
+            });
+            return this._bufferParser;
+        }
+        throw new Error("This ZIP source is streaming; random access is not available");
+    }
+    async get(path) {
+        const parser = await this._ensureBufferParser();
+        const info = parser.getEntry(path);
+        if (!info) {
+            return null;
+        }
+        return new UnzipEntry({ kind: "buffer", parser, info });
+    }
+    async *entries() {
+        // Buffer mode
+        if (this._source instanceof Uint8Array ||
+            this._source instanceof ArrayBuffer ||
+            typeof this._source === "string" ||
+            (typeof Blob !== "undefined" && this._source instanceof Blob)) {
+            const parser = await this._ensureBufferParser();
+            for (const info of parser.getEntries()) {
+                yield new UnzipEntry({ kind: "buffer", parser, info });
+            }
+            return;
+        }
+        // Streaming mode
+        // Always prefer forceStream mode for backpressure and bounded buffering.
+        const parse = createParse({ ...(this._options.parse ?? {}), forceStream: true });
+        const feedPromise = (async () => {
+            try {
+                for await (const chunk of toAsyncIterable(this._source)) {
+                    await new Promise((resolve, reject) => {
+                        parse.write(chunk, (err) => {
+                            if (err) {
+                                reject(err);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    });
+                }
+                parse.end();
+                await parse.promise();
+            }
+            catch (e) {
+                parse.destroy(e instanceof Error ? e : new Error(String(e)));
+                throw e;
+            }
+        })();
+        try {
+            for await (const entry of parse) {
+                yield new UnzipEntry({ kind: "stream", entry });
+            }
+            await feedPromise;
+        }
+        finally {
+            // Ensure the feed task does not get stranded.
+            await feedPromise.catch(() => { });
+        }
+    }
+    async bytes(path) {
+        const entry = await this.get(path);
+        if (!entry) {
+            return null;
+        }
+        return entry.bytes();
+    }
+    async close() {
+        // No persistent resources in buffer mode.
+    }
+}
+export function unzip(source, options) {
+    return new ZipReader(source, options);
+}

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

@@ -1,6 +1,7 @@
 import { Duplex, PassThrough, Transform, type Readable } from "@stream";
-import { ByteQueue } from "@archive/byte-queue";
+import { ByteQueue } from "@archive/internal/byte-queue";
 import { parseZipExtraFields, type ZipExtraFields, type ZipVars } from "@archive/utils/zip-extra-fields";
+export declare const DATA_DESCRIPTOR_SIGNATURE_BYTES: Uint8Array<ArrayBufferLike>;
 export declare const CRX_HEADER_FORMAT: [string, number][];
 export declare const LOCAL_FILE_HEADER_FORMAT: [string, number][];
 export declare const DATA_DESCRIPTOR_FORMAT: [string, number][];
@@ -119,9 +120,14 @@ export interface ValidatedDataDescriptorScanResult {
  */
 export declare function scanValidatedDataDescriptor(view: Uint8Array, dataDescriptorSignature: Uint8Array, bytesEmitted: number, startIndex?: number, out?: ValidatedDataDescriptorScanResult): ValidatedDataDescriptorScanResult;
 export interface StreamUntilValidatedDataDescriptorSource {
-    getView(): Uint8Array;
     getLength(): number;
     read(length: number): Uint8Array;
+    /** Optional: zero-copy chunk views for streaming writes. */
+    peekChunks?(length: number): Uint8Array[];
+    /** Optional: consume bytes previously written from peekChunks(). */
+    discard?(length: number): void;
+    indexOfPattern(pattern: Uint8Array, startIndex: number): number;
+    peekUint32LE(offset: number): number | null;
     isFinished(): boolean;
     onDataAvailable(cb: () => void): () => void;
     maybeReleaseWriteCallback?: () => void;
@@ -142,6 +148,34 @@ export declare function streamUntilValidatedDataDescriptor(options: StreamUntilV
 export interface ParseOptions {
     verbose?: boolean;
     forceStream?: boolean;
+    /**
+     * Browser-only: use a Web Worker to run inflate off the main thread.
+     * Defaults to false.
+     */
+    useWorkerInflate?: boolean;
+    /**
+     * Browser-only: provide an explicit Worker script URL.
+     *
+     * Useful under strict CSP that blocks `blob:` workers. When set, the browser
+     * parser will try to construct `new Worker(workerInflateUrl)`.
+     */
+    workerInflateUrl?: string;
+    /**
+     * Input backpressure high-water mark (bytes).
+     *
+     * When provided, implementations may delay the writable callback until the
+     * internal input buffer drops below `inputLowWaterMarkBytes`.
+     *
+     * This is primarily used by the browser parser, because its writable side
+     * otherwise tends to accept unlimited data and can cause large memory spikes.
+     */
+    inputHighWaterMarkBytes?: number;
+    /**
+     * Input backpressure low-water mark (bytes).
+     * When the internal buffer drops to (or below) this value, a delayed writable
+     * callback may be released.
+     */
+    inputLowWaterMarkBytes?: number;
     /**
      * Threshold (in bytes) for small file optimization.
      * Files smaller than this will use sync decompression (no stream overhead).