@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/esm/utils/zip/index.js

@@ -0,0 +1,55 @@
+/**
+ * Native ZIP utilities - Pure native implementation without third-party dependencies
+ *
+ * This module provides ZIP file creation using only native platform APIs:
+ * - Node.js: Uses native zlib module (C++ implementation, fastest)
+ * - Browser: Uses CompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+)
+ *
+ * Features:
+ * - Full ZIP format support (Local File Headers, Central Directory, EOCD)
+ * - DEFLATE compression (level 0-9 on Node.js, fixed level on browser)
+ * - STORE mode (no compression)
+ * - UTF-8 filename support
+ * - File comments and ZIP comments
+ * - Streaming API for large files
+ * - Both sync (Node.js) and async APIs
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createZip } from "./utils/zip/index.js";
+ *
+ * const zipData = await createZip([
+ *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
+ *   { name: "folder/nested.txt", data: new TextEncoder().encode("Nested file") }
+ * ], { level: 6 });
+ *
+ * // Write to file (Node.js)
+ * fs.writeFileSync("output.zip", zipData);
+ * ```
+ *
+ * @example Streaming usage
+ * ```ts
+ * import { ZipBuilder } from "./utils/zip/index.js";
+ *
+ * const builder = new ZipBuilder({ level: 1 });
+ *
+ * // Add files one by one
+ * const [header1, data1] = await builder.addFile({
+ *   name: "file1.txt",
+ *   data: new TextEncoder().encode("File 1 content")
+ * });
+ * stream.write(header1);
+ * stream.write(data1);
+ *
+ * // Finalize and write central directory
+ * for (const chunk of builder.finalize()) {
+ *   stream.write(chunk);
+ * }
+ * ```
+ */
+// CRC32 utilities
+export { crc32, crc32Update, crc32Finalize } from "./crc32.js";
+// Compression utilities
+export { compress, compressSync, decompress, decompressSync, hasNativeZlib, hasCompressionStream } from "./compress.js";
+// ZIP builder
+export { createZip, createZipSync, ZipBuilder } from "./zip-builder.js";

package/dist/esm/utils/zip/streaming-zip.js

@@ -0,0 +1,259 @@
+/**
+ * Streaming ZIP creator - fflate-compatible API
+ *
+ * This module provides a streaming ZIP API compatible with fflate's Zip/ZipDeflate,
+ * but uses native zlib compression for better performance.
+ *
+ * Usage:
+ * ```ts
+ * const zip = new StreamingZip((err, data, final) => {
+ *   if (err) handleError(err);
+ *   else {
+ *     stream.write(data);
+ *     if (final) stream.end();
+ *   }
+ * });
+ *
+ * const file = new ZipDeflateFile("path/file.txt", { level: 6 });
+ * zip.add(file);
+ * file.push(data1);
+ * file.push(data2, true); // true = final chunk
+ *
+ * zip.end();
+ * ```
+ */
+import { crc32 } from "./crc32.js";
+import { compressSync } from "./compress.js";
+// ZIP signature constants
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+// ZIP version constants
+const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+const COMPRESSION_STORE = 0;
+const COMPRESSION_DEFLATE = 8;
+const encoder = new TextEncoder();
+/**
+ * Convert Date to DOS time format
+ */
+function dateToDos(date) {
+    const dosTime = ((date.getHours() & 0x1f) << 11) |
+        ((date.getMinutes() & 0x3f) << 5) |
+        ((date.getSeconds() >> 1) & 0x1f);
+    const dosDate = (((date.getFullYear() - 1980) & 0x7f) << 9) |
+        (((date.getMonth() + 1) & 0x0f) << 5) |
+        (date.getDate() & 0x1f);
+    return [dosTime, dosDate];
+}
+/**
+ * ZipDeflate-compatible file stream
+ * Collects data chunks, compresses on finalization
+ */
+export class ZipDeflateFile {
+    constructor(name, options) {
+        this.chunks = [];
+        this.totalSize = 0;
+        this.finalized = false;
+        this._ondata = null;
+        this.name = name;
+        this.level = options?.level ?? 6;
+    }
+    /**
+     * Set data callback (called by StreamingZip)
+     */
+    set ondata(cb) {
+        this._ondata = cb;
+    }
+    /**
+     * Push data to the file
+     * @param data - Data chunk
+     * @param final - Whether this is the final chunk
+     */
+    push(data, final = false) {
+        if (this.finalized) {
+            throw new Error("Cannot push to finalized ZipDeflateFile");
+        }
+        if (data.length > 0) {
+            this.chunks.push(data);
+            this.totalSize += data.length;
+        }
+        if (final) {
+            this.finalized = true;
+            this._flush();
+        }
+    }
+    /**
+     * Flush collected data through compression and emit
+     */
+    _flush() {
+        if (!this._ondata) {
+            return;
+        }
+        // Combine chunks
+        let uncompressed;
+        if (this.chunks.length === 0) {
+            uncompressed = new Uint8Array(0);
+        }
+        else if (this.chunks.length === 1) {
+            uncompressed = this.chunks[0];
+        }
+        else {
+            uncompressed = new Uint8Array(this.totalSize);
+            let offset = 0;
+            for (const chunk of this.chunks) {
+                uncompressed.set(chunk, offset);
+                offset += chunk.length;
+            }
+        }
+        // Compress if level > 0 and data is not empty
+        const shouldCompress = this.level > 0 && uncompressed.length > 0;
+        const compressed = shouldCompress
+            ? compressSync(uncompressed, { level: this.level })
+            : uncompressed;
+        // Build local file header + data
+        const nameBytes = encoder.encode(this.name);
+        const crcValue = crc32(uncompressed);
+        const [dosTime, dosDate] = dateToDos(new Date());
+        // Local file header (30 bytes + filename)
+        const header = new Uint8Array(30 + nameBytes.length);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, LOCAL_FILE_HEADER_SIG, true);
+        view.setUint16(4, VERSION_NEEDED, true);
+        view.setUint16(6, 0x0800, true); // UTF-8 flag
+        view.setUint16(8, shouldCompress ? COMPRESSION_DEFLATE : COMPRESSION_STORE, true);
+        view.setUint16(10, dosTime, true);
+        view.setUint16(12, dosDate, true);
+        view.setUint32(14, crcValue, true);
+        view.setUint32(18, compressed.length, true);
+        view.setUint32(22, uncompressed.length, true);
+        view.setUint16(26, nameBytes.length, true);
+        view.setUint16(28, 0, true); // Extra field length
+        header.set(nameBytes, 30);
+        // Store info for central directory BEFORE emitting data
+        // (StreamingZip reads this in the final callback)
+        this._entryInfo = {
+            name: nameBytes,
+            crc: crcValue,
+            compressedSize: compressed.length,
+            uncompressedSize: uncompressed.length,
+            compressionMethod: shouldCompress ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            dosTime,
+            dosDate,
+            offset: -1 // Will be set by StreamingZip
+        };
+        // Emit header
+        this._ondata(header, false);
+        // Emit compressed data (final chunk)
+        this._ondata(compressed, true);
+        // Clear chunks for GC
+        this.chunks.length = 0;
+    }
+    /**
+     * Get entry info (called by StreamingZip after finalization)
+     */
+    getEntryInfo() {
+        return this._entryInfo || null;
+    }
+}
+/**
+ * Streaming ZIP - fflate Zip-compatible API
+ * Creates ZIP files in a streaming manner
+ */
+export class StreamingZip {
+    /**
+     * Create a streaming ZIP
+     * @param callback - Called with (err, data, final) as data becomes available
+     */
+    constructor(callback) {
+        this.entries = [];
+        this.currentOffset = 0;
+        this.ended = false;
+        this.callback = callback;
+    }
+    /**
+     * Add a file to the ZIP
+     * @param file - ZipDeflateFile instance
+     */
+    add(file) {
+        if (this.ended) {
+            throw new Error("Cannot add files after calling end()");
+        }
+        // Capture offset when first data is written, not when add() is called
+        // This is important because streaming files may have data pushed later
+        let startOffset = -1;
+        file.ondata = (data, final) => {
+            // Capture offset on first data chunk
+            if (startOffset === -1) {
+                startOffset = this.currentOffset;
+            }
+            this.currentOffset += data.length;
+            this.callback(null, data, false);
+            if (final) {
+                // Get entry info and set offset
+                const entryInfo = file.getEntryInfo();
+                if (entryInfo) {
+                    entryInfo.offset = startOffset;
+                    this.entries.push(entryInfo);
+                }
+            }
+        };
+    }
+    /**
+     * Finalize the ZIP
+     * Writes central directory and end-of-central-directory record
+     */
+    end() {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        const centralDirOffset = this.currentOffset;
+        const centralDirChunks = [];
+        // Build central directory headers
+        for (const entry of this.entries) {
+            const header = new Uint8Array(46 + entry.name.length);
+            const view = new DataView(header.buffer);
+            view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true);
+            view.setUint16(4, VERSION_MADE_BY, true);
+            view.setUint16(6, VERSION_NEEDED, true);
+            view.setUint16(8, 0x0800, true); // UTF-8 flag
+            view.setUint16(10, entry.compressionMethod, true);
+            view.setUint16(12, entry.dosTime, true);
+            view.setUint16(14, entry.dosDate, true);
+            view.setUint32(16, entry.crc, true);
+            view.setUint32(20, entry.compressedSize, true);
+            view.setUint32(24, entry.uncompressedSize, true);
+            view.setUint16(28, entry.name.length, true);
+            view.setUint16(30, 0, true); // Extra field length
+            view.setUint16(32, 0, true); // Comment length
+            view.setUint16(34, 0, true); // Disk number start
+            view.setUint16(36, 0, true); // Internal file attributes
+            view.setUint32(38, 0, true); // External file attributes
+            view.setUint32(42, entry.offset, true);
+            header.set(entry.name, 46);
+            centralDirChunks.push(header);
+        }
+        // Emit central directory
+        for (const chunk of centralDirChunks) {
+            this.callback(null, chunk, false);
+        }
+        const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+        // Build end of central directory
+        const eocd = new Uint8Array(22);
+        const eocdView = new DataView(eocd.buffer);
+        eocdView.setUint32(0, END_OF_CENTRAL_DIR_SIG, true);
+        eocdView.setUint16(4, 0, true); // Disk number
+        eocdView.setUint16(6, 0, true); // Disk with central dir
+        eocdView.setUint16(8, this.entries.length, true);
+        eocdView.setUint16(10, this.entries.length, true);
+        eocdView.setUint32(12, centralDirSize, true);
+        eocdView.setUint32(16, centralDirOffset, true);
+        eocdView.setUint16(20, 0, true); // Comment length
+        // Emit end of central directory (final chunk)
+        this.callback(null, eocd, true);
+    }
+}
+// Export aliases for fflate compatibility
+export { StreamingZip as Zip, ZipDeflateFile as ZipDeflate };

package/dist/esm/utils/zip/zip-builder.js

@@ -0,0 +1,372 @@
+/**
+ * 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 { crc32 } from "./crc32.js";
+import { compress, compressSync } from "./compress.js";
+// ZIP signature constants
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+// ZIP version constants
+const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+const COMPRESSION_STORE = 0;
+const COMPRESSION_DEFLATE = 8;
+/**
+ * Convert Date to DOS time format
+ * @param date - Date to convert
+ * @returns [dosTime, dosDate]
+ */
+function dateToDos(date) {
+    const dosTime = ((date.getHours() & 0x1f) << 11) |
+        ((date.getMinutes() & 0x3f) << 5) |
+        ((date.getSeconds() >> 1) & 0x1f);
+    const dosDate = (((date.getFullYear() - 1980) & 0x7f) << 9) |
+        (((date.getMonth() + 1) & 0x0f) << 5) |
+        (date.getDate() & 0x1f);
+    return [dosTime, dosDate];
+}
+/**
+ * Encode string to UTF-8 bytes
+ */
+const encoder = new TextEncoder();
+function encodeString(str) {
+    return encoder.encode(str);
+}
+/**
+ * Build Local File Header (30 bytes + filename + extra)
+ */
+function buildLocalFileHeader(entry) {
+    const header = new Uint8Array(30 + entry.name.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, LOCAL_FILE_HEADER_SIG, true); // Signature
+    view.setUint16(4, VERSION_NEEDED, true); // Version needed to extract
+    view.setUint16(6, 0x0800, true); // General purpose bit flag (UTF-8 names)
+    view.setUint16(8, entry.compressionMethod, true); // Compression method
+    view.setUint16(10, entry.modTime, true); // Last mod time
+    view.setUint16(12, entry.modDate, true); // Last mod date
+    view.setUint32(14, entry.crc, true); // CRC-32
+    view.setUint32(18, entry.compressedData.length, true); // Compressed size
+    view.setUint32(22, entry.data.length, true); // Uncompressed size
+    view.setUint16(26, entry.name.length, true); // Filename length
+    view.setUint16(28, 0, true); // Extra field length
+    header.set(entry.name, 30);
+    return header;
+}
+/**
+ * Build Central Directory Header (46 bytes + filename + extra + comment)
+ */
+function buildCentralDirHeader(entry) {
+    const header = new Uint8Array(46 + entry.name.length + entry.comment.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true); // Signature
+    view.setUint16(4, VERSION_MADE_BY, true); // Version made by
+    view.setUint16(6, VERSION_NEEDED, true); // Version needed to extract
+    view.setUint16(8, 0x0800, true); // General purpose bit flag (UTF-8 names)
+    view.setUint16(10, entry.compressionMethod, true); // Compression method
+    view.setUint16(12, entry.modTime, true); // Last mod time
+    view.setUint16(14, entry.modDate, true); // Last mod date
+    view.setUint32(16, entry.crc, true); // CRC-32
+    view.setUint32(20, entry.compressedData.length, true); // Compressed size
+    view.setUint32(24, entry.data.length, true); // Uncompressed size
+    view.setUint16(28, entry.name.length, true); // Filename length
+    view.setUint16(30, 0, true); // Extra field length
+    view.setUint16(32, entry.comment.length, true); // Comment length
+    view.setUint16(34, 0, true); // Disk number start
+    view.setUint16(36, 0, true); // Internal file attributes
+    view.setUint32(38, 0, true); // External file attributes
+    view.setUint32(42, entry.offset, true); // Relative offset of local header
+    header.set(entry.name, 46);
+    if (entry.comment.length > 0) {
+        header.set(entry.comment, 46 + entry.name.length);
+    }
+    return header;
+}
+/**
+ * Build End of Central Directory Record (22 bytes + comment)
+ */
+function buildEndOfCentralDir(entryCount, centralDirSize, centralDirOffset, comment) {
+    const record = new Uint8Array(22 + comment.length);
+    const view = new DataView(record.buffer);
+    view.setUint32(0, END_OF_CENTRAL_DIR_SIG, true); // Signature
+    view.setUint16(4, 0, true); // Number of this disk
+    view.setUint16(6, 0, true); // Disk where central dir starts
+    view.setUint16(8, entryCount, true); // Number of entries on this disk
+    view.setUint16(10, entryCount, true); // Total number of entries
+    view.setUint32(12, centralDirSize, true); // Size of central directory
+    view.setUint32(16, centralDirOffset, true); // Offset of central directory
+    view.setUint16(20, comment.length, true); // Comment length
+    if (comment.length > 0) {
+        record.set(comment, 22);
+    }
+    return record;
+}
+/**
+ * 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 ?? 6;
+    const zipComment = encodeString(options.comment ?? "");
+    const now = new Date();
+    // Process entries
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (const entry of entries) {
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const modDate = entry.modTime ?? now;
+        const [dosTime, dosDate] = dateToDos(modDate);
+        // Compress data
+        const isCompressed = level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed ? await compress(entry.data, { level }) : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: currentOffset
+        };
+        // Calculate offset for next entry
+        currentOffset += 30 + nameBytes.length + compressedData.length;
+        processedEntries.push(processedEntry);
+    }
+    // Build ZIP structure
+    const chunks = [];
+    // Local file headers and data
+    for (const entry of processedEntries) {
+        chunks.push(buildLocalFileHeader(entry));
+        chunks.push(entry.compressedData);
+    }
+    const centralDirOffset = currentOffset;
+    // Central directory
+    const centralDirChunks = [];
+    for (const entry of processedEntries) {
+        centralDirChunks.push(buildCentralDirHeader(entry));
+    }
+    chunks.push(...centralDirChunks);
+    const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+    // End of central directory
+    chunks.push(buildEndOfCentralDir(processedEntries.length, centralDirSize, centralDirOffset, zipComment));
+    // Combine all chunks
+    const totalSize = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+/**
+ * Create a ZIP file from entries (sync, Node.js only)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ * @throws Error if not in Node.js environment
+ */
+export function createZipSync(entries, options = {}) {
+    const level = options.level ?? 6;
+    const zipComment = encodeString(options.comment ?? "");
+    const now = new Date();
+    // Process entries
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (const entry of entries) {
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const modDate = entry.modTime ?? now;
+        const [dosTime, dosDate] = dateToDos(modDate);
+        // Compress data
+        const isCompressed = level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed ? compressSync(entry.data, { level }) : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: currentOffset
+        };
+        currentOffset += 30 + nameBytes.length + compressedData.length;
+        processedEntries.push(processedEntry);
+    }
+    // Build ZIP structure
+    const chunks = [];
+    // Local file headers and data
+    for (const entry of processedEntries) {
+        chunks.push(buildLocalFileHeader(entry));
+        chunks.push(entry.compressedData);
+    }
+    const centralDirOffset = currentOffset;
+    // Central directory
+    const centralDirChunks = [];
+    for (const entry of processedEntries) {
+        centralDirChunks.push(buildCentralDirHeader(entry));
+    }
+    chunks.push(...centralDirChunks);
+    const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+    // End of central directory
+    chunks.push(buildEndOfCentralDir(processedEntries.length, centralDirSize, centralDirOffset, zipComment));
+    // Combine all chunks
+    const totalSize = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+/**
+ * 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 ?? 6;
+        this.zipComment = encodeString(options.comment ?? "");
+    }
+    /**
+     * 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");
+        }
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const [dosTime, dosDate] = dateToDos(entry.modTime ?? new Date());
+        // Compress data
+        const isCompressed = this.level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed
+            ? await compress(entry.data, { level: this.level })
+            : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: this.currentOffset
+        };
+        this.entries.push(processedEntry);
+        this.currentOffset += 30 + nameBytes.length + compressedData.length;
+        return [buildLocalFileHeader(processedEntry), compressedData];
+    }
+    /**
+     * Add a file to the ZIP (sync, Node.js only)
+     * @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");
+        }
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const [dosTime, dosDate] = dateToDos(entry.modTime ?? new Date());
+        // Compress data
+        const isCompressed = this.level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed
+            ? compressSync(entry.data, { level: this.level })
+            : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: this.currentOffset
+        };
+        this.entries.push(processedEntry);
+        this.currentOffset += 30 + nameBytes.length + compressedData.length;
+        return [buildLocalFileHeader(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;
+        const chunks = [];
+        // Central directory
+        for (const entry of this.entries) {
+            chunks.push(buildCentralDirHeader(entry));
+        }
+        const centralDirSize = chunks.reduce((sum, c) => sum + c.length, 0);
+        // End of central directory
+        chunks.push(buildEndOfCentralDir(this.entries.length, centralDirSize, this.currentOffset, this.zipComment));
+        return chunks;
+    }
+    /**
+     * Get current number of entries
+     */
+    get entryCount() {
+        return this.entries.length;
+    }
+    /**
+     * Get current ZIP data size (without central directory)
+     */
+    get dataSize() {
+        return this.currentOffset;
+    }
+}