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

package/dist/esm/modules/archive/{compression/streaming-compress.browser.js → streaming-compress.browser.js}

@@ -6,11 +6,11 @@
  *
  * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
  */
-import { EventEmitter } from "../../stream/index.js";
+import { EventEmitter } from "../stream/index.js";
 import { deflateRawCompressed, inflateRaw } from "./deflate-fallback.js";
 import { hasDeflateRawWebStreams } from "./compress.base.js";
-import { concatUint8Arrays } from "../utils/bytes.js";
-import { DEFAULT_COMPRESS_LEVEL } from "../defaults.js";
+import { concatUint8Arrays } from "./utils/bytes.js";
+import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
 import { asError } from "./streaming-compress.base.js";
 /**
  * Check if deflate-raw streaming compression is supported by this library.

package/dist/esm/modules/archive/{compression/streaming-compress.js → streaming-compress.js}

@@ -5,8 +5,8 @@
  * Each write() immediately produces compressed output without waiting for end().
  */
 import { createDeflateRaw, createInflateRaw, constants } from "zlib";
-import { Transform } from "../../stream/index.js";
-import { DEFAULT_COMPRESS_LEVEL } from "../defaults.js";
+import { Transform } from "../stream/index.js";
+import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
 /**
  * Wrapper around zlib DeflateRaw that flushes after every write
  * This ensures true streaming behavior - data is emitted immediately, not buffered

package/dist/{browser/modules/archive/zip/stream.js → esm/modules/archive/streaming-zip.js}

@@ -2,16 +2,15 @@
  * True Streaming ZIP creator - shared implementation.
  *
  * This module is intentionally platform-agnostic.
- * - In Node builds it uses `./compression/crc32` + `./compression/streaming-compress` (zlib-backed).
+ * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
  * - In browser builds the bundler aliases those imports to their browser variants.
  */
-import { crc32Update, crc32Finalize } from "../compression/crc32.browser.js";
-import { createDeflateStream } from "../compression/streaming-compress.browser.js";
-import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "../defaults.js";
-import { buildZipEntryMetadata, resolveZipCompressionMethod } from "./zip-entry-metadata.js";
-import { decodeUtf8, encodeUtf8 } from "../utils/text.js";
-import { isProbablyIncompressible } from "../utils/compressibility.js";
-import { buildCentralDirectoryHeader, buildDataDescriptor, buildEndOfCentralDirectory, buildLocalFileHeader, VERSION_MADE_BY, VERSION_NEEDED } from "../zip-spec/zip-records.js";
+import { crc32Update, crc32Finalize } from "./crc32.js";
+import { createDeflateStream } from "./streaming-compress.js";
+import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "./defaults.js";
+import { buildZipEntryMetadata } from "./zip-entry-metadata.js";
+import { buildCentralDirectoryHeader, buildDataDescriptor, buildEndOfCentralDirectory, buildLocalFileHeader } from "./zip-records.js";
+import { VERSION_MADE_BY, VERSION_NEEDED } from "./zip-constants.js";
 /**
  * True Streaming ZIP File - compresses chunk by chunk
  */
@@ -24,15 +23,9 @@ export class ZipDeflateFile {
         this._finalized = false;
         this._headerEmitted = false;
         this._ondata = null;
-        this._onerror = null;
         this._centralDirEntryInfo = null;
         this._pendingEnd = false;
         this._emittedDataDescriptor = false;
-        this._localHeader = null;
-        // Smart STORE: delay method selection until we sample data.
-        this._deflateWanted = null;
-        this._pendingChunks = [];
-        this._sampleLen = 0;
         // Promise resolution for completion (including data descriptor)
         this._completeResolve = null;
         this._completeReject = null;
@@ -41,70 +34,46 @@ export class ZipDeflateFile {
         // Queue for incoming data before ondata is set
         this._dataQueue = [];
         this._finalQueued = false;
-        // Serialize push() calls so callers don't need to await to preserve ordering.
-        this._pushChain = Promise.resolve();
         this.name = name;
         const modTime = options?.modTime ?? new Date();
         this._modTime = modTime;
         this.level = options?.level ?? DEFAULT_ZIP_LEVEL;
-        this._smartStore = options?.smartStore ?? true;
-        this._sampleBuffer = this._smartStore ? new Uint8Array(64 * 1024) : new Uint8Array(0);
         const metadata = buildZipEntryMetadata({
             name,
-            comment: options?.comment ?? "",
+            comment: "",
             modTime,
             timestamps: options?.timestamps ?? DEFAULT_ZIP_TIMESTAMPS,
             useDataDescriptor: true,
-            deflate: false
+            deflate: this.level > 0
         });
         this.nameBytes = metadata.nameBytes;
-        this.commentBytes = metadata.commentBytes;
         this.dosTime = metadata.dosTime;
         this.dosDate = metadata.dosDate;
         this.extraField = metadata.extraField;
         this._flags = metadata.flags;
         this._compressionMethod = metadata.compressionMethod;
-        // If smart store is disabled, decide method upfront and keep true streaming semantics.
-        if (!this._smartStore) {
-            const deflate = this.level > 0;
-            this._deflateWanted = deflate;
-            this._compressionMethod = this._buildCompressionMethod(deflate);
-            if (deflate) {
-                this._initDeflateStream();
-            }
-            return;
-        }
-        // Level 0: always STORE.
-        if (this.level === 0) {
-            this._deflateWanted = false;
-            this._compressionMethod = this._buildCompressionMethod(false);
-        }
-    }
-    _buildCompressionMethod(deflate) {
-        return resolveZipCompressionMethod(deflate);
-    }
-    _initDeflateStream() {
-        if (this._deflate) {
-            return;
+        // Create deflate stream for compression
+        if (this.level > 0) {
+            this._deflate = createDeflateStream({ level: this.level });
+            this._deflate.on("error", (err) => {
+                this._rejectComplete(err);
+            });
+            // Handle compressed output - this is true streaming!
+            this._deflate.on("data", (chunk) => {
+                this._compressedSize += chunk.length;
+                this._enqueueData(chunk, false);
+            });
+            // Handle end - emit data descriptor
+            // IMPORTANT: Only use 'end' event, NOT 'finish'!
+            // Node.js zlib emits events in order: finish -> data -> end
+            this._deflate.on("end", () => {
+                if (this._pendingEnd && !this._emittedDataDescriptor) {
+                    this._emittedDataDescriptor = true;
+                    this._emitDataDescriptor();
+                }
+            });
         }
-        this._deflate = createDeflateStream({ level: this.level });
-        this._deflate.on("error", (err) => {
-            this._rejectComplete(err);
-        });
-        // Handle compressed output - this is true streaming!
-        this._deflate.on("data", (chunk) => {
-            this._compressedSize += chunk.length;
-            this._enqueueData(chunk, false);
-        });
-        // Handle end - emit data descriptor
-        // IMPORTANT: Only use 'end' event, NOT 'finish'!
-        // Node.js zlib emits events in order: finish -> data -> end
-        this._deflate.on("end", () => {
-            if (this._pendingEnd && !this._emittedDataDescriptor) {
-                this._emittedDataDescriptor = true;
-                this._emitDataDescriptor();
-            }
-        });
+        this._localHeader = this._buildLocalHeader();
     }
     _buildLocalHeader() {
         // CRC + sizes are written via data descriptor for true streaming.
@@ -121,63 +90,6 @@ export class ZipDeflateFile {
             versionNeeded: VERSION_NEEDED
         });
     }
-    _accumulateSample(data) {
-        if (this._deflateWanted !== null) {
-            return;
-        }
-        if (this._sampleLen >= this._sampleBuffer.length) {
-            return;
-        }
-        const take = Math.min(this._sampleBuffer.length - this._sampleLen, data.length);
-        if (take <= 0) {
-            return;
-        }
-        this._sampleBuffer.set(data.subarray(0, take), this._sampleLen);
-        this._sampleLen += take;
-    }
-    _shouldDecide(final) {
-        if (this._deflateWanted !== null) {
-            return false;
-        }
-        return final || this._sampleLen >= 16 * 1024;
-    }
-    _decideCompressionIfNeeded(final) {
-        if (this._deflateWanted !== null) {
-            return;
-        }
-        // Match non-streaming builder semantics: empty files never need DEFLATE.
-        if (final && this._sampleLen === 0) {
-            this._deflateWanted = false;
-            this._compressionMethod = this._buildCompressionMethod(false);
-            this._localHeader = null;
-            return;
-        }
-        // Default to DEFLATE unless heuristic says STORE.
-        const sample = this._sampleBuffer.subarray(0, this._sampleLen);
-        const store = isProbablyIncompressible(sample);
-        this._deflateWanted = !store;
-        this._compressionMethod = this._buildCompressionMethod(this._deflateWanted);
-        this._localHeader = null;
-        if (this._deflateWanted) {
-            this._initDeflateStream();
-        }
-    }
-    _emitHeaderIfNeeded() {
-        if (this._headerEmitted) {
-            return;
-        }
-        this._emitHeader();
-        this._headerEmitted = true;
-    }
-    async _flushPendingChunks() {
-        if (this._pendingChunks.length === 0) {
-            return;
-        }
-        for (const chunk of this._pendingChunks) {
-            await this._writeData(chunk);
-        }
-        this._pendingChunks = [];
-    }
     _enqueueData(data, final) {
         if (this._ondata) {
             this._ondata(data, final);
@@ -209,29 +121,13 @@ export class ZipDeflateFile {
         // Flush any queued data
         this._flushQueue();
     }
-    get onerror() {
-        return this._onerror ?? undefined;
-    }
-    set onerror(cb) {
-        this._onerror = cb;
-        // If an error already occurred, surface it immediately.
-        if (this._completeError) {
-            cb(this._completeError);
-        }
-    }
     _resolveComplete() {
         if (this._completeResolve) {
             this._completeResolve();
         }
     }
     _rejectComplete(err) {
-        if (this._completeError) {
-            return;
-        }
         this._completeError = err;
-        if (this._onerror) {
-            this._onerror(err);
-        }
         if (this._completeReject) {
             this._completeReject(err);
         }
@@ -257,6 +153,13 @@ export class ZipDeflateFile {
         }
         promise.then(() => callback()).catch(err => callback(err));
     }
+    _emitHeaderIfNeeded() {
+        if (this._headerEmitted) {
+            return;
+        }
+        this._emitHeader();
+        this._headerEmitted = true;
+    }
     _writeData(data) {
         if (data.length === 0) {
             return Promise.resolve();
@@ -314,60 +217,27 @@ export class ZipDeflateFile {
         this._emitDataDescriptor();
         return completePromise;
     }
-    _pushUnchained(data, final, callback) {
+    /**
+     * Push data - immediately compresses and outputs
+     * Returns a Promise that resolves when the write is complete.
+     * If final=true, it resolves after the data descriptor is emitted.
+     */
+    push(data, final = false, callback) {
         if (this._finalized) {
             const promise = Promise.reject(new Error("Cannot push to finalized ZipDeflateFile"));
             this._tapCallback(promise, callback);
             return promise;
         }
-        if (this._deflateWanted === null) {
-            this._accumulateSample(data);
-            if (!this._shouldDecide(final)) {
-                if (data.length > 0) {
-                    this._pendingChunks.push(data);
-                }
-                const promise = Promise.resolve();
-                this._tapCallback(promise, callback);
-                return promise;
-            }
-            this._decideCompressionIfNeeded(final);
-            this._emitHeaderIfNeeded();
-            const hadPendingChunks = this._pendingChunks.length > 0;
-            const flushPromise = this._flushPendingChunks();
-            let writePromise = flushPromise;
-            if (data.length > 0) {
-                writePromise = hadPendingChunks
-                    ? flushPromise.then(() => this._writeData(data))
-                    : this._writeData(data);
-            }
-            const promise = final ? this._finalizeAfterWrite(writePromise) : writePromise;
-            this._tapCallback(promise, callback);
-            return promise;
-        }
         this._emitHeaderIfNeeded();
         const writePromise = this._writeData(data);
         const promise = final ? this._finalizeAfterWrite(writePromise) : writePromise;
         this._tapCallback(promise, callback);
         return promise;
     }
-    /**
-     * Push data - immediately compresses and outputs
-     * Returns a Promise that resolves when the write is complete.
-     * If final=true, it resolves after the data descriptor is emitted.
-     */
-    push(data, final = false, callback) {
-        const promise = (this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback)));
-        // Prevent unhandled rejection when callers intentionally ignore the Promise.
-        promise.catch(() => { });
-        return promise;
-    }
     /**
      * Emit local file header with Data Descriptor flag
      */
     _emitHeader() {
-        if (!this._localHeader) {
-            this._localHeader = this._buildLocalHeader();
-        }
         this._enqueueData(this._localHeader, false);
     }
     /**
@@ -380,7 +250,6 @@ export class ZipDeflateFile {
         this._centralDirEntryInfo = {
             name: this.nameBytes,
             extraField: this.extraField,
-            comment: this.commentBytes,
             flags: this._flags,
             crc: crcValue,
             compressedSize: this._compressedSize,
@@ -419,7 +288,7 @@ export class ZipDeflateFile {
             crc32: this._centralDirEntryInfo.crc,
             lastModified: this._modTime,
             localHeaderOffset: this._centralDirEntryInfo.offset,
-            comment: decodeUtf8(this._centralDirEntryInfo.comment),
+            comment: "",
             externalAttributes: 0,
             isEncrypted: false
         };
@@ -436,7 +305,7 @@ export class ZipDeflateFile {
  * Streaming ZIP Creator - processes files sequentially
  */
 export class StreamingZip {
-    constructor(callback, options) {
+    constructor(callback) {
         this.entries = [];
         this.currentOffset = 0;
         this.ended = false;
@@ -446,12 +315,10 @@ export class StreamingZip {
         this.fileQueueIndex = 0;
         this.activeFile = null;
         this.callback = callback;
-        // Avoid per-instance TextEncoder allocations.
-        this.zipComment = options?.comment ? encodeUtf8(options.comment) : new Uint8Array(0);
     }
     add(file) {
         if (this.ended) {
-            throw new Error("Cannot add files after calling end() ");
+            throw new Error("Cannot add files after calling end()");
         }
         this.fileQueue.push(file);
         // If no active file, process this one
@@ -474,18 +341,7 @@ export class StreamingZip {
         const file = this.fileQueue[this.fileQueueIndex++];
         this.activeFile = file;
         const startOffset = this.currentOffset;
-        const empty = new Uint8Array(0);
-        file.onerror = (err) => {
-            if (this.ended) {
-                return;
-            }
-            this.ended = true;
-            this.callback(err, empty, true);
-        };
         file.ondata = (data, final) => {
-            if (this.ended) {
-                return;
-            }
             this.currentOffset += data.length;
             this.callback(null, data, false);
             if (final) {
@@ -511,7 +367,7 @@ export class StreamingZip {
             const header = buildCentralDirectoryHeader({
                 fileName: entry.name,
                 extraField: entry.extraField,
-                comment: entry.comment ?? empty,
+                comment: empty,
                 flags: entry.flags,
                 compressionMethod: entry.compressionMethod,
                 dosTime: entry.dosTime,
@@ -530,7 +386,7 @@ export class StreamingZip {
             entryCount: this.entries.length,
             centralDirSize,
             centralDirOffset,
-            comment: this.zipComment
+            comment: empty
         });
         this.callback(null, eocd, true);
     }

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

@@ -45,18 +45,21 @@ 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) {
-        return buffer.indexOf(pattern[0], start);
+        const p0 = pattern[0];
+        for (let i = start; i < bufLen; i++) {
+            if (buffer[i] === p0) {
+                return i;
+            }
+        }
+        return -1;
     }
     if (patLen === 2) {
         const p0 = pattern[0];
         const p1 = pattern[1];
-        const last = bufLen - 2;
-        let i = buffer.indexOf(p0, start);
-        while (i !== -1 && i <= last) {
-            if (buffer[i + 1] === p1) {
+        for (let i = start; i <= bufLen - 2; i++) {
+            if (buffer[i] === p0 && buffer[i + 1] === p1) {
                 return i;
             }
-            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }
@@ -64,13 +67,10 @@ export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
         const p0 = pattern[0];
         const p1 = pattern[1];
         const p2 = pattern[2];
-        const last = bufLen - 3;
-        let i = buffer.indexOf(p0, start);
-        while (i !== -1 && i <= last) {
-            if (buffer[i + 1] === p1 && buffer[i + 2] === p2) {
+        for (let i = start; i <= bufLen - 3; i++) {
+            if (buffer[i] === p0 && 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];
-        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) {
+        for (let i = start; i <= bufLen - 4; i++) {
+            if (buffer[i] === p0 &&
+                buffer[i + 1] === p1 &&
+                buffer[i + 2] === p2 &&
+                buffer[i + 3] === p3) {
                 return i;
             }
-            i = buffer.indexOf(p0, i + 1);
         }
         return -1;
     }

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

@@ -1,3 +1,25 @@
+/**
+ * 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,
@@ -16,30 +38,10 @@
  */
 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) {
-            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!");
-            }
+            result[key] = readUIntLE(buffer, offset, size);
         }
         else {
             result[key] = null;

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

@@ -1,65 +1,4 @@
-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));
-}
+import { buildExtendedTimestampExtraFieldFromDate, parseExtendedTimestampMtimeUnixSeconds } from "./zip-extra.js";
 /**
  * DOS date/time helpers for ZIP files.
  */

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

@@ -1,31 +1,10 @@
 /**
  * ZIP extra field parsing helpers.
  *
- * Kept standalone so both streaming parser (`stream.base.ts`) and buffer parser
+ * Kept standalone so both streaming parser (`parse.base.ts`) and buffer parser
  * (`zip-parser.ts`) can share ZIP64 + Info-ZIP timestamp handling.
  */
-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;
-}
+import { parseExtendedTimestampMtimeUnixSeconds } from "./zip-extra.js";
 function readUint64LE(view, offset) {
     // Convert to Number via 2x Uint32 to avoid BigInt requirements.
     const low = view.getUint32(offset, true);
@@ -64,9 +43,18 @@ export function parseZipExtraFields(extraField, vars) {
             }
         }
         else if (signature === 0x5455) {
-            const unixSeconds = parseExtendedTimestampMtimeUnixSeconds(extraField.subarray(offset, dataEnd));
-            if (unixSeconds !== undefined) {
-                extra.mtimeUnixSeconds = unixSeconds;
+            // 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;
+                    }
+                }
             }
         }
         offset = dataEnd;