@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

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

@@ -1,109 +1,11 @@
-import { parseDosDateTimeUTC, resolveZipLastModifiedDateFromUnixSeconds } from "../utils/timestamps.js";
-import { Duplex, PassThrough, Transform, concatUint8Arrays, pipeline, finished } from "../../stream/index.browser.js";
-import { parseTyped as parseBuffer } from "../utils/parse-buffer.js";
-import { ByteQueue } from "../internal/byte-queue.js";
-import { indexOfUint8ArrayPattern } from "../utils/bytes.js";
-import { PatternScanner } from "../utils/pattern-scanner.js";
-import { readUint32LE, writeUint32LE } from "../utils/binary.js";
-import { parseZipExtraFields } from "../utils/zip-extra-fields.js";
-import { CENTRAL_DIR_HEADER_SIG, DATA_DESCRIPTOR_SIG, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG, ZIP64_END_OF_CENTRAL_DIR_SIG } from "../zip-spec/zip-records.js";
-export const DATA_DESCRIPTOR_SIGNATURE_BYTES = writeUint32LE(DATA_DESCRIPTOR_SIG);
-const DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK = 256 * 1024;
-// Shared parseBuffer() formats
-export const CRX_HEADER_FORMAT = [
-    ["version", 4],
-    ["pubKeyLength", 4],
-    ["signatureLength", 4]
-];
-export const LOCAL_FILE_HEADER_FORMAT = [
-    ["versionsNeededToExtract", 2],
-    ["flags", 2],
-    ["compressionMethod", 2],
-    ["lastModifiedTime", 2],
-    ["lastModifiedDate", 2],
-    ["crc32", 4],
-    ["compressedSize", 4],
-    ["uncompressedSize", 4],
-    ["fileNameLength", 2],
-    ["extraFieldLength", 2]
-];
-export const DATA_DESCRIPTOR_FORMAT = [
-    ["dataDescriptorSignature", 4],
-    ["crc32", 4],
-    ["compressedSize", 4],
-    ["uncompressedSize", 4]
-];
-export const CENTRAL_DIRECTORY_FILE_HEADER_FORMAT = [
-    ["versionMadeBy", 2],
-    ["versionsNeededToExtract", 2],
-    ["flags", 2],
-    ["compressionMethod", 2],
-    ["lastModifiedTime", 2],
-    ["lastModifiedDate", 2],
-    ["crc32", 4],
-    ["compressedSize", 4],
-    ["uncompressedSize", 4],
-    ["fileNameLength", 2],
-    ["extraFieldLength", 2],
-    ["fileCommentLength", 2],
-    ["diskNumber", 2],
-    ["internalFileAttributes", 2],
-    ["externalFileAttributes", 4],
-    ["offsetToLocalFileHeader", 4]
-];
-export const END_OF_CENTRAL_DIRECTORY_FORMAT = [
-    ["diskNumber", 2],
-    ["diskStart", 2],
-    ["numberOfRecordsOnDisk", 2],
-    ["numberOfRecords", 2],
-    ["sizeOfCentralDirectory", 4],
-    ["offsetToStartOfCentralDirectory", 4],
-    ["commentLength", 2]
-];
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
-export function decodeZipEntryPath(pathBuffer) {
-    return textDecoder.decode(pathBuffer);
-}
-export function isZipUnicodeFlag(flags) {
-    return ((flags ?? 0) & 0x800) !== 0;
-}
-export function isZipDirectoryPath(path) {
-    if (path.length === 0) {
-        return false;
-    }
-    const last = path.charCodeAt(path.length - 1);
-    return last === 47 || last === 92;
-}
-export function getZipEntryType(path, uncompressedSize) {
-    return uncompressedSize === 0 && isZipDirectoryPath(path) ? "Directory" : "File";
-}
-export function buildZipEntryProps(path, pathBuffer, flags) {
-    return {
-        path,
-        pathBuffer,
-        flags: {
-            isUnicode: isZipUnicodeFlag(flags)
-        }
-    };
-}
-export function resolveZipEntryLastModifiedDateTime(vars, extraFields) {
-    const dosDate = vars.lastModifiedDate ?? 0;
-    const dosTime = vars.lastModifiedTime ?? 0;
-    const dosDateTime = parseDosDateTimeUTC(dosDate, dosTime);
-    const unixSecondsMtime = extraFields.mtimeUnixSeconds;
-    if (unixSecondsMtime === undefined) {
-        return dosDateTime;
-    }
-    return resolveZipLastModifiedDateFromUnixSeconds(dosDate, dosTime, unixSecondsMtime);
-}
-export const parseExtraField = parseZipExtraFields;
-export function hasDataDescriptorFlag(flags) {
-    return ((flags ?? 0) & 0x08) !== 0;
-}
-export function isFileSizeKnown(flags, compressedSize) {
-    return !hasDataDescriptorFlag(flags) || (compressedSize ?? 0) > 0;
-}
+import { Duplex, PassThrough, Transform, pipeline, finished } from "../../stream/index.browser.js";
+import { concatUint8Arrays, textEncoder as utf8Encoder } from "../../../utils/binary.js";
+import { ByteQueue } from "../shared/byte-queue.js";
+import { EMPTY_UINT8ARRAY } from "../shared/bytes.js";
+import { decodeZipPath, resolveZipStringCodec } from "../shared/text.js";
+import { PatternScanner } from "./pattern-scanner.js";
+import { DEFAULT_PARSE_THRESHOLD_BYTES, buildZipEntryProps, getZipEntryType, hasDataDescriptorFlag, isFileSizeKnown, parseExtraField, readDataDescriptor, readLocalFileHeader, resolveZipEntryLastModifiedDateTime, runParseLoopCore, isValidZipRecordSignature } from "./parser-core.js";
+export const DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK = 256 * 1024;
 export function autodrain(stream) {
     const draining = stream.pipe(new Transform({
         transform(_chunk, _encoding, callback) {
@@ -143,24 +45,101 @@ export class PullStream extends Duplex {
     set buffer(value) {
         this._queue.reset(value);
     }
-    constructor() {
+    constructor(opts = {}) {
         super({ decodeStrings: false, objectMode: true });
         this._queue = new ByteQueue();
         this.finished = false;
+        // 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);
         this.on("finish", () => {
             this.finished = true;
+            this._notifyPendingChunkWaiter();
             this.emit("chunk", false);
         });
     }
+    _notifyPendingChunkWaiter() {
+        if (!this._pendingChunkResolve) {
+            return;
+        }
+        const resolve = this._pendingChunkResolve;
+        this._pendingChunkResolve = undefined;
+        this._pendingChunkPromise = undefined;
+        resolve();
+    }
+    _waitForChunkSignal() {
+        if (this._pendingChunkPromise) {
+            return this._pendingChunkPromise;
+        }
+        this._pendingChunkPromise = new Promise(resolve => {
+            this._pendingChunkResolve = resolve;
+        });
+        return this._pendingChunkPromise;
+    }
+    async _pullFixedLength(length) {
+        const queue = this._queue;
+        let remaining = length;
+        let firstChunk = null;
+        let chunks = null;
+        const appendChunk = (chunk) => {
+            if (chunk.length === 0) {
+                return;
+            }
+            if (!firstChunk) {
+                firstChunk = chunk;
+                return;
+            }
+            if (!chunks) {
+                chunks = [firstChunk, chunk];
+                return;
+            }
+            chunks.push(chunk);
+        };
+        while (remaining > 0) {
+            while (queue.length === 0) {
+                if (this.finished) {
+                    throw new Error("FILE_ENDED");
+                }
+                await this._waitForChunkSignal();
+            }
+            const toRead = Math.min(remaining, queue.length);
+            appendChunk(queue.read(toRead));
+            remaining -= toRead;
+            if (queue.length === 0) {
+                this._maybeReleaseWriteCallback();
+            }
+        }
+        this._maybeReleaseWriteCallback();
+        if (!firstChunk) {
+            return EMPTY_UINT8ARRAY;
+        }
+        if (!chunks) {
+            return firstChunk;
+        }
+        return concatUint8Arrays(chunks);
+    }
     _write(chunk, _encoding, callback) {
-        const data = typeof chunk === "string" ? textEncoder.encode(chunk) : chunk;
+        const data = typeof chunk === "string" ? utf8Encoder.encode(chunk) : chunk;
         this._queue.append(data);
-        this.cb = callback;
+        // Apply writable backpressure by deferring the callback when the input buffer is large.
+        // Otherwise, release it immediately so producers can stream in more bytes.
+        if (this._queue.length >= this._inputHighWaterMarkBytes) {
+            this.cb = callback;
+        }
+        else {
+            callback();
+        }
+        this._notifyPendingChunkWaiter();
         this.emit("chunk");
     }
     _read() { }
     _maybeReleaseWriteCallback() {
-        if (typeof this.cb === STR_FUNCTION) {
+        // Only release a deferred write callback when we've drained enough data.
+        // This provides bounded buffering while still preventing deadlocks.
+        if (typeof this.cb === STR_FUNCTION && this._queue.length <= this._inputLowWaterMarkBytes) {
             const callback = this.cb;
             this.cb = undefined;
             callback();
@@ -183,6 +162,10 @@ export class PullStream extends Duplex {
         const cb = () => {
             this._maybeReleaseWriteCallback();
         };
+        const onDrain = () => {
+            waitingDrain = false;
+            pull();
+        };
         const pull = () => {
             if (done || waitingDrain) {
                 return;
@@ -242,10 +225,7 @@ export class PullStream extends Duplex {
                 }
                 if (!ok) {
                     waitingDrain = true;
-                    p.once("drain", () => {
-                        waitingDrain = false;
-                        pull();
-                    });
+                    p.once("drain", onDrain);
                     return;
                 }
                 if (done) {
@@ -273,27 +253,21 @@ export class PullStream extends Duplex {
     }
     pull(eof, includeEof) {
         if (eof === 0) {
-            return Promise.resolve(new Uint8Array(0));
+            return Promise.resolve(EMPTY_UINT8ARRAY);
         }
-        // If we already have the required data in buffer
-        // we can resolve the request immediately
-        if (typeof eof === "number" && this._queue.length >= eof) {
-            const data = this._queue.read(eof);
-            // Allow the upstream writer to continue once the consumer makes progress.
-            // Waiting for a full drain can deadlock when the producer must call `end()`
-            // but is blocked behind a deferred write callback.
-            this._maybeReleaseWriteCallback();
-            return Promise.resolve(data);
+        if (typeof eof === "number") {
+            return this._pullFixedLength(eof);
         }
+        const queue = this._queue;
         // Otherwise we wait for more data and fulfill directly from the internal queue.
         // This avoids constructing intermediate streams for small pulls (hot path).
-        const chunks = [];
+        let firstChunk = null;
+        let chunks = null;
         let pullStreamRejectHandler;
         // Pattern scanning state (only used when eof is a pattern)
-        const eofIsNumber = typeof eof === "number";
-        const pattern = eofIsNumber ? undefined : eof;
-        const patternLen = pattern ? pattern.length : 0;
-        const scanner = eofIsNumber ? undefined : new PatternScanner(pattern);
+        const pattern = eof;
+        const patternLen = pattern.length;
+        const scanner = new PatternScanner(pattern);
         return new Promise((resolve, reject) => {
             let settled = false;
             pullStreamRejectHandler = (e) => {
@@ -313,11 +287,29 @@ export class PullStream extends Duplex {
             const finalize = () => {
                 cleanup();
                 settled = true;
-                if (chunks.length === 0) {
-                    resolve(new Uint8Array(0));
+                if (!firstChunk) {
+                    resolve(EMPTY_UINT8ARRAY);
                     return;
                 }
-                resolve(chunks.length === 1 ? chunks[0] : concatUint8Arrays(chunks));
+                if (!chunks) {
+                    resolve(firstChunk);
+                    return;
+                }
+                resolve(concatUint8Arrays(chunks));
+            };
+            const appendChunk = (chunk) => {
+                if (chunk.length === 0) {
+                    return;
+                }
+                if (!firstChunk) {
+                    firstChunk = chunk;
+                    return;
+                }
+                if (!chunks) {
+                    chunks = [firstChunk, chunk];
+                    return;
+                }
+                chunks.push(chunk);
             };
             const onFinish = () => {
                 if (settled) {
@@ -331,39 +323,19 @@ export class PullStream extends Duplex {
                 }
             };
             const onChunk = () => {
-                if (typeof eof === "number") {
-                    const available = this._queue.length;
-                    if (available <= 0) {
-                        return;
-                    }
-                    const toRead = Math.min(eof, available);
-                    if (toRead > 0) {
-                        chunks.push(this._queue.read(toRead));
-                        eof -= toRead;
-                    }
-                    // Allow upstream to continue as soon as we consume bytes.
-                    // This avoids deadlocks when the last upstream chunk is waiting on its
-                    // callback and the parser needs an EOF signal after draining buffered data.
-                    this._maybeReleaseWriteCallback();
-                    if (eof === 0) {
-                        finalize();
-                    }
-                    return;
-                }
-                // eof is a pattern
-                while (this._queue.length > 0) {
-                    const bufLen = this._queue.length;
-                    const match = scanner.find(this._queue);
+                while (queue.length > 0) {
+                    const bufLen = queue.length;
+                    const match = scanner.find(queue);
                     if (match !== -1) {
                         // store signature match byte offset to allow us to reference
                         // this for zip64 offset
                         this.match = match;
                         const toRead = includeEof ? match + patternLen : match;
                         if (toRead > 0) {
-                            chunks.push(this._queue.read(toRead));
+                            appendChunk(queue.read(toRead));
                             scanner.onConsume(toRead);
                         }
-                        if (this._queue.length === 0 || (patternLen && this._queue.length <= patternLen)) {
+                        if (queue.length === 0 || (patternLen && queue.length <= patternLen)) {
                             this._maybeReleaseWriteCallback();
                         }
                         finalize();
@@ -377,9 +349,9 @@ export class PullStream extends Duplex {
                         this._maybeReleaseWriteCallback();
                         return;
                     }
-                    chunks.push(this._queue.read(safeLen));
+                    appendChunk(queue.read(safeLen));
                     scanner.onConsume(safeLen);
-                    if (this._queue.length === 0 || (patternLen && this._queue.length <= patternLen)) {
+                    if (queue.length === 0 || (patternLen && queue.length <= patternLen)) {
                         this._maybeReleaseWriteCallback();
                         return;
                     }
@@ -390,191 +362,18 @@ export class PullStream extends Duplex {
             this.once("finish", onFinish);
             // Attempt immediate fulfillment from any already-buffered data.
             onChunk();
+            // Race fix: `finish` can fire between the early `this.finished` check and
+            // registering the listener above. If that happens and we don't have enough
+            // buffered bytes to fulfill the pull, the Promise would never settle.
+            if (this.finished) {
+                onFinish();
+            }
         });
     }
     pullUntil(pattern, includeEof) {
         return this.pull(pattern, includeEof);
     }
 }
-export async function readCrxHeader(pull) {
-    const data = await pull(12);
-    const header = data.length >= 12 ? parseCrxHeaderFast(data) : parseBuffer(data, CRX_HEADER_FORMAT);
-    const pubKeyLength = header.pubKeyLength ?? 0;
-    const signatureLength = header.signatureLength ?? 0;
-    const keyAndSig = await pull(pubKeyLength + signatureLength);
-    header.publicKey = keyAndSig.subarray(0, pubKeyLength);
-    header.signature = keyAndSig.subarray(pubKeyLength);
-    return header;
-}
-export async function readLocalFileHeader(pull) {
-    const data = await pull(26);
-    const vars = data.length >= 26
-        ? parseLocalFileHeaderVarsFast(data)
-        : parseBuffer(data, LOCAL_FILE_HEADER_FORMAT);
-    const fileNameBuffer = await pull(vars.fileNameLength ?? 0);
-    const extraFieldData = await pull(vars.extraFieldLength ?? 0);
-    return { vars, fileNameBuffer, extraFieldData };
-}
-export async function readDataDescriptor(pull) {
-    const data = await pull(16);
-    return data.length >= 16
-        ? parseDataDescriptorVarsFast(data)
-        : parseBuffer(data, DATA_DESCRIPTOR_FORMAT);
-}
-export async function consumeCentralDirectoryFileHeader(pull) {
-    const data = await pull(42);
-    const vars = parseBuffer(data, CENTRAL_DIRECTORY_FILE_HEADER_FORMAT);
-    await pull(vars.fileNameLength ?? 0);
-    await pull(vars.extraFieldLength ?? 0);
-    await pull(vars.fileCommentLength ?? 0);
-}
-export async function consumeEndOfCentralDirectoryRecord(pull) {
-    const data = await pull(18);
-    const vars = parseBuffer(data, END_OF_CENTRAL_DIRECTORY_FORMAT);
-    await pull(vars.commentLength ?? 0);
-}
-// =============================================================================
-// Validated Data Descriptor Scan (shared by Node + Browser)
-// =============================================================================
-function isValidZipRecordSignature(sig) {
-    switch (sig) {
-        case LOCAL_FILE_HEADER_SIG:
-        case CENTRAL_DIR_HEADER_SIG:
-        case END_OF_CENTRAL_DIR_SIG:
-        case ZIP64_END_OF_CENTRAL_DIR_SIG:
-        case ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG:
-            return true;
-        default:
-            return false;
-    }
-}
-function readUint32LEFromBytes(view, offset) {
-    return ((view[offset] |
-        0 |
-        ((view[offset + 1] | 0) << 8) |
-        ((view[offset + 2] | 0) << 16) |
-        ((view[offset + 3] | 0) << 24)) >>>
-        0);
-}
-function readUint16LEFromBytes(view, offset) {
-    return (view[offset] | ((view[offset + 1] | 0) << 8)) >>> 0;
-}
-function parseCrxHeaderFast(data) {
-    return {
-        version: readUint32LEFromBytes(data, 0),
-        pubKeyLength: readUint32LEFromBytes(data, 4),
-        signatureLength: readUint32LEFromBytes(data, 8)
-    };
-}
-function parseLocalFileHeaderVarsFast(data) {
-    return {
-        versionsNeededToExtract: readUint16LEFromBytes(data, 0),
-        flags: readUint16LEFromBytes(data, 2),
-        compressionMethod: readUint16LEFromBytes(data, 4),
-        lastModifiedTime: readUint16LEFromBytes(data, 6),
-        lastModifiedDate: readUint16LEFromBytes(data, 8),
-        crc32: readUint32LEFromBytes(data, 10),
-        compressedSize: readUint32LEFromBytes(data, 14),
-        uncompressedSize: readUint32LEFromBytes(data, 18),
-        fileNameLength: readUint16LEFromBytes(data, 22),
-        extraFieldLength: readUint16LEFromBytes(data, 24)
-    };
-}
-function parseDataDescriptorVarsFast(data) {
-    return {
-        dataDescriptorSignature: readUint32LEFromBytes(data, 0),
-        crc32: readUint32LEFromBytes(data, 4),
-        compressedSize: readUint32LEFromBytes(data, 8),
-        uncompressedSize: readUint32LEFromBytes(data, 12)
-    };
-}
-function indexOf4BytesPattern(buffer, pattern, startIndex) {
-    if (pattern.length !== 4) {
-        return indexOfUint8ArrayPattern(buffer, pattern, startIndex);
-    }
-    const b0 = pattern[0];
-    const b1 = pattern[1];
-    const b2 = pattern[2];
-    const b3 = pattern[3];
-    const bufLen = buffer.length;
-    let start = startIndex | 0;
-    if (start < 0) {
-        start = 0;
-    }
-    if (start > bufLen - 4) {
-        return -1;
-    }
-    const last = bufLen - 4;
-    let i = buffer.indexOf(b0, start);
-    while (i !== -1 && i <= last) {
-        if (buffer[i + 1] === b1 && buffer[i + 2] === b2 && buffer[i + 3] === b3) {
-            return i;
-        }
-        i = buffer.indexOf(b0, i + 1);
-    }
-    return -1;
-}
-function initScanResult(out) {
-    if (out) {
-        return out;
-    }
-    return { foundIndex: -1, nextSearchFrom: 0 };
-}
-/**
- * Scan for a validated DATA_DESCRIPTOR record boundary.
- *
- * Scanning for the 4-byte signature alone is unsafe because it can appear inside
- * compressed data. We validate a candidate by requiring:
- * - the next 4 bytes after the 16-byte descriptor form a known ZIP record signature, and
- * - the descriptor's compressedSize matches the number of compressed bytes emitted so far.
- */
-export function scanValidatedDataDescriptor(view, dataDescriptorSignature, bytesEmitted, startIndex = 0, out) {
-    const result = initScanResult(out);
-    const viewLen = view.length;
-    let searchFrom = startIndex | 0;
-    if (searchFrom < 0) {
-        searchFrom = 0;
-    }
-    if (searchFrom > viewLen) {
-        searchFrom = viewLen;
-    }
-    // To avoid missing a signature split across chunk boundaries, we may need
-    // to re-check the last (sigLen - 1) bytes on the next scan.
-    const sigLen = dataDescriptorSignature.length | 0;
-    const overlap = sigLen > 0 ? sigLen - 1 : 0;
-    const viewLimit = Math.max(0, viewLen - overlap);
-    while (searchFrom < viewLen) {
-        const match = indexOf4BytesPattern(view, dataDescriptorSignature, searchFrom);
-        if (match === -1) {
-            result.foundIndex = -1;
-            result.nextSearchFrom = Math.max(searchFrom, viewLimit);
-            return result;
-        }
-        const idx = match;
-        // Need 16 bytes for descriptor + 4 bytes for next record signature.
-        const nextSigOffset = idx + 16;
-        if (nextSigOffset + 4 <= viewLen) {
-            const nextSig = readUint32LEFromBytes(view, nextSigOffset);
-            const descriptorCompressedSize = readUint32LEFromBytes(view, idx + 8);
-            const expectedCompressedSize = (bytesEmitted + idx) >>> 0;
-            if (isValidZipRecordSignature(nextSig) &&
-                descriptorCompressedSize === expectedCompressedSize) {
-                result.foundIndex = idx;
-                result.nextSearchFrom = idx;
-                return result;
-            }
-            searchFrom = idx + 1;
-            continue;
-        }
-        // Not enough bytes to validate yet. Re-check this candidate once more bytes arrive.
-        result.foundIndex = -1;
-        result.nextSearchFrom = idx;
-        return result;
-    }
-    result.foundIndex = -1;
-    result.nextSearchFrom = Math.max(searchFrom, viewLimit);
-    return result;
-}
 /**
  * Stream compressed file data until we reach a validated DATA_DESCRIPTOR boundary.
  *
@@ -597,6 +396,10 @@ export function streamUntilValidatedDataDescriptor(options) {
             unsubscribe = undefined;
         }
     };
+    const onDrain = () => {
+        waitingDrain = false;
+        pull();
+    };
     const pull = () => {
         if (done) {
             return;
@@ -636,10 +439,7 @@ export function streamUntilValidatedDataDescriptor(options) {
                                     written += part.length;
                                     if (!ok) {
                                         waitingDrain = true;
-                                        output.once("drain", () => {
-                                            waitingDrain = false;
-                                            pull();
-                                        });
+                                        output.once("drain", onDrain);
                                         break;
                                     }
                                 }
@@ -658,10 +458,7 @@ export function streamUntilValidatedDataDescriptor(options) {
                                 scanner.onConsume(idx);
                                 if (!ok) {
                                     waitingDrain = true;
-                                    output.once("drain", () => {
-                                        waitingDrain = false;
-                                        pull();
-                                    });
+                                    output.once("drain", onDrain);
                                     return;
                                 }
                             }
@@ -693,10 +490,7 @@ export function streamUntilValidatedDataDescriptor(options) {
                         written += part.length;
                         if (!ok) {
                             waitingDrain = true;
-                            output.once("drain", () => {
-                                waitingDrain = false;
-                                pull();
-                            });
+                            output.once("drain", onDrain);
                             break;
                         }
                     }
@@ -720,10 +514,7 @@ export function streamUntilValidatedDataDescriptor(options) {
                 }
                 if (!ok) {
                     waitingDrain = true;
-                    output.once("drain", () => {
-                        waitingDrain = false;
-                        pull();
-                    });
+                    output.once("drain", onDrain);
                 }
                 return;
             }
@@ -744,54 +535,11 @@ export function streamUntilValidatedDataDescriptor(options) {
     queueMicrotask(pull);
     return output;
 }
-/**
- * Default threshold for small file optimization (5MB).
- */
-export const DEFAULT_PARSE_THRESHOLD_BYTES = 5 * 1024 * 1024;
-const endDirectorySignature = writeUint32LE(END_OF_CENTRAL_DIR_SIG);
 export async function runParseLoop(opts, io, emitter, inflateFactory, state, inflateRawSync) {
     const thresholdBytes = opts.thresholdBytes ?? DEFAULT_PARSE_THRESHOLD_BYTES;
-    while (true) {
-        const sigBytes = await io.pull(4);
-        if (sigBytes.length === 0) {
-            emitter.emitClose();
-            return;
-        }
-        const signature = readUint32LE(sigBytes, 0);
-        if (signature === 0x34327243) {
-            state.crxHeader = await readCrxHeader(async (length) => io.pull(length));
-            emitter.emitCrxHeader(state.crxHeader);
-            continue;
-        }
-        if (signature === LOCAL_FILE_HEADER_SIG) {
-            await readFileRecord(opts, io, emitter, inflateFactory, state, thresholdBytes, inflateRawSync);
-            continue;
-        }
-        if (signature === CENTRAL_DIR_HEADER_SIG) {
-            state.reachedCD = true;
-            await consumeCentralDirectoryFileHeader(async (length) => io.pull(length));
-            continue;
-        }
-        if (signature === END_OF_CENTRAL_DIR_SIG) {
-            await consumeEndOfCentralDirectoryRecord(async (length) => io.pull(length));
-            io.setDone();
-            emitter.emitClose();
-            return;
-        }
-        if (state.reachedCD) {
-            // We are in central directory trailing data; resync by scanning for EOCD signature.
-            // consumeEndOfCentralDirectoryRecord expects the EOCD signature to be consumed, so includeEof=true.
-            const includeEof = true;
-            await io.pullUntil(endDirectorySignature, includeEof);
-            await consumeEndOfCentralDirectoryRecord(async (length) => io.pull(length));
-            io.setDone();
-            emitter.emitClose();
-            return;
-        }
-        emitter.emitError(new Error("invalid signature: 0x" + signature.toString(16)));
-        emitter.emitClose();
-        return;
-    }
+    await runParseLoopCore(opts, io, emitter, state, async (_opts, _io, _emitter, _state) => {
+        await readFileRecord(opts, io, emitter, inflateFactory, state, thresholdBytes, inflateRawSync);
+    });
 }
 async function pumpKnownCompressedSizeToEntry(io, inflater, entry, compressedSize) {
     // Keep chunks reasonably large to reduce per-await overhead.
@@ -804,46 +552,61 @@ async function pumpKnownCompressedSizeToEntry(io, inflater, entry, compressedSiz
     inflater.once("error", onError);
     entry.once("error", onError);
     let skipping = false;
+    const anyInflater = inflater;
+    let waitResolve = null;
+    const cleanupWaitListeners = () => {
+        try {
+            anyInflater?.removeListener?.("drain", onDrain);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            entry.removeListener("__autodrain", onAutodrain);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            entry.removeListener("close", onClose);
+        }
+        catch {
+            // ignore
+        }
+    };
+    const resolveWait = () => {
+        const resolve = waitResolve;
+        if (!resolve) {
+            return;
+        }
+        waitResolve = null;
+        cleanupWaitListeners();
+        resolve();
+    };
+    const onDrain = () => {
+        resolveWait();
+    };
+    const onAutodrain = () => {
+        resolveWait();
+    };
+    const onClose = () => {
+        resolveWait();
+    };
     const waitForDrainOrSkipSignal = async () => {
         await new Promise(resolve => {
-            const anyInflater = inflater;
-            const cleanup = () => {
-                try {
-                    anyInflater?.removeListener?.("drain", onDrain);
-                }
-                catch {
-                    // ignore
-                }
-                try {
-                    entry.removeListener("__autodrain", onAutodrain);
-                }
-                catch {
-                    // ignore
-                }
-                try {
-                    entry.removeListener("close", onClose);
-                }
-                catch {
-                    // ignore
-                }
-            };
-            const onDrain = () => {
-                cleanup();
-                resolve();
-            };
-            const onAutodrain = () => {
-                cleanup();
-                resolve();
-            };
-            const onClose = () => {
-                cleanup();
-                resolve();
-            };
+            waitResolve = resolve;
             if (typeof anyInflater?.once === "function") {
                 anyInflater.once("drain", onDrain);
             }
             entry.once("__autodrain", onAutodrain);
             entry.once("close", onClose);
+            // Guard against a race where __autodrain was emitted between the
+            // inflater.write() call and the listener registration above.
+            // Without this check the pump can deadlock on Windows where
+            // event-loop scheduling differs from macOS/Linux.
+            if (entry.__autodraining || entry.destroyed) {
+                resolveWait();
+            }
         });
     };
     const switchToSkip = async () => {
@@ -923,7 +686,19 @@ async function readFileRecord(opts, io, emitter, inflateFactory, state, threshol
     if (state.crxHeader) {
         vars.crxHeader = state.crxHeader;
     }
-    const fileName = decodeZipEntryPath(fileNameBuffer);
+    // Parse extra fields first so we can use Unicode Path Extra Field for decoding
+    const zipVars = {
+        uncompressedSize: vars.uncompressedSize ?? 0,
+        compressedSize: vars.compressedSize ?? 0
+    };
+    const extra = parseExtraField(extraFieldData, zipVars);
+    // Write back ZIP64-corrected sizes so downstream code uses the real values
+    // instead of the 0xFFFFFFFF sentinel for entries > 4GB.
+    vars.uncompressedSize = zipVars.uncompressedSize;
+    vars.compressedSize = zipVars.compressedSize;
+    const decoder = opts.encoding ? resolveZipStringCodec(opts.encoding) : undefined;
+    // Decode filename: UTF-8 flag → Unicode extra field → CP437 (or custom decoder)
+    const fileName = decodeZipPath(fileNameBuffer, vars.flags, extra, decoder);
     const entry = new PassThrough({
         highWaterMark: DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK
     });
@@ -955,14 +730,9 @@ async function readFileRecord(opts, io, emitter, inflateFactory, state, threshol
             }
         }
     }
-    const zipVars = {
-        uncompressedSize: vars.uncompressedSize ?? 0,
-        compressedSize: vars.compressedSize ?? 0
-    };
-    const extra = parseExtraField(extraFieldData, zipVars);
     vars.lastModifiedDateTime = resolveZipEntryLastModifiedDateTime({
         flags: vars.flags,
-        uncompressedSize: zipVars.uncompressedSize,
+        uncompressedSize: vars.uncompressedSize ?? 0,
         lastModifiedDate: vars.lastModifiedDate,
         lastModifiedTime: vars.lastModifiedTime
     }, extra);