@cj-tech-master/excelts 4.2.1 → 4.2.2

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

@@ -1,14 +1,12 @@
 import zlib from "zlib";
-import { writeUint32LE } from "./utils/binary.js";
-import { PullStream, runParseLoop, streamUntilValidatedDataDescriptor } from "./parse.base.js";
-import { DATA_DESCRIPTOR_SIG } from "./zip-constants.js";
+import { DATA_DESCRIPTOR_SIGNATURE_BYTES, PullStream, runParseLoop, streamUntilValidatedDataDescriptor } from "./stream.base.js";
 /**
  * Creates an InflateRaw stream using Node.js native zlib.
  */
 function createInflateRaw() {
     return zlib.createInflateRaw();
 }
-const dataDescriptorSignature = writeUint32LE(DATA_DESCRIPTOR_SIG);
+const dataDescriptorSignature = DATA_DESCRIPTOR_SIGNATURE_BYTES;
 export function createParseClass(createInflateRawFn) {
     return class Parse extends PullStream {
         constructor(opts = {}) {
@@ -63,9 +61,12 @@ 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);

package/dist/browser/modules/archive/{zip-parser.d.ts → unzip/zip-parser.d.ts}

@@ -3,7 +3,7 @@
  * Works in both Node.js and browser environments
  * No dependency on Node.js stream module
  */
-import type { ZipEntryInfo } from "@archive/zip-entry-info";
+import type { ZipEntryInfo } from "@archive/zip-spec/zip-entry-info";
 export type { ZipEntryInfo };
 /**
  * ZIP parsing options

package/dist/{esm/modules/archive → browser/modules/archive/unzip}/zip-parser.js

@@ -3,11 +3,11 @@
  * Works in both Node.js and browser environments
  * No dependency on Node.js stream module
  */
-import { decompress, decompressSync } from "./compress.js";
-import { BinaryReader } from "./utils/binary.js";
-import { resolveZipLastModifiedDateFromUnixSeconds } from "./utils/timestamps.js";
-import { parseZipExtraFields } from "./utils/zip-extra-fields.js";
-import { CENTRAL_DIR_HEADER_SIG, COMPRESSION_DEFLATE, COMPRESSION_STORE, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, UINT16_MAX, UINT32_MAX, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG, ZIP64_END_OF_CENTRAL_DIR_SIG } from "./zip-constants.js";
+import { decompress, decompressSync } from "../compression/compress.browser.js";
+import { BinaryReader } from "../utils/binary.js";
+import { resolveZipLastModifiedDateFromUnixSeconds } from "../utils/timestamps.js";
+import { parseZipExtraFields } from "../utils/zip-extra-fields.js";
+import { CENTRAL_DIR_HEADER_SIG, COMPRESSION_DEFLATE, COMPRESSION_STORE, LOCAL_FILE_HEADER_SIG, UINT16_MAX, UINT32_MAX, ZIP64_END_OF_CENTRAL_DIR_SIG } from "../zip-spec/zip-records.js";
 /**
  * Find the End of Central Directory record
  * Searches backwards from the end of the file
@@ -16,9 +16,13 @@ function findEndOfCentralDir(data) {
     // EOCD is at least 22 bytes, search backwards
     // Comment can be up to 65535 bytes
     const minOffset = Math.max(0, data.length - 65557);
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    // Signature bytes (little-endian): 0x06054b50 -> 50 4b 05 06
+    const b0 = 0x50;
+    const b1 = 0x4b;
+    const b2 = 0x05;
+    const b3 = 0x06;
     for (let i = data.length - 22; i >= minOffset; i--) {
-        if (view.getUint32(i, true) === END_OF_CENTRAL_DIR_SIG) {
+        if (data[i] === b0 && data[i + 1] === b1 && data[i + 2] === b2 && data[i + 3] === b3) {
             return i;
         }
     }
@@ -33,8 +37,11 @@ function findZip64EOCDLocator(data, eocdOffset) {
     if (locatorOffset < 0) {
         return -1;
     }
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    if (view.getUint32(locatorOffset, true) === ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
+    // Signature bytes (little-endian): 0x07064b50 -> 50 4b 06 07
+    if (data[locatorOffset] === 0x50 &&
+        data[locatorOffset + 1] === 0x4b &&
+        data[locatorOffset + 2] === 0x06 &&
+        data[locatorOffset + 3] === 0x07) {
         return locatorOffset;
     }
     return -1;
@@ -44,7 +51,7 @@ function findZip64EOCDLocator(data, eocdOffset) {
  */
 function parseZipEntries(data, options = {}) {
     const { decodeStrings = true } = options;
-    const entries = [];
+    let entries = [];
     // Find End of Central Directory
     const eocdOffset = findEndOfCentralDir(data);
     if (eocdOffset === -1) {
@@ -96,6 +103,10 @@ function parseZipEntries(data, options = {}) {
             }
         }
     }
+    // Preallocate to avoid repeated array growth on large archives.
+    if (totalEntries > 0) {
+        entries = new Array(totalEntries);
+    }
     // Read Central Directory entries
     const centralReader = new BinaryReader(data, centralDirOffset);
     for (let i = 0; i < totalEntries; i++) {
@@ -144,23 +155,26 @@ function parseZipEntries(data, options = {}) {
         // Check for UTF-8 flag (bit 11)
         const isUtf8 = (flags & 0x800) !== 0;
         const useUtf8 = decodeStrings && isUtf8;
-        const fileName = centralReader.readString(fileNameLength, useUtf8);
-        const extraField = centralReader.readBytes(extraFieldLength);
-        const comment = centralReader.readString(commentLength, useUtf8);
-        const vars = {
-            compressedSize,
-            uncompressedSize,
-            offsetToLocalFileHeader: localHeaderOffset
-        };
-        const extraFields = extraFieldLength > 0 ? parseZipExtraFields(extraField, vars) : {};
-        compressedSize = vars.compressedSize;
-        uncompressedSize = vars.uncompressedSize;
-        localHeaderOffset = vars.offsetToLocalFileHeader ?? localHeaderOffset;
+        const fileName = fileNameLength > 0 ? centralReader.readString(fileNameLength, useUtf8) : "";
+        let extraFields = {};
+        if (extraFieldLength > 0) {
+            const extraField = centralReader.readBytes(extraFieldLength);
+            const vars = {
+                compressedSize,
+                uncompressedSize,
+                offsetToLocalFileHeader: localHeaderOffset
+            };
+            extraFields = parseZipExtraFields(extraField, vars);
+            compressedSize = vars.compressedSize;
+            uncompressedSize = vars.uncompressedSize;
+            localHeaderOffset = vars.offsetToLocalFileHeader ?? localHeaderOffset;
+        }
+        const comment = commentLength > 0 ? centralReader.readString(commentLength, useUtf8) : "";
         const isDirectory = fileName.endsWith("/") || (externalAttributes & 0x10) !== 0;
         const isEncrypted = (flags & 0x01) !== 0;
         const unixSecondsMtime = extraFields.mtimeUnixSeconds;
         const lastModified = resolveZipLastModifiedDateFromUnixSeconds(lastModDate, lastModTime, unixSecondsMtime);
-        entries.push({
+        entries[i] = {
             path: fileName,
             isDirectory,
             compressedSize,
@@ -172,7 +186,7 @@ function parseZipEntries(data, options = {}) {
             comment,
             externalAttributes,
             isEncrypted
-        });
+        };
     }
     return entries;
 }

package/dist/browser/modules/archive/utils/async-queue.d.ts

@@ -0,0 +1,7 @@
+export type AsyncQueue<T> = {
+    push: (value: T) => void;
+    fail: (err: Error) => void;
+    close: () => void;
+    iterable: AsyncIterable<T>;
+};
+export declare function createAsyncQueue<T>(): AsyncQueue<T>;

package/dist/browser/modules/archive/utils/async-queue.js

@@ -0,0 +1,103 @@
+export function createAsyncQueue() {
+    const values = [];
+    let valuesHead = 0;
+    const waiters = [];
+    let waitersHead = 0;
+    let done = false;
+    let error = null;
+    const maybeCompact = () => {
+        // Prevent unbounded growth of the underlying arrays.
+        if (valuesHead > 1024 && valuesHead * 2 > values.length) {
+            values.splice(0, valuesHead);
+            valuesHead = 0;
+        }
+        if (waitersHead > 1024 && waitersHead * 2 > waiters.length) {
+            waiters.splice(0, waitersHead);
+            waitersHead = 0;
+        }
+    };
+    const shiftWaiter = () => {
+        while (waitersHead < waiters.length) {
+            const w = waiters[waitersHead];
+            waiters[waitersHead] = undefined;
+            waitersHead++;
+            if (w) {
+                maybeCompact();
+                return w;
+            }
+        }
+        maybeCompact();
+        return undefined;
+    };
+    const shiftValue = () => {
+        while (valuesHead < values.length) {
+            const v = values[valuesHead];
+            values[valuesHead] = undefined;
+            valuesHead++;
+            if (v !== undefined) {
+                maybeCompact();
+                return v;
+            }
+        }
+        maybeCompact();
+        return undefined;
+    };
+    const push = (value) => {
+        if (done || error) {
+            return;
+        }
+        const waiter = shiftWaiter();
+        if (waiter) {
+            waiter.resolve({ value, done: false });
+        }
+        else {
+            values.push(value);
+        }
+    };
+    const fail = (err) => {
+        if (done || error) {
+            return;
+        }
+        error = err;
+        while (true) {
+            const waiter = shiftWaiter();
+            if (!waiter) {
+                break;
+            }
+            waiter.reject(err);
+        }
+    };
+    const close = () => {
+        if (done || error) {
+            return;
+        }
+        done = true;
+        while (true) {
+            const waiter = shiftWaiter();
+            if (!waiter) {
+                break;
+            }
+            waiter.resolve({ value: undefined, done: true });
+        }
+    };
+    const iterable = {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (error) {
+                        return Promise.reject(error);
+                    }
+                    const value = shiftValue();
+                    if (value !== undefined) {
+                        return Promise.resolve({ value, done: false });
+                    }
+                    if (done) {
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise((resolve, reject) => waiters.push({ resolve, reject }));
+                }
+            };
+        }
+    };
+    return { push, fail, close, iterable };
+}

package/dist/browser/modules/archive/utils/bytes.js

@@ -45,21 +45,18 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
     }
     // Fast paths for small patterns (very common in ZIP parsing: 2/3/4-byte signatures).
     if (patLen === 1) {
-        const p0 = pattern[0];
-        for (let i = start; i < bufLen; i++) {
-            if (buffer[i] === p0) {
-                return i;
-            }
-        }
-        return -1;
+        return buffer.indexOf(pattern[0], start);
     }
     if (patLen === 2) {
         const p0 = pattern[0];
         const p1 = pattern[1];
-        for (let i = start; i <= bufLen - 2; i++) {
-            if (buffer[i] === p0 && buffer[i + 1] === p1) {
+        const last = bufLen - 2;
+        let i = buffer.indexOf(p0, start);
+        while (i !== -1 && i <= last) {
+            if (buffer[i + 1] === p1) {
                 return i;
             }
+            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }
@@ -67,10 +64,13 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
         const p0 = pattern[0];
         const p1 = pattern[1];
         const p2 = pattern[2];
-        for (let i = start; i <= bufLen - 3; i++) {
-            if (buffer[i] === p0 && buffer[i + 1] === p1 && buffer[i + 2] === p2) {
+        const last = bufLen - 3;
+        let i = buffer.indexOf(p0, start);
+        while (i !== -1 && i <= last) {
+            if (buffer[i + 1] === p1 && buffer[i + 2] === p2) {
                 return i;
             }
+            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }
@@ -79,13 +79,13 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
         const p1 = pattern[1];
         const p2 = pattern[2];
         const p3 = pattern[3];
-        for (let i = start; i <= bufLen - 4; i++) {
-            if (buffer[i] === p0 &&
-                buffer[i + 1] === p1 &&
-                buffer[i + 2] === p2 &&
-                buffer[i + 3] === p3) {
+        const last = bufLen - 4;
+        let i = buffer.indexOf(p0, start);
+        while (i !== -1 && i <= last) {
+            if (buffer[i + 1] === p1 && buffer[i + 2] === p2 && buffer[i + 3] === p3) {
                 return i;
             }
+            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }

package/dist/browser/modules/archive/utils/compressibility.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Heuristic: detect incompressible (high-entropy) data.
+ *
+ * This is a performance optimization: if data looks random, DEFLATE usually
+ * wastes CPU and may even produce slightly larger output.
+ */
+export declare function isProbablyIncompressible(data: Uint8Array, options?: {
+    sampleBytes?: number;
+    minDecisionBytes?: number;
+}): boolean;

package/dist/browser/modules/archive/utils/compressibility.js

@@ -0,0 +1,57 @@
+const DEFAULT_SAMPLE_BYTES = 64 * 1024;
+const MIN_DECISION_BYTES = 16 * 1024;
+function log2(x) {
+    return Math.log(x) / Math.LN2;
+}
+function shannonEntropy(bytes) {
+    const counts = new Uint32Array(256);
+    for (let i = 0; i < bytes.length; i++) {
+        counts[bytes[i]] += 1;
+    }
+    let entropy = 0;
+    const total = bytes.length;
+    for (let i = 0; i < 256; i++) {
+        const count = counts[i];
+        if (count === 0) {
+            continue;
+        }
+        const p = count / total;
+        entropy -= p * log2(p);
+    }
+    return entropy;
+}
+/**
+ * Heuristic: detect incompressible (high-entropy) data.
+ *
+ * This is a performance optimization: if data looks random, DEFLATE usually
+ * wastes CPU and may even produce slightly larger output.
+ */
+export function isProbablyIncompressible(data, options = {}) {
+    const sampleBytes = options.sampleBytes ?? DEFAULT_SAMPLE_BYTES;
+    const minDecisionBytes = options.minDecisionBytes ?? MIN_DECISION_BYTES;
+    const len = Math.min(data.length, sampleBytes);
+    if (len < minDecisionBytes) {
+        return false;
+    }
+    const sample = data.subarray(0, len);
+    // Fast-ish early filter: if there are too few unique bytes, it's probably compressible.
+    // (e.g. text, repeated patterns)
+    const seen = new Uint8Array(256);
+    let unique = 0;
+    for (let i = 0; i < sample.length; i++) {
+        const b = sample[i];
+        if (seen[b] === 0) {
+            seen[b] = 1;
+            unique += 1;
+            if (unique >= 200) {
+                break;
+            }
+        }
+    }
+    if (unique < 200) {
+        return false;
+    }
+    // Shannon entropy in bits/byte; random tends to ~8.
+    // Threshold picked to be conservative.
+    return shannonEntropy(sample) >= 7.95;
+}

package/dist/browser/modules/archive/utils/parse-buffer.js

@@ -1,25 +1,3 @@
-/**
- * Read unsigned little-endian integer from Uint8Array
- */
-function readUIntLE(buffer, offset, size) {
-    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    switch (size) {
-        case 1:
-            return view.getUint8(offset);
-        case 2:
-            return view.getUint16(offset, true);
-        case 4:
-            return view.getUint32(offset, true);
-        case 8: {
-            // Read as BigUint64 and convert to Number
-            const low = view.getUint32(offset, true);
-            const high = view.getUint32(offset + 4, true);
-            return high * 0x100000000 + low;
-        }
-        default:
-            throw new Error("Unsupported UInt LE size!");
-    }
-}
 /**
  * Parses sequential unsigned little endian numbers from the head of the passed buffer according to
  * the specified format passed. If the buffer is not large enough to satisfy the full format,
@@ -38,10 +16,30 @@ function readUIntLE(buffer, offset, size) {
  */
 export function parse(buffer, format) {
     const result = {};
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
     let offset = 0;
     for (const [key, size] of format) {
         if (buffer.length >= offset + size) {
-            result[key] = readUIntLE(buffer, offset, size);
+            switch (size) {
+                case 1:
+                    result[key] = view.getUint8(offset);
+                    break;
+                case 2:
+                    result[key] = view.getUint16(offset, true);
+                    break;
+                case 4:
+                    result[key] = view.getUint32(offset, true);
+                    break;
+                case 8: {
+                    // Keep behavior (Number) while avoiding BigInt costs.
+                    const low = view.getUint32(offset, true);
+                    const high = view.getUint32(offset + 4, true);
+                    result[key] = high * 0x100000000 + low;
+                    break;
+                }
+                default:
+                    throw new Error("Unsupported UInt LE size!");
+            }
         }
         else {
             result[key] = null;

package/dist/browser/modules/archive/utils/pattern-scanner.d.ts

@@ -0,0 +1,21 @@
+export interface PatternSearchTarget {
+    indexOfPattern(pattern: Uint8Array, startIndex: number): number;
+}
+/**
+ * Stateful helper for incremental pattern scanning in growing buffers.
+ *
+ * The scanner tracks a `searchFrom` cursor and an `overlap` region so callers
+ * can avoid rescanning bytes that cannot start a match.
+ */
+export declare class PatternScanner {
+    readonly pattern: Uint8Array;
+    readonly overlap: number;
+    searchFrom: number;
+    constructor(pattern: Uint8Array);
+    /** Find the next match index starting at the current `searchFrom`. */
+    find(target: PatternSearchTarget): number;
+    /** Update `searchFrom` after consuming `consumed` bytes from the front. */
+    onConsume(consumed: number): void;
+    /** Update `searchFrom` after a no-match scan on a buffer of length `bufferLength`. */
+    onNoMatch(bufferLength: number): void;
+}

package/dist/browser/modules/archive/utils/pattern-scanner.js

@@ -0,0 +1,27 @@
+/**
+ * Stateful helper for incremental pattern scanning in growing buffers.
+ *
+ * The scanner tracks a `searchFrom` cursor and an `overlap` region so callers
+ * can avoid rescanning bytes that cannot start a match.
+ */
+export class PatternScanner {
+    constructor(pattern) {
+        this.searchFrom = 0;
+        this.pattern = pattern;
+        this.overlap = Math.max(0, pattern.length - 1);
+    }
+    /** Find the next match index starting at the current `searchFrom`. */
+    find(target) {
+        return target.indexOfPattern(this.pattern, this.searchFrom);
+    }
+    /** Update `searchFrom` after consuming `consumed` bytes from the front. */
+    onConsume(consumed) {
+        if (consumed > 0) {
+            this.searchFrom = Math.max(0, this.searchFrom - consumed);
+        }
+    }
+    /** Update `searchFrom` after a no-match scan on a buffer of length `bufferLength`. */
+    onNoMatch(bufferLength) {
+        this.searchFrom = Math.max(this.searchFrom, Math.max(0, bufferLength - this.overlap));
+    }
+}

package/dist/browser/modules/archive/utils/timestamps.js

@@ -1,4 +1,65 @@
-import { buildExtendedTimestampExtraFieldFromDate, parseExtendedTimestampMtimeUnixSeconds } from "./zip-extra.js";
+const EXTENDED_TIMESTAMP_ID = 0x5455;
+function clampUint32(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    if (value <= 0) {
+        return 0;
+    }
+    // 0xFFFFFFFF fits JS safe integer.
+    if (value >= 0xffffffff) {
+        return 0xffffffff;
+    }
+    return value >>> 0;
+}
+function unixSecondsFromDate(date) {
+    return clampUint32(Math.floor(date.getTime() / 1000));
+}
+/**
+ * Parse Info-ZIP "Extended Timestamp" extra field (0x5455) and return mtime.
+ * Returns Unix seconds (UTC) if present.
+ */
+function parseExtendedTimestampMtimeUnixSeconds(extraField) {
+    const view = new DataView(extraField.buffer, extraField.byteOffset, extraField.byteLength);
+    let offset = 0;
+    while (offset + 4 <= extraField.length) {
+        const headerId = view.getUint16(offset, true);
+        const dataSize = view.getUint16(offset + 2, true);
+        const dataStart = offset + 4;
+        const dataEnd = dataStart + dataSize;
+        if (dataEnd > extraField.length) {
+            break;
+        }
+        if (headerId === EXTENDED_TIMESTAMP_ID && dataSize >= 1) {
+            const flags = extraField[dataStart];
+            if ((flags & 0x01) !== 0 && dataSize >= 5) {
+                // mtime is 4 bytes right after flags.
+                return view.getUint32(dataStart + 1, true) >>> 0;
+            }
+        }
+        offset = dataEnd;
+    }
+    return undefined;
+}
+/**
+ * Build Info-ZIP "Extended Timestamp" extra field (0x5455).
+ * We write only mtime (UTC, Unix seconds) to minimize size.
+ */
+function buildExtendedTimestampExtraFieldFromUnixSeconds(unixSeconds) {
+    const ts = clampUint32(unixSeconds);
+    // flags(1) + mtime(4)
+    const payloadSize = 5;
+    const out = new Uint8Array(4 + payloadSize);
+    const view = new DataView(out.buffer);
+    view.setUint16(0, EXTENDED_TIMESTAMP_ID, true);
+    view.setUint16(2, payloadSize, true);
+    out[4] = 0x01; // mtime present
+    view.setUint32(5, ts, true);
+    return out;
+}
+function buildExtendedTimestampExtraFieldFromDate(date) {
+    return buildExtendedTimestampExtraFieldFromUnixSeconds(unixSecondsFromDate(date));
+}
 /**
  * DOS date/time helpers for ZIP files.
  */

package/dist/browser/modules/archive/utils/zip-extra-fields.d.ts

@@ -1,7 +1,7 @@
 /**
  * ZIP extra field parsing helpers.
  *
- * Kept standalone so both streaming parser (`parse.base.ts`) and buffer parser
+ * Kept standalone so both streaming parser (`stream.base.ts`) and buffer parser
  * (`zip-parser.ts`) can share ZIP64 + Info-ZIP timestamp handling.
  */
 export interface ZipVars {

package/dist/browser/modules/archive/utils/zip-extra-fields.js

@@ -1,10 +1,31 @@
 /**
  * ZIP extra field parsing helpers.
  *
- * Kept standalone so both streaming parser (`parse.base.ts`) and buffer parser
+ * Kept standalone so both streaming parser (`stream.base.ts`) and buffer parser
  * (`zip-parser.ts`) can share ZIP64 + Info-ZIP timestamp handling.
  */
-import { parseExtendedTimestampMtimeUnixSeconds } from "./zip-extra.js";
+const EXTENDED_TIMESTAMP_ID = 0x5455;
+function parseExtendedTimestampMtimeUnixSeconds(extraField) {
+    const view = new DataView(extraField.buffer, extraField.byteOffset, extraField.byteLength);
+    let offset = 0;
+    while (offset + 4 <= extraField.length) {
+        const headerId = view.getUint16(offset, true);
+        const dataSize = view.getUint16(offset + 2, true);
+        const dataStart = offset + 4;
+        const dataEnd = dataStart + dataSize;
+        if (dataEnd > extraField.length) {
+            break;
+        }
+        if (headerId === EXTENDED_TIMESTAMP_ID && dataSize >= 1) {
+            const flags = extraField[dataStart];
+            if ((flags & 0x01) !== 0 && dataSize >= 5) {
+                return view.getUint32(dataStart + 1, true) >>> 0;
+            }
+        }
+        offset = dataEnd;
+    }
+    return undefined;
+}
 function readUint64LE(view, offset) {
     // Convert to Number via 2x Uint32 to avoid BigInt requirements.
     const low = view.getUint32(offset, true);
@@ -43,18 +64,9 @@ export function parseZipExtraFields(extraField, vars) {
             }
         }
         else if (signature === 0x5455) {
-            // Fast-path parse for Info-ZIP extended timestamp (mtime only).
-            if (partSize >= 1) {
-                const flags = extraField[dataStart];
-                if ((flags & 0x01) !== 0 && partSize >= 5) {
-                    extra.mtimeUnixSeconds = view.getUint32(dataStart + 1, true) >>> 0;
-                }
-                else {
-                    const unixSeconds = parseExtendedTimestampMtimeUnixSeconds(extraField.subarray(offset, dataEnd));
-                    if (unixSeconds !== undefined) {
-                        extra.mtimeUnixSeconds = unixSeconds;
-                    }
-                }
+            const unixSeconds = parseExtendedTimestampMtimeUnixSeconds(extraField.subarray(offset, dataEnd));
+            if (unixSeconds !== undefined) {
+                extra.mtimeUnixSeconds = unixSeconds;
             }
         }
         offset = dataEnd;