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

package/dist/browser/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/browser/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/browser/modules/archive/utils/zip-extra-fields.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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.
  */
 export interface ZipVars {

package/dist/browser/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;

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

@@ -0,0 +1,18 @@
+export declare function unixSecondsFromDate(date: Date): number;
+/**
+ * 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 declare function buildExtendedTimestampExtraFieldFromUnixSeconds(unixSeconds: number): Uint8Array;
+export declare function buildExtendedTimestampExtraFieldFromDate(date: Date): Uint8Array;
+/**
+ * Parse Info-ZIP "Extended Timestamp" extra field (0x5455) and return mtime.
+ * Returns Unix seconds (UTC) if present.
+ */
+export declare function parseExtendedTimestampMtimeUnixSeconds(extraField: Uint8Array): number | undefined;

package/dist/browser/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/browser/modules/archive/zip-builder.d.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 { type CompressOptions } from "@archive/compress";
+import { type ZipTimestampMode } from "@archive/utils/timestamps";
+/**
+ * ZIP file entry
+ */
+export interface ZipEntry {
+    /** File name (can include directory path, use forward slashes) */
+    name: string;
+    /** File data (will be compressed unless level=0) */
+    data: Uint8Array;
+    /** File modification time (optional, defaults to current time) */
+    modTime?: Date;
+    /** File comment (optional) */
+    comment?: string;
+}
+/**
+ * ZIP builder options
+ */
+export interface ZipOptions extends CompressOptions {
+    /** ZIP file comment (optional) */
+    comment?: string;
+    /**
+     * Timestamp writing strategy.
+     * - "dos": only write DOS date/time fields (smallest output)
+     * - "dos+utc": also write UTC mtime in 0x5455 extra field (default, best practice)
+     */
+    timestamps?: ZipTimestampMode;
+}
+/**
+ * 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 declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file from entries (sync)
+ *
+ * This is supported in both Node.js and browser builds.
+ */
+export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;
+/**
+ * Streaming ZIP builder for large files
+ * Writes chunks to a callback as they are generated
+ */
+export declare class ZipBuilder {
+    private entries;
+    private currentOffset;
+    private level;
+    private zipComment;
+    private timestamps;
+    private compressOptions;
+    private settings;
+    private finalized;
+    /**
+     * Create a new ZIP builder
+     * @param options - ZIP options
+     */
+    constructor(options?: ZipOptions);
+    /**
+     * Add a file to the ZIP (async)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFile(entry: ZipEntry): Promise<Uint8Array[]>;
+    /**
+     * Add a file to the ZIP (sync)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFileSync(entry: ZipEntry): Uint8Array[];
+    /**
+     * Finalize the ZIP and return central directory + end record
+     * @returns Central directory and end of central directory chunks
+     */
+    finalize(): Uint8Array[];
+    /**
+     * Get current number of entries
+     */
+    get entryCount(): number;
+    /**
+     * Get current ZIP data size (without central directory)
+     */
+    get dataSize(): number;
+}

package/dist/browser/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.browser.js";
+import { crc32 } from "./crc32.browser.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;
+    }
+}