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

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

@@ -0,0 +1,68 @@
+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;
+}
+export function unixSecondsFromDate(date) {
+    return clampUint32(Math.floor(date.getTime() / 1000));
+}
+/**
+ * Build Info-ZIP "Extended Timestamp" extra field (0x5455).
+ * We write only mtime (UTC, Unix seconds) to minimize size.
+ *
+ * Layout:
+ * - Header ID: 2 bytes (0x5455)
+ * - Data size: 2 bytes
+ * - Flags: 1 byte (bit0 = mtime)
+ * - mtime: 4 bytes (Unix seconds)
+ */
+export 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;
+}
+export function buildExtendedTimestampExtraFieldFromDate(date) {
+    return buildExtendedTimestampExtraFieldFromUnixSeconds(unixSecondsFromDate(date));
+}
+/**
+ * Parse Info-ZIP "Extended Timestamp" extra field (0x5455) and return mtime.
+ * Returns Unix seconds (UTC) if present.
+ */
+export 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;
+}

package/dist/esm/modules/archive/zip-builder.js

@@ -0,0 +1,292 @@
+/**
+ * ZIP file format builder
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * ZIP file structure:
+ * ┌──────────────────────────┐
+ * │   Local File Header 1    │
+ * │   File Data 1            │
+ * ├──────────────────────────┤
+ * │   Local File Header 2    │
+ * │   File Data 2            │
+ * ├──────────────────────────┤
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │  Central Directory 1     │
+ * │  Central Directory 2     │
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │ End of Central Directory │
+ * └──────────────────────────┘
+ */
+import { compress, compressSync } from "./compress.js";
+import { crc32 } from "./crc32.js";
+import { concatUint8Arrays, sumUint8ArrayLengths } from "./utils/bytes.js";
+import {} from "./utils/timestamps.js";
+import { buildZipEntryMetadata, resolveZipCompressionMethod } from "./zip-entry-metadata.js";
+import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "./defaults.js";
+import { buildCentralDirectoryHeader, buildEndOfCentralDirectory, buildLocalFileHeader } from "./zip-records.js";
+import { FLAG_UTF8, VERSION_MADE_BY, VERSION_NEEDED } from "./zip-constants.js";
+const LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+function encodeZipComment(comment) {
+    // Keep empty comment as empty bytes (no encoding surprises).
+    return comment ? new TextEncoder().encode(comment) : new Uint8Array(0);
+}
+function shouldDeflate(level, data) {
+    return level > 0 && data.length > 0;
+}
+function computeLocalRecordSize(entry) {
+    return (LOCAL_FILE_HEADER_FIXED_SIZE +
+        entry.name.length +
+        entry.extraField.length +
+        entry.compressedData.length);
+}
+function buildProcessedEntry(entry, offset, settings, compressedData) {
+    const modDate = entry.modTime ?? settings.defaultModTime;
+    const isCompressed = shouldDeflate(settings.level, entry.data);
+    const metadata = buildZipEntryMetadata({
+        name: entry.name,
+        comment: entry.comment,
+        modTime: modDate,
+        timestamps: settings.timestamps,
+        useDataDescriptor: false,
+        deflate: isCompressed
+    });
+    return {
+        name: metadata.nameBytes,
+        data: entry.data,
+        compressedData,
+        crc: crc32(entry.data),
+        compressionMethod: resolveZipCompressionMethod(isCompressed),
+        modTime: metadata.dosTime,
+        modDate: metadata.dosDate,
+        extraField: metadata.extraField,
+        comment: metadata.commentBytes,
+        offset
+    };
+}
+function appendProcessedEntry(processedEntries, entry, compressedData, currentOffset, settings) {
+    const processedEntry = buildProcessedEntry(entry, currentOffset, settings, compressedData);
+    processedEntries.push(processedEntry);
+    return {
+        processedEntry,
+        nextOffset: currentOffset + computeLocalRecordSize(processedEntry)
+    };
+}
+function finalizeZip(processedEntries, zipComment, centralDirOffset) {
+    // Build ZIP structure
+    const chunks = [];
+    // Local file headers and data
+    for (const entry of processedEntries) {
+        chunks.push(buildLocalFileHeaderChunk(entry));
+        chunks.push(entry.compressedData);
+    }
+    chunks.push(...buildCentralDirectorySection(processedEntries, centralDirOffset, zipComment));
+    return concatUint8Arrays(chunks);
+}
+function buildLocalFileHeaderChunk(entry) {
+    return buildLocalFileHeader({
+        fileName: entry.name,
+        extraField: entry.extraField,
+        flags: FLAG_UTF8,
+        compressionMethod: entry.compressionMethod,
+        dosTime: entry.modTime,
+        dosDate: entry.modDate,
+        crc32: entry.crc,
+        compressedSize: entry.compressedData.length,
+        uncompressedSize: entry.data.length,
+        versionNeeded: VERSION_NEEDED
+    });
+}
+function buildCentralDirHeaderChunk(entry) {
+    return buildCentralDirectoryHeader({
+        fileName: entry.name,
+        extraField: entry.extraField,
+        comment: entry.comment,
+        flags: FLAG_UTF8,
+        compressionMethod: entry.compressionMethod,
+        dosTime: entry.modTime,
+        dosDate: entry.modDate,
+        crc32: entry.crc,
+        compressedSize: entry.compressedData.length,
+        uncompressedSize: entry.data.length,
+        localHeaderOffset: entry.offset,
+        versionMadeBy: VERSION_MADE_BY,
+        versionNeeded: VERSION_NEEDED
+    });
+}
+function buildCentralDirectorySection(processedEntries, centralDirOffset, zipComment) {
+    const chunks = [];
+    for (const entry of processedEntries) {
+        chunks.push(buildCentralDirHeaderChunk(entry));
+    }
+    const centralDirSize = sumUint8ArrayLengths(chunks);
+    chunks.push(buildEndOfCentralDirectory({
+        entryCount: processedEntries.length,
+        centralDirSize,
+        centralDirOffset,
+        comment: zipComment
+    }));
+    return chunks;
+}
+/**
+ * Create a ZIP file from entries (async)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ *
+ * @example
+ * ```ts
+ * const zip = await createZip([
+ *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
+ *   { name: "folder/file.txt", data: new TextEncoder().encode("Nested!") }
+ * ], { level: 6 });
+ * ```
+ */
+export async function createZip(entries, options = {}) {
+    const level = options.level ?? DEFAULT_ZIP_LEVEL;
+    const timestamps = options.timestamps ?? DEFAULT_ZIP_TIMESTAMPS;
+    const zipComment = encodeZipComment(options.comment);
+    const defaultModTime = new Date();
+    const settings = {
+        level,
+        timestamps,
+        defaultModTime
+    };
+    const compressOptions = {
+        level,
+        thresholdBytes: options.thresholdBytes
+    };
+    const compressedDatas = await Promise.all(entries.map(async (entry) => {
+        return shouldDeflate(level, entry.data) ? compress(entry.data, compressOptions) : entry.data;
+    }));
+    // Process entries
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const compressedData = compressedDatas[i];
+        const result = appendProcessedEntry(processedEntries, entry, compressedData, currentOffset, settings);
+        currentOffset = result.nextOffset;
+    }
+    return finalizeZip(processedEntries, zipComment, currentOffset);
+}
+/**
+ * Create a ZIP file from entries (sync)
+ *
+ * This is supported in both Node.js and browser builds.
+ */
+export function createZipSync(entries, options = {}) {
+    const level = options.level ?? DEFAULT_ZIP_LEVEL;
+    const timestamps = options.timestamps ?? DEFAULT_ZIP_TIMESTAMPS;
+    const zipComment = encodeZipComment(options.comment);
+    const defaultModTime = new Date();
+    const settings = {
+        level,
+        timestamps,
+        defaultModTime
+    };
+    const compressOptions = {
+        level,
+        thresholdBytes: options.thresholdBytes
+    };
+    // Process entries
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (const entry of entries) {
+        // Compress data
+        const compressedData = shouldDeflate(level, entry.data)
+            ? compressSync(entry.data, compressOptions)
+            : entry.data;
+        const result = appendProcessedEntry(processedEntries, entry, compressedData, currentOffset, settings);
+        currentOffset = result.nextOffset;
+    }
+    return finalizeZip(processedEntries, zipComment, currentOffset);
+}
+/**
+ * Streaming ZIP builder for large files
+ * Writes chunks to a callback as they are generated
+ */
+export class ZipBuilder {
+    /**
+     * Create a new ZIP builder
+     * @param options - ZIP options
+     */
+    constructor(options = {}) {
+        this.entries = [];
+        this.currentOffset = 0;
+        this.finalized = false;
+        this.level = options.level ?? DEFAULT_ZIP_LEVEL;
+        this.zipComment = encodeZipComment(options.comment);
+        this.timestamps = options.timestamps ?? DEFAULT_ZIP_TIMESTAMPS;
+        this.compressOptions = {
+            level: this.level,
+            thresholdBytes: options.thresholdBytes
+        };
+        this.settings = {
+            level: this.level,
+            timestamps: this.timestamps,
+            defaultModTime: new Date()
+        };
+    }
+    /**
+     * Add a file to the ZIP (async)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    async addFile(entry) {
+        if (this.finalized) {
+            throw new Error("Cannot add files after finalizing");
+        }
+        // Compress data
+        const compressedData = shouldDeflate(this.level, entry.data)
+            ? await compress(entry.data, this.compressOptions)
+            : entry.data;
+        const result = appendProcessedEntry(this.entries, entry, compressedData, this.currentOffset, this.settings);
+        this.currentOffset = result.nextOffset;
+        return [buildLocalFileHeaderChunk(result.processedEntry), compressedData];
+    }
+    /**
+     * Add a file to the ZIP (sync)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFileSync(entry) {
+        if (this.finalized) {
+            throw new Error("Cannot add files after finalizing");
+        }
+        // Compress data
+        const compressedData = shouldDeflate(this.level, entry.data)
+            ? compressSync(entry.data, this.compressOptions)
+            : entry.data;
+        const result = appendProcessedEntry(this.entries, entry, compressedData, this.currentOffset, this.settings);
+        this.currentOffset = result.nextOffset;
+        return [buildLocalFileHeaderChunk(result.processedEntry), compressedData];
+    }
+    /**
+     * Finalize the ZIP and return central directory + end record
+     * @returns Central directory and end of central directory chunks
+     */
+    finalize() {
+        if (this.finalized) {
+            throw new Error("ZIP already finalized");
+        }
+        this.finalized = true;
+        return buildCentralDirectorySection(this.entries, this.currentOffset, this.zipComment);
+    }
+    /**
+     * Get current number of entries
+     */
+    get entryCount() {
+        return this.entries.length;
+    }
+    /**
+     * Get current ZIP data size (without central directory)
+     */
+    get dataSize() {
+        return this.currentOffset;
+    }
+}

package/dist/esm/modules/archive/zip-constants.js

@@ -0,0 +1,23 @@
+/**
+ * ZIP format constants (PKWARE APPNOTE)
+ * Shared by ZIP writer and parser implementations.
+ */
+// Signatures
+export const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+export const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+export const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+export const DATA_DESCRIPTOR_SIG = 0x08074b50;
+export const ZIP64_END_OF_CENTRAL_DIR_SIG = 0x06064b50;
+export const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50;
+// Versions
+export const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+export const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+export const COMPRESSION_STORE = 0;
+export const COMPRESSION_DEFLATE = 8;
+// General purpose bit flags
+export const FLAG_UTF8 = 0x0800;
+export const FLAG_DATA_DESCRIPTOR = 0x0008;
+// ZIP64 / sentinel sizes
+export const UINT16_MAX = 0xffff;
+export const UINT32_MAX = 0xffffffff;

package/dist/{browser/modules/archive/zip → esm/modules/archive}/zip-entry-metadata.js

@@ -1,6 +1,6 @@
-import { encodeUtf8 } from "../utils/text.js";
-import { buildZipTimestampExtraField, dateToZipDos } from "../utils/timestamps.js";
-import { COMPRESSION_DEFLATE, COMPRESSION_STORE, FLAG_DATA_DESCRIPTOR, FLAG_UTF8 } from "../zip-spec/zip-records.js";
+import { encodeUtf8 } from "./utils/text.js";
+import { buildZipTimestampExtraField, dateToZipDos } from "./utils/timestamps.js";
+import { COMPRESSION_DEFLATE, COMPRESSION_STORE, FLAG_DATA_DESCRIPTOR, FLAG_UTF8 } from "./zip-constants.js";
 export function resolveZipCompressionMethod(deflate) {
     return deflate ? COMPRESSION_DEFLATE : COMPRESSION_STORE;
 }

package/dist/{browser/modules/archive/unzip → esm/modules/archive}/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 "../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";
+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";
 /**
  * Find the End of Central Directory record
  * Searches backwards from the end of the file
@@ -16,13 +16,9 @@ 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);
-    // Signature bytes (little-endian): 0x06054b50 -> 50 4b 05 06
-    const b0 = 0x50;
-    const b1 = 0x4b;
-    const b2 = 0x05;
-    const b3 = 0x06;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     for (let i = data.length - 22; i >= minOffset; i--) {
-        if (data[i] === b0 && data[i + 1] === b1 && data[i + 2] === b2 && data[i + 3] === b3) {
+        if (view.getUint32(i, true) === END_OF_CENTRAL_DIR_SIG) {
             return i;
         }
     }
@@ -37,11 +33,8 @@ function findZip64EOCDLocator(data, eocdOffset) {
     if (locatorOffset < 0) {
         return -1;
     }
-    // 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) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (view.getUint32(locatorOffset, true) === ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
         return locatorOffset;
     }
     return -1;
@@ -51,7 +44,7 @@ function findZip64EOCDLocator(data, eocdOffset) {
  */
 function parseZipEntries(data, options = {}) {
     const { decodeStrings = true } = options;
-    let entries = [];
+    const entries = [];
     // Find End of Central Directory
     const eocdOffset = findEndOfCentralDir(data);
     if (eocdOffset === -1) {
@@ -103,10 +96,6 @@ 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++) {
@@ -155,26 +144,23 @@ function parseZipEntries(data, options = {}) {
         // Check for UTF-8 flag (bit 11)
         const isUtf8 = (flags & 0x800) !== 0;
         const useUtf8 = decodeStrings && isUtf8;
-        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 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 isDirectory = fileName.endsWith("/") || (externalAttributes & 0x10) !== 0;
         const isEncrypted = (flags & 0x01) !== 0;
         const unixSecondsMtime = extraFields.mtimeUnixSeconds;
         const lastModified = resolveZipLastModifiedDateFromUnixSeconds(lastModDate, lastModTime, unixSecondsMtime);
-        entries[i] = {
+        entries.push({
             path: fileName,
             isDirectory,
             compressedSize,
@@ -186,7 +172,7 @@ function parseZipEntries(data, options = {}) {
             comment,
             externalAttributes,
             isEncrypted
-        };
+        });
     }
     return entries;
 }

package/dist/esm/modules/archive/zip-records.js

@@ -0,0 +1,84 @@
+/**
+ * ZIP record builders (PKWARE APPNOTE)
+ *
+ * Shared by streaming zip writer and buffer zip builder.
+ */
+import { CENTRAL_DIR_HEADER_SIG, DATA_DESCRIPTOR_SIG, END_OF_CENTRAL_DIR_SIG, LOCAL_FILE_HEADER_SIG, VERSION_MADE_BY, VERSION_NEEDED } from "./zip-constants.js";
+export function buildLocalFileHeader(input) {
+    const versionNeeded = input.versionNeeded ?? VERSION_NEEDED;
+    const header = new Uint8Array(30 + input.fileName.length + input.extraField.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, LOCAL_FILE_HEADER_SIG, true);
+    view.setUint16(4, versionNeeded, true);
+    view.setUint16(6, input.flags, true);
+    view.setUint16(8, input.compressionMethod, true);
+    view.setUint16(10, input.dosTime, true);
+    view.setUint16(12, input.dosDate, true);
+    view.setUint32(14, input.crc32, true);
+    view.setUint32(18, input.compressedSize, true);
+    view.setUint32(22, input.uncompressedSize, true);
+    view.setUint16(26, input.fileName.length, true);
+    view.setUint16(28, input.extraField.length, true);
+    header.set(input.fileName, 30);
+    if (input.extraField.length > 0) {
+        header.set(input.extraField, 30 + input.fileName.length);
+    }
+    return header;
+}
+export function buildCentralDirectoryHeader(input) {
+    const versionMadeBy = input.versionMadeBy ?? VERSION_MADE_BY;
+    const versionNeeded = input.versionNeeded ?? VERSION_NEEDED;
+    const externalAttributes = input.externalAttributes ?? 0;
+    const header = new Uint8Array(46 + input.fileName.length + input.extraField.length + input.comment.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true);
+    view.setUint16(4, versionMadeBy, true);
+    view.setUint16(6, versionNeeded, true);
+    view.setUint16(8, input.flags, true);
+    view.setUint16(10, input.compressionMethod, true);
+    view.setUint16(12, input.dosTime, true);
+    view.setUint16(14, input.dosDate, true);
+    view.setUint32(16, input.crc32, true);
+    view.setUint32(20, input.compressedSize, true);
+    view.setUint32(24, input.uncompressedSize, true);
+    view.setUint16(28, input.fileName.length, true);
+    view.setUint16(30, input.extraField.length, true);
+    view.setUint16(32, input.comment.length, true);
+    view.setUint16(34, 0, true); // disk number start
+    view.setUint16(36, 0, true); // internal file attributes
+    view.setUint32(38, externalAttributes, true);
+    view.setUint32(42, input.localHeaderOffset, true);
+    header.set(input.fileName, 46);
+    if (input.extraField.length > 0) {
+        header.set(input.extraField, 46 + input.fileName.length);
+    }
+    if (input.comment.length > 0) {
+        header.set(input.comment, 46 + input.fileName.length + input.extraField.length);
+    }
+    return header;
+}
+export function buildEndOfCentralDirectory(input) {
+    const record = new Uint8Array(22 + input.comment.length);
+    const view = new DataView(record.buffer);
+    view.setUint32(0, END_OF_CENTRAL_DIR_SIG, true);
+    view.setUint16(4, 0, true);
+    view.setUint16(6, 0, true);
+    view.setUint16(8, input.entryCount, true);
+    view.setUint16(10, input.entryCount, true);
+    view.setUint32(12, input.centralDirSize, true);
+    view.setUint32(16, input.centralDirOffset, true);
+    view.setUint16(20, input.comment.length, true);
+    if (input.comment.length > 0) {
+        record.set(input.comment, 22);
+    }
+    return record;
+}
+export function buildDataDescriptor(crc32, compressedSize, uncompressedSize) {
+    const descriptor = new Uint8Array(16);
+    const view = new DataView(descriptor.buffer);
+    view.setUint32(0, DATA_DESCRIPTOR_SIG, true);
+    view.setUint32(4, crc32, true);
+    view.setUint32(8, compressedSize, true);
+    view.setUint32(12, uncompressedSize, true);
+    return descriptor;
+}

package/dist/esm/modules/excel/stream/workbook-reader.browser.js

@@ -9,7 +9,7 @@
  * with filesystem-specific features (filename input + temp-file buffering).
  */
 import { EventEmitter, Readable } from "../../stream/index.js";
-import { createParse } from "../../archive/unzip/stream.js";
+import { createParse } from "../../archive/parse.js";
 import { iterateStream } from "../utils/iterate-stream.js";
 import { getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, normalizeZipPath, OOXML_PATHS, worksheetRelTarget } from "../utils/ooxml-paths.js";
 import { parseSax } from "../utils/parse-sax.js";

package/dist/esm/modules/excel/stream/workbook-writer.browser.js

@@ -7,7 +7,7 @@
  * Node.js uses `workbook-writer.ts`, which extends the same base implementation
  * with filesystem-specific features (filename output + image loading).
  */
-import { Zip, ZipDeflate } from "../../archive/zip/stream.js";
+import { Zip, ZipDeflate } from "../../archive/streaming-zip.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { base64ToUint8Array } from "../../../utils/utils.js";
 import { RelType } from "../xlsx/rel-type.js";

package/dist/esm/modules/excel/xlsx/xlsx.browser.js

@@ -30,8 +30,8 @@ import { theme1Xml } from "./xml/theme1.js";
 import { RelType } from "./rel-type.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { bufferToString, base64ToUint8Array } from "../../../utils/utils.js";
-import { StreamingZip, ZipDeflateFile } from "../../archive/zip/stream.js";
-import { ZipParser } from "../../archive/unzip/zip-parser.js";
+import { StreamingZip, ZipDeflateFile } from "../../archive/streaming-zip.js";
+import { ZipParser } from "../../archive/index.js";
 import { PassThrough, concatUint8Arrays } from "../../stream/index.js";
 import { commentsPath, commentsRelTargetFromWorksheetName, ctrlPropPath, drawingPath, drawingRelsPath, OOXML_REL_TARGETS, pivotTableRelTargetFromWorksheetName, pivotCacheDefinitionRelTargetFromWorkbook, getCommentsIndexFromPath, getDrawingNameFromPath, getDrawingNameFromRelsPath, getMediaFilenameFromPath, mediaPath, getPivotCacheDefinitionNameFromPath, getPivotCacheDefinitionNameFromRelsPath, getPivotCacheRecordsNameFromPath, getPivotTableNameFromPath, getPivotTableNameFromRelsPath, pivotCacheDefinitionPath, pivotCacheDefinitionRelsPath, pivotCacheDefinitionRelTargetFromPivotTable, pivotCacheRecordsPath, pivotCacheRecordsRelTarget, pivotTablePath, pivotTableRelsPath, getTableNameFromPath, tablePath, tableRelTargetFromWorksheetName, themePath, getThemeNameFromPath, getVmlDrawingNameFromPath, getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, isBinaryEntryPath, normalizeZipPath, OOXML_PATHS, vmlDrawingRelTargetFromWorksheetName, vmlDrawingPath, worksheetPath, worksheetRelsPath } from "../utils/ooxml-paths.js";
 class StreamingZipWriterAdapter {
@@ -126,7 +126,10 @@ class StreamingZipWriterAdapter {
             timestamps: this.timestamps
         });
         this.zip.add(file);
-        file.push(buffer, true);
+        const pushResult = file.push(buffer, true);
+        if (pushResult && typeof pushResult.catch === "function") {
+            pushResult.catch((err) => this._emit("error", err));
+        }
     }
     finalize() {
         if (this.finalized) {

package/dist/esm/modules/excel/xlsx/xlsx.js

@@ -16,7 +16,7 @@
 import fs from "fs";
 import { fileExists } from "../../../utils/utils.js";
 import { XLSX as XLSXBase } from "./xlsx.browser.js";
-import { Parse } from "../../archive/unzip/stream.js";
+import { Parse } from "../../archive/index.js";
 import { Writable, pipeline } from "../../stream/index.js";
 class XLSX extends XLSXBase {
     constructor(workbook) {