neozip-cli 0.70.0-alpha

package/dist/neozipkit-bundles/core.js

@@ -0,0 +1,3766 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// neozipkit/dist/core/constants/Errors.js
+var require_Errors = __commonJS({
+  "neozipkit/dist/core/constants/Errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.default = {
+      /* Header error messages */
+      INVALID_LOC: "Invalid LOC header (bad signature)",
+      INVALID_CEN: "Invalid CEN header (bad signature)",
+      INVALID_END: "Invalid END header (bad signature)",
+      /* ZipEntry error messages*/
+      NO_DATA: "Nothing to decompress",
+      FILE_IN_THE_WAY: "There is a file in the way: %s",
+      UNKNOWN_METHOD: "Invalid/unsupported compression method",
+      /* Encryption Errors */
+      STRONG_ENCRYPT_UNSUPPORTED: "Strong Encryption is not supported",
+      /* Timestamp error messages */
+      INVALID_TIMESTAMP: "Invalid timestamp",
+      TIMESTAMP_FAILED: "Failed to create the timestamp",
+      /* Inflater error messages */
+      AVAIL_DATA: "inflate::Available inflate data did not terminate",
+      INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+      TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
+      INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
+      INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
+      INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
+      INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
+      INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
+      INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
+      INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
+      /* Extract error messages */
+      INVALID_CMP_DATA_LENGTH: "Compressed data length does not match the expected length",
+      EXTRACT_FAILED: "Failed to extract file",
+      INVALID_CRC: "CRC32 checksum does not match the expected value",
+      UNKNOWN_SHA256: "The SHA-256 hash has not been saved",
+      INVALID_SHA256: "The SHA-256 hash does not match the expected value",
+      /* NEO-ZIP error messages */
+      CANT_EXTRACT_FILE: "Could not extract the file",
+      CANT_OVERRIDE: "Target file already exists",
+      NO_ZIP: "No zip file was loaded",
+      NO_ENTRY: "Entry doesn't exist",
+      DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
+      FILE_NOT_FOUND: "File not found: %s",
+      NOT_IMPLEMENTED: "Not implemented",
+      INVALID_FILENAME: "Invalid filename",
+      INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
+      // NeoZipKit error messages
+      NO_STREAM_SUPPORT: "Streams are not supported in this environment",
+      NO_BLOB_SUPPORT: "Blobs are not supported in this environment",
+      NO_FILE_READER_SUPPORT: "FileReader is not supported in this environment",
+      // Create Zip error messages
+      NO_FILES: "No files added, Zip file not created",
+      DATATYPE_STRING_UNSUPPORTED: "The String type is not supported by this platform.",
+      DATATYPE_ARRAY_UNSUPPORTED: "The Array type is not supported by this platform.",
+      DATATYPE_BUFFER_UNSUPPORTED: "The Buffer type is not supported by this platform.",
+      DATATYPE_BLOB_UNSUPPORTED: "The Blob type is not supported by this platform.",
+      DATATYPE_U8ARRAY_UNSUPPORTED: "The uint8Array type is not supported by this platform.",
+      DATATYPE_ARRAYBUFFER_UNSUPPORTED: "The ArrayBuffer type is not supported by this platform.",
+      DATATYPE_UNSUPPORTED: "Unsupported input type.",
+      COMPRESS_FAILED: "Failed to compress data",
+      COMPRESSION_ERROR: "Error occurred during compression",
+      DECOMPRESSION_ERROR: "Error occurred during decompression",
+      ENCRYPT_FAILED: "Encryption failed"
+    };
+  }
+});
+
+// neozipkit/dist/core/constants/Headers.js
+var require_Headers = __commonJS({
+  "neozipkit/dist/core/constants/Headers.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DOS_FILE_ATTR = exports2.FILE_SYSTEM = exports2.HDR_ID = exports2.EXTENSIBLE_DATA_FIELDS = exports2.GP_FLAG = exports2.CMP_METHOD = exports2.ZIP64_CENTRAL_END = exports2.ZIP64_CENTRAL_DIR = exports2.CENTRAL_END = exports2.CENTRAL_DIR = exports2.DATA_DESC = exports2.ENCRYPT_HDR_SIZE = exports2.LOCAL_HDR = exports2.TOKENIZED_METADATA = exports2.TIMESTAMP_METADATA = exports2.TIMESTAMP_SUBMITTED = exports2.DATA_DESCRIPTOR = exports2.ZIP64_CENTRAL_DIRECTORY_END = exports2.ZIP64_CENTRAL_DIRECTORY_LOCATOR = exports2.CENTRAL_DIRECTORY_END = exports2.CENTRAL_FILE_HEADER = exports2.LOCAL_FILE_HEADER = void 0;
+    exports2.LOCAL_FILE_HEADER = "PK";
+    exports2.CENTRAL_FILE_HEADER = "PK
";
+    exports2.CENTRAL_DIRECTORY_END = "PK";
+    exports2.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x07";
+    exports2.ZIP64_CENTRAL_DIRECTORY_END = "PK";
+    exports2.DATA_DESCRIPTOR = "PK\x07\b";
+    exports2.TIMESTAMP_SUBMITTED = "META-INF/TS-SUBMIT.OTS";
+    exports2.TIMESTAMP_METADATA = "META-INF/TIMESTAMP.OTS";
+    exports2.TOKENIZED_METADATA = "META-INF/NZIP.TOKEN";
+    exports2.LOCAL_HDR = {
+      SIZE: 30,
+      // LOC header size in bytes
+      SIGNATURE: 67324752,
+      // "PK\003\004"
+      VER_EXTRACT: 4,
+      // version needed to extract
+      FLAGS: 6,
+      // general purpose bit flag
+      COMPRESSION: 8,
+      // compression method
+      TIMEDATE_DOS: 10,
+      // modification time (2 bytes time, 2 bytes date)
+      CRC: 14,
+      // uncompressed file crc-32 value
+      CMP_SIZE: 18,
+      // compressed size
+      UNCMP_SIZE: 22,
+      // uncompressed size
+      FNAME_LEN: 26,
+      // filename length
+      EXTRA_LEN: 28
+      // extra field length
+    };
+    exports2.ENCRYPT_HDR_SIZE = 12;
+    exports2.DATA_DESC = {
+      SIGNATURE: 134695760,
+      // "PK\007\008"
+      SIZE: 16,
+      // EXT header size in bytes
+      CRC: 4,
+      // uncompressed file crc-32 value (offset)
+      CMP_SIZE: 8,
+      // compressed size (offset)
+      UNCMP_SIZE: 12
+      // uncompressed size
+    };
+    exports2.CENTRAL_DIR = {
+      SIZE: 46,
+      // Central directory header size
+      SIGNATURE: 33639248,
+      // "PK\001\002"
+      VER_MADE: 4,
+      // version made by
+      VER_EXT: 6,
+      // version needed to extract
+      FLAGS: 8,
+      // encrypt, decrypt flags
+      CMP_METHOD: 10,
+      // compression method
+      TIMEDATE_DOS: 12,
+      // DOS modification time (2 bytes time, 2 bytes date)
+      CRC: 16,
+      // uncompressed file crc-32 value
+      CMP_SIZE: 20,
+      // compressed size
+      UNCMP_SIZE: 24,
+      // uncompressed size
+      FNAME_LEN: 28,
+      // filename length
+      EXTRA_LEN: 30,
+      // extra field length
+      COMMENT_LEN: 32,
+      // file comment length
+      DISK_NUM: 34,
+      // volume number start
+      INT_FILE_ATTR: 36,
+      // internal file attributes
+      EXT_FILE_ATTR: 38,
+      // external file attributes (host system dependent)
+      LOCAL_HDR_OFFSET: 42
+      // LOC header offset
+    };
+    exports2.CENTRAL_END = {
+      SIZE: 22,
+      // END header size
+      SIGNATURE: 101010256,
+      // "PK\005\006"
+      VOL_NUM: 4,
+      // number of this disk
+      VOLDIR_START: 6,
+      // number of the volume/disk with start of the Central Directory
+      VOL_ENTRIES: 8,
+      // number of entries on this volume/disk
+      TOTAL_ENTRIES: 10,
+      // total number of entries on this disk
+      CENTRAL_DIR_SIZE: 12,
+      // central directory size in bytes
+      CENTRAL_DIR_OFFSET: 16,
+      // offset of first CEN header
+      ZIP_COMMENT_LEN: 20
+      // zip file comment length
+    };
+    exports2.ZIP64_CENTRAL_DIR = {
+      SIGNATURE: 101075792,
+      // zip64 signature, "PK\006\006"
+      SIZE: 56,
+      // zip64 record minimum size
+      LEAD: 12,
+      // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE
+      SIZE_FIELD: 4,
+      // zip64 size of the central directory record
+      VER_MADEBY: 12,
+      // zip64 version made by
+      VER_NEEDED: 14,
+      // zip64 version needed to extract
+      VOL_NUM: 16,
+      // zip64 number of this disk
+      VOLDIR_START: 20,
+      // number of the disk with the start of the record directory
+      VOL_ENTRIES: 24,
+      // number of entries on this disk
+      TOTAL_ENTRIES: 32,
+      // total number of entries
+      CENTRAL_DIR_SIZE: 40,
+      // zip64 central directory size in bytes
+      CENTRAL_DIR_OFFSET: 48,
+      // offset of start of central directory with respect to the starting disk number
+      EXTRA_FIELD: 56
+      // extensible data sector
+    };
+    exports2.ZIP64_CENTRAL_END = {
+      SIZE: 20,
+      // zip64 END header size
+      SIGNATURE: 117853008,
+      // zip64 Locator signature, "PK\006\007"
+      VOL_NUM: 4,
+      // number of the disk with the start of the zip64
+      CENTRAL_DIR_OFFSET: 8,
+      // relative offset of the zip64 end of central directory
+      TOTAL_DISKS: 16
+      // total number of disks
+    };
+    exports2.CMP_METHOD = {
+      STORED: 0,
+      // no compression
+      SHRUNK: 1,
+      // shrunk
+      REDUCED1: 2,
+      // reduced with compression factor 1
+      REDUCED2: 3,
+      // reduced with compression factor 2
+      REDUCED3: 4,
+      // reduced with compression factor 3
+      REDUCED4: 5,
+      // reduced with compression factor 4
+      IMPLODED: 6,
+      // imploded
+      DEFLATED: 8,
+      // deflated
+      ENHANCED_DEFLATE: 9,
+      // enhanced deflated
+      BZIP2: 12,
+      //  compressed using BZIP2
+      LZMA: 14,
+      // LZMA
+      IBM_TERSE: 18,
+      // compressed using IBM TERSE
+      IBM_LZ77: 19,
+      // IBM LZ77
+      ZSTD: 93,
+      // Zstandard compression
+      AES_ENCRYPT: 99
+      // WinZIP AES encryption method
+    };
+    exports2.GP_FLAG = {
+      ENCRYPTED: 1,
+      // Bit 0: encrypted file
+      COMPRESSION1: 2,
+      // Bit 1, compression option
+      COMPRESSION2: 4,
+      // Bit 2, compression option
+      DATA_DESC: 8,
+      // Bit 3, data descriptor 
+      ENHANCED_DEFLATE: 16,
+      // Bit 4, enhanced deflating
+      PATCHED: 32,
+      // Bit 5, indicates that the file is compressed patched data.
+      STRONG_ENCRYPT: 64,
+      // Bit 6, strong encryption (patented)
+      // Bits 7-10: Currently unused.
+      EFS: 2048,
+      // Bit 11: Language encoding flag (EFS)
+      // Bit 12: Reserved by PKWARE for enhanced compression.
+      // Bit 13: encrypted the Central Directory (patented).
+      // Bits 14-15: Reserved by PKWARE.
+      MASK: 4096
+      // mask header values
+    };
+    exports2.EXTENSIBLE_DATA_FIELDS = {
+      ID: 0,
+      SIZE: 2
+    };
+    exports2.HDR_ID = {
+      ZIP64: 1,
+      // ZIP64 Extended Information Extra Field
+      AVINFO: 7,
+      // AV Info
+      PFS: 8,
+      // PFS Extra Field
+      OS2: 9,
+      // OS/2 Extra Field
+      NTFS: 10,
+      // NTFS Extra Field
+      OPENVMS: 12,
+      // OpenVMS Extra Field
+      UNIX: 13,
+      // Unix Extra Field
+      FORK: 14,
+      // Fork Data Extra Field
+      PATCH: 15,
+      // Patch Descriptor Extra Field
+      x509PKCS7: 20,
+      // X.509 Certificate Store (PKCS#7)
+      x509CERT_IDF: 21,
+      // X.509 Certificate ID and Fingerprint
+      x509CERT_IDC: 22,
+      // X.509 Certificate ID and Certificate
+      STRONG_ENC: 23,
+      // Strong Encryption Header
+      RECORD_MGT: 24,
+      // Record Management Controls
+      x509PKCS7RL: 25,
+      // X.509 Certificate Revocation List (PKCS#7)
+      IBM1: 101,
+      // IBM S/390 (Z390) - Attribute
+      IBM2: 102,
+      // IBM S/390 (Z390) - Attribute
+      SHA256: 334,
+      // SHA256 "N\01" with 64 bytes (256 bit) of SHA256 hash data
+      POSZIP: 18064,
+      // POSZIP 4690
+      UNV_TIME: 21589,
+      // Universal Time (UT) (32-bit) 5 data bytes
+      UID_GID: 30837,
+      // Unix UID/GID (any size)
+      UNICODE_PATH: 28789,
+      // Info-ZIP Unicode Path Extra Field
+      SYMLINK: 30805,
+      // Unix Symbolic Link Extra Field
+      HARDLINK: 30821
+      // Unix Hard Link Extra Field
+    };
+    exports2.FILE_SYSTEM = {
+      MSDOS: 0,
+      // MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems)
+      AMIGA: 1,
+      // Amiga
+      OPENVMS: 2,
+      // OpenVMS
+      UNIX: 3,
+      // UNIX
+      VM_CMS: 4,
+      // VM/CMS
+      ATARI: 5,
+      // Atari ST
+      OS2: 6,
+      // OS/2 H.P.F.S.
+      MAC: 7,
+      // Macintosh
+      CP_M: 9,
+      // CP/M
+      NTFS: 10,
+      // Windows NTFS
+      MVS: 11,
+      // MVS (OS/390 - Z/OS)
+      VSE: 12,
+      // VSE
+      ACORN: 13,
+      // Acorn Risc
+      VFAT: 14,
+      // VFAT
+      ALTMVS: 15,
+      // Alternate MVS
+      BEOS: 16,
+      // BeOS
+      TANDEM: 17,
+      // Tandem
+      OS400: 18,
+      // OS/400
+      DARWIN: 19
+      // Apple OS/X (Darwin)
+    };
+    exports2.DOS_FILE_ATTR = {
+      READONLY: 1,
+      HIDDEN: 2,
+      SYSTEM: 4,
+      VOLUME: 8,
+      DIRECTORY: 16,
+      ARCHIVE: 32
+    };
+  }
+});
+
+// neozipkit/dist/core/components/Logger.js
+var require_Logger = __commonJS({
+  "neozipkit/dist/core/components/Logger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Logger = void 0;
+    exports2.configureLoggerFromEnvironment = configureLoggerFromEnvironment;
+    var Logger = class {
+      static {
+        __name(this, "Logger");
+      }
+      /**
+       * Configure the logger
+       */
+      static configure(config) {
+        this.config = { ...this.config, ...config };
+      }
+      /**
+       * Get current logger configuration
+       */
+      static getConfig() {
+        return { ...this.config };
+      }
+      /**
+       * Enable logging
+       */
+      static enable() {
+        this.config.enabled = true;
+      }
+      /**
+       * Disable all logging
+       */
+      static disable() {
+        this.config.enabled = false;
+      }
+      /**
+       * Set log level
+       */
+      static setLevel(level) {
+        this.config.level = level;
+      }
+      /**
+       * Check if a log level should be output
+       */
+      static shouldLog(level) {
+        if (!this.config.enabled)
+          return false;
+        const levels = ["debug", "info", "warn", "error", "silent"];
+        const currentLevelIndex = levels.indexOf(this.config.level);
+        const requestedLevelIndex = levels.indexOf(level);
+        return requestedLevelIndex >= currentLevelIndex;
+      }
+      /**
+       * Log a message
+       */
+      static log(...args) {
+        if (this.shouldLog("info")) {
+          this.originalConsole.log(...args);
+        }
+      }
+      /**
+       * Log an error message
+       */
+      static error(...args) {
+        if (this.shouldLog("error")) {
+          this.originalConsole.error(...args);
+        }
+      }
+      /**
+       * Log a warning message
+       */
+      static warn(...args) {
+        if (this.shouldLog("warn")) {
+          this.originalConsole.warn(...args);
+        }
+      }
+      /**
+       * Log a debug message
+       */
+      static debug(...args) {
+        if (this.shouldLog("debug")) {
+          this.originalConsole.log(...args);
+        }
+      }
+      /**
+       * Log an info message
+       */
+      static info(...args) {
+        if (this.shouldLog("info")) {
+          this.originalConsole.info(...args);
+        }
+      }
+      /**
+       * Override console methods globally (use with caution)
+       */
+      static overrideConsole() {
+        console.log = (...args) => this.log(...args);
+        console.error = (...args) => this.error(...args);
+        console.warn = (...args) => this.warn(...args);
+        console.debug = (...args) => this.debug(...args);
+        console.info = (...args) => this.info(...args);
+      }
+      /**
+       * Restore original console methods
+       */
+      static restoreConsole() {
+        console.log = this.originalConsole.log;
+        console.error = this.originalConsole.error;
+        console.warn = this.originalConsole.warn;
+        console.debug = this.originalConsole.debug;
+        console.info = this.originalConsole.info;
+      }
+    };
+    exports2.Logger = Logger;
+    Logger.config = {
+      enabled: true,
+      level: "info"
+    };
+    Logger.originalConsole = {
+      log: console.log,
+      error: console.error,
+      warn: console.warn,
+      debug: console.debug,
+      info: console.info
+    };
+    function configureLoggerFromEnvironment() {
+      const env = typeof process !== "undefined" ? process.env : {};
+      if (env.NEOZIP_DEBUG === "false") {
+        Logger.disable();
+      } else if (env.NEOZIP_DEBUG === "true") {
+        Logger.enable();
+        Logger.setLevel("debug");
+      }
+      if (env.NEOZIP_LOG_LEVEL) {
+        const level = env.NEOZIP_LOG_LEVEL;
+        if (["debug", "info", "warn", "error", "silent"].includes(level)) {
+          Logger.setLevel(level);
+        }
+      }
+      if (env.NODE_ENV === "production") {
+        Logger.setLevel("error");
+      }
+    }
+    __name(configureLoggerFromEnvironment, "configureLoggerFromEnvironment");
+    configureLoggerFromEnvironment();
+  }
+});
+
+// neozipkit/dist/core/encryption/types.js
+var require_types = __commonJS({
+  "neozipkit/dist/core/encryption/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EncryptionMethod = void 0;
+    var EncryptionMethod;
+    (function(EncryptionMethod2) {
+      EncryptionMethod2[EncryptionMethod2["NONE"] = 0] = "NONE";
+      EncryptionMethod2[EncryptionMethod2["ZIP_CRYPTO"] = 1] = "ZIP_CRYPTO";
+    })(EncryptionMethod || (exports2.EncryptionMethod = EncryptionMethod = {}));
+  }
+});
+
+// neozipkit/dist/core/encryption/ZipCrypto.js
+var require_ZipCrypto = __commonJS({
+  "neozipkit/dist/core/encryption/ZipCrypto.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DecryptionStream = exports2.ZipCrypto = void 0;
+    exports2.crc32 = crc32;
+    exports2.crc32update = crc32update;
+    exports2.sha256 = sha256;
+    var types_1 = require_types();
+    var Logger_12 = require_Logger();
+    var Headers_1 = require_Headers();
+    var crypto_1 = require("crypto");
+    var ZipCrypto = class _ZipCrypto {
+      static {
+        __name(this, "ZipCrypto");
+      }
+      canHandle(method) {
+        return method === types_1.EncryptionMethod.ZIP_CRYPTO;
+      }
+      getMethodName() {
+        return "ZIP-Crypto";
+      }
+      getKeyLength() {
+        return _ZipCrypto.KEY_LENGTH;
+      }
+      async encrypt(data, options) {
+        try {
+          if (options.method !== types_1.EncryptionMethod.ZIP_CRYPTO) {
+            return {
+              success: false,
+              error: "ZIP-Crypto encryption method required"
+            };
+          }
+          const keys = this.initKeys(options.password);
+          const encryptedData = Buffer.alloc(data.length);
+          for (let i = 0; i < data.length; i++) {
+            const byte = data[i];
+            const encryptedByte = this.encryptByte(keys, byte);
+            encryptedData[i] = encryptedByte;
+            this.updateKeys(keys, byte);
+          }
+          return {
+            success: true,
+            encryptedData
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown encryption error"
+          };
+        }
+      }
+      async decrypt(data, options) {
+        try {
+          if (options.method !== types_1.EncryptionMethod.ZIP_CRYPTO) {
+            return {
+              success: false,
+              error: "ZIP-Crypto decryption method required"
+            };
+          }
+          const keys = this.initKeys(options.password);
+          const decryptedData = Buffer.alloc(data.length);
+          for (let i = 0; i < data.length; i++) {
+            const encryptedByte = data[i];
+            const decryptedByte = this.decryptByte(keys, encryptedByte);
+            decryptedData[i] = decryptedByte;
+            this.updateKeys(keys, decryptedByte);
+          }
+          return {
+            success: true,
+            decryptedData
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown decryption error"
+          };
+        }
+      }
+      /**
+       * Verify password using check byte from decrypted header
+       * @param decryptedHeader - 12-byte decrypted encryption header
+       * @param checkByte - Expected check byte value
+       * @throws Error if password verification fails
+       */
+      verifyPassword(decryptedHeader, checkByte) {
+        if (decryptedHeader.length < 12) {
+          throw new Error("Decrypted header must be at least 12 bytes");
+        }
+        if (decryptedHeader[11] !== checkByte) {
+          throw new Error("Password verification FAILED");
+        }
+      }
+      /**
+       * Parse local header to extract information needed for decryption
+       * @param localHeaderBuffer - 30-byte local header buffer
+       * @param entry - ZIP entry to update with extracted information
+       * @returns Object with bitFlags, lastModTimeDate, localCrc, and checkByte
+       */
+      parseLocalHeaderForDecryption(localHeaderBuffer, entry) {
+        if (localHeaderBuffer.readUInt32LE(0) !== 67324752) {
+          throw new Error("Invalid local header signature");
+        }
+        const bitFlags = localHeaderBuffer.readUInt16LE(6);
+        const lastModTimeDate = localHeaderBuffer.readUInt32LE(10);
+        const localCrc = localHeaderBuffer.readUInt32LE(14);
+        if (bitFlags & Headers_1.GP_FLAG.DATA_DESC && (!entry.lastModTimeDate || entry.lastModTimeDate === 0)) {
+          entry.lastModTimeDate = lastModTimeDate;
+        }
+        entry.localCrc = localCrc;
+        let checkByte;
+        if (bitFlags & Headers_1.GP_FLAG.DATA_DESC) {
+          const timeDate = entry.lastModTimeDate || entry.timeDateDOS || 0;
+          checkByte = timeDate >> 8 & 255;
+        } else {
+          const crc = localCrc && localCrc !== 0 ? localCrc : entry.crc;
+          checkByte = crc >> 24 & 255;
+        }
+        return { bitFlags, lastModTimeDate, localCrc, checkByte };
+      }
+      /**
+       * Create encryption header (12 bytes) for PKZIP encryption
+       * Generates 11 random bytes + 1 check byte
+       * @param entry - ZIP entry to create header for
+       * @param password - Password for encryption (used to calculate check byte)
+       * @returns 12-byte encryption header buffer
+       */
+      createEncryptionHeader(entry, password) {
+        const header = Buffer.alloc(Headers_1.ENCRYPT_HDR_SIZE);
+        const random = (0, crypto_1.randomBytes)(11);
+        random.copy(header, 0);
+        let checkByte;
+        if ((entry.bitFlags & Headers_1.GP_FLAG.DATA_DESC) !== 0) {
+          const timeDate = entry.lastModTimeDate || entry.timeDateDOS || 0;
+          checkByte = timeDate >> 8 & 255;
+        } else {
+          checkByte = entry.crc >> 24 & 255;
+        }
+        header[11] = checkByte;
+        Logger_12.Logger.debug(`[ZipCrypto] Created encryption header: checkByte=0x${checkByte.toString(16).padStart(2, "0")}, DATA_DESC=${(entry.bitFlags & Headers_1.GP_FLAG.DATA_DESC) !== 0}`);
+        return header;
+      }
+      /**
+       * Encrypt buffer (header + compressed data) for PKZIP encryption
+       * Creates encryption header, concatenates with compressed data, and encrypts everything
+       * @param entry - ZIP entry to encrypt
+       * @param compressedData - Compressed data to encrypt
+       * @param password - Password for encryption
+       * @returns Encrypted buffer (encrypted header + encrypted compressed data)
+       */
+      encryptBuffer(entry, compressedData, password) {
+        const header = this.createEncryptionHeader(entry, password);
+        const dataToEncrypt = Buffer.concat([header, compressedData]);
+        const keys = this.initKeys(password);
+        const encryptedData = Buffer.alloc(dataToEncrypt.length);
+        for (let i = 0; i < dataToEncrypt.length; i++) {
+          const byte = dataToEncrypt[i];
+          const encryptedByte = this.encryptByte(keys, byte);
+          encryptedData[i] = encryptedByte;
+          this.updateKeys(keys, byte);
+        }
+        Logger_12.Logger.debug(`[ZipCrypto] Encrypted buffer: ${compressedData.length} bytes compressed data + ${Headers_1.ENCRYPT_HDR_SIZE} bytes header = ${encryptedData.length} bytes total`);
+        return encryptedData;
+      }
+      /**
+       * Decrypt buffer-based encrypted data (for in-memory extraction)
+       * Handles local header parsing, encryption header extraction, and decryption
+       * @param entry - ZIP entry with encryption information
+       * @param buffer - Full ZIP file buffer
+       * @param encryptedData - Encrypted data without header (from parseLocalHeader)
+       * @param password - Password for decryption
+       * @returns Decrypted compressed data (without header)
+       */
+      decryptBuffer(entry, buffer, encryptedData, password) {
+        const localData = buffer.subarray(entry.localHdrOffset);
+        const localHeaderBuffer = localData.subarray(0, 30);
+        const { bitFlags, localCrc, checkByte } = this.parseLocalHeaderForDecryption(localHeaderBuffer, entry);
+        const fnameLen = localHeaderBuffer.readUInt16LE(26);
+        const extraLen = localHeaderBuffer.readUInt16LE(28);
+        const localSize = 30 + fnameLen + extraLen;
+        const ENCRYPT_HDR_SIZE = 12;
+        const encryptHeader = localData.subarray(localSize, localSize + ENCRYPT_HDR_SIZE);
+        const encryptedDataWithHeader = Buffer.concat([encryptHeader, encryptedData]);
+        const keys = this.initKeys(password);
+        for (let i = 0; i < encryptedDataWithHeader.length; i++) {
+          const encryptedByte = encryptedDataWithHeader[i];
+          const decryptedByte = this.decryptByte(keys, encryptedByte);
+          encryptedDataWithHeader[i] = decryptedByte;
+          this.updateKeys(keys, decryptedByte);
+        }
+        const decryptedHeader = encryptedDataWithHeader.subarray(0, ENCRYPT_HDR_SIZE);
+        this.verifyPassword(decryptedHeader, checkByte);
+        return encryptedDataWithHeader.subarray(ENCRYPT_HDR_SIZE);
+      }
+      /**
+       * Create a streaming decryptor for chunked data processing
+       * Handles 12-byte header decryption and verification, then yields decrypted chunks
+       *
+       * MEMORY EFFICIENCY: This method processes encrypted data one block at a time.
+       * - Decryption state (keys) is maintained across blocks via updateKeys()
+       * - Only the minimum 12-byte header is accumulated before password verification
+       * - Each decrypted block is yielded immediately without accumulation
+       *
+       * @param password - Password for decryption
+       * @param checkByte - Expected check byte value for password verification
+       * @param encryptedStream - Async generator of encrypted data chunks (one block at a time)
+       * @returns Async generator of decrypted data chunks (one block at a time)
+       */
+      async *createStreamDecryptor(password, checkByte, encryptedStream) {
+        const keys = this.initKeys(password);
+        const ENCRYPT_HDR_SIZE = 12;
+        const headerBuffer = Buffer.alloc(ENCRYPT_HDR_SIZE);
+        let headerBytesCollected = 0;
+        let currentChunk = null;
+        let currentChunkOffset = 0;
+        while (headerBytesCollected < ENCRYPT_HDR_SIZE) {
+          if (!currentChunk || currentChunkOffset >= currentChunk.length) {
+            const result = await encryptedStream.next();
+            if (result.done || !result.value) {
+              throw new Error("ZIP-Crypto: insufficient encrypted data (missing encryption header)");
+            }
+            currentChunk = result.value;
+            currentChunkOffset = 0;
+          }
+          const bytesNeeded = ENCRYPT_HDR_SIZE - headerBytesCollected;
+          const bytesToCopy = Math.min(bytesNeeded, currentChunk.length - currentChunkOffset);
+          currentChunk.copy(headerBuffer, headerBytesCollected, currentChunkOffset, currentChunkOffset + bytesToCopy);
+          headerBytesCollected += bytesToCopy;
+          currentChunkOffset += bytesToCopy;
+        }
+        for (let i = 0; i < ENCRYPT_HDR_SIZE; i++) {
+          const encryptedByte = headerBuffer[i];
+          const decryptedByte = this.decryptByte(keys, encryptedByte) & 255;
+          headerBuffer[i] = decryptedByte;
+          this.updateKeys(keys, decryptedByte);
+        }
+        this.verifyPassword(headerBuffer, checkByte);
+        if (currentChunk && currentChunkOffset < currentChunk.length) {
+          const remainingInChunk = currentChunk.length - currentChunkOffset;
+          for (let i = 0; i < remainingInChunk; i++) {
+            const pos = currentChunkOffset + i;
+            const encryptedByte = currentChunk[pos];
+            const decryptedByte = this.decryptByte(keys, encryptedByte);
+            currentChunk[pos] = decryptedByte;
+            this.updateKeys(keys, decryptedByte);
+          }
+          yield currentChunk.subarray(currentChunkOffset);
+        }
+        for await (const encryptedChunk of encryptedStream) {
+          for (let i = 0; i < encryptedChunk.length; i++) {
+            const encryptedByte = encryptedChunk[i];
+            const decryptedByte = this.decryptByte(keys, encryptedByte);
+            encryptedChunk[i] = decryptedByte;
+            this.updateKeys(keys, decryptedByte);
+          }
+          yield encryptedChunk;
+        }
+      }
+      /**
+       * Initialize encryption keys from password
+       */
+      initKeys(password) {
+        const keys = [305419896, 591751049, 878082192];
+        for (let i = 0; i < password.length; i++) {
+          this.updateKeys(keys, password.charCodeAt(i));
+        }
+        return keys;
+      }
+      /**
+       * Update encryption keys with a byte
+       * Based on zip.js implementation - uses Math.imul for 32-bit integer multiplication
+       */
+      updateKeys(keys, byte) {
+        keys[0] = (keys[0] >>> 8 ^ _ZipCrypto.CRC_TABLE[(keys[0] ^ byte) & 255]) >>> 0;
+        keys[1] = (Math.imul(keys[1] + (keys[0] & 255), 134775813) + 1 & 4294967295) >>> 0;
+        keys[2] = (keys[2] >>> 8 ^ _ZipCrypto.CRC_TABLE[(keys[2] ^ keys[1] >>> 24) & 255]) >>> 0;
+      }
+      /**
+       * Encrypt a single byte
+       * Based on zip.js implementation - uses Math.imul for 32-bit integer multiplication
+       */
+      encryptByte(keys, byte) {
+        const temp = keys[2] | 2;
+        return (byte ^ Math.imul(temp, temp ^ 1) >>> 8) & 255;
+      }
+      /**
+       * Decrypt a single byte
+       * Based on zip.js implementation - uses Math.imul for 32-bit integer multiplication
+       */
+      decryptByte(keys, encryptedByte) {
+        const temp = keys[2] | 2;
+        return (encryptedByte ^ Math.imul(temp, temp ^ 1) >>> 8) & 255;
+      }
+      /**
+       * CRC32 implementation for ZIP crypto (single byte update)
+       * Used internally for key updates during encryption/decryption
+       */
+      crc32(crc, byte) {
+        return (crc >>> 8 ^ _ZipCrypto.CRC_TABLE[(crc ^ byte) & 255]) >>> 0;
+      }
+      /**
+       * Static CRC32 calculation for a full buffer
+       * Delegates to exported crc32() function
+       * @param buf - Buffer or string to calculate CRC32 for
+       * @returns CRC32 checksum as unsigned 32-bit integer
+       */
+      static crc32(buf) {
+        return crc32Impl(buf);
+      }
+      /**
+       * Static CRC32 incremental update (single byte)
+       * Delegates to exported crc32update() function
+       * @param crc - Current CRC32 value
+       * @param byte - Byte to update with
+       * @returns Updated CRC32 value
+       */
+      static crc32update(crc, byte) {
+        return crc32updateImpl(crc, byte);
+      }
+    };
+    exports2.ZipCrypto = ZipCrypto;
+    ZipCrypto.KEY_LENGTH = 3;
+    ZipCrypto.CRC_TABLE = [
+      0,
+      1996959894,
+      3993919788,
+      2567524794,
+      124634137,
+      1886057615,
+      3915621685,
+      2657392035,
+      249268274,
+      2044508324,
+      3772115230,
+      2547177864,
+      162941995,
+      2125561021,
+      3887607047,
+      2428444049,
+      498536548,
+      1789927666,
+      4089016648,
+      2227061214,
+      450548861,
+      1843258603,
+      4107580753,
+      2211677639,
+      325883990,
+      1684777152,
+      4251122042,
+      2321926636,
+      335633487,
+      1661365465,
+      4195302755,
+      2366115317,
+      997073096,
+      1281953886,
+      3579855332,
+      2724688242,
+      1006888145,
+      1258607687,
+      3524101629,
+      2768942443,
+      901097722,
+      1119000684,
+      3686517206,
+      2898065728,
+      853044451,
+      1172266101,
+      3705015759,
+      2882616665,
+      651767980,
+      1373503546,
+      3369554304,
+      3218104598,
+      565507253,
+      1454621731,
+      3485111705,
+      3099436303,
+      671266974,
+      1594198024,
+      3322730930,
+      2970347812,
+      795835527,
+      1483230225,
+      3244367275,
+      3060149565,
+      1994146192,
+      31158534,
+      2563907772,
+      4023717930,
+      1907459465,
+      112637215,
+      2680153253,
+      3904427059,
+      2013776290,
+      251722036,
+      2517215374,
+      3775830040,
+      2137656763,
+      141376813,
+      2439277719,
+      3865271297,
+      1802195444,
+      476864866,
+      2238001368,
+      4066508878,
+      1812370925,
+      453092731,
+      2181625025,
+      4111451223,
+      1706088902,
+      314042704,
+      2344532202,
+      4240017532,
+      1658658271,
+      366619977,
+      2362670323,
+      4224994405,
+      1303535960,
+      984961486,
+      2747007092,
+      3569037538,
+      1256170817,
+      1037604311,
+      2765210733,
+      3554079995,
+      1131014506,
+      879679996,
+      2909243462,
+      3663771856,
+      1141124467,
+      855842277,
+      2852801631,
+      3708648649,
+      1342533948,
+      654459306,
+      3188396048,
+      3373015174,
+      1466479909,
+      544179635,
+      3110523913,
+      3462522015,
+      1591671054,
+      702138776,
+      2966460450,
+      3352799412,
+      1504918807,
+      783551873,
+      3082640443,
+      3233442989,
+      3988292384,
+      2596254646,
+      62317068,
+      1957810842,
+      3939845945,
+      2647816111,
+      81470997,
+      1943803523,
+      3814918930,
+      2489596804,
+      225274430,
+      2053790376,
+      3826175755,
+      2466906013,
+      167816743,
+      2097651377,
+      4027552580,
+      2265490386,
+      503444072,
+      1762050814,
+      4150417245,
+      2154129355,
+      426522225,
+      1852507879,
+      4275313526,
+      2312317920,
+      282753626,
+      1742555852,
+      4189708143,
+      2394877945,
+      397917763,
+      1622183637,
+      3604390888,
+      2714866558,
+      953729732,
+      1340076626,
+      3518719985,
+      2797360999,
+      1068828381,
+      1219638859,
+      3624741850,
+      2936675148,
+      906185462,
+      1090812512,
+      3747672003,
+      2825379669,
+      829329135,
+      1181335161,
+      3412177804,
+      3160834842,
+      628085408,
+      1382605366,
+      3423369109,
+      3138078467,
+      570562233,
+      1426400815,
+      3317316542,
+      2998733608,
+      733239954,
+      1555261956,
+      3268935591,
+      3050360625,
+      752459403,
+      1541320221,
+      2607071920,
+      3965973030,
+      1969922972,
+      40735498,
+      2617837225,
+      3943577151,
+      1913087877,
+      83908371,
+      2512341634,
+      3803740692,
+      2075208622,
+      213261112,
+      2463272603,
+      3855990285,
+      2094854071,
+      198958881,
+      2262029012,
+      4057260610,
+      1759359992,
+      534414190,
+      2176718541,
+      4139329115,
+      1873836001,
+      414664567,
+      2282248934,
+      4279200368,
+      1711684554,
+      285281116,
+      2405801727,
+      4167216745,
+      1634467795,
+      376229701,
+      2685067896,
+      3608007406,
+      1308918612,
+      956543938,
+      2808555105,
+      3495958263,
+      1231636301,
+      1047427035,
+      2932959818,
+      3654703836,
+      1088359270,
+      936918e3,
+      2847714899,
+      3736837829,
+      1202900863,
+      817233897,
+      3183342108,
+      3401237130,
+      1404277552,
+      615818150,
+      3134207493,
+      3453421203,
+      1423857449,
+      601450431,
+      3009837614,
+      3294710456,
+      1567103746,
+      711928724,
+      3020668471,
+      3272380065,
+      1510334235,
+      755167117
+    ];
+    function crc32Impl(buf) {
+      if (typeof buf === "string") {
+        buf = Buffer.from(buf, "utf8");
+      }
+      let len = buf.length;
+      let crc = ~0;
+      for (let off = 0; off < len; ) {
+        crc = ZipCrypto.CRC_TABLE[(crc ^ buf[off++]) & 255] ^ crc >>> 8;
+      }
+      return ~crc >>> 0;
+    }
+    __name(crc32Impl, "crc32Impl");
+    function crc32updateImpl(crc, byte) {
+      return ZipCrypto.CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+    }
+    __name(crc32updateImpl, "crc32updateImpl");
+    function crc32(buf) {
+      return crc32Impl(buf);
+    }
+    __name(crc32, "crc32");
+    function crc32update(crc, byte) {
+      return crc32updateImpl(crc, byte);
+    }
+    __name(crc32update, "crc32update");
+    var crypto_2 = require("crypto");
+    function sha256(data) {
+      const hash = (0, crypto_2.createHash)("sha256");
+      return hash.update(data).digest("hex");
+    }
+    __name(sha256, "sha256");
+    var DecryptionStream = class {
+      static {
+        __name(this, "DecryptionStream");
+      }
+      constructor(options) {
+        this.password = options.password;
+        this.method = options.method;
+        this.entry = options.entry;
+        this.zipCrypto = new ZipCrypto();
+      }
+      /**
+       * Decrypt compressed data stream chunk by chunk
+       */
+      async *decrypt(encryptedStream) {
+        if (this.method !== types_1.EncryptionMethod.ZIP_CRYPTO) {
+          throw new Error(`Unsupported encryption method: ${this.method}`);
+        }
+        const checkByte = this.calculateCheckByte();
+        yield* this.zipCrypto.createStreamDecryptor(this.password, checkByte, encryptedStream);
+      }
+      /**
+       * Calculate check byte for password verification
+       * For DATA_DESC files: lastModTimeDate >> 8
+       * For non-DATA_DESC files: CRC >> 24
+       */
+      calculateCheckByte() {
+        if (this.entry.bitFlags & Headers_1.GP_FLAG.DATA_DESC) {
+          let lastModTimeDate = this.entry.lastModTimeDate;
+          if (!lastModTimeDate || lastModTimeDate === 0) {
+            lastModTimeDate = this.entry.timeDateDOS || 0;
+          }
+          const checkByte = lastModTimeDate >> 8 & 255;
+          return checkByte;
+        } else {
+          const crc = this.entry.localCrc && this.entry.localCrc !== 0 ? this.entry.localCrc : this.entry.crc;
+          const checkByte = crc >> 24 & 255;
+          return checkByte;
+        }
+      }
+      /**
+       * Prepare entry for decryption by parsing local header from file handle
+       * This extracts the information needed for check byte calculation
+       * @param fileHandle - File handle to read from
+       * @param entry - ZIP entry to update
+       * @returns Check byte value for password verification
+       */
+      static async prepareEntryForDecryption(fileHandle, entry) {
+        const localHeaderBuffer = Buffer.alloc(30);
+        await fileHandle.read(localHeaderBuffer, 0, 30, entry.localHdrOffset);
+        const zipCrypto = new ZipCrypto();
+        const { checkByte } = zipCrypto.parseLocalHeaderForDecryption(localHeaderBuffer, entry);
+        return checkByte;
+      }
+    };
+    exports2.DecryptionStream = DecryptionStream;
+  }
+});
+
+// neozipkit/dist/core/ZipEntry.js
+var require_ZipEntry = __commonJS({
+  "neozipkit/dist/core/ZipEntry.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ZipEntry = void 0;
+    var Errors_1 = __importDefault2(require_Errors());
+    var Headers_1 = require_Headers();
+    var Logger_12 = require_Logger();
+    var ZipCrypto_12 = require_ZipCrypto();
+    var VER_ENCODING = 30;
+    var VER_EXTRACT = 10;
+    var ZipEntry = class {
+      static {
+        __name(this, "ZipEntry");
+      }
+      /**
+       * Creates a new ZIP entry
+       * @param fname - Name of the file within the ZIP
+       * @param comment - Optional comment for this entry
+       * @param debug - Enable debug logging
+       */
+      constructor(fname, comment, debug) {
+        this.debug = true;
+        this.verMadeBy = 0;
+        this.verExtract = 0;
+        this.bitFlags = 0;
+        this.cmpMethod = 0;
+        this.timeDateDOS = 0;
+        this.crc = 0;
+        this.compressedSize = 0;
+        this.uncompressedSize = 0;
+        this.volNumber = 0;
+        this.intFileAttr = 0;
+        this.extFileAttr = 0;
+        this.localHdrOffset = 0;
+        this.filename = "";
+        this.extraField = null;
+        this.comment = null;
+        this.fileBuffer = null;
+        this.cmpData = null;
+        this.isEncrypted = false;
+        this.isStrongEncrypt = false;
+        this.encryptHdr = null;
+        this.lastModTimeDate = 0;
+        this.decrypt = null;
+        this.isUpdated = true;
+        this.isDirectory = false;
+        this.isMetaData = false;
+        this.platform = null;
+        this.universalTime = null;
+        this.uid = null;
+        this.gid = null;
+        this.sha256 = null;
+        this.isSymlink = false;
+        this.linkTarget = null;
+        this.isHardLink = false;
+        this.originalEntry = null;
+        this.inode = null;
+        this.isMSDOS = this.platform === null;
+        this.isUnixLike = this.platform != null && this.platform !== "win32";
+        this.isMacOS = this.platform != null && this.platform === "darwin";
+        this.isLinux = this.platform != null && this.platform === "linux";
+        this.VER_MADE_BY = (() => {
+          switch (this.platform) {
+            case "darwin":
+              return Headers_1.FILE_SYSTEM.DARWIN << 8 | VER_ENCODING;
+            case "win32":
+              return Headers_1.FILE_SYSTEM.NTFS << 8 | VER_ENCODING;
+            default:
+              return Headers_1.FILE_SYSTEM.UNIX << 8 | VER_ENCODING;
+          }
+        })();
+        this.filename = fname || "";
+        this.comment = comment || null;
+        this.debug = debug || false;
+        this.bitFlags |= Headers_1.GP_FLAG.EFS;
+      }
+      /**
+       * Reads ZIP entry data from a central directory buffer
+       * @param data - Buffer containing central directory entry data
+       * @returns Buffer positioned at start of next entry
+       * @throws Error if central directory entry is invalid
+       */
+      readZipEntry(data) {
+        if (data.length < Headers_1.CENTRAL_DIR.SIZE) {
+          throw new Error("Zip entry data is too small or corrupt");
+        }
+        if (data.readUInt32LE(0) !== Headers_1.CENTRAL_DIR.SIGNATURE) {
+          throw new Error(Errors_1.default.INVALID_CEN);
+        }
+        this.verMadeBy = data.readUInt16LE(Headers_1.CENTRAL_DIR.VER_MADE);
+        this.verExtract = data.readUInt16LE(Headers_1.CENTRAL_DIR.VER_EXT);
+        this.bitFlags = data.readUInt16LE(Headers_1.CENTRAL_DIR.FLAGS);
+        if ((this.bitFlags & Headers_1.GP_FLAG.ENCRYPTED) != 0) {
+          this.isEncrypted = true;
+          if ((this.bitFlags & Headers_1.GP_FLAG.STRONG_ENCRYPT) != 0)
+            this.isStrongEncrypt = true;
+        }
+        this.cmpMethod = data.readUInt16LE(Headers_1.CENTRAL_DIR.CMP_METHOD);
+        this.timeDateDOS = data.readUInt32LE(Headers_1.CENTRAL_DIR.TIMEDATE_DOS);
+        this.crc = data.readUInt32LE(Headers_1.CENTRAL_DIR.CRC);
+        this.compressedSize = data.readUInt32LE(Headers_1.CENTRAL_DIR.CMP_SIZE);
+        this.uncompressedSize = data.readUInt32LE(Headers_1.CENTRAL_DIR.UNCMP_SIZE);
+        this.volNumber = data.readUInt16LE(Headers_1.CENTRAL_DIR.DISK_NUM);
+        this.intFileAttr = data.readUInt16LE(Headers_1.CENTRAL_DIR.INT_FILE_ATTR);
+        this.extFileAttr = data.readUInt32LE(Headers_1.CENTRAL_DIR.EXT_FILE_ATTR);
+        if (this.extFileAttr & Headers_1.DOS_FILE_ATTR.DIRECTORY)
+          this.isDirectory = true;
+        this.localHdrOffset = data.readUInt32LE(Headers_1.CENTRAL_DIR.LOCAL_HDR_OFFSET);
+        let fnameLen = data.readUInt16LE(Headers_1.CENTRAL_DIR.FNAME_LEN);
+        const filename = data.toString("utf8", Headers_1.CENTRAL_DIR.SIZE, Headers_1.CENTRAL_DIR.SIZE + fnameLen);
+        this.filename = filename;
+        if (this.filename.endsWith("/"))
+          this.isDirectory = true;
+        let extraLen = data.readUInt16LE(Headers_1.CENTRAL_DIR.EXTRA_LEN);
+        if (extraLen > 0) {
+          this.extraField = data.subarray(Headers_1.CENTRAL_DIR.SIZE + fnameLen, Headers_1.CENTRAL_DIR.SIZE + fnameLen + extraLen);
+          for (let i = 0; i < extraLen; ) {
+            let _id = this.extraField.readUInt16LE(i);
+            let _len = this.extraField.readUInt16LE(i + 2);
+            let _data = this.extraField.subarray(i + 4, i + 4 + _len);
+            if (_id === Headers_1.HDR_ID.UNICODE_PATH && _len >= 5) {
+              const version = _data.readUInt8(0);
+              const nameCrc32 = _data.readUInt32LE(1);
+              const fnameBuf = Buffer.from(this.filename);
+              const calculatedCrc = (0, ZipCrypto_12.crc32)(fnameBuf);
+              if (calculatedCrc === nameCrc32) {
+                const unicodeName = _data.subarray(5).toString("utf8");
+                this.filename = unicodeName;
+                if (this.debug) {
+                  Logger_12.Logger.log(`Using Unicode Path: ${this.filename}`);
+                }
+              }
+            }
+            i += 4 + _len;
+          }
+          for (let i = 0; i < extraLen; ) {
+            let _id = this.extraField.readUInt16LE(i);
+            let _len = this.extraField.readUInt16LE(i + 2);
+            let _data = this.extraField.subarray(i + 4, i + 4 + _len);
+            if (_id === Headers_1.HDR_ID.SHA256) {
+              if (_len === 64)
+                this.sha256 = _data.toString("utf8");
+              else
+                this.sha256 = _data.toString("hex");
+            } else if (_id === Headers_1.HDR_ID.UNV_TIME) {
+              if (_len >= 5) {
+                const flags = _data.readUInt8(0);
+                if (flags & 1) {
+                  this.universalTime = _data.readUInt32LE(1);
+                }
+              }
+            } else if (_id === Headers_1.HDR_ID.UID_GID) {
+              if (_len >= 5) {
+                const version = _data.readUInt8(0);
+                const uidSize = _data.readUInt8(1);
+                if (uidSize <= 4 && _len >= 2 + uidSize) {
+                  this.uid = _data.readUIntLE(2, uidSize);
+                  if (_len >= 2 + uidSize + 1) {
+                    const gidSize = _data.readUInt8(2 + uidSize);
+                    if (gidSize <= 4 && _len >= 2 + uidSize + 1 + gidSize) {
+                      this.gid = _data.readUIntLE(2 + uidSize + 1, gidSize);
+                    }
+                  }
+                }
+              }
+            } else if (_id === Headers_1.HDR_ID.SYMLINK) {
+              if (_len >= 3) {
+                const version = _data.readUInt8(0);
+                const targetLength = _data.readUInt16LE(1);
+                if (targetLength > 0 && _len >= 3 + targetLength) {
+                  this.isSymlink = true;
+                  this.linkTarget = _data.subarray(3, 3 + targetLength).toString("utf8");
+                }
+              }
+            } else if (_id === Headers_1.HDR_ID.HARDLINK) {
+              if (_len >= 11) {
+                const version = _data.readUInt8(0);
+                this.inode = _data.readUInt32LE(1);
+                const originalLength = _data.readUInt16LE(5);
+                if (originalLength > 0 && _len >= 7 + originalLength) {
+                  this.isHardLink = true;
+                  this.originalEntry = _data.subarray(7, 7 + originalLength).toString("utf8");
+                }
+              }
+            }
+            i += 4 + _len;
+          }
+        }
+        let comLen = data.readUInt16LE(Headers_1.CENTRAL_DIR.COMMENT_LEN);
+        if (comLen > 0)
+          this.comment = data.toString("utf8", Headers_1.CENTRAL_DIR.SIZE + fnameLen, Headers_1.CENTRAL_DIR.SIZE + fnameLen + comLen);
+        if (this.debug)
+          this.showVerboseInfo();
+        let rawSize = Headers_1.CENTRAL_DIR.SIZE + fnameLen + extraLen + comLen;
+        return data.subarray(rawSize);
+      }
+      /**
+       * Checks if the filename contains characters that require Unicode handling
+       * @returns true if the filename contains non-ASCII characters or special characters
+       */
+      needsUnicodeHandling() {
+        return /[^\x00-\x7E]|['"]/.test(this.filename);
+      }
+      /**
+       * Adds UTF-8 Unicode Path field to a buffer
+       * @param buffer - The buffer to write to
+       * @param offset - The offset in the buffer to start writing
+       * @returns The new offset after writing
+       */
+      addUnicodePathField(buffer, offset) {
+        const unicodePathBuf = Buffer.from(this.filename, "utf8");
+        const asciiName = this.filename.replace(/[^\x00-\x7E]/g, "?");
+        const asciiNameBuf = Buffer.from(asciiName, "ascii");
+        const nameCrc32 = (0, ZipCrypto_12.crc32)(asciiNameBuf);
+        const unicodePathLen = 5 + unicodePathBuf.length;
+        buffer.writeUInt16LE(Headers_1.HDR_ID.UNICODE_PATH, offset);
+        buffer.writeUInt16LE(unicodePathLen, offset + 2);
+        buffer.writeUInt8(1, offset + 4);
+        buffer.writeUInt32LE(nameCrc32, offset + 5);
+        unicodePathBuf.copy(buffer, offset + 9);
+        return offset + 4 + unicodePathLen;
+      }
+      /**
+       * Creates a local header for this ZIP entry
+       * @returns Buffer containing the local header data
+       */
+      createLocalHdr() {
+        let extraFieldLen = 0;
+        const needsUnicode = this.needsUnicodeHandling();
+        if (needsUnicode) {
+          const unicodeNameLen = Buffer.from(this.filename, "utf8").length;
+          extraFieldLen = 5 + unicodeNameLen + 4;
+        }
+        const data = Buffer.alloc(Headers_1.LOCAL_HDR.SIZE + this.filename.length + extraFieldLen);
+        data.writeUInt32LE(Headers_1.LOCAL_HDR.SIGNATURE, 0);
+        data.writeUInt16LE(VER_EXTRACT, Headers_1.LOCAL_HDR.VER_EXTRACT);
+        data.writeUInt16LE(this.bitFlags >>> 0, Headers_1.LOCAL_HDR.FLAGS);
+        data.writeUInt16LE(this.cmpMethod, Headers_1.LOCAL_HDR.COMPRESSION);
+        data.writeUInt32LE(this.timeDateDOS >>> 0, Headers_1.LOCAL_HDR.TIMEDATE_DOS);
+        data.writeUInt32LE(this.crc, Headers_1.LOCAL_HDR.CRC);
+        data.writeUInt32LE(this.compressedSize, Headers_1.LOCAL_HDR.CMP_SIZE);
+        data.writeUInt32LE(this.uncompressedSize, Headers_1.LOCAL_HDR.UNCMP_SIZE);
+        data.writeUInt16LE(this.filename.length, Headers_1.LOCAL_HDR.FNAME_LEN);
+        data.writeUInt16LE(extraFieldLen, Headers_1.LOCAL_HDR.EXTRA_LEN);
+        const asciiName = this.filename.replace(/[^\x00-\x7E]/g, "?");
+        const fnameBuf = Buffer.from(asciiName);
+        fnameBuf.copy(data, Headers_1.LOCAL_HDR.SIZE);
+        let extraOffset = Headers_1.LOCAL_HDR.SIZE + fnameBuf.length;
+        if (needsUnicode) {
+          extraOffset = this.addUnicodePathField(data, extraOffset);
+        }
+        return data;
+      }
+      /**
+       * Creates a central directory entry for this ZIP entry
+       * @returns Buffer containing the central directory entry data
+       */
+      centralDirEntry() {
+        const commentLen = this.comment ? Buffer.from(this.comment, "utf8").length : 0;
+        const utfLen = this.universalTime ? 9 : 0;
+        const uidgidLen = this.uid && this.gid ? 11 + 4 : 0;
+        const sha256Buf = this.sha256 ? Buffer.from(this.sha256, "hex") : null;
+        const sha256Len = sha256Buf ? sha256Buf.length + 4 : 0;
+        const symlinkLen = this.isSymlink && this.linkTarget ? 4 + 1 + 2 + Buffer.byteLength(this.linkTarget, "utf8") : 0;
+        const hardlinkLen = this.isHardLink && this.originalEntry && this.inode !== null ? 4 + 1 + 4 + 2 + Buffer.byteLength(this.originalEntry, "utf8") : 0;
+        const needsUnicode = this.needsUnicodeHandling();
+        let unicodePathLen = 0;
+        if (needsUnicode) {
+          const unicodeNameLen = Buffer.from(this.filename, "utf8").length;
+          unicodePathLen = 5 + unicodeNameLen + 4;
+        }
+        const extraLen = utfLen + sha256Len + uidgidLen + symlinkLen + hardlinkLen + (needsUnicode ? unicodePathLen : 0);
+        const asciiName = this.filename.replace(/[^\x00-\x7E]/g, "?");
+        const fnameLen = asciiName.length;
+        const data = Buffer.alloc(Headers_1.CENTRAL_DIR.SIZE + fnameLen + commentLen + extraLen);
+        data.writeUInt32LE(Headers_1.CENTRAL_DIR.SIGNATURE, 0);
+        data.writeUInt16LE(this.isUpdated ? this.VER_MADE_BY : this.verMadeBy, Headers_1.CENTRAL_DIR.VER_MADE);
+        data.writeInt16LE(this.isUpdated ? VER_EXTRACT : this.verMadeBy, Headers_1.CENTRAL_DIR.VER_EXT);
+        data.writeInt16LE(this.bitFlags >>> 0, Headers_1.CENTRAL_DIR.FLAGS);
+        data.writeInt16LE(this.cmpMethod, Headers_1.CENTRAL_DIR.CMP_METHOD);
+        data.writeUInt32LE(this.timeDateDOS >>> 0, Headers_1.CENTRAL_DIR.TIMEDATE_DOS);
+        data.writeUInt32LE(this.crc, Headers_1.CENTRAL_DIR.CRC);
+        data.writeUInt32LE(this.compressedSize, Headers_1.CENTRAL_DIR.CMP_SIZE);
+        data.writeUInt32LE(this.uncompressedSize, Headers_1.CENTRAL_DIR.UNCMP_SIZE);
+        data.writeUInt16LE(this.filename.length, Headers_1.CENTRAL_DIR.FNAME_LEN);
+        data.writeUInt16LE(extraLen, Headers_1.CENTRAL_DIR.EXTRA_LEN);
+        data.writeUInt16LE(commentLen, Headers_1.CENTRAL_DIR.COMMENT_LEN);
+        data.writeUInt16LE(0, Headers_1.CENTRAL_DIR.DISK_NUM);
+        data.writeUInt16LE(this.intFileAttr >>> 0, Headers_1.CENTRAL_DIR.INT_FILE_ATTR);
+        data.writeUInt32LE(this.extFileAttr >>> 0, Headers_1.CENTRAL_DIR.EXT_FILE_ATTR);
+        data.writeUInt32LE(this.localHdrOffset, Headers_1.CENTRAL_DIR.LOCAL_HDR_OFFSET);
+        const fnameBuf = Buffer.from(asciiName);
+        fnameBuf.copy(data, Headers_1.CENTRAL_DIR.SIZE);
+        let currentOffset = Headers_1.CENTRAL_DIR.SIZE + fnameLen;
+        if (commentLen > 0 && this.comment) {
+          const commentBuf = Buffer.from(this.comment, "utf8");
+          commentBuf.copy(data, currentOffset);
+          currentOffset += commentLen;
+        }
+        let extraOffset = currentOffset;
+        if (this.universalTime) {
+          data.writeUInt16LE(Headers_1.HDR_ID.UNV_TIME, extraOffset);
+          data.writeUInt16LE(5, extraOffset + 2);
+          data.writeUInt8(1, extraOffset + 4);
+          data.writeUInt32LE(Math.floor(Date.now() / 1e3), extraOffset + 5);
+          extraOffset += 9;
+        }
+        if (sha256Buf) {
+          data.writeUInt16LE(Headers_1.HDR_ID.SHA256, extraOffset);
+          data.writeUInt16LE(sha256Buf.length, extraOffset + 2);
+          sha256Buf.copy(data, extraOffset + 4);
+          extraOffset += 4 + sha256Buf.length;
+        }
+        if (this.uid && this.gid) {
+          data.writeUInt16LE(Headers_1.HDR_ID.UID_GID, extraOffset);
+          data.writeUInt16LE(11, extraOffset + 2);
+          data.writeUInt8(1, extraOffset + 4);
+          data.writeUInt8(4, extraOffset + 5);
+          data.writeUInt32LE(this.uid, extraOffset + 6);
+          data.writeUInt8(4, extraOffset + 10);
+          data.writeUInt32LE(this.gid, extraOffset + 11);
+          extraOffset += 15;
+        }
+        if (this.isSymlink && this.linkTarget) {
+          const targetBuf = Buffer.from(this.linkTarget, "utf8");
+          const dataLen = 1 + 2 + targetBuf.length;
+          data.writeUInt16LE(Headers_1.HDR_ID.SYMLINK, extraOffset);
+          data.writeUInt16LE(dataLen, extraOffset + 2);
+          data.writeUInt8(1, extraOffset + 4);
+          data.writeUInt16LE(targetBuf.length, extraOffset + 5);
+          targetBuf.copy(data, extraOffset + 7);
+          extraOffset += 4 + dataLen;
+        }
+        if (this.isHardLink && this.originalEntry && this.inode !== null) {
+          const originalBuf = Buffer.from(this.originalEntry, "utf8");
+          const dataLen = 1 + 4 + 2 + originalBuf.length;
+          data.writeUInt16LE(Headers_1.HDR_ID.HARDLINK, extraOffset);
+          data.writeUInt16LE(dataLen, extraOffset + 2);
+          data.writeUInt8(1, extraOffset + 4);
+          data.writeUInt32LE(this.inode, extraOffset + 5);
+          data.writeUInt16LE(originalBuf.length, extraOffset + 9);
+          originalBuf.copy(data, extraOffset + 11);
+          extraOffset += 4 + dataLen;
+        }
+        if (needsUnicode) {
+          extraOffset = this.addUnicodePathField(data, extraOffset);
+        }
+        return data;
+      }
+      // ======================================
+      //	Routines to handle the details of the Zip Entry
+      // ======================================
+      /**
+       * Sets the DOS date/time for this entry
+       * @param date - Date to convert to DOS format
+       * @returns number - DOS format date/time
+       */
+      setDateTime(date) {
+        if (!date)
+          return 0;
+        const year = date.getFullYear() - 1980;
+        const month = date.getMonth() + 1;
+        const day = date.getDate();
+        const hour = date.getHours();
+        const minute = date.getMinutes();
+        const second = date.getSeconds();
+        const datePart = (year & 127) << 9 | (month & 15) << 5 | day & 31;
+        const timePart = (hour & 31) << 11 | (minute & 63) << 5 | second >> 1 & 31;
+        const time = datePart << 16 | timePart;
+        return time;
+      }
+      /**
+       * Converts DOS date/time to JavaScript Date
+       * @param timeStamp - DOS format date/time
+       * @returns Date object or null if timestamp is 0
+       */
+      parseDateTime(timeStamp) {
+        if (timeStamp == 0)
+          return null;
+        const datePart = timeStamp >> 16 & 65535;
+        const year = (datePart >> 9 & 127) + 1980;
+        const month = (datePart >> 5 & 15) - 1;
+        const day = datePart & 31;
+        const timePart = timeStamp & 65535;
+        const hour = timePart >> 11 & 31;
+        const minute = timePart >> 5 & 63;
+        const second = (timePart & 31) << 1;
+        return new Date(year, month, day, hour, minute, second);
+      }
+      /**
+       * Formats the entry's date in local format
+       * @returns String in MM/DD/YYYY format or "--/--/----" if no date
+       */
+      toLocalDateString() {
+        let _timeDate = this.parseDateTime(this.timeDateDOS);
+        if (_timeDate === null)
+          return "--/--/----";
+        return _timeDate.toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "2-digit",
+          day: "2-digit"
+        }).slice(0, 10);
+      }
+      /**
+       * Formats the entry's time
+       * @returns String in HH:MM format or "--:--" if no time
+       */
+      toTimeString() {
+        let _timeDate = this.parseDateTime(this.timeDateDOS);
+        if (_timeDate === null)
+          return "--:--";
+        return _timeDate.toTimeString().slice(0, 5);
+      }
+      /**
+       * Formats the entry's date and time in local format
+       * @returns String like "Jan 01, 2024 13:45:30" or "--/--/-- --:--" if no date/time
+       */
+      toFormattedDateString() {
+        let _timeDate = this.parseDateTime(this.timeDateDOS);
+        if (_timeDate == null)
+          return "--/--/-- --:--";
+        const datePart = _timeDate.toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "short",
+          day: "2-digit"
+        });
+        const timePart = _timeDate.toLocaleTimeString("en-US", {
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+          hour12: false
+        });
+        return `${datePart} ${timePart}`;
+      }
+      /**
+       * Formats the entry's date and time in UTC
+       * @returns String like "Jan 01, 2024 13:45:30 UTC" or "--/--/-- --:--" if no date/time
+       */
+      toFormattedUTCDateString() {
+        let _timeDate = this.parseDateTime(this.timeDateDOS);
+        if (_timeDate == null)
+          return "--/--/-- --:--";
+        const datePart = _timeDate.toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "short",
+          day: "2-digit",
+          timeZone: "UTC"
+        });
+        const timePart = _timeDate.toLocaleTimeString("en-US", {
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+          hour12: false,
+          timeZone: "UTC"
+        });
+        return `${datePart} ${timePart} UTC`;
+      }
+      /**
+       * Converts compression method code to human-readable string
+       * @returns String describing the compression method
+       */
+      cmpMethodToString() {
+        switch (this.cmpMethod) {
+          case Headers_1.CMP_METHOD.STORED:
+            return "Stored";
+          case Headers_1.CMP_METHOD.SHRUNK:
+            return "Shrunk";
+          case Headers_1.CMP_METHOD.REDUCED1:
+            return "Reduced-1";
+          case Headers_1.CMP_METHOD.REDUCED2:
+            return "Reduced-2";
+          case Headers_1.CMP_METHOD.REDUCED3:
+            return "Reduced-3";
+          case Headers_1.CMP_METHOD.REDUCED4:
+            return "Reduced-4";
+          case Headers_1.CMP_METHOD.IMPLODED:
+            return "Imploded";
+          case Headers_1.CMP_METHOD.DEFLATED:
+            switch (this.bitFlags & 6) {
+              case 0:
+                return "Deflate-N";
+              case 2:
+                return "Deflate-M";
+              case 4:
+                return "Deflate-F";
+              case 6:
+                return "Deflate-S";
+            }
+          case Headers_1.CMP_METHOD.ENHANCED_DEFLATE:
+            return "Deflate-Enh";
+          case Headers_1.CMP_METHOD.IBM_TERSE:
+            return "PKDCL-LZ77";
+          case Headers_1.CMP_METHOD.ZSTD:
+            return "Zstandard";
+          default:
+            return "Unknown";
+        }
+      }
+      /**
+       * Converts file system code to human-readable string
+       * @returns String describing the file system
+       */
+      fileSystemToString() {
+        switch (this.verMadeBy >> 8) {
+          case Headers_1.FILE_SYSTEM.MSDOS:
+            return "MS-DOS";
+          case Headers_1.FILE_SYSTEM.AMIGA:
+            return "Amiga";
+          case Headers_1.FILE_SYSTEM.OPENVMS:
+            return "OpenVMS";
+          case Headers_1.FILE_SYSTEM.UNIX:
+            return "Unix";
+          case Headers_1.FILE_SYSTEM.VM_CMS:
+            return "VM/CMS";
+          case Headers_1.FILE_SYSTEM.ATARI:
+            return "Atari ST";
+          case Headers_1.FILE_SYSTEM.OS2:
+            return "OS/2 HPFS";
+          case Headers_1.FILE_SYSTEM.MAC:
+            return "Macintosh";
+          case Headers_1.FILE_SYSTEM.CP_M:
+            return "CP/M";
+          case Headers_1.FILE_SYSTEM.NTFS:
+            return "Windows NTFS";
+          case Headers_1.FILE_SYSTEM.MVS:
+            return "MVS (OS/390 - Z/OS)";
+          case Headers_1.FILE_SYSTEM.VSE:
+            return "VSE";
+          case Headers_1.FILE_SYSTEM.ACORN:
+            return "Acorn Risc";
+          case Headers_1.FILE_SYSTEM.ALTMVS:
+            return "Alternate MVS";
+          case Headers_1.FILE_SYSTEM.BEOS:
+            return "BeOS";
+          case Headers_1.FILE_SYSTEM.TANDEM:
+            return "Tandem";
+          case Headers_1.FILE_SYSTEM.OS400:
+            return "OS/400";
+          case Headers_1.FILE_SYSTEM.DARWIN:
+            return "Apple OS/X (Darwin)";
+          default:
+            return "Unknown";
+        }
+      }
+      /**
+       * Converts MS-DOS file attributes to string representation
+       * @returns String like "----" where R=readonly, H=hidden, S=system, A=archive
+       */
+      dosAttributesToString() {
+        let dosAttr = this.extFileAttr & 65535;
+        if (dosAttr === 0)
+          return "none";
+        let attrs = "";
+        attrs += dosAttr & Headers_1.DOS_FILE_ATTR.READONLY ? "r" : "-";
+        attrs += dosAttr & Headers_1.DOS_FILE_ATTR.HIDDEN ? "h" : "-";
+        attrs += dosAttr & Headers_1.DOS_FILE_ATTR.SYSTEM ? "s" : "-";
+        attrs += dosAttr & Headers_1.DOS_FILE_ATTR.DIRECTORY ? "d" : "-";
+        attrs += dosAttr & Headers_1.DOS_FILE_ATTR.ARCHIVE ? "a" : "-";
+        return attrs;
+      }
+      /**
+       * Outputs detailed information about this entry for debugging
+       * Includes compression, encryption, timestamps, and extra fields
+       */
+      showVerboseInfo() {
+        Logger_12.Logger.log("=== Central Directory Entry (%s) ===", this.filename);
+        Logger_12.Logger.log("unzip from start of archive: ", this.localHdrOffset);
+        Logger_12.Logger.log("File system or operating system of origin:    ", this.fileSystemToString());
+        Logger_12.Logger.log("Version of encoding software:                 ", this.verMadeBy);
+        Logger_12.Logger.log("Compression Method:                           ", this.cmpMethodToString());
+        Logger_12.Logger.log("File Security Status:                         ", this.bitFlags & Headers_1.GP_FLAG.ENCRYPTED ? this.bitFlags & Headers_1.GP_FLAG.STRONG_ENCRYPT ? "Strong Encrypt" : "Encrypted" : "Not Encrypted");
+        Logger_12.Logger.log("File Modified (DOS date/time)                 ", this.toFormattedDateString());
+        Logger_12.Logger.log("File Modified (UTC)                           ", this.toFormattedUTCDateString());
+        Logger_12.Logger.log("Compressed Size:                              ", this.compressedSize);
+        Logger_12.Logger.log("UnCompressed Size:                            ", this.uncompressedSize);
+        Logger_12.Logger.log(`32-bit CRC value (hex):                        ${this.crc.toString(16).padStart(8, "0")}`);
+        Logger_12.Logger.log("Length of extra field:                        ", this.extraField?.length ?? 0);
+        Logger_12.Logger.log("Length of file comment:                       ", this.comment?.length ?? 0);
+        Logger_12.Logger.log("Unix File Attributes:                         ");
+        Logger_12.Logger.log("MS-DOS File Attributes:                       ", this.dosAttributesToString());
+        if (this.extraField) {
+          Logger_12.Logger.log("\nThe Central-Directory Extra Field contains:");
+          try {
+            for (let i = 0; i < this.extraField.length; ) {
+              if (i + 4 > this.extraField.length) {
+                Logger_12.Logger.log(`   Warning: Truncated extra field at offset ${i}`);
+                break;
+              }
+              let _id = this.extraField.readUInt16LE(i);
+              let _idStr = _id.toString(16).padStart(4, "0");
+              let _len = this.extraField.readUInt16LE(i + 2);
+              if (_len < 0 || i + 4 + _len > this.extraField.length) {
+                Logger_12.Logger.log(`   Warning: Invalid extra field length (${_len}) at offset ${i} for ID ${_idStr}`);
+                break;
+              }
+              let _data = this.extraField.subarray(i + 4, i + 4 + _len);
+              try {
+                if (_id === Headers_1.HDR_ID.SHA256) {
+                  Logger_12.Logger.log(`   ID[0x${_idStr}] NeoZip-SHA256: ${_data.toString("hex")}`);
+                } else if (_id === Headers_1.HDR_ID.UNV_TIME) {
+                  if (_len >= 5) {
+                    const flags = _data.readUInt8(0);
+                    const timestamp = _data.readUInt32LE(1);
+                    const date = new Date(timestamp * 1e3);
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Universal Time: flags=${flags}, time=${date.toISOString()}`);
+                  } else {
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Universal Time: (invalid length ${_len})`);
+                  }
+                } else if (_id === Headers_1.HDR_ID.UID_GID) {
+                  if (_len >= 5) {
+                    const version = _data.readUInt8(0);
+                    const uidSize = _data.readUInt8(1);
+                    if (2 + uidSize > _len) {
+                      Logger_12.Logger.log(`   ID[0x${_idStr}] Unix UID/GID: (invalid UID size ${uidSize})`);
+                    } else {
+                      const uid = _data.readUIntLE(2, Math.min(uidSize, 4));
+                      let gid = 0;
+                      if (2 + uidSize + 1 < _len) {
+                        const gidSize = _data.readUInt8(2 + uidSize);
+                        if (2 + uidSize + 1 + gidSize <= _len) {
+                          gid = _data.readUIntLE(2 + uidSize + 1, Math.min(gidSize, 4));
+                        }
+                      }
+                      Logger_12.Logger.log(`   ID[0x${_idStr}] Unix UID/GID: version=${version}, uid=${uid}, gid=${gid}`);
+                    }
+                  } else {
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Unix UID/GID: (invalid length ${_len})`);
+                  }
+                } else if (_id === Headers_1.HDR_ID.SYMLINK) {
+                  if (_len >= 3) {
+                    const version = _data.readUInt8(0);
+                    const targetLength = _data.readUInt16LE(1);
+                    if (targetLength > 0 && _len >= 3 + targetLength) {
+                      const target = _data.subarray(3, 3 + targetLength).toString("utf8");
+                      Logger_12.Logger.log(`   ID[0x${_idStr}] Symbolic Link: version=${version}, target="${target}"`);
+                    } else {
+                      Logger_12.Logger.log(`   ID[0x${_idStr}] Symbolic Link: (invalid target length ${targetLength})`);
+                    }
+                  } else {
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Symbolic Link: (invalid length ${_len})`);
+                  }
+                } else if (_id === Headers_1.HDR_ID.HARDLINK) {
+                  if (_len >= 11) {
+                    const version = _data.readUInt8(0);
+                    const inode = _data.readUInt32LE(1);
+                    const originalLength = _data.readUInt16LE(5);
+                    if (originalLength > 0 && _len >= 7 + originalLength) {
+                      const original = _data.subarray(7, 7 + originalLength).toString("utf8");
+                      Logger_12.Logger.log(`   ID[0x${_idStr}] Hard Link: version=${version}, inode=${inode}, original="${original}"`);
+                    } else {
+                      Logger_12.Logger.log(`   ID[0x${_idStr}] Hard Link: (invalid original length ${originalLength})`);
+                    }
+                  } else {
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Hard Link: (invalid length ${_len})`);
+                  }
+                } else if (_id === Headers_1.HDR_ID.UNICODE_PATH) {
+                  if (_len >= 5) {
+                    const version = _data.readUInt8(0);
+                    const nameCrc32 = _data.readUInt32LE(1);
+                    const unicodeName = _data.subarray(5).toString("utf8");
+                    const fnameBuf = Buffer.from(this.filename);
+                    const calculatedCrc = (0, ZipCrypto_12.crc32)(fnameBuf);
+                    const crcMatch = nameCrc32 === calculatedCrc ? "MATCH" : "MISMATCH";
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Unicode Path: version=${version}, CRC32=${nameCrc32.toString(16)} (${crcMatch})`);
+                    Logger_12.Logger.log(`                      Path: "${unicodeName}"`);
+                  } else {
+                    Logger_12.Logger.log(`   ID[0x${_idStr}] Unicode Path: (invalid length ${_len})`);
+                  }
+                } else if (_id === Headers_1.HDR_ID.ZIP64) {
+                  Logger_12.Logger.log(`   ID[0x${_idStr}] ZIP64 Extended Information:`);
+                  if (_len >= 8) {
+                    let offset = 0;
+                    if (offset + 8 <= _len) {
+                      const uncompressedSize = _data.readBigUInt64LE(offset);
+                      Logger_12.Logger.log(`     Uncompressed Size (ZIP64): ${uncompressedSize.toString()} bytes`);
+                      offset += 8;
+                    }
+                    if (offset + 8 <= _len) {
+                      const compressedSize = _data.readBigUInt64LE(offset);
+                      Logger_12.Logger.log(`     Compressed Size (ZIP64): ${compressedSize.toString()} bytes`);
+                      offset += 8;
+                    }
+                    if (offset + 8 <= _len) {
+                      const localHeaderOffset = _data.readBigUInt64LE(offset);
+                      Logger_12.Logger.log(`     Local Header Offset (ZIP64): ${localHeaderOffset.toString()}`);
+                      offset += 8;
+                    }
+                    if (offset + 4 <= _len) {
+                      const diskNumber = _data.readUInt32LE(offset);
+                      Logger_12.Logger.log(`     Disk Number (ZIP64): ${diskNumber}`);
+                    }
+                  } else {
+                    Logger_12.Logger.log(`     ZIP64 Extended Information: (invalid length ${_len})`);
+                  }
+                } else {
+                  const preview = _len > 0 ? _data.slice(0, Math.min(16, _len)).toString("hex") : "";
+                  Logger_12.Logger.log(`   ID[0x${_idStr}] Unknown field: length=${_len} bytes${preview ? ", data=" + preview + "..." : ""}`);
+                }
+              } catch (error) {
+                Logger_12.Logger.log(`   Error parsing extra field ID[0x${_idStr}]: ${error.message}`);
+              }
+              i += 4 + _len;
+            }
+          } catch (error) {
+            Logger_12.Logger.log(`   Error parsing extra fields: ${error.message}`);
+          }
+        }
+        Logger_12.Logger.log("\n");
+      }
+    };
+    exports2.default = ZipEntry;
+    exports2.ZipEntry = ZipEntry;
+  }
+});
+
+// neozipkit/dist/types/index.js
+var require_types2 = __commonJS({
+  "neozipkit/dist/types/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.NEOZIPKIT_INFO = exports2.NETWORKS = void 0;
+    exports2.NETWORKS = {
+      "base": {
+        name: "Base Mainnet",
+        rpcUrl: "https://mainnet.base.org",
+        chainId: 8453,
+        explorerUrl: "https://basescan.org"
+      },
+      "base-sepolia": {
+        name: "Base Sepolia",
+        rpcUrl: "https://sepolia.base.org",
+        chainId: 84532,
+        explorerUrl: "https://sepolia.basescan.org"
+      },
+      "base-goerli": {
+        name: "Base Goerli",
+        rpcUrl: "https://goerli.base.org",
+        chainId: 84531,
+        explorerUrl: "https://goerli.basescan.org"
+      },
+      "localhost": {
+        name: "Localhost",
+        rpcUrl: "http://localhost:8545",
+        chainId: 31337,
+        explorerUrl: "http://localhost:8545"
+      }
+    };
+    exports2.NEOZIPKIT_INFO = {
+      version: "0.70.0-alpha",
+      releaseDate: "2024-10-04"
+    };
+  }
+});
+
+// neozipkit/dist/core/components/HashCalculator.js
+var require_HashCalculator = __commonJS({
+  "neozipkit/dist/core/components/HashCalculator.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = /* @__PURE__ */ __name(function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      }, "ownKeys");
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+            if (k[i] !== "default")
+              __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HashCalculator = void 0;
+    var crypto = __importStar(require("crypto"));
+    var ZipCrypto_12 = require_ZipCrypto();
+    var HashCalculator = class _HashCalculator {
+      static {
+        __name(this, "HashCalculator");
+      }
+      /**
+       * Creates a new HashCalculator instance
+       * @param options - Configuration options:
+       *   - useSHA256: Enable SHA-256 calculation for incremental mode (default: false)
+       *   - enableAccumulation: Enable hash accumulation mode (default: false)
+       */
+      constructor(options) {
+        this.crc32State = ~0;
+        this.sha256Hash = null;
+        this.useSHA256 = false;
+        this.hashes = [];
+        this.xorResult = Buffer.alloc(32, 0);
+        this.enableAccumulation = false;
+        this.merkleLeaves = [];
+        this.merkleLayers = [];
+        this.merkleOptions = {
+          hashLeaves: false,
+          sortLeaves: true,
+          sortPairs: true,
+          duplicateOdd: true
+        };
+        this.useSHA256 = options?.useSHA256 || false;
+        this.enableAccumulation = options?.enableAccumulation || false;
+        if (this.useSHA256) {
+          this.sha256Hash = crypto.createHash("sha256");
+        }
+      }
+      // ============================================================================
+      // Incremental Hash Calculation Methods (from StreamHashCalculator)
+      // ============================================================================
+      /**
+       * Update hash state with a new chunk of data
+       * Updates both CRC-32 and SHA-256 (if enabled) incrementally
+       * @param chunk - Data chunk to process
+       */
+      update(chunk) {
+        for (let i = 0; i < chunk.length; i++) {
+          this.crc32State = (0, ZipCrypto_12.crc32update)(this.crc32State, chunk[i]);
+        }
+        if (this.sha256Hash) {
+          this.sha256Hash.update(chunk);
+        }
+      }
+      /**
+       * Get final CRC-32 value
+       * @returns Final CRC-32 value as unsigned 32-bit integer
+       */
+      finalizeCRC32() {
+        return ~this.crc32State >>> 0;
+      }
+      /**
+       * Get final SHA-256 hash as hex string
+       * @returns SHA-256 hash as hex string, or null if SHA-256 not enabled
+       */
+      finalizeSHA256() {
+        if (this.sha256Hash) {
+          return this.sha256Hash.digest("hex");
+        }
+        return null;
+      }
+      /**
+       * Reset the incremental hash calculation state
+       */
+      reset() {
+        this.crc32State = ~0;
+        if (this.sha256Hash) {
+          this.sha256Hash = crypto.createHash("sha256");
+        }
+      }
+      // ============================================================================
+      // Hash Accumulation Methods (from HashAccumulator)
+      // ============================================================================
+      /**
+       * Adds a pre-computed SHA-256 hash to both the XOR accumulation and hash array
+       * @param hash - Hash value as hex string or Buffer (must be 32 bytes for SHA-256)
+       */
+      addHash(hash) {
+        if (!this.enableAccumulation) {
+          throw new Error("Hash accumulation not enabled. Set enableAccumulation: true in constructor.");
+        }
+        const hashBuffer = typeof hash === "string" ? Buffer.from(hash, "hex") : hash;
+        this.hashes.push(hashBuffer);
+        this.merkleLeaves.push(hashBuffer);
+        for (let i = 0; i < 32; i++) {
+          this.xorResult[i] ^= hashBuffer[i];
+        }
+        this.rebuildMerkleTree();
+      }
+      /**
+       * Gets the accumulated XOR of all added hashes
+       * @returns Hex string of XOR result
+       */
+      xorHash() {
+        if (!this.enableAccumulation) {
+          throw new Error("Hash accumulation not enabled. Set enableAccumulation: true in constructor.");
+        }
+        return this.xorResult.toString("hex");
+      }
+      /**
+       * Creates a Merkle tree from accumulated hashes and returns the root
+       * @returns Hex string of Merkle root, or null if no hashes added
+       */
+      merkleRoot() {
+        if (!this.enableAccumulation) {
+          throw new Error("Hash accumulation not enabled. Set enableAccumulation: true in constructor.");
+        }
+        if (this.merkleLeaves.length === 0) {
+          return null;
+        }
+        if (this.merkleLayers.length === 0) {
+          this.rebuildMerkleTree();
+        }
+        const root = this.merkleLayers[this.merkleLayers.length - 1];
+        if (root && root.length > 0) {
+          return root[0].toString("hex");
+        }
+        return null;
+      }
+      /**
+       * Gets the number of hashes accumulated
+       * @returns Number of accumulated hashes
+       */
+      leafCount() {
+        if (!this.enableAccumulation) {
+          throw new Error("Hash accumulation not enabled. Set enableAccumulation: true in constructor.");
+        }
+        return this.hashes.length;
+      }
+      /**
+       * Clears the accumulated hashes and resets XOR buffer
+       */
+      clear() {
+        if (!this.enableAccumulation) {
+          throw new Error("Hash accumulation not enabled. Set enableAccumulation: true in constructor.");
+        }
+        this.hashes = [];
+        this.merkleLeaves = [];
+        this.merkleLayers = [];
+        this.xorResult = Buffer.alloc(32, 0);
+      }
+      /**
+       * Combines multiple hash results into a single Merkle root
+       * Static method for combining results from multiple HashCalculator instances
+       * @param results - Array of objects containing merkleRoot properties
+       * @returns Combined Merkle root as hex string, or null if no valid roots
+       */
+      static combineResults(results) {
+        const calculator = new _HashCalculator({ enableAccumulation: true });
+        for (const result of results) {
+          if (result.merkleRoot) {
+            calculator.addHash(result.merkleRoot);
+          }
+        }
+        return calculator.merkleRoot();
+      }
+      // ============================================================================
+      // Merkle Tree Methods (from MerkleTree)
+      // ============================================================================
+      /**
+       * Computes SHA-256 hash of input data
+       * @param data - Data to hash
+       * @returns Buffer containing hash
+       */
+      hash(data) {
+        return crypto.createHash("sha256").update(data).digest();
+      }
+      /**
+       * Combines two child hashes to create parent hash
+       * @param left - Left child hash
+       * @param right - Right child hash
+       * @returns Combined hash of children
+       */
+      combinedHash(left, right) {
+        if (this.merkleOptions.sortPairs && Buffer.compare(left, right) > 0) {
+          [left, right] = [right, left];
+        }
+        return this.hash(Buffer.concat([left, right]));
+      }
+      /**
+       * Builds the Merkle tree by creating successive layers of hashes
+       * @param nodes - Array of nodes in current layer
+       */
+      createHashes(nodes) {
+        while (nodes.length > 1) {
+          const layerIndex = this.merkleLayers.length;
+          this.merkleLayers.push([]);
+          for (let i = 0; i < nodes.length - 1; i += 2) {
+            const left = nodes[i];
+            const right = nodes[i + 1];
+            const hash = this.combinedHash(left, right);
+            this.merkleLayers[layerIndex].push(hash);
+          }
+          if (nodes.length % 2 === 1) {
+            const last = nodes[nodes.length - 1];
+            if (this.merkleOptions.duplicateOdd) {
+              const hash = this.combinedHash(last, last);
+              this.merkleLayers[layerIndex].push(hash);
+            } else {
+              this.merkleLayers[layerIndex].push(last);
+            }
+          }
+          nodes = this.merkleLayers[layerIndex];
+        }
+      }
+      /**
+       * Rebuilds the Merkle tree from current leaves
+       */
+      rebuildMerkleTree() {
+        if (this.merkleLeaves.length === 0) {
+          this.merkleLayers = [];
+          return;
+        }
+        const processedLeaves = this.merkleLeaves.map((leaf) => {
+          if (this.merkleOptions.hashLeaves) {
+            return this.hash(leaf);
+          }
+          return Buffer.isBuffer(leaf) ? leaf : Buffer.from(leaf);
+        });
+        if (this.merkleOptions.sortLeaves) {
+          processedLeaves.sort(Buffer.compare);
+        }
+        this.merkleLayers = [processedLeaves];
+        this.createHashes(processedLeaves);
+      }
+      /**
+       * Generates a proof of inclusion for a leaf node
+       * @param leaf - The leaf node to generate proof for
+       * @returns Array of sibling hashes needed to reconstruct root
+       * @throws Error if leaf not found in tree or accumulation not enabled
+       */
+      getProof(leaf) {
+        if (!this.enableAccumulation) {
+          throw new Error("Hash accumulation not enabled. Set enableAccumulation: true in constructor.");
+        }
+        if (this.merkleLayers.length === 0) {
+          this.rebuildMerkleTree();
+        }
+        let index = this.merkleLeaves.findIndex((item) => item.equals(leaf));
+        if (index === -1) {
+          throw new Error("Leaf not found in tree");
+        }
+        return this.merkleLayers.reduce((proof, layer) => {
+          if (layer.length === 1)
+            return proof;
+          const pairIndex = index % 2 === 0 ? index + 1 : index - 1;
+          if (pairIndex < layer.length) {
+            proof.push(layer[pairIndex]);
+          }
+          index = Math.floor(index / 2);
+          return proof;
+        }, []);
+      }
+      /**
+       * Verifies a proof of inclusion for a leaf node
+       * @param proof - Array of sibling hashes from getProof()
+       * @param targetHash - Hash of the leaf node being verified
+       * @param root - Expected root hash
+       * @returns boolean indicating if proof is valid
+       */
+      verify(proof, targetHash, root) {
+        let computedHash = targetHash;
+        for (const proofElement of proof) {
+          computedHash = Buffer.compare(computedHash, proofElement) <= 0 ? this.combinedHash(computedHash, proofElement) : this.combinedHash(proofElement, computedHash);
+        }
+        return computedHash.equals(root);
+      }
+    };
+    exports2.HashCalculator = HashCalculator;
+    exports2.default = HashCalculator;
+  }
+});
+
+// neozipkit/dist/core/ZipCompress.js
+var require_ZipCompress = __commonJS({
+  "neozipkit/dist/core/ZipCompress.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ZipCompress = void 0;
+    var pako = require("pako");
+    var zstd_js_1 = require("@oneidentity/zstd-js");
+    var Logger_12 = require_Logger();
+    var Headers_1 = require_Headers();
+    var HashCalculator_12 = require_HashCalculator();
+    var ZipCrypto_12 = require_ZipCrypto();
+    var zstdCodec = null;
+    async function initZstd() {
+      if (!zstdCodec) {
+        zstdCodec = await (0, zstd_js_1.ZstdInit)();
+      }
+      return zstdCodec;
+    }
+    __name(initZstd, "initZstd");
+    var ZipCompress = class _ZipCompress {
+      static {
+        __name(this, "ZipCompress");
+      }
+      /**
+       * Internal logging method - only logs if class logging is enabled
+       */
+      log(...args) {
+        if (_ZipCompress.loggingEnabled) {
+          Logger_12.Logger.debug(`[ZipCompress]`, ...args);
+        }
+      }
+      /**
+       * Creates a new ZipCompress instance
+       * @param zipkit - Zipkit instance to use for ZIP operations
+       */
+      constructor(zipkit) {
+        this.zipkit = zipkit;
+        this.debug = false;
+        if (_ZipCompress.loggingEnabled) {
+          Logger_12.Logger.setLevel("debug");
+        }
+        this.log(`ZipCompress initialized`);
+      }
+      /**
+       * Compresses data for a ZIP entry (Buffer-based only)
+       * @param entry - ZIP entry to compress
+       * @param data - Buffer containing data to compress
+       * @param options - Compression options
+       * @param onOutputBuffer - Optional callback for streaming output
+       * @returns Buffer containing compressed data
+       */
+      async compressData(entry, data, options, onOutputBuffer) {
+        this.log(`compressData() called for entry: ${entry.filename}`);
+        if (!entry.uncompressedSize || entry.uncompressedSize === 0) {
+          entry.uncompressedSize = data.length;
+        }
+        const totalSize = data.length;
+        const bufferSize = options?.bufferSize || this.zipkit.getBufferSize();
+        this.log(`Compressing ${totalSize} bytes for entry: ${entry.filename}`);
+        this.log(`Compression options:`, { level: options?.level, useZstd: options?.useZstd, bufferSize });
+        let compressionMethod;
+        if (options?.level === 0) {
+          compressionMethod = Headers_1.CMP_METHOD.STORED;
+          this.log(`Using STORED method (no compression)`);
+        } else if (options?.useZstd) {
+          if (totalSize < 100) {
+            compressionMethod = Headers_1.CMP_METHOD.STORED;
+            this.log(`ZSTD fallback to STORED (file too small: ${totalSize} bytes)`);
+          } else {
+            compressionMethod = Headers_1.CMP_METHOD.ZSTD;
+            this.log(`Using ZSTD method (zstd compression)`);
+          }
+        } else {
+          compressionMethod = Headers_1.CMP_METHOD.DEFLATED;
+          this.log(`Using DEFLATED method (default compression)`);
+        }
+        entry.cmpMethod = compressionMethod;
+        const needsHashCalculation = !entry.crc || entry.crc === 0 || options?.useSHA256 && !entry.sha256;
+        const hashCalculator = needsHashCalculation ? new HashCalculator_12.HashCalculator({ useSHA256: options?.useSHA256 && !entry.sha256 || false }) : null;
+        if (hashCalculator) {
+          hashCalculator.update(data);
+          if (!entry.crc || entry.crc === 0) {
+            entry.crc = hashCalculator.finalizeCRC32();
+          }
+          if (options?.useSHA256 && !entry.sha256) {
+            entry.sha256 = hashCalculator.finalizeSHA256();
+          }
+          this.log(`Final hashes: CRC32=0x${entry.crc.toString(16).padStart(8, "0")}, SHA256=${entry.sha256 || "N/A"}`);
+        }
+        if (options?.password) {
+          this.log(`Encrypting compressed data for entry: ${entry.filename}`);
+          entry.gpFlag = (entry.gpFlag || 0) | Headers_1.GP_FLAG.ENCRYPTED;
+          entry.isEncrypted = true;
+        }
+        let compressedData;
+        const methodName = compressionMethod === Headers_1.CMP_METHOD.ZSTD ? "ZSTD" : compressionMethod === Headers_1.CMP_METHOD.DEFLATED ? "DEFLATED" : "STORED";
+        if (compressionMethod === Headers_1.CMP_METHOD.STORED) {
+          compressedData = data;
+        } else {
+          this.log(`Processing sequence for ${methodName}: [HASH] -> [COMPRESS] -> [OUTPUT]`);
+          this.log(`Compressing: method=${methodName}, input=${totalSize} bytes, buffer size=${bufferSize} bytes`);
+          this.log(`Calculating hashes: CRC32=${!entry.crc || entry.crc === 0}, SHA256=${options?.useSHA256}`);
+          if (compressionMethod === Headers_1.CMP_METHOD.ZSTD) {
+            compressedData = await this.zstdCompress(data, options, bufferSize, entry, onOutputBuffer);
+          } else {
+            compressedData = await this.deflateCompress(data, options, bufferSize, entry, onOutputBuffer);
+          }
+        }
+        if (options?.password) {
+          compressedData = this.encryptCompressedData(entry, compressedData, options.password);
+        }
+        entry.compressedSize = compressedData.length;
+        return compressedData;
+      }
+      /**
+       * Compress data using deflate algorithm with chunked processing
+       * @param data - Data to compress (Buffer or chunked reader)
+       * @param options - Compression options
+       * @param bufferSize - Buffer size for chunked processing
+       * @param entry - ZIP entry being compressed
+       * @param onOutputBuffer - Optional callback for streaming output
+       * @returns Buffer containing compressed data
+       */
+      async deflateCompress(data, options, bufferSize, entry, onOutputBuffer) {
+        this.log(`deflateCompress() called - entry: ${entry?.filename ?? "unknown"}, bufferSize: ${bufferSize}, level: ${options?.level ?? 6}`);
+        const effectiveBufferSize = bufferSize || this.zipkit.getBufferSize();
+        const level = options?.level ?? 6;
+        if (typeof data === "object" && "totalSize" in data && "onReadChunk" in data) {
+          throw new Error("Chunked reader mode not supported in ZipCompress");
+        }
+        if (data.length <= effectiveBufferSize) {
+          return this.deflate(data, options);
+        }
+        const deflator = new pako.Deflate({ level, raw: true });
+        const compressedChunks = [];
+        let totalProcessed = 0;
+        let totalCompressedSize = 0;
+        try {
+          for (let offset = 0; offset < data.length; offset += effectiveBufferSize) {
+            const chunk = data.slice(offset, offset + effectiveBufferSize);
+            const isLast = offset + effectiveBufferSize >= data.length;
+            deflator.push(chunk, isLast);
+            if (deflator.result && deflator.result.length > 0) {
+              const compressedChunk = Buffer.from(deflator.result);
+              compressedChunks.push(compressedChunk);
+              totalCompressedSize += compressedChunk.length;
+              if (onOutputBuffer) {
+                await onOutputBuffer(compressedChunk);
+              }
+            }
+            totalProcessed += chunk.length;
+          }
+          const ratio = totalProcessed > 0 ? Math.round(totalCompressedSize / totalProcessed * 100) : 0;
+          this.log(`Final hashes: CRC32=0x${entry?.crc?.toString(16).padStart(8, "0")}, SHA256=${entry?.sha256 || "N/A"}`);
+          this.log(`Deflate compression complete: ${totalCompressedSize} bytes from ${totalProcessed} bytes (ratio=${ratio}%)`);
+          return Buffer.concat(compressedChunks);
+        } catch (e) {
+          throw new Error(`Deflate compression failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+      /**
+       * Compress data using deflate algorithm (synchronous, small buffers only)
+       * @param inbuf - Buffer containing data to compress
+       * @param options - Compression options
+       * @returns Buffer containing compressed data
+       */
+      deflate(inbuf, options) {
+        this.log(`deflate() called with buffer size: ${inbuf.length}, level: ${options?.level ?? 6}`);
+        const level = options?.level ?? 6;
+        const result = pako.deflateRaw(inbuf, { level });
+        const ratio = inbuf.length > 0 ? Math.round(result.length / inbuf.length * 100) : 0;
+        this.log(`Deflate compression complete: ${result.length} bytes from ${inbuf.length} bytes (ratio=${ratio}%)`);
+        return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+      }
+      /**
+       * Compress data using Zstandard (zstd) algorithm
+       * @param input - Input data to compress (Buffer or chunked reader)
+       * @param options - Compression options
+       * @param bufferSize - Buffer size for chunked processing
+       * @param entry - ZIP entry being compressed
+       * @param onOutputBuffer - Optional callback for streaming output
+       * @returns Buffer containing compressed data
+       */
+      async zstdCompress(input, options, bufferSize, entry, onOutputBuffer) {
+        this.log(`zstdCompress() called - entry: ${entry?.filename ?? "unknown"}, bufferSize: ${bufferSize}, level: ${options?.level ?? 6}`);
+        const effectiveBufferSize = bufferSize || this.zipkit.getBufferSize();
+        const level = options?.level ?? 6;
+        if (typeof input === "object" && "totalSize" in input && "readChunk" in input) {
+          throw new Error("Chunked reader mode not supported in ZipCompress");
+        }
+        const zstdCodec2 = await initZstd();
+        if (!input || input.length === 0) {
+          throw new Error("ZSTD compression: empty input buffer");
+        }
+        const inputArray = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+        if (input.length <= effectiveBufferSize) {
+          const compressed2 = zstdCodec2.ZstdSimple.compress(inputArray, level);
+          const compressedBuffer2 = Buffer.from(compressed2);
+          if (onOutputBuffer) {
+            await onOutputBuffer(compressedBuffer2);
+          }
+          return compressedBuffer2;
+        }
+        const compressed = zstdCodec2.ZstdSimple.compress(inputArray, level);
+        const compressedBuffer = Buffer.from(compressed);
+        if (onOutputBuffer) {
+          await onOutputBuffer(compressedBuffer);
+        }
+        return compressedBuffer;
+      }
+      /**
+       * Encrypt compressed data using PKZIP encryption
+       * @param entry - ZIP entry to encrypt
+       * @param compressedData - Compressed data to encrypt
+       * @param password - Password for encryption
+       * @returns Buffer containing encrypted data (includes 12-byte header)
+       */
+      encryptCompressedData(entry, compressedData, password) {
+        this.log(`encryptCompressedData() called for entry: ${entry.filename}, compressed size: ${compressedData.length}`);
+        const zipCrypto = new ZipCrypto_12.ZipCrypto();
+        const encryptedData = zipCrypto.encryptBuffer(entry, compressedData, password);
+        this.log(`Encryption complete: ${compressedData.length} bytes compressed -> ${encryptedData.length} bytes encrypted (includes ${Headers_1.ENCRYPT_HDR_SIZE}-byte header)`);
+        return encryptedData;
+      }
+      /**
+       * Compress file data in memory and return ZIP entry information as Buffer
+       * @param entry - ZIP entry to compress
+       * @param fileData - File data buffer to compress
+       * @param cmpOptions - Compression options
+       * @returns Buffer containing local header + compressed data
+       */
+      async compressFileBuffer(entry, fileData, cmpOptions) {
+        this.log(`compressFileBuffer() called for entry: ${entry.filename}, size: ${fileData.length}`);
+        entry.uncompressedSize = fileData.length;
+        const hashCalculator = new HashCalculator_12.HashCalculator({ useSHA256: cmpOptions?.useSHA256 || false });
+        hashCalculator.update(fileData);
+        entry.crc = hashCalculator.finalizeCRC32();
+        if (cmpOptions?.useSHA256) {
+          entry.sha256 = hashCalculator.finalizeSHA256();
+          this.log(`SHA-256 calculated: ${entry.sha256}`);
+        }
+        const compressedData = await this.compressData(entry, fileData, cmpOptions);
+        if (cmpOptions?.password) {
+          this.log(`Encrypting compressed data for entry: ${entry.filename}`);
+          entry.gpFlag = (entry.gpFlag || 0) | Headers_1.GP_FLAG.ENCRYPTED;
+          entry.isEncrypted = true;
+          const zipCrypto = new ZipCrypto_12.ZipCrypto();
+          const encryptedData = zipCrypto.encryptBuffer(entry, compressedData, cmpOptions.password);
+          return encryptedData;
+        }
+        return compressedData;
+      }
+    };
+    exports2.ZipCompress = ZipCompress;
+    ZipCompress.loggingEnabled = false;
+  }
+});
+
+// neozipkit/dist/core/ZipDecompress.js
+var require_ZipDecompress = __commonJS({
+  "neozipkit/dist/core/ZipDecompress.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var pako = require("pako");
+    var zstd_js_1 = require("@oneidentity/zstd-js");
+    var Logger_12 = require_Logger();
+    var Errors_1 = __importDefault2(require_Errors());
+    var Headers_1 = require_Headers();
+    var ZipCrypto_12 = require_ZipCrypto();
+    var zstdCodec = null;
+    async function initZstd() {
+      if (!zstdCodec) {
+        zstdCodec = await (0, zstd_js_1.ZstdInit)();
+      }
+      return zstdCodec;
+    }
+    __name(initZstd, "initZstd");
+    var ZipDecompress = class _ZipDecompress {
+      static {
+        __name(this, "ZipDecompress");
+      }
+      /**
+       * Internal logging method - only logs if class logging is enabled
+       */
+      log(...args) {
+        if (_ZipDecompress.loggingEnabled) {
+          Logger_12.Logger.debug(`[ZipDecompress]`, ...args);
+        }
+      }
+      constructor(zipkit) {
+        this.zstdCodec = null;
+        this.zipkit = zipkit;
+        this.debug = false;
+        if (_ZipDecompress.loggingEnabled) {
+          Logger_12.Logger.setLevel("debug");
+        }
+      }
+      /**
+       * Extract file data (Buffer-based ZIP only)
+       * Public method that validates buffer mode and extracts entry
+       *
+       * @param entry ZIP entry to extract
+       * @param skipHashCheck Skip hash verification (CRC-32 or SHA-256)
+       * @returns Promise resolving to extracted data as Buffer, or null if failed
+       * @throws Error if not a Buffer-based ZIP
+       */
+      async extract(entry, skipHashCheck) {
+        if (!this.zipkit.hasInBuffer()) {
+          throw new Error("extract() requires Buffer-based ZIP. Use ZipkitServer.extractToFile() for file-based ZIP or call loadZip() first.");
+        }
+        this.log(`extract() called for entry: ${entry.filename}, method: ${entry.cmpMethod}, skipHashCheck: ${skipHashCheck}`);
+        if (entry.cmpMethod === Headers_1.CMP_METHOD.ZSTD && !this.zstdCodec) {
+          this.zstdCodec = await initZstd();
+        }
+        const buffer = this.zipkit.ensureBuffer();
+        let fdata = this.zipkit.parseLocalHeader(entry, buffer);
+        if (entry.isEncrypted && this.zipkit?.password) {
+          this.log(`Starting in-memory decryption for entry: ${entry.filename}`);
+          const zipCrypto = new ZipCrypto_12.ZipCrypto();
+          fdata = zipCrypto.decryptBuffer(entry, buffer, fdata, this.zipkit.password);
+          this.log(`Decryption successful, decrypted compressed data length: ${fdata.length}`);
+        }
+        if (fdata.length === 0) {
+          return null;
+        }
+        return this.unCompress(fdata, entry, skipHashCheck);
+      }
+      /**
+       * Inflate data using pako (internal use only)
+       */
+      inflate(data) {
+        this.log(`inflate() called with ${data.length} bytes`);
+        const result = pako.inflateRaw(data);
+        return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+      }
+      /**
+       * Synchronous zstd decompress method for in-memory mode
+       * ZSTD codec is guaranteed to be initialized via factory method
+       * Internal method only
+       */
+      zstdDecompressSync(data) {
+        this.log(`zstdDecompressSync() called with ${data.length} bytes`);
+        try {
+          if (!this.zstdCodec) {
+            throw new Error("ZSTD codec not initialized.");
+          }
+          const decompressed = this.zstdCodec.ZstdSimple.decompress(data);
+          this.log(`ZSTD synchronous decompression successful: ${data.length} bytes -> ${decompressed.length} bytes`);
+          return Buffer.from(decompressed);
+        } catch (error) {
+          this.log(`ZSTD synchronous decompression failed: ${error}`);
+          throw new Error(`ZSTD synchronous decompression failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      /**
+       * Uncompress compressed data buffer (synchronous for in-memory mode)
+       * Handles decompression and hash verification
+       * Internal method only
+       */
+      unCompress(compressedData, entry, skipHashCheck) {
+        this.log(`unCompress() called for entry: ${entry.filename}, method: ${entry.cmpMethod}, data length: ${compressedData.length}`);
+        if (compressedData.length === 0) {
+          return Buffer.alloc(0);
+        }
+        let outBuf;
+        if (entry.cmpMethod === Headers_1.CMP_METHOD.STORED) {
+          outBuf = compressedData;
+        } else if (entry.cmpMethod === Headers_1.CMP_METHOD.DEFLATED) {
+          outBuf = this.inflate(compressedData);
+        } else if (entry.cmpMethod === Headers_1.CMP_METHOD.ZSTD) {
+          outBuf = this.zstdDecompressSync(compressedData);
+        } else {
+          throw new Error(`Unsupported compression method: ${entry.cmpMethod}`);
+        }
+        if (!skipHashCheck) {
+          if (entry.sha256) {
+            const isValid = this.zipkit.testSHA256(entry, outBuf);
+            if (!isValid) {
+              throw new Error(Errors_1.default.INVALID_SHA256);
+            }
+          } else {
+            const isValid = this.zipkit.testCRC32(entry, outBuf);
+            if (!isValid) {
+              throw new Error(Errors_1.default.INVALID_CRC);
+            }
+          }
+        }
+        return outBuf;
+      }
+    };
+    ZipDecompress.loggingEnabled = false;
+    exports2.default = ZipDecompress;
+  }
+});
+
+// neozipkit/dist/core/Zipkit.js
+var require_Zipkit = __commonJS({
+  "neozipkit/dist/core/Zipkit.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HDR_ID = exports2.CENTRAL_DIRECTORY_END = exports2.CENTRAL_FILE_HEADER = exports2.LOCAL_FILE_HEADER = exports2.GP_FLAG = exports2.ZIP64_CENTRAL_DIR = exports2.ZIP64_CENTRAL_END = exports2.CENTRAL_DIR = exports2.CENTRAL_END = exports2.ENCRYPT_HDR_SIZE = exports2.LOCAL_HDR = exports2.TOKENIZED_METADATA = exports2.TIMESTAMP_SUBMITTED = exports2.TIMESTAMP_METADATA = exports2.CMP_METHOD = exports2.Errors = exports2.ZipEntry = void 0;
+    var ZipEntry_1 = __importDefault2(require_ZipEntry());
+    exports2.ZipEntry = ZipEntry_1.default;
+    var Errors_1 = __importDefault2(require_Errors());
+    exports2.Errors = Errors_1.default;
+    var Logger_12 = require_Logger();
+    var types_1 = require_types2();
+    var ZipCompress_12 = require_ZipCompress();
+    var ZipDecompress_1 = __importDefault2(require_ZipDecompress());
+    var ZipCrypto_12 = require_ZipCrypto();
+    var HashCalculator_12 = __importDefault2(require_HashCalculator());
+    var Headers_1 = require_Headers();
+    Object.defineProperty(exports2, "LOCAL_HDR", { enumerable: true, get: function() {
+      return Headers_1.LOCAL_HDR;
+    } });
+    Object.defineProperty(exports2, "ENCRYPT_HDR_SIZE", { enumerable: true, get: function() {
+      return Headers_1.ENCRYPT_HDR_SIZE;
+    } });
+    Object.defineProperty(exports2, "CMP_METHOD", { enumerable: true, get: function() {
+      return Headers_1.CMP_METHOD;
+    } });
+    Object.defineProperty(exports2, "CENTRAL_END", { enumerable: true, get: function() {
+      return Headers_1.CENTRAL_END;
+    } });
+    Object.defineProperty(exports2, "CENTRAL_DIR", { enumerable: true, get: function() {
+      return Headers_1.CENTRAL_DIR;
+    } });
+    Object.defineProperty(exports2, "ZIP64_CENTRAL_END", { enumerable: true, get: function() {
+      return Headers_1.ZIP64_CENTRAL_END;
+    } });
+    Object.defineProperty(exports2, "ZIP64_CENTRAL_DIR", { enumerable: true, get: function() {
+      return Headers_1.ZIP64_CENTRAL_DIR;
+    } });
+    Object.defineProperty(exports2, "GP_FLAG", { enumerable: true, get: function() {
+      return Headers_1.GP_FLAG;
+    } });
+    Object.defineProperty(exports2, "TIMESTAMP_SUBMITTED", { enumerable: true, get: function() {
+      return Headers_1.TIMESTAMP_SUBMITTED;
+    } });
+    Object.defineProperty(exports2, "TIMESTAMP_METADATA", { enumerable: true, get: function() {
+      return Headers_1.TIMESTAMP_METADATA;
+    } });
+    Object.defineProperty(exports2, "TOKENIZED_METADATA", { enumerable: true, get: function() {
+      return Headers_1.TOKENIZED_METADATA;
+    } });
+    Object.defineProperty(exports2, "LOCAL_FILE_HEADER", { enumerable: true, get: function() {
+      return Headers_1.LOCAL_FILE_HEADER;
+    } });
+    Object.defineProperty(exports2, "CENTRAL_FILE_HEADER", { enumerable: true, get: function() {
+      return Headers_1.CENTRAL_FILE_HEADER;
+    } });
+    Object.defineProperty(exports2, "CENTRAL_DIRECTORY_END", { enumerable: true, get: function() {
+      return Headers_1.CENTRAL_DIRECTORY_END;
+    } });
+    Object.defineProperty(exports2, "HDR_ID", { enumerable: true, get: function() {
+      return Headers_1.HDR_ID;
+    } });
+    var Zipkit = class {
+      static {
+        __name(this, "Zipkit");
+      }
+      /**
+       * Creates a new Zipkit instance with optional configuration
+       *
+       * @param config - Optional configuration object (ZipkitConfig)
+       *   - bufferSize: Buffer size for streaming operations (default: 512KB)
+       *   - debug: Enable debug logging (default: false)
+       *
+       * @example
+       * const zip = new Zipkit({ bufferSize: 512 * 1024, debug: true });
+       */
+      constructor(config = {}) {
+        this.inBuffer = null;
+        this.zipEntries = [];
+        this.centralDirSize = 0;
+        this.centralDirOffset = 0;
+        this.zipComment = null;
+        this._zipkitCmp = null;
+        this._zipkitDeCmp = null;
+        this.config = {
+          bufferSize: config.bufferSize || 512 * 1024,
+          // 512KB default (optimal for modern systems)
+          debug: config.debug || false
+          // Default false
+        };
+        if (this.config.debug) {
+          Logger_12.Logger.setLevel("debug");
+        }
+      }
+      /**
+       * Lazy-load ZipCompress instance
+       * @returns ZipCompress instance (created on first access)
+       */
+      getZipCompress() {
+        if (!this._zipkitCmp) {
+          this._zipkitCmp = new ZipCompress_12.ZipCompress(this);
+        }
+        return this._zipkitCmp;
+      }
+      /**
+       * Lazy-load ZipDecompress instance
+       * @returns ZipDecompress instance (created on first access)
+       */
+      getZipDecompress() {
+        if (!this._zipkitDeCmp) {
+          this._zipkitDeCmp = new ZipDecompress_1.default(this);
+        }
+        return this._zipkitDeCmp;
+      }
+      /**
+       * Get the configured buffer size for streaming operations
+       * @returns Buffer size in bytes (default: 512KB)
+       */
+      getBufferSize() {
+        return this.config.bufferSize || 512 * 1024;
+      }
+      /**
+       * Check if ZIP is loaded in buffer mode
+       * @returns true if buffer-based ZIP is loaded
+       */
+      hasInBuffer() {
+        return this.inBuffer !== null && this.inBuffer.length > 0;
+      }
+      // ============================================================================
+      // ZipCompress Wrapper Methods
+      // ============================================================================
+      /**
+       * Compress data for a ZIP entry (Buffer-based only)
+       * Wrapper for ZipCompress.compressData()
+       *
+       * @param entry - ZIP entry to compress
+       * @param data - Buffer containing data to compress
+       * @param options - Compression options
+       * @param onOutputBuffer - Optional callback for streaming output
+       * @returns Promise resolving to Buffer containing compressed data
+       */
+      async compressData(entry, data, options, onOutputBuffer) {
+        return this.getZipCompress().compressData(entry, data, options, onOutputBuffer);
+      }
+      /**
+       * Compress data using deflate algorithm with chunked processing
+       * Wrapper for ZipCompress.deflateCompress()
+       *
+       * @param data - Data to compress (Buffer or chunked reader)
+       * @param options - Compression options
+       * @param bufferSize - Size of buffer to read (default: 512KB)
+       * @param entry - Optional ZIP entry for hash calculation
+       * @param onOutputBuffer - Optional callback for streaming output
+       * @returns Promise resolving to Buffer containing compressed data
+       */
+      async deflateCompress(data, options, bufferSize, entry, onOutputBuffer) {
+        return this.getZipCompress().deflateCompress(data, options, bufferSize, entry, onOutputBuffer);
+      }
+      /**
+       * Compress data using deflate algorithm (synchronous, small buffers only)
+       * Wrapper for ZipCompress.deflate()
+       *
+       * @param inbuf - Buffer containing data to compress
+       * @param options - Compression options
+       * @returns Buffer containing compressed data
+       */
+      deflate(inbuf, options) {
+        return this.getZipCompress().deflate(inbuf, options);
+      }
+      /**
+       * Compress data using Zstandard (zstd) algorithm
+       * Wrapper for ZipCompress.zstdCompress()
+       *
+       * Note: ZSTD codec is lazily initialized on first use (module-level singleton).
+       * Initialization happens automatically when needed.
+       *
+       * @param input - Buffer to compress OR chunked reader object
+       * @param options - Compression options
+       * @param bufferSize - Size of buffer to read if using chunked reader (default: 512KB)
+       * @param entry - Optional ZIP entry for hash calculation
+       * @param onOutputBuffer - Optional callback for streaming output
+       * @returns Promise resolving to Buffer containing compressed data
+       */
+      async zstdCompress(input, options, bufferSize, entry, onOutputBuffer) {
+        return this.getZipCompress().zstdCompress(input, options, bufferSize, entry, onOutputBuffer);
+      }
+      /**
+       * Compress file data in memory and return ZIP entry information as Buffer
+       * Wrapper for ZipCompress.compressFileBuffer()
+       *
+       * @param entry - ZIP entry to compress
+       * @param fileData - File data buffer to compress
+       * @param cmpOptions - Compression options
+       * @returns Promise resolving to Buffer containing local header + compressed data
+       */
+      async compressFileBuffer(entry, fileData, cmpOptions) {
+        return this.getZipCompress().compressFileBuffer(entry, fileData, cmpOptions);
+      }
+      // ============================================================================
+      // ZipDecompress Wrapper Methods
+      // ============================================================================
+      /**
+       * Extract file data (Buffer-based ZIP only)
+       * Wrapper for ZipDecompress.extract()
+       *
+       * @param entry - ZIP entry to extract
+       * @param skipHashCheck - Skip hash verification (CRC-32 or SHA-256)
+       * @returns Promise resolving to Buffer containing extracted data, or null if failed
+       * @throws Error if not a Buffer-based ZIP
+       */
+      async extract(entry, skipHashCheck) {
+        return this.getZipDecompress().extract(entry, skipHashCheck);
+      }
+      // ============================================================================
+      // Static Logging Wrapper Methods
+      // ============================================================================
+      /**
+       * Note: Logging for ZipCompress and ZipDecompress is controlled by their
+       * static loggingEnabled property. Set it directly:
+       *   ZipCompress.loggingEnabled = true/false;
+       *   ZipDecompress.loggingEnabled = true/false;
+       */
+      /**
+       * Load ZIP file from buffer (in-memory mode)
+       *
+       * **Required**: You must call this method (or the appropriate load method for your platform)
+       * before calling `getDirectory()` or any other ZIP operations. This method:
+       * 1. Resets all ZIP data
+       * 2. Stores the buffer in this.inBuffer
+       * 3. Loads EOCD and parses central directory
+       * 4. Populates this.zipEntries[] array
+       *
+       * For browser applications, use `ZipkitBrowser.loadZipBlob()` instead.
+       * For server applications with file paths, use `ZipkitServer.loadZipFile()` instead.
+       *
+       * @param inBuf - Buffer containing the complete ZIP file data
+       * @returns ZipEntry[] Array of all entries in the ZIP file
+       */
+      loadZip(inBuf) {
+        this.resetZipData();
+        this.inBuffer = inBuf;
+        this.loadEOCDFromBuffer(inBuf);
+        const entries = this.getDirectoryFromBuffer();
+        this.zipEntries = entries;
+        return entries;
+      }
+      /**
+       * Reset all ZIP-related data to initial state
+       *
+       * Clears all internal state including zipEntries[], inBuffer, and zipComment.
+       *
+       * Note: ZipCompress and ZipDecompress instances are not recreated.
+       * ZSTD codec is a module-level singleton and is lazily initialized on first use,
+       * so no cleanup is needed. No memory buffers are allocated until compression/decompression
+       * operations are performed.
+       */
+      resetZipData() {
+        this.inBuffer = null;
+        this.zipEntries = [];
+        this.reset();
+        this.zipComment = null;
+        this._zipkitCmp = null;
+        this._zipkitDeCmp = null;
+      }
+      /**
+       * Get central directory entries (synchronous, buffer-based only)
+       *
+       * Returns entries from zipEntries[] array which serves as unified storage.
+       *
+       * **Important**: This method does NOT load the ZIP file. You must call `loadZip()` first
+       * to populate zipEntries[]. If the ZIP is not loaded, this method returns an empty array.
+       *
+       * @param debug - Optional debug flag for logging
+       * @returns Array of ZipEntry objects, or empty array if ZIP not loaded
+       */
+      getDirectory(debug) {
+        return this.zipEntries;
+      }
+      /**
+       * Get specific ZIP entry by filename from zipEntries[] array
+       *
+       * @param filename - The name/path of the file/directory to find
+       * @returns ZipEntry object if found, null if not found
+       */
+      getZipEntry(filename) {
+        try {
+          const centralDir = this.getDirectory();
+          return centralDir.find((entry) => entry.filename === filename) || null;
+        } catch (error) {
+          return null;
+        }
+      }
+      /**
+       * Ensure buffer is available (in-memory mode)
+       */
+      ensureBuffer() {
+        if (!this.inBuffer) {
+          this.inBuffer = Buffer.alloc(0);
+        }
+        return this.inBuffer;
+      }
+      /**
+       * Parse local header (in-memory mode)
+       */
+      parseLocalHeader(entry, buffer) {
+        const localData = buffer.subarray(entry.localHdrOffset);
+        if (localData.readUInt32LE(0) !== Headers_1.LOCAL_HDR.SIGNATURE) {
+          throw new Error(Errors_1.default.INVALID_CEN);
+        }
+        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;
+        }
+        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;
+        const dataStart = _localSize + _encryptLen;
+        const dataEnd = _localSize + entry.compressedSize;
+        return localData.subarray(dataStart, dataEnd);
+      }
+      /**
+       * Test CRC32 checksum
+       * Always checks CRC against entry.crc from central directory
+       * For DATA_DESC files, CRC is stored in central directory, not local header
+       */
+      testCRC32(entry, data) {
+        const _crc = (0, ZipCrypto_12.crc32)(data);
+        const isValid = _crc === entry.crc;
+        Logger_12.Logger.debug(`[DEBUG] testCRC32() comparison: calculated=${_crc}, stored=${entry.crc}, isValid=${isValid ? "\u2713" : "\u2717"}, DATA_DESC=${(entry.bitFlags & 8) !== 0 ? "YES" : "NO"}`);
+        return isValid;
+      }
+      /**
+       * Test SHA256 hash
+       */
+      testSHA256(entry, data) {
+        if (!entry.sha256) {
+          throw new Error(Errors_1.default.UNKNOWN_SHA256);
+        }
+        const _sha256 = (0, ZipCrypto_12.sha256)(data);
+        const isValid = _sha256 === entry.sha256;
+        Logger_12.Logger.debug(`[DEBUG] testSHA256() comparison: calculated=${_sha256}, stored=${entry.sha256}, isValid=${isValid ? "\u2713" : "\u2717"}`);
+        return isValid;
+      }
+      /**
+       * Get memory usage statistics
+       *
+       * @returns Object containing backend type, total memory usage in bytes, and entry count
+       */
+      getMemoryUsage() {
+        const baseMemory = this.inBuffer?.length || 0;
+        const entriesMemory = this.zipEntries.length * 1024;
+        let backend;
+        if (this.inBuffer) {
+          backend = "buffer";
+        } else {
+          backend = "none";
+        }
+        return {
+          backend,
+          memoryUsage: baseMemory + entriesMemory,
+          entries: this.zipEntries.length
+        };
+      }
+      /**
+       * Create a new ZIP entry and automatically add it to zipEntries[]
+       *
+       * @param filename - Entry filename
+       * @param data - Optional entry data (for CRC calculation)
+       * @param options - Optional entry options
+       * @returns Created ZipEntry instance
+       */
+      createZipEntry(filename, data, options) {
+        const entry = new ZipEntry_1.default(filename, null, false);
+        if (data) {
+          entry.crc = (0, ZipCrypto_12.crc32)(data);
+          entry.uncompressedSize = data.length;
+          entry.compressedSize = data.length;
+        } else {
+          entry.crc = 0;
+          entry.uncompressedSize = 0;
+          entry.compressedSize = 0;
+        }
+        entry.cmpMethod = Headers_1.CMP_METHOD.STORED;
+        entry.bitFlags = 0;
+        this.zipEntries.push(entry);
+        return entry;
+      }
+      /**
+       * Copy entry from another ZIP (buffer-based only)
+       * For file-based ZIP operations, use ZipkitServer.copyEntry()
+       */
+      async copyEntry(sourceEntry) {
+        if (sourceEntry.cmpData) {
+          const localHdr = sourceEntry.createLocalHdr();
+          return Buffer.concat([localHdr, sourceEntry.cmpData]);
+        }
+        throw new Error("Cannot copy entry: no compressed data available");
+      }
+      /**
+       * Central end header getter (for compatibility)
+       *
+       * Returns a function that creates the central end header using totalEntries from zipEntries[].
+       *
+       * @returns Function that creates central end header buffer
+       */
+      get centralEndHdr() {
+        return (centralDirSize, centralDirOffset) => {
+          const totalEntries = this.zipEntries.length;
+          return this.centralEndHdrMethod(centralDirSize, centralDirOffset, totalEntries);
+        };
+      }
+      /**
+       * Get ZIP comment
+       *
+       * @returns ZIP file comment string or null
+       */
+      getZipComment() {
+        return this.zipComment;
+      }
+      // ============================================================================
+      // Buffer-based ZIP Loading Methods (merged from ZipLoadEntries)
+      // ============================================================================
+      /**
+       * Load EOCD from in-memory buffer (buffer mode)
+       */
+      loadEOCDFromBuffer(buffer) {
+        const fileSize = buffer.length;
+        const searchSize = Math.min(65535 + 22, fileSize);
+        const searchStart = fileSize - searchSize;
+        const scan = buffer.subarray(searchStart, searchStart + searchSize);
+        let eocdOffset = -1;
+        for (let i = scan.length - 22; i >= 0; i--) {
+          if (scan[i] === 80) {
+            if (scan.readUInt32LE(i) === Headers_1.CENTRAL_END.SIGNATURE) {
+              eocdOffset = searchStart + i;
+              break;
+            }
+          }
+        }
+        if (eocdOffset === -1) {
+          throw new Error(Errors_1.default.INVALID_FORMAT);
+        }
+        const eocdBuffer = buffer.subarray(eocdOffset, eocdOffset + 22);
+        if (eocdBuffer.readUInt32LE(0) === Headers_1.CENTRAL_END.SIGNATURE) {
+          this.centralDirSize = eocdBuffer.readUInt32LE(Headers_1.CENTRAL_END.CENTRAL_DIR_SIZE);
+          this.centralDirOffset = eocdBuffer.readUInt32LE(Headers_1.CENTRAL_END.CENTRAL_DIR_OFFSET);
+          if (this.centralDirOffset === 4294967295) {
+            const locatorOffset = eocdOffset - 20;
+            const locatorBuffer = buffer.subarray(locatorOffset, locatorOffset + 20);
+            if (locatorBuffer.readUInt32LE(0) === Headers_1.ZIP64_CENTRAL_END.SIGNATURE) {
+              const zip64Offset = Number(locatorBuffer.readBigUInt64LE(8));
+              const zip64Buffer = buffer.subarray(zip64Offset, zip64Offset + 56);
+              this.centralDirSize = Number(zip64Buffer.readBigUInt64LE(Headers_1.ZIP64_CENTRAL_DIR.CENTRAL_DIR_SIZE));
+              this.centralDirOffset = Number(zip64Buffer.readBigUInt64LE(Headers_1.ZIP64_CENTRAL_DIR.CENTRAL_DIR_OFFSET));
+            }
+          }
+        } else {
+          throw new Error(Errors_1.default.INVALID_FORMAT);
+        }
+        const commentLength = eocdBuffer.readUInt16LE(Headers_1.CENTRAL_END.ZIP_COMMENT_LEN);
+        if (commentLength > 0) {
+          const commentStart = eocdOffset + 22;
+          this.zipComment = buffer.subarray(commentStart, commentStart + commentLength).toString();
+        }
+      }
+      /**
+       * Get directory from buffer (buffer mode only)
+       * Note: zipEntries[] in Zipkit is the single source of truth for caching.
+       * This method always parses fresh from the buffer.
+       */
+      getDirectoryFromBuffer() {
+        if (!this.inBuffer) {
+          return [];
+        }
+        const buffer = this.inBuffer;
+        const entries = [];
+        let offset = this.centralDirOffset;
+        let remaining = this.centralDirSize;
+        const bufferSize = this.config.bufferSize || 512 * 1024;
+        while (remaining > 0) {
+          const currentBufferSize = Math.min(bufferSize, remaining);
+          const chunk = buffer.subarray(offset, offset + currentBufferSize);
+          let chunkOffset = 0;
+          while (chunkOffset < chunk.length) {
+            if (chunk.readUInt32LE(chunkOffset) !== Headers_1.CENTRAL_DIR.SIGNATURE) {
+              break;
+            }
+            const entry = new ZipEntry_1.default(null, null, false);
+            const entryData = chunk.subarray(chunkOffset);
+            const remainingData = entry.readZipEntry(entryData);
+            entries.push(entry);
+            chunkOffset += entryData.length - remainingData.length;
+          }
+          offset += currentBufferSize;
+          remaining -= currentBufferSize;
+        }
+        return entries;
+      }
+      /**
+       * Reset internal state (private method for Zipkit to call)
+       * Clears all ZIP-related data while keeping the instance alive
+       */
+      reset() {
+        this.centralDirSize = 0;
+        this.centralDirOffset = 0;
+      }
+      /**
+       * Create central end header
+       * Note: totalEntries must be passed as parameter since zipEntries[] in Zipkit is the cache
+       */
+      centralEndHdrMethod(centralDirSize, centralDirOffset, totalEntries) {
+        const ceBuf = Buffer.alloc(Headers_1.CENTRAL_END.SIZE);
+        ceBuf.writeUInt32LE(Headers_1.CENTRAL_END.SIGNATURE, 0);
+        ceBuf.writeUInt16LE(0, 4);
+        ceBuf.writeUInt16LE(0, 6);
+        ceBuf.writeUInt16LE(totalEntries, 8);
+        ceBuf.writeUInt16LE(totalEntries, 10);
+        ceBuf.writeUInt32LE(centralDirSize, 12);
+        ceBuf.writeUInt32LE(centralDirOffset, 16);
+        ceBuf.writeUInt16LE(0, 20);
+        return ceBuf;
+      }
+      /**
+       * Calculate Merkle Root of the ZIP file
+       *
+       * Excludes blockchain metadata files to ensure consistent calculation.
+       * Simply calls getDirectory() and returns null if empty.
+       *
+       * @returns Merkle root string or null if calculation fails
+       */
+      getMerkleRoot() {
+        let zipEntries;
+        try {
+          zipEntries = this.getDirectory();
+        } catch (error) {
+          Logger_12.Logger.error(`getMerkleRoot(): Error calling getDirectory(): ${error instanceof Error ? error.message : String(error)}`);
+          Logger_12.Logger.error(`getMerkleRoot(): Stack trace: ${error instanceof Error ? error.stack : "No stack trace"}`);
+          return null;
+        }
+        if (!zipEntries || zipEntries.length === 0) {
+          return null;
+        }
+        const hashAccumulator = new HashCalculator_12.default({ enableAccumulation: true });
+        const contentEntries = zipEntries.filter((entry) => {
+          const filename = entry.filename || "";
+          return filename !== Headers_1.TIMESTAMP_SUBMITTED && filename !== Headers_1.TIMESTAMP_METADATA && filename !== Headers_1.TOKENIZED_METADATA;
+        });
+        for (const entry of contentEntries) {
+          if (entry.sha256) {
+            const hashBuffer = Buffer.from(entry.sha256, "hex");
+            hashAccumulator.addHash(hashBuffer);
+          }
+        }
+        const merkleRoot = hashAccumulator.merkleRoot();
+        if (!merkleRoot) {
+          return null;
+        }
+        return merkleRoot;
+      }
+      /**
+       * Calculate Merkle Root of the ZIP file asynchronously
+       *
+       * Excludes blockchain metadata files to ensure consistent calculation.
+       * Works with both buffer-based and file-based ZIPs.
+       *
+       * @returns Promise resolving to Merkle root string or null if calculation fails
+       */
+      async getMerkleRootAsync() {
+        let zipEntries = [];
+        try {
+          if (this.inBuffer) {
+            zipEntries = this.getDirectory();
+          } else {
+            Logger_12.Logger.error("getMerkleRootAsync() called on file-based ZIP. Use ZipkitServer.getMerkleRootAsync() instead.");
+            return null;
+          }
+        } catch (error) {
+          Logger_12.Logger.error(`Failed to get directory for merkle root calculation: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+        if (!zipEntries || zipEntries.length === 0) {
+          return null;
+        }
+        const hashAccumulator = new HashCalculator_12.default({ enableAccumulation: true });
+        const contentEntries = zipEntries.filter((entry) => {
+          const filename = entry.filename || "";
+          return filename !== Headers_1.TIMESTAMP_SUBMITTED && filename !== Headers_1.TIMESTAMP_METADATA && filename !== Headers_1.TOKENIZED_METADATA;
+        });
+        for (const entry of contentEntries) {
+          if (entry.sha256) {
+            const hashBuffer = Buffer.from(entry.sha256, "hex");
+            hashAccumulator.addHash(hashBuffer);
+          }
+        }
+        const merkleRoot = hashAccumulator.merkleRoot();
+        if (!merkleRoot) {
+          return null;
+        }
+        return merkleRoot;
+      }
+    };
+    Zipkit.version = types_1.NEOZIPKIT_INFO.version;
+    Zipkit.releaseDate = types_1.NEOZIPKIT_INFO.releaseDate;
+    exports2.default = Zipkit;
+  }
+});
+
+// neozipkit/dist/core/components/Support.js
+var require_Support = __commonJS({
+  "neozipkit/dist/core/components/Support.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var Support = {
+      /** Base64 encoding support (always true) */
+      base64: true,
+      /** Array support (always true) */
+      array: true,
+      /** String support (always true) */
+      string: true,
+      /**
+       * Detects if code is running in Node.js environment
+       * True if process.versions.node exists, undefined in browser
+       */
+      isNode: true,
+      /**
+       * Detects if Node.js Buffer is available
+       * True in Node.js, undefined in browser
+       */
+      buffer: true,
+      /**
+       * Detects support for Uint8Array typed array
+       * Used for binary data handling
+       */
+      uint8array: true,
+      /**
+       * Detects support for both ArrayBuffer and Uint8Array
+       * Required for binary data operations
+       */
+      arrayBuffer: typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined",
+      /**
+       * Detects support for Blob with ArrayBuffer
+       * Tests by attempting to create an empty ZIP Blob
+       * @returns {boolean} True if Blob creation succeeds
+       */
+      blob: true,
+      /**
+       * Detects support for Streams API
+       * Checks for ReadableStream/WritableStream in browser
+       * or 'stream' module in Node.js
+       * @returns {boolean} True if streams are supported in current environment
+       */
+      streams: true,
+      /**
+       * Detects support for FileReader
+       * @returns {boolean} True if FileReader is supported
+       */
+      fileReader: false
+    };
+    exports2.default = Support;
+  }
+});
+
+// neozipkit/dist/core/components/Util.js
+var require_Util = __commonJS({
+  "neozipkit/dist/core/components/Util.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isMetadataFile = exports2.uMul = exports2.DATATYPE = void 0;
+    exports2.readBigUInt64LE = readBigUInt64LE;
+    exports2.isStream = isStream;
+    exports2.getTypeOf = getTypeOf;
+    var Support_1 = __importDefault2(require_Support());
+    var Errors_1 = __importDefault2(require_Errors());
+    var Headers_1 = require_Headers();
+    exports2.DATATYPE = {
+      STRING: "string",
+      BUFFER: "buffer",
+      ARRAY: "array",
+      ARRAYBUFFER: "arraybuffer",
+      U8ARRAY: "uint8array",
+      BLOB: "blob",
+      STREAM: "stream"
+    };
+    function readBigUInt64LE(buffer, index) {
+      var buf = Buffer.from(buffer.subarray(index, index + 8));
+      buf.swap64();
+      return parseInt(`0x${buf.toString("hex")}`);
+    }
+    __name(readBigUInt64LE, "readBigUInt64LE");
+    var uMul = /* @__PURE__ */ __name((a, b) => Math.imul(a, b) >>> 0, "uMul");
+    exports2.uMul = uMul;
+    function isStream(obj) {
+      if (!obj || typeof obj !== "object")
+        return false;
+      const streamLike = obj;
+      return typeof streamLike.on === "function" && typeof streamLike.pause === "function" && typeof streamLike.resume === "function";
+    }
+    __name(isStream, "isStream");
+    function getTypeOf(input) {
+      if (typeof input === "string") {
+        if (!Support_1.default.string)
+          throw new Error(Errors_1.default.DATATYPE_STRING_UNSUPPORTED);
+        return exports2.DATATYPE.STRING;
+      } else if (Object.prototype.toString.call(input) === "[object Array]") {
+        if (!Support_1.default.array)
+          throw new Error(Errors_1.default.DATATYPE_ARRAY_UNSUPPORTED);
+        return exports2.DATATYPE.ARRAY;
+      } else if (Buffer.isBuffer(input)) {
+        if (!Support_1.default.buffer)
+          throw new Error(Errors_1.default.DATATYPE_BUFFER_UNSUPPORTED);
+        return exports2.DATATYPE.BUFFER;
+      } else if (input instanceof Blob) {
+        if (!Support_1.default.blob)
+          throw new Error(Errors_1.default.DATATYPE_BLOB_UNSUPPORTED);
+        return exports2.DATATYPE.BLOB;
+      } else if (input instanceof Uint8Array) {
+        if (!Support_1.default.uint8array)
+          throw new Error(Errors_1.default.DATATYPE_U8ARRAY_UNSUPPORTED);
+        return exports2.DATATYPE.U8ARRAY;
+      } else if (input instanceof ArrayBuffer) {
+        if (!Support_1.default.arrayBuffer)
+          throw new Error(Errors_1.default.DATATYPE_ARRAYBUFFER_UNSUPPORTED);
+        return exports2.DATATYPE.ARRAYBUFFER;
+      } else {
+        throw new Error(Errors_1.default.DATATYPE_UNSUPPORTED);
+      }
+    }
+    __name(getTypeOf, "getTypeOf");
+    var isMetadataFile = /* @__PURE__ */ __name((filename) => {
+      return filename === Headers_1.TIMESTAMP_SUBMITTED || filename === Headers_1.TIMESTAMP_METADATA || filename === Headers_1.TOKENIZED_METADATA;
+    }, "isMetadataFile");
+    exports2.isMetadataFile = isMetadataFile;
+  }
+});
+
+// neozipkit/dist/core/components/ProgressTracker.js
+var require_ProgressTracker = __commonJS({
+  "neozipkit/dist/core/components/ProgressTracker.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ProgressTracker = void 0;
+    var ProgressTracker = class {
+      static {
+        __name(this, "ProgressTracker");
+      }
+      constructor(fileName, totalBytes) {
+        this.lastReportedPercent = -1;
+        this.fileName = fileName;
+        this.totalBytes = totalBytes;
+        this.processedBytes = 0;
+        this.startTime = Date.now();
+        this.lastUpdateTime = this.startTime;
+      }
+      /**
+       * Update progress with bytes processed
+       * @param bytesProcessed - Number of bytes processed in this update
+       */
+      update(bytesProcessed) {
+        this.processedBytes += bytesProcessed;
+        this.reportProgress();
+      }
+      /**
+       * Set total bytes (useful when file size changes)
+       */
+      setTotalBytes(totalBytes) {
+        this.totalBytes = totalBytes;
+      }
+      /**
+       * Report progress if enough time has passed or significant progress made
+       */
+      reportProgress() {
+        const now = Date.now();
+        const percent = Math.floor(this.processedBytes / this.totalBytes * 100);
+        const shouldReport = percent > this.lastReportedPercent || now - this.lastUpdateTime > 500;
+        if (shouldReport) {
+          this.lastReportedPercent = percent;
+          this.lastUpdateTime = now;
+          this.printProgress();
+        }
+      }
+      /**
+       * Print progress information
+       */
+      printProgress() {
+        const elapsed = (Date.now() - this.startTime) / 1e3;
+        const rate = this.processedBytes / elapsed;
+        const eta = this.totalBytes > this.processedBytes ? (this.totalBytes - this.processedBytes) / rate : 0;
+        const percent = Math.floor(this.processedBytes / this.totalBytes * 100);
+        const formatBytes = /* @__PURE__ */ __name((bytes) => {
+          const units = ["B", "KB", "MB", "GB"];
+          let size = bytes;
+          let unitIndex = 0;
+          while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+          }
+          return `${size.toFixed(1)}${units[unitIndex]}`;
+        }, "formatBytes");
+        const formatTime = /* @__PURE__ */ __name((seconds) => {
+          if (seconds < 60)
+            return `${seconds.toFixed(0)}s`;
+          if (seconds < 3600)
+            return `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(0)}s`;
+          return `${Math.floor(seconds / 3600)}h ${Math.floor(seconds % 3600 / 60)}m`;
+        }, "formatTime");
+        process.stdout.write(`\r${this.fileName}: ${percent}% (${formatBytes(this.processedBytes)}/${formatBytes(this.totalBytes)}) [${formatBytes(rate)}/s] ETA: ${formatTime(eta)}`);
+      }
+      /**
+       * Complete progress tracking
+       */
+      complete() {
+        const elapsed = (Date.now() - this.startTime) / 1e3;
+        const rate = this.processedBytes / elapsed;
+        const formatBytes = /* @__PURE__ */ __name((bytes) => {
+          const units = ["B", "KB", "MB", "GB"];
+          let size = bytes;
+          let unitIndex = 0;
+          while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+          }
+          return `${size.toFixed(1)}${units[unitIndex]}`;
+        }, "formatBytes");
+        console.log(`\r${this.fileName}: 100% (${formatBytes(this.processedBytes)}) [${formatBytes(rate)}/s] completed in ${elapsed.toFixed(1)}s`);
+      }
+      /**
+       * Get current progress percentage
+       */
+      getProgressPercent() {
+        return Math.floor(this.processedBytes / this.totalBytes * 100);
+      }
+      /**
+       * Get processing rate in bytes per second
+       */
+      getProcessingRate() {
+        const elapsed = (Date.now() - this.startTime) / 1e3;
+        return this.processedBytes / elapsed;
+      }
+    };
+    exports2.ProgressTracker = ProgressTracker;
+  }
+});
+
+// neozipkit/dist/core/encryption/Manager.js
+var require_Manager = __commonJS({
+  "neozipkit/dist/core/encryption/Manager.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.EncryptionManager = void 0;
+    var types_1 = require_types();
+    var ZipCrypto_12 = require_ZipCrypto();
+    var EncryptionManager = class {
+      static {
+        __name(this, "EncryptionManager");
+      }
+      constructor() {
+        this.providers = /* @__PURE__ */ new Map();
+        this.registerProvider(new ZipCrypto_12.ZipCrypto());
+      }
+      /**
+       * Register a new encryption provider
+       */
+      registerProvider(provider) {
+        if (provider.canHandle(types_1.EncryptionMethod.ZIP_CRYPTO)) {
+          this.providers.set(types_1.EncryptionMethod.ZIP_CRYPTO, provider);
+        }
+      }
+      /**
+       * Get available encryption methods
+       */
+      getAvailableMethods() {
+        return Array.from(this.providers.keys());
+      }
+      /**
+       * Get encryption provider for a specific method
+       */
+      getProvider(method) {
+        return this.providers.get(method) || null;
+      }
+      /**
+       * Encrypt data using specified method
+       */
+      async encrypt(data, options) {
+        const provider = this.getProvider(options.method);
+        if (!provider) {
+          return {
+            success: false,
+            error: `No encryption provider available for method ${options.method}`
+          };
+        }
+        return await provider.encrypt(data, options);
+      }
+      /**
+       * Decrypt data using specified method
+       */
+      async decrypt(data, options) {
+        const provider = this.getProvider(options.method);
+        if (!provider) {
+          return {
+            success: false,
+            error: `No decryption provider available for method ${options.method}`
+          };
+        }
+        return await provider.decrypt(data, options);
+      }
+      /**
+       * Get recommended encryption method (ZIP_CRYPTO)
+       */
+      getRecommendedMethod() {
+        return types_1.EncryptionMethod.ZIP_CRYPTO;
+      }
+      /**
+       * Validate encryption options
+       */
+      validateOptions(options) {
+        const errors = [];
+        if (!options.method) {
+          errors.push("Encryption method is required");
+        }
+        if (!options.password || options.password.length === 0) {
+          errors.push("Password is required");
+        }
+        if (options.password && options.password.length < 4) {
+          errors.push("Password must be at least 4 characters long");
+        }
+        return {
+          isValid: errors.length === 0,
+          errors
+        };
+      }
+      /**
+       * Get encryption method info
+       */
+      getMethodInfo(method) {
+        const provider = this.getProvider(method);
+        if (!provider) {
+          return null;
+        }
+        return {
+          name: provider.getMethodName(),
+          keyLength: provider.getKeyLength(),
+          secure: false
+        };
+      }
+      /**
+       * List all available encryption methods with their details
+       */
+      listMethods() {
+        const methods = [];
+        for (const [method, provider] of this.providers) {
+          methods.push({
+            method,
+            name: provider.getMethodName(),
+            keyLength: provider.getKeyLength(),
+            secure: false
+          });
+        }
+        return methods.sort((a, b) => {
+          return a.name.localeCompare(b.name);
+        });
+      }
+    };
+    exports2.EncryptionManager = EncryptionManager;
+  }
+});
+
+// neozipkit/dist/core/version.js
+var require_version = __commonJS({
+  "neozipkit/dist/core/version.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VERSION = void 0;
+    var currentDate = /* @__PURE__ */ new Date();
+    var releaseDate = `${String(currentDate.getMonth() + 1).padStart(2, "0")}-${String(currentDate.getDate()).padStart(2, "0")}-${currentDate.getFullYear()}`;
+    exports2.VERSION = {
+      number: "0.3.0",
+      // packageJson.version,
+      date: releaseDate
+    };
+  }
+});
+
+// neozipkit/dist/core/index.js
+var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+  if (k2 === void 0)
+    k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = { enumerable: true, get: function() {
+      return m[k];
+    } };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+  if (k2 === void 0)
+    k2 = k;
+  o[k2] = m[k];
+});
+var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+  for (var p in m)
+    if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+      __createBinding(exports2, m, p);
+};
+var __importDefault = exports && exports.__importDefault || function(mod) {
+  return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLoggerFromEnvironment = exports.Logger = exports.sha256 = exports.crc32update = exports.crc32 = exports.ZipCrypto = exports.EncryptionManager = exports.ProgressTracker = exports.HashCalculatorClass = exports.HashCalculator = exports.ZipCompress = void 0;
+var Zipkit_1 = __importDefault(require_Zipkit());
+__exportStar(require_Zipkit(), exports);
+__exportStar(require_ZipEntry(), exports);
+var ZipCompress_1 = require_ZipCompress();
+Object.defineProperty(exports, "ZipCompress", { enumerable: true, get: function() {
+  return ZipCompress_1.ZipCompress;
+} });
+exports.default = Zipkit_1.default;
+var HashCalculator_1 = require_HashCalculator();
+Object.defineProperty(exports, "HashCalculator", { enumerable: true, get: function() {
+  return __importDefault(HashCalculator_1).default;
+} });
+Object.defineProperty(exports, "HashCalculatorClass", { enumerable: true, get: function() {
+  return HashCalculator_1.HashCalculator;
+} });
+__exportStar(require_Util(), exports);
+__exportStar(require_Support(), exports);
+var ProgressTracker_1 = require_ProgressTracker();
+Object.defineProperty(exports, "ProgressTracker", { enumerable: true, get: function() {
+  return ProgressTracker_1.ProgressTracker;
+} });
+var Manager_1 = require_Manager();
+Object.defineProperty(exports, "EncryptionManager", { enumerable: true, get: function() {
+  return Manager_1.EncryptionManager;
+} });
+var ZipCrypto_1 = require_ZipCrypto();
+Object.defineProperty(exports, "ZipCrypto", { enumerable: true, get: function() {
+  return ZipCrypto_1.ZipCrypto;
+} });
+Object.defineProperty(exports, "crc32", { enumerable: true, get: function() {
+  return ZipCrypto_1.crc32;
+} });
+Object.defineProperty(exports, "crc32update", { enumerable: true, get: function() {
+  return ZipCrypto_1.crc32update;
+} });
+Object.defineProperty(exports, "sha256", { enumerable: true, get: function() {
+  return ZipCrypto_1.sha256;
+} });
+__exportStar(require_types2(), exports);
+__exportStar(require_Headers(), exports);
+__exportStar(require_Errors(), exports);
+__exportStar(require_version(), exports);
+var Logger_1 = require_Logger();
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function() {
+  return Logger_1.Logger;
+} });
+Object.defineProperty(exports, "configureLoggerFromEnvironment", { enumerable: true, get: function() {
+  return Logger_1.configureLoggerFromEnvironment;
+} });
+//# sourceMappingURL=core.js.map