neozipkit 0.1.1

package/dist/shared/ZipKit.js

@@ -0,0 +1,789 @@
+"use strict";
+// ======================================
+//	ZipKit.ts
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HDR_ID = exports.CENTRAL_DIRECTORY_END = exports.CENTRAL_FILE_HEADER = exports.LOCAL_FILE_HEADER = exports.GP_FLAG = exports.ZIP64_CENTRAL_DIR = exports.ZIP64_CENTRAL_END = exports.CENTRAL_DIR = exports.CENTRAL_END = exports.ENCRYPT_HDR_SIZE = exports.LOCAL_HDR = exports.TOKENIZED_METADATA = exports.TIMESTAMP_SUBMITTED = exports.TIMESTAMP_METADATA = exports.CMP_METHOD = exports.Errors = exports.ZipEntry = void 0;
+const ZipEntry_1 = __importDefault(require("./ZipEntry"));
+exports.ZipEntry = ZipEntry_1.default;
+const Errors_1 = __importDefault(require("./constants/Errors"));
+exports.Errors = Errors_1.default;
+const Util_1 = require("./components/Util");
+const ZipCrypto_1 = require("./components/ZipCrypto");
+const Support_1 = __importDefault(require("./components/Support"));
+const pako_1 = __importDefault(require("pako"));
+const Headers_1 = require("./constants/Headers");
+Object.defineProperty(exports, "LOCAL_HDR", { enumerable: true, get: function () { return Headers_1.LOCAL_HDR; } });
+Object.defineProperty(exports, "ENCRYPT_HDR_SIZE", { enumerable: true, get: function () { return Headers_1.ENCRYPT_HDR_SIZE; } });
+Object.defineProperty(exports, "CMP_METHOD", { enumerable: true, get: function () { return Headers_1.CMP_METHOD; } });
+Object.defineProperty(exports, "CENTRAL_END", { enumerable: true, get: function () { return Headers_1.CENTRAL_END; } });
+Object.defineProperty(exports, "CENTRAL_DIR", { enumerable: true, get: function () { return Headers_1.CENTRAL_DIR; } });
+Object.defineProperty(exports, "ZIP64_CENTRAL_END", { enumerable: true, get: function () { return Headers_1.ZIP64_CENTRAL_END; } });
+Object.defineProperty(exports, "ZIP64_CENTRAL_DIR", { enumerable: true, get: function () { return Headers_1.ZIP64_CENTRAL_DIR; } });
+Object.defineProperty(exports, "GP_FLAG", { enumerable: true, get: function () { return Headers_1.GP_FLAG; } });
+Object.defineProperty(exports, "TIMESTAMP_SUBMITTED", { enumerable: true, get: function () { return Headers_1.TIMESTAMP_SUBMITTED; } });
+Object.defineProperty(exports, "TIMESTAMP_METADATA", { enumerable: true, get: function () { return Headers_1.TIMESTAMP_METADATA; } });
+Object.defineProperty(exports, "TOKENIZED_METADATA", { enumerable: true, get: function () { return Headers_1.TOKENIZED_METADATA; } });
+Object.defineProperty(exports, "LOCAL_FILE_HEADER", { enumerable: true, get: function () { return Headers_1.LOCAL_FILE_HEADER; } });
+Object.defineProperty(exports, "CENTRAL_FILE_HEADER", { enumerable: true, get: function () { return Headers_1.CENTRAL_FILE_HEADER; } });
+Object.defineProperty(exports, "CENTRAL_DIRECTORY_END", { enumerable: true, get: function () { return Headers_1.CENTRAL_DIRECTORY_END; } });
+Object.defineProperty(exports, "HDR_ID", { enumerable: true, get: function () { return Headers_1.HDR_ID; } });
+const HashAccumulator_1 = __importDefault(require("./components/HashAccumulator"));
+const zstd_js_1 = require("@oneidentity/zstd-js");
+const types_1 = require("./types");
+// We'll initialize zstd when needed
+let zstdCodec = null;
+// Async initialization function for zstd
+async function initZstd() {
+    if (!zstdCodec) {
+        zstdCodec = await (0, zstd_js_1.ZstdInit)();
+    }
+    return zstdCodec;
+}
+/**
+ * Main class for ZIP file operations including compression, extraction, and encryption
+ */
+class ZipKit {
+    /**
+     * Creates a new ZipKit instance
+     */
+    constructor() {
+        this.inBuffer = null;
+        this.zipEntries = [];
+        this.sortName = false;
+        // Central End Directory values for existing Zip file
+        this.centralDirSize = 0;
+        this.centralDirOffset = 0;
+        // Timestamp values
+        this.stampEntry = null;
+        this.zipComment = null;
+    }
+    /**
+     * Resets all ZIP-related data to initial state
+     */
+    resetZipData() {
+        this.inBuffer = null;
+        this.zipEntries = [];
+        this.centralDirSize = 0;
+        this.centralDirOffset = 0;
+        this.zipComment = null;
+    }
+    /**
+     * Loads a ZIP file from a buffer
+     * @param inBuf - Buffer containing ZIP file data
+     */
+    loadZip(inBuf) {
+        this.resetZipData();
+        this.inBuffer = inBuf;
+    }
+    /**
+     * Tests if data matches the CRC32 checksum
+     * @param entry - ZIP entry to check
+     * @param data - Data buffer to verify
+     * @returns boolean indicating if CRC matches
+     */
+    testCRC32(entry, data) {
+        // if bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written
+        if ((entry.bitFlags & 0x8) !== 0x8) {
+            const _crc = (0, Util_1.crc32)(data);
+            // console.log('    CRC: '+ sprintf("%08x", _crc));
+            // console.log('ent.CRC: ' + sprintf("%08x", entry.crc));
+            if (_crc !== entry.crc) {
+                return false;
+            }
+        }
+        else {
+            // @TODO: load and check data descriptor header
+            // The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure
+            // (optionally preceded by a 4-byte signature) immediately after the compressed data:
+        }
+        return true;
+    }
+    /**
+     * Tests if data matches the SHA256 hash
+     * @param entry - ZIP entry to check
+     * @param data - Data buffer to verify
+     * @returns boolean indicating if SHA256 matches
+     * @throws Error if entry has no SHA256 hash
+     */
+    testSHA256(entry, data) {
+        if (!entry.sha256) {
+            throw new Error(Errors_1.default.UNKNOWN_SHA256);
+        }
+        const _sha256 = (0, ZipCrypto_1.sha256)(data);
+        return _sha256 === entry.sha256;
+    }
+    /**
+     * Locates and parses the central end directory
+     * @param inBuffer - Buffer containing ZIP file data
+     * @returns Number of entries in ZIP file
+     * @throws Error if central directory is invalid
+     */
+    getCentralEnd(inBuffer) {
+        let i = inBuffer.length - Headers_1.CENTRAL_END.SIZE;
+        let max = Math.max(0, i - 0xffff); // 0xFFFF is the max zip file comment length
+        let endStart = inBuffer.length;
+        let endOffset = -1; // Start offset of the END header
+        let commentEnd = 0;
+        let volEntries = 0;
+        let totalEntries = 0;
+        for (let n = max; i >= n; i--) {
+            if (inBuffer[i] !== 0x50)
+                continue; // quick check that the byte is 'P'
+            if (inBuffer.readUInt32LE(i) === Headers_1.CENTRAL_END.SIGNATURE) {
+                // "PK\005\006"
+                endOffset = i;
+                commentEnd = i;
+                endStart = i + Headers_1.CENTRAL_END.SIZE;
+                // We already found a regular signature, let's look just a bit further to check if there's any zip64 signature
+                n = i - Headers_1.ZIP64_CENTRAL_END.SIZE;
+                continue;
+            }
+            if (inBuffer.readUInt32LE(i) === Headers_1.ZIP64_CENTRAL_END.SIGNATURE) {
+                // Found a zip64 signature, let's continue reading the whole zip64 record
+                n = max;
+                continue;
+            }
+            if (inBuffer.readUInt32LE(i) === Headers_1.ZIP64_CENTRAL_DIR.SIGNATURE) {
+                // Found the zip64 record, let's determine it's size
+                endOffset = i;
+                endStart = i + (0, Util_1.readBigUInt64LE)(inBuffer, i + Headers_1.ZIP64_CENTRAL_DIR.SIZE) + Headers_1.ZIP64_CENTRAL_DIR.LEAD;
+                break;
+            }
+        }
+        if (!~endOffset)
+            throw new Error(Errors_1.default.INVALID_FORMAT);
+        let data = inBuffer.subarray(endOffset, endStart);
+        if (data.readUInt32LE(0) == Headers_1.CENTRAL_END.SIGNATURE) {
+            // number of entries on this volume
+            volEntries = data.readUInt16LE(Headers_1.CENTRAL_END.VOL_ENTRIES);
+            // total number of entries
+            totalEntries = data.readUInt16LE(Headers_1.CENTRAL_END.TOTAL_ENTRIES);
+            // central directory size in bytes
+            this.centralDirSize = data.readUInt32LE(Headers_1.CENTRAL_END.CENTRAL_DIR_SIZE);
+            // offset of first CEN header
+            this.centralDirOffset = data.readUInt32LE(Headers_1.CENTRAL_END.CENTRAL_DIR_OFFSET);
+        }
+        else {
+            // number of entries on this volume
+            volEntries = (0, Util_1.readBigUInt64LE)(data, Headers_1.ZIP64_CENTRAL_DIR.VOL_ENTRIES);
+            // total number of entries
+            totalEntries = (0, Util_1.readBigUInt64LE)(data, Headers_1.ZIP64_CENTRAL_DIR.TOTAL_ENTRIES);
+            // central directory size in bytes
+            this.centralDirSize = (0, Util_1.readBigUInt64LE)(data, Headers_1.ZIP64_CENTRAL_DIR.CENTRAL_DIR_SIZE);
+            // offset of first CEN header
+            this.centralDirOffset = (0, Util_1.readBigUInt64LE)(data, Headers_1.ZIP64_CENTRAL_DIR.CENTRAL_DIR_OFFSET);
+        }
+        // zip file comment length
+        let commentLength = data.readUInt16LE(Headers_1.CENTRAL_END.ZIP_COMMENT_LEN);
+        if (commentLength > 0) {
+            this.zipComment = inBuffer.subarray(endStart, endStart + commentLength).toString();
+        }
+        // console.log('totalEntries: ', totalEntries);
+        // console.log('centralDirSize; ', this.centralDirSize);
+        // console.log('centralDirOffset: ', this.centralDirOffset);
+        // console.log('commentLength: ', commentLength);
+        // console.log('zipComment: ', this.zipComment);
+        return totalEntries;
+    }
+    /**
+     * Creates the central end directory header
+     * @param centralDirSize - Size of central directory
+     * @param centralDirOffset - Offset to central directory
+     * @returns Buffer containing end directory header
+     */
+    centralEndHdr(centralDirSize, centralDirOffset) {
+        const commentLen = this.zipComment ? this.zipComment.length : 0;
+        const data = Buffer.alloc(Headers_1.CENTRAL_END.SIZE + commentLen);
+        // "PK\005\006"
+        data.writeUInt32LE(Headers_1.CENTRAL_END.SIGNATURE, 0);
+        // number of this disk
+        data.writeUInt16LE(0, Headers_1.CENTRAL_END.VOL_NUM);
+        // number of the volume/disk with start of the Central Directory
+        data.writeUInt16LE(0, Headers_1.CENTRAL_END.VOLDIR_START);
+        // number of entries on this volume/disk
+        data.writeUInt16LE(0, Headers_1.CENTRAL_END.VOL_ENTRIES);
+        // total number of entries on this disk
+        data.writeUInt16LE(this.zipEntries.length, Headers_1.CENTRAL_END.TOTAL_ENTRIES);
+        // central directory size in bytes
+        data.writeUInt32LE(centralDirSize, Headers_1.CENTRAL_END.CENTRAL_DIR_SIZE);
+        // offset of first Central Directory Entry
+        data.writeUInt32LE(centralDirOffset, Headers_1.CENTRAL_END.CENTRAL_DIR_OFFSET);
+        // Zip file comment length
+        data.writeUInt16LE(commentLen, Headers_1.CENTRAL_END.ZIP_COMMENT_LEN);
+        if (commentLen > 0 && this.zipComment) {
+            const zipCommentBuf = Buffer.from(this.zipComment, 'utf8');
+            zipCommentBuf.copy(data, Headers_1.CENTRAL_END.SIZE);
+        }
+        return data;
+    }
+    /**
+     * Reads and parses the ZIP file directory
+     * @param debug - Enable debug logging
+     * @returns Array of ZIP entries
+     */
+    getDirectory(debug) {
+        if (this.zipEntries.length > 0) {
+            return this.zipEntries;
+        }
+        const buffer = this.ensureBuffer();
+        // Add this check for empty buffers - if empty, there's no need to try parsing
+        if (buffer.length === 0) {
+            // This is a new ZIP file, so we return an empty array
+            return this.zipEntries;
+        }
+        const entries = this.getCentralEnd(buffer);
+        if (entries === 0)
+            return [];
+        var entryData = buffer.subarray(this.centralDirOffset, this.centralDirOffset + this.centralDirSize);
+        if (entryData.readUInt32LE(0) !== Headers_1.CENTRAL_DIR.SIGNATURE)
+            throw new Error(Errors_1.default.INVALID_CEN);
+        const entryList = [];
+        for (var i = 0; i < entries; i++) {
+            let entry = new ZipEntry_1.default(null, null, debug);
+            entryData = entry.readZipEntry(entryData);
+            entryList.push(entry);
+            // entry.outputZipEntry();
+        }
+        this.zipEntries = entryList;
+        // Sort Zip Entries if sortName option set
+        if (this.sortName && this.zipEntries.length > 1)
+            this.zipEntries.sort((a, b) => {
+                return (a.filename || '').toLowerCase()
+                    .localeCompare((b.filename || '').toLowerCase());
+            });
+        return this.zipEntries;
+    }
+    /**
+     * Gets a ZIP entry by filename
+     * @param fname - Filename to search for
+     * @returns ZipEntry if found, null otherwise
+     */
+    getZipEntry(fname) {
+        try {
+            const centralDir = this.getDirectory();
+            if (centralDir) {
+                for (const entry of centralDir) {
+                    if (entry.filename === fname) {
+                        return entry;
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            // If we get here, treat as a new file (no existing entry)
+            return null;
+        }
+    }
+    /**
+     * Creates a new ZIP entry
+     * @param fname - Filename for new entry
+     * @param comment - Optional entry comment
+     * @returns Created ZipEntry
+     */
+    createZipEntry(fname, comment) {
+        const entry = new ZipEntry_1.default(fname, comment);
+        this.zipEntries.push(entry);
+        return entry;
+    }
+    /**
+     * Deletes an entry from the ZIP file
+     * @param fname - Filename to delete
+     * @returns boolean indicating if file was deleted
+     */
+    deleteFile(fname) {
+        const entries = this.ensureZipEntries();
+        const index = entries.findIndex(zipEntry => zipEntry.filename === fname);
+        if (index < 0)
+            return false;
+        entries.splice(index, 1);
+        return true;
+    }
+    /**
+     * Parses local header and returns entry data
+     * @param entry - ZIP entry to parse
+     * @param withLocalHdrData - Include header in returned data
+     * @returns Buffer containing entry data
+     * @throws Error if header is invalid
+     */
+    parseLocalHeader(entry, withLocalHdrData) {
+        const buffer = this.ensureBuffer();
+        const localData = buffer.subarray(entry.localHdrOffset);
+        // data should be 30 bytes and start with "PK 03 04" 
+        if (localData.readUInt32LE(0) !== Headers_1.LOCAL_HDR.SIGNATURE) {
+            throw new Error(Errors_1.default.INVALID_CEN);
+        }
+        // Check for Data Descriptor Flag
+        let _encryptLen = 0;
+        const _bitFlags = localData.readUInt16LE(Headers_1.LOCAL_HDR.FLAGS);
+        if (_bitFlags & Headers_1.GP_FLAG.ENCRYPTED) {
+            _encryptLen = Headers_1.ENCRYPT_HDR_SIZE;
+        }
+        if (_bitFlags & Headers_1.GP_FLAG.DATA_DESC) {
+            entry.bitFlags |= Headers_1.GP_FLAG.DATA_DESC;
+            entry.lastModTimeDate = localData.readUInt32LE(Headers_1.LOCAL_HDR.TIMEDATE_DOS);
+        }
+        let _fnameLen = localData.readUInt16LE(Headers_1.LOCAL_HDR.FNAME_LEN);
+        let _extraLen = localData.readUInt16LE(Headers_1.LOCAL_HDR.EXTRA_LEN);
+        let _localSize = Headers_1.LOCAL_HDR.SIZE + _fnameLen + _extraLen;
+        if (_encryptLen != 0) {
+            entry.encryptHdr = Buffer.from(localData.subarray(_localSize, _localSize + _encryptLen));
+        }
+        if (withLocalHdrData)
+            return localData.subarray(0, _localSize + entry.compressedSize);
+        return localData.subarray(_localSize + _encryptLen, _localSize + entry.compressedSize);
+    }
+    /**
+     * Copies an entry's data from source ZIP
+     * @param entry - Entry to copy
+     * @returns Buffer containing entry data with headers
+     */
+    copyEntry(entry) {
+        return this.parseLocalHeader(entry, true);
+    }
+    /**
+     * Compresses data for a ZIP entry
+     * @param entry - ZIP entry to compress
+     * @param data - Data to compress
+     * @param options - Compression options
+     * @returns Buffer containing compressed data
+     */
+    async compressData(entry, data, options) {
+        // Initialize with empty buffer instead of null
+        let buffer = Buffer.alloc(0);
+        // Determine compression method based on options
+        if (options?.level === 0) {
+            // Level 0 means "store" (no compression)
+            entry.cmpMethod = Headers_1.CMP_METHOD.STORED;
+            buffer = data;
+        }
+        else if (options?.useZstd) {
+            // Use Zstandard compression
+            if (data.length < 100) {
+                // ZStd requires at least 100 bytes, store it without compression
+                entry.cmpMethod = Headers_1.CMP_METHOD.STORED;
+                buffer = data;
+            }
+            else {
+                entry.cmpMethod = Headers_1.CMP_METHOD.ZSTD;
+                buffer = await this.zstdCompress(data, options);
+            }
+        }
+        else {
+            // Default to deflate
+            entry.cmpMethod = Headers_1.CMP_METHOD.DEFLATED;
+            buffer = this.deflate(data, options);
+        }
+        entry.crc = (0, Util_1.crc32)(data);
+        // console.log('CRC: '+ sprintf("%08x", entry.crc));
+        if (options?.useSHA256) {
+            entry.sha256 = (0, ZipCrypto_1.sha256)(data);
+            console.log('SHA256: ', entry.sha256);
+        }
+        ;
+        if (options?.password) {
+            entry.bitFlags = Headers_1.GP_FLAG.ENCRYPTED;
+            const _check = (entry.crc >> 24) & 0xff;
+            const encryptedBuffer = (0, ZipCrypto_1.encrypter)(buffer, _check, options.password);
+            // Handle potential null return from encrypter
+            if (!encryptedBuffer) {
+                throw new Error(Errors_1.default.ENCRYPT_FAILED);
+            }
+            buffer = encryptedBuffer;
+        }
+        entry.compressedSize = buffer.length;
+        return buffer;
+    }
+    /**
+     * Compresses data using deflate algorithm
+     * @param inbuf - Data to compress
+     * @param options - Compression options
+     * @returns Compressed data buffer
+     */
+    deflate(inbuf, options) {
+        if (options?.level == 0) {
+            return inbuf; // Store without compression
+        }
+        try {
+            const level = options?.level;
+            const result = pako_1.default.deflateRaw(inbuf, {
+                level: level ?? 6
+            });
+            return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+        }
+        catch (e) {
+            console.error('Error during compression:', e);
+            throw new Error(Errors_1.default.COMPRESSION_ERROR);
+        }
+    }
+    /**
+     * Compresses data using Zstandard (zstd) algorithm
+     * @param inbuf - Data to compress
+     * @param options - Compression options
+     * @returns Compressed data buffer
+     */
+    async zstdCompress(inbuf, options) {
+        if (options?.level == 0) {
+            return inbuf; // Store without compression
+        }
+        try {
+            // Ensure zstd is initialized
+            const codec = await initZstd();
+            // Zstd compression levels range from 1 (fastest) to 22 (highest compression)
+            // Map our 1-9 level to a reasonable zstd range (1-19)
+            const level = options?.level ?? 6;
+            const zstdLevel = Math.min(Math.max(1, Math.floor(level * 2.1)), 19);
+            // Compress the data with zstd
+            const compressedData = codec.ZstdSimple.compress(inbuf, zstdLevel);
+            return Buffer.from(compressedData);
+        }
+        catch (e) {
+            console.error('Error during zstd compression:', e);
+            throw new Error(Errors_1.default.COMPRESSION_ERROR);
+        }
+    }
+    /**
+     * Decompresses data using Zstandard (zstd) algorithm
+     * @param inbuf - Compressed data buffer
+     * @returns Decompressed data buffer
+     */
+    async zstdDecompress(inbuf) {
+        try {
+            // Ensure zstd is initialized
+            const codec = await initZstd();
+            const decompressedData = codec.ZstdSimple.decompress(inbuf);
+            return Buffer.from(decompressedData);
+        }
+        catch (e) {
+            console.error('Error during zstd decompression:', e);
+            throw new Error(Errors_1.default.DECOMPRESSION_ERROR);
+        }
+    }
+    // ======================================
+    // deflateAsync(inbuf: Buffer, callback: (result: Buffer) => void) {
+    //   var opts = { chunkSize: ((inbuf.length >> 10) + 1) * 1024 };
+    //   var tmp = zlib.createDeflateRaw(opts),
+    //   parts = [],
+    //   total = 0;
+    //   tmp.on("data", function (data) {
+    //     parts.push(data);
+    //     total += data.length;
+    //   });
+    //   tmp.on("end", function () {
+    //     var buf = Buffer.alloc(total),
+    //       written = 0;
+    //     buf.fill(0);
+    //     for (var i = 0; i < parts.length; i++) {
+    //       var part = parts[i];
+    //       part.copy(buf, written);
+    //       written += part.length;
+    //     }
+    //     callback && callback(buf);
+    //   });
+    //   tmp.end(inbuf);
+    // }
+    /**
+     * Creates new Zip data file with the passed ZipEntries
+     * @param cmpOptions - Compression options
+     * @param zipOptions - Create ZIP options
+     * @returns Promise<number> - The offset of the last entry
+     */
+    async createZipFileData(cmpOptions, zipOptions) {
+        const _onError = zipOptions?.onError || ((error) => { throw error; });
+        const _onEntryDone = zipOptions?.onEntryDone || (() => { });
+        const _onReadEntryData = zipOptions?.onReadEntryData ||
+            (() => { throw new Error('onReadEntryData callback is required'); });
+        const _onOutputBuffer = zipOptions?.onOutputBuffer || (() => { });
+        if (this.zipEntries.length === 0) {
+            _onError(new Error(Errors_1.default.NO_FILES));
+            return 0; // Return 0 instead of undefined
+        }
+        // console.log('Creating Zip File Data with ZipEntries: ', this.zipEntries);
+        let offset = 0;
+        let entryCnt = this.zipEntries.length;
+        for (let index = 0; index < entryCnt; index++) {
+            const entry = this.zipEntries[index];
+            // Remove any existing Timestamp Metadata entries
+            if (entry.filename === Headers_1.TIMESTAMP_METADATA || entry.filename === Headers_1.TIMESTAMP_SUBMITTED) {
+                this.zipEntries.splice(index, 1);
+                entryCnt--;
+                index--;
+                console.log('Deleting Timestamp Metadata entry: ', entry.filename);
+                continue;
+            }
+            if (!entry.isUpdated) {
+                console.log('Copying Entry: ', entry.filename);
+                const inData = this.copyEntry(entry);
+                entry.localHdrOffset = offset;
+                offset += inData.length;
+                _onOutputBuffer(inData);
+                _onEntryDone(entry, 'Copied ');
+                continue;
+            }
+            // Compress the file data to set all zipEntry fields correctly
+            const fileBuffer = _onReadEntryData(entry);
+            const cmpData = await this.compressData(entry, fileBuffer, cmpOptions);
+            // Create a local header data buffer
+            const localHdr = entry.createLocalHdr();
+            // Save local header offset for entry and calculate next offset
+            entry.localHdrOffset = offset;
+            offset += localHdr.length + cmpData.length;
+            // Write the data to the output file
+            _onOutputBuffer(localHdr);
+            _onOutputBuffer(cmpData);
+            _onEntryDone(entry, 'Written');
+        }
+        return offset;
+    }
+    /**
+     * Finishes Zip data file by adding any Metadata entries and the Central End Directory
+     * @param offset - The current offset in the zip data file
+     * @param onOutputBuffer - The callback function to output the data buffer
+     * @param metaEntry - The Metadata ZipEntry to add to the Zip file
+     */
+    async finishZipFileData(offset, onOutputBuffer, metaEntry) {
+        if (metaEntry && metaEntry.fileBuffer) {
+            const localHdr = metaEntry.createLocalHdr();
+            metaEntry.localHdrOffset = offset;
+            offset += localHdr.length + metaEntry.fileBuffer.length;
+            onOutputBuffer(localHdr);
+            onOutputBuffer(metaEntry.fileBuffer);
+        }
+        // Output ZipEntries as Central End Directory
+        const centralDirOffset = offset;
+        for (const entry of this.zipEntries) {
+            const centralDirEntry = entry.centralDirEntry();
+            offset += centralDirEntry.length;
+            onOutputBuffer(centralDirEntry);
+        }
+        const centralDirSize = offset - centralDirOffset;
+        const ceBuf = this.centralEndHdr(centralDirSize, centralDirOffset);
+        onOutputBuffer(ceBuf);
+    }
+    /**
+     * Unzips the data buffer using pako inflate method
+     * @param inbuf - Data buffer to inflate
+     * @returns Inflated data buffer
+     * @throws Error if extraction fails
+     */
+    inflate(inbuf) {
+        const result = pako_1.default.inflateRaw(inbuf);
+        return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+    }
+    /**
+     * Extracts the data from the ZipEntry and returns the data as a Buffer
+     * @param entry - ZIP entry to extract
+     * @param skipHashCheck - Whether to skip hash checking
+     * @returns Buffer containing extracted data or null if extraction fails
+     */
+    async extract(entry, skipHashCheck) {
+        const fdata = this.parseLocalHeader(entry);
+        if (fdata.length == 0) {
+            return null;
+        }
+        let outBuf = null;
+        switch (entry.cmpMethod) {
+            case Headers_1.CMP_METHOD.STORED:
+                outBuf = fdata;
+                break;
+            case Headers_1.CMP_METHOD.DEFLATED:
+                outBuf = this.inflate(fdata);
+                break;
+            case Headers_1.CMP_METHOD.ZSTD:
+                outBuf = await this.zstdDecompress(fdata);
+                break;
+            default:
+                throw new Error(Errors_1.default.UNKNOWN_METHOD);
+        }
+        // If no hash checking is requested, return the unmodified data
+        if (skipHashCheck) {
+            return outBuf;
+        }
+        // Verify integrity - use SHA256 if available, otherwise CRC32
+        if (entry.sha256) {
+            if (!this.testSHA256(entry, outBuf)) {
+                throw new Error(Errors_1.default.INVALID_SHA256);
+            }
+        }
+        else {
+            if (!this.testCRC32(entry, outBuf)) {
+                throw new Error(Errors_1.default.INVALID_CRC);
+            }
+        }
+        return outBuf;
+    }
+    /**
+     * Decrypts the entry data
+     * @param entry - ZIP entry to decrypt
+     * @param password - Password for decryption
+     * @returns Decrypted data buffer or null if decryption fails
+     */
+    decryptEntry(entry, password) {
+        if (!entry.isEncrypted)
+            return null;
+        if (entry.isStrongEncrypt)
+            throw new Error(Errors_1.default.STRONG_ENCRYPT_UNSUPPORTED);
+        if (!password)
+            return null;
+        // Read the encryption header at start of data
+        let _localData = this.parseLocalHeader(entry);
+        const _decrypt = (0, ZipCrypto_1.decrypter)(password);
+        const _encHdr = entry.encryptHdr;
+        if (!_encHdr)
+            return null;
+        const decryptedHeader = _decrypt(_encHdr);
+        const _check = (entry.bitFlags & Headers_1.GP_FLAG.DATA_DESC) ?
+            (entry.lastModTimeDate >> 8) & 0xff :
+            ((entry.crc >> 24) & 0xff);
+        if (decryptedHeader[11] !== _check)
+            return null;
+        _localData = _decrypt(_localData);
+        return _localData;
+    }
+    /**
+     * Checks if a filename is a blockchain metadata file that should be excluded from Merkle Root calculation
+     * @param filename - The filename to check
+     * @returns boolean - True if the file is a metadata file
+     */
+    isMetadataFile(filename) {
+        return filename === Headers_1.TIMESTAMP_SUBMITTED ||
+            filename === Headers_1.TIMESTAMP_METADATA ||
+            filename === Headers_1.TOKENIZED_METADATA;
+    }
+    /**
+     * Calculates the Merkle Root of the ZIP file
+     * Excludes blockchain metadata files (META-INF/*) to ensure consistent calculation
+     * @returns string - The Merkle Root of the ZIP file
+     */
+    getMerkleRoot() {
+        const zipEntries = this.getDirectory();
+        if (zipEntries.length === 0)
+            return null;
+        let _hashAccumulator = new HashAccumulator_1.default();
+        // Filter out blockchain metadata files to ensure consistent Merkle Root calculation
+        const contentEntries = zipEntries.filter(entry => !this.isMetadataFile(entry.filename));
+        for (const entry of contentEntries) {
+            if (entry.sha256) {
+                _hashAccumulator.addHash(entry.sha256);
+            }
+        }
+        const merkleRoot = _hashAccumulator.merkleRoot();
+        if (!merkleRoot)
+            return null;
+        return merkleRoot;
+    }
+    /**
+     * Checks if a ZIP file contains valid timestamp metadata
+     * @returns { merkleRoot: string | null, ots: Buffer | null }
+     * Returns the merkle root hash and timestamp metadata if found, null otherwise
+     */
+    checkForTimestamp() {
+        const zipEntries = this.getDirectory();
+        if (zipEntries.length === 0)
+            return null;
+        this.stampEntry = null;
+        let _hashAccumulator = new HashAccumulator_1.default();
+        for (const entry of zipEntries) {
+            if (entry.filename === Headers_1.TIMESTAMP_METADATA) {
+                this.stampEntry = entry;
+            }
+            else if (entry.filename === Headers_1.TIMESTAMP_SUBMITTED) {
+                if (this.stampEntry == null)
+                    this.stampEntry = entry;
+            }
+            else if (!this.isMetadataFile(entry.filename) && entry.sha256) {
+                // Only include content files (non-metadata) in Merkle Root calculation
+                _hashAccumulator.addHash(entry.sha256);
+            }
+        }
+        if (!this.stampEntry)
+            return null;
+        const merkleRoot = _hashAccumulator.merkleRoot();
+        return merkleRoot;
+    }
+    /**
+     * Gets the OTS from the timestamp metadata entry
+     * @returns Promise<Buffer | null> - The OTS from the timestamp metadata entry or null if not found
+     */
+    async getOts() {
+        if (!this.stampEntry)
+            return null;
+        const ots = await this.extract(this.stampEntry);
+        return ots;
+    }
+    /**
+     * Creates a new timestamp metadata entry for the ZIP file
+     * Calculates merkle root from file hashes and obtains blockchain timestamp
+     * @returns Promise<ZipEntry | null> The created timestamp metadata entry or null if failed
+     */
+    createTimestampMetadataEntry(ots) {
+        if (!ots)
+            return null;
+        const tsEntry = this.createZipEntry(Headers_1.TIMESTAMP_SUBMITTED);
+        tsEntry.crc = (0, Util_1.crc32)(ots);
+        tsEntry.uncompressedSize = ots.length;
+        tsEntry.compressedSize = ots.length;
+        tsEntry.cmpMethod = Headers_1.CMP_METHOD.STORED;
+        tsEntry.fileBuffer = ots;
+        tsEntry.isMetaData = true;
+        return tsEntry;
+    }
+    /**
+     * Sets the ZIP file comment
+     * @param msg - Comment to set
+     */
+    setZipComment(msg) {
+        this.zipComment = msg;
+    }
+    /**
+     * Gets the ZIP file comment
+     * @returns string | null - The ZIP file comment
+     */
+    getZipComment() {
+        return this.zipComment;
+    }
+    /**
+     * Converts the compression method to a string
+     * @param cmpMethod - Compression method number
+     * @returns string - Compression method as a string
+     */
+    cmpMethodToString(cmpMethod) {
+        switch (cmpMethod) {
+            case 0: return 'Stored';
+            case 8: return 'Deflate';
+            case 93: return 'Zstd';
+            default: return 'Unknown';
+        }
+    }
+    /**
+     * Ensures ZIP entries are loaded
+     * @returns Array of ZIP entries
+     * @throws Error if no ZIP entries are loaded
+     */
+    ensureZipEntries() {
+        if (this.zipEntries.length === 0)
+            throw new Error('No ZIP entries loaded');
+        return this.zipEntries;
+    }
+    /**
+     * Ensures ZIP data buffer is loaded
+     * @returns Buffer containing ZIP data
+     * @throws Error if no ZIP data is loaded
+     */
+    ensureBuffer() {
+        if (!this.inBuffer) {
+            // Instead of throwing an error, return an empty buffer
+            this.inBuffer = Buffer.alloc(0);
+        }
+        return this.inBuffer;
+    }
+}
+ZipKit.version = types_1.NEOZIPKIT_INFO.version;
+ZipKit.releaseDate = types_1.NEOZIPKIT_INFO.releaseDate;
+ZipKit.support = Support_1.default;
+exports.default = ZipKit;