@cj-tech-master/excelts 4.2.0 → 4.2.1-canary.20260112134913.a3cecdd

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

@@ -7,18 +7,16 @@ exports.Parse = void 0;
 exports.createParseClass = createParseClass;
 exports.createParse = createParse;
 const zlib_1 = __importDefault(require("zlib"));
-const binary_1 = require("./utils/binary.js");
-const parse_base_1 = require("./parse.base.js");
-const zip_constants_1 = require("./zip-constants.js");
+const stream_base_1 = require("./stream.base.js");
 /**
  * Creates an InflateRaw stream using Node.js native zlib.
  */
 function createInflateRaw() {
     return zlib_1.default.createInflateRaw();
 }
-const dataDescriptorSignature = (0, binary_1.writeUint32LE)(zip_constants_1.DATA_DESCRIPTOR_SIG);
+const dataDescriptorSignature = stream_base_1.DATA_DESCRIPTOR_SIGNATURE_BYTES;
 function createParseClass(createInflateRawFn) {
-    return class Parse extends parse_base_1.PullStream {
+    return class Parse extends stream_base_1.PullStream {
         constructor(opts = {}) {
             super();
             this._driverState = {};
@@ -58,7 +56,7 @@ function createParseClass(createInflateRawFn) {
                 }
             };
             // Parse records as data arrives. Only emit `close` when parsing is complete.
-            (0, parse_base_1.runParseLoop)(this._opts, io, emitter, createInflateRawFn, this._driverState).catch((e) => {
+            (0, stream_base_1.runParseLoop)(this._opts, io, emitter, createInflateRawFn, this._driverState, (data) => zlib_1.default.inflateRawSync(data)).catch((e) => {
                 if (!this.__emittedError || this.__emittedError !== e) {
                     this.emit("error", e);
                 }
@@ -69,11 +67,14 @@ function createParseClass(createInflateRawFn) {
          * Stream file data until we reach a DATA_DESCRIPTOR record boundary.
          */
         _streamUntilValidatedDataDescriptor() {
-            return (0, parse_base_1.streamUntilValidatedDataDescriptor)({
+            return (0, stream_base_1.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/cjs/modules/archive/{zip-parser.js → unzip/zip-parser.js}

@@ -6,11 +6,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipParser = void 0;
-const compress_1 = require("./compress.js");
-const binary_1 = require("./utils/binary.js");
-const timestamps_1 = require("./utils/timestamps.js");
-const zip_extra_fields_1 = require("./utils/zip-extra-fields.js");
-const zip_constants_1 = require("./zip-constants.js");
+const compress_1 = require("../compression/compress.js");
+const binary_1 = require("../utils/binary.js");
+const timestamps_1 = require("../utils/timestamps.js");
+const zip_extra_fields_1 = require("../utils/zip-extra-fields.js");
+const zip_records_1 = require("../zip-spec/zip-records.js");
 /**
  * Find the End of Central Directory record
  * Searches backwards from the end of the file
@@ -19,9 +19,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) === zip_constants_1.END_OF_CENTRAL_DIR_SIG) {
+        if (data[i] === b0 && data[i + 1] === b1 && data[i + 2] === b2 && data[i + 3] === b3) {
             return i;
         }
     }
@@ -36,8 +40,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) === zip_constants_1.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;
@@ -47,7 +54,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) {
@@ -81,7 +88,7 @@ function parseZipEntries(data, options = {}) {
         // Read ZIP64 EOCD
         const zip64Reader = new binary_1.BinaryReader(data, zip64EOCDOffset);
         const zip64Sig = zip64Reader.readUint32();
-        if (zip64Sig === zip_constants_1.ZIP64_END_OF_CENTRAL_DIR_SIG) {
+        if (zip64Sig === zip_records_1.ZIP64_END_OF_CENTRAL_DIR_SIG) {
             zip64Reader.skip(8); // size of ZIP64 EOCD
             zip64Reader.skip(2); // version made by
             zip64Reader.skip(2); // version needed
@@ -91,19 +98,23 @@ function parseZipEntries(data, options = {}) {
             zip64Reader.skip(8); // central directory size (unused)
             const zip64CentralDirOffset = Number(zip64Reader.readBigUint64());
             // Use ZIP64 values if standard values are maxed out
-            if (totalEntries === zip_constants_1.UINT16_MAX) {
+            if (totalEntries === zip_records_1.UINT16_MAX) {
                 totalEntries = zip64TotalEntries;
             }
-            if (centralDirOffset === zip_constants_1.UINT32_MAX) {
+            if (centralDirOffset === zip_records_1.UINT32_MAX) {
                 centralDirOffset = zip64CentralDirOffset;
             }
         }
     }
+    // Preallocate to avoid repeated array growth on large archives.
+    if (totalEntries > 0) {
+        entries = new Array(totalEntries);
+    }
     // Read Central Directory entries
     const centralReader = new binary_1.BinaryReader(data, centralDirOffset);
     for (let i = 0; i < totalEntries; i++) {
         const sig = centralReader.readUint32();
-        if (sig !== zip_constants_1.CENTRAL_DIR_HEADER_SIG) {
+        if (sig !== zip_records_1.CENTRAL_DIR_HEADER_SIG) {
             throw new Error(`Invalid Central Directory header signature at entry ${i}`);
         }
         // Central Directory File Header format:
@@ -147,23 +158,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 ? (0, zip_extra_fields_1.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 = (0, zip_extra_fields_1.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 = (0, timestamps_1.resolveZipLastModifiedDateFromUnixSeconds)(lastModDate, lastModTime, unixSecondsMtime);
-        entries.push({
+        entries[i] = {
             path: fileName,
             isDirectory,
             compressedSize,
@@ -175,7 +189,7 @@ function parseZipEntries(data, options = {}) {
             comment,
             externalAttributes,
             isEncrypted
-        });
+        };
     }
     return entries;
 }
@@ -190,10 +204,10 @@ async function extractEntryData(data, entry) {
         throw new Error(`File "${entry.path}" is encrypted and cannot be extracted`);
     }
     const compressedData = readEntryCompressedData(data, entry);
-    if (entry.compressionMethod === zip_constants_1.COMPRESSION_STORE) {
+    if (entry.compressionMethod === zip_records_1.COMPRESSION_STORE) {
         return compressedData;
     }
-    if (entry.compressionMethod === zip_constants_1.COMPRESSION_DEFLATE) {
+    if (entry.compressionMethod === zip_records_1.COMPRESSION_DEFLATE) {
         return (0, compress_1.decompress)(compressedData);
     }
     throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
@@ -209,10 +223,10 @@ function extractEntryDataSync(data, entry) {
         throw new Error(`File "${entry.path}" is encrypted and cannot be extracted`);
     }
     const compressedData = readEntryCompressedData(data, entry);
-    if (entry.compressionMethod === zip_constants_1.COMPRESSION_STORE) {
+    if (entry.compressionMethod === zip_records_1.COMPRESSION_STORE) {
         return compressedData;
     }
-    if (entry.compressionMethod === zip_constants_1.COMPRESSION_DEFLATE) {
+    if (entry.compressionMethod === zip_records_1.COMPRESSION_DEFLATE) {
         return (0, compress_1.decompressSync)(compressedData);
     }
     throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
@@ -220,7 +234,7 @@ function extractEntryDataSync(data, entry) {
 function readEntryCompressedData(data, entry) {
     const reader = new binary_1.BinaryReader(data, entry.localHeaderOffset);
     const sig = reader.readUint32();
-    if (sig !== zip_constants_1.LOCAL_FILE_HEADER_SIG) {
+    if (sig !== zip_records_1.LOCAL_FILE_HEADER_SIG) {
         throw new Error(`Invalid local file header signature for "${entry.path}"`);
     }
     reader.skip(2); // version needed

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsyncQueue = createAsyncQueue;
+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/cjs/modules/archive/utils/bytes.js

@@ -50,21 +50,18 @@ 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;
     }
@@ -72,10 +69,13 @@ 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;
     }
@@ -84,13 +84,13 @@ 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/cjs/modules/archive/utils/compressibility.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProbablyIncompressible = isProbablyIncompressible;
+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.
+ */
+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/cjs/modules/archive/utils/parse-buffer.js

@@ -2,28 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = parse;
 exports.parseTyped = parseTyped;
-/**
- * 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,
@@ -42,10 +20,30 @@ function readUIntLE(buffer, offset, size) {
  */
 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/cjs/modules/archive/utils/pattern-scanner.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternScanner = void 0;
+/**
+ * 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.
+ */
+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));
+    }
+}
+exports.PatternScanner = PatternScanner;

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

@@ -6,7 +6,68 @@ exports.resolveZipLastModifiedDateFromUnixSeconds = resolveZipLastModifiedDateFr
 exports.resolveZipLastModifiedDateFromExtraField = resolveZipLastModifiedDateFromExtraField;
 exports.buildZipTimestampExtraField = buildZipTimestampExtraField;
 exports.dateToZipDos = dateToZipDos;
-const zip_extra_1 = require("./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.
  */
@@ -44,11 +105,11 @@ function resolveZipLastModifiedDateFromUnixSeconds(dosDate, dosTime, mtimeUnixSe
     return new Date(mtimeUnixSeconds * 1000);
 }
 function resolveZipLastModifiedDateFromExtraField(dosDate, dosTime, extraField) {
-    const unixSeconds = (0, zip_extra_1.parseExtendedTimestampMtimeUnixSeconds)(extraField);
+    const unixSeconds = parseExtendedTimestampMtimeUnixSeconds(extraField);
     return resolveZipLastModifiedDateFromUnixSeconds(dosDate, dosTime, unixSeconds);
 }
 function buildZipTimestampExtraField(modTime, mode) {
-    return mode === "dos+utc" ? (0, zip_extra_1.buildExtendedTimestampExtraFieldFromDate)(modTime) : new Uint8Array(0);
+    return mode === "dos+utc" ? buildExtendedTimestampExtraFieldFromDate(modTime) : new Uint8Array(0);
 }
 function dateToZipDos(modTime) {
     const [dosTime, dosDate] = dateToDos(modTime);