@cj-tech-master/excelts 1.4.5-canary.20251212143538.45665af → 1.4.5-canary.20251212160853.7621827

package/dist/browser/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
- * @cj-tech-master/excelts v1.4.5-canary.20251212143538.45665af
+ * @cj-tech-master/excelts v1.4.5-canary.20251212160853.7621827
  * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
  * (c) 2025 cjnoname
  * Released under the MIT License

package/dist/browser/excelts.iife.min.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v1.4.5-canary.20251212143538.45665af
+* @cj-tech-master/excelts v1.4.5-canary.20251212160853.7621827
 * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
 * (c) 2025 cjnoname
 * Released under the MIT License

package/dist/cjs/utils/unzip/extract.js

@@ -2,18 +2,19 @@
 /**
  * Simple ZIP extraction utilities
  * Provides easy-to-use Promise-based API for extracting ZIP files
+ * Works in both Node.js and browser environments
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipParser = void 0;
 exports.extractAll = extractAll;
 exports.extractFile = extractFile;
 exports.listFiles = listFiles;
 exports.forEachEntry = forEachEntry;
-const stream_1 = require("stream");
-const parse_js_1 = require("./parse");
+const zip_parser_js_1 = require("./zip-parser");
 /**
  * Extract all files from a ZIP buffer
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @returns Map of file paths to their content
  *
  * @example
@@ -30,40 +31,24 @@ const parse_js_1 = require("./parse");
  */
 async function extractAll(zipData) {
     const files = new Map();
-    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
-    const parse = (0, parse_js_1.createParse)({ forceStream: true });
-    const stream = stream_1.Readable.from([buffer]);
-    stream.pipe(parse);
-    for await (const entry of parse) {
-        const zipEntry = entry;
-        const isDirectory = zipEntry.type === "Directory";
-        if (isDirectory) {
-            files.set(zipEntry.path, {
-                path: zipEntry.path,
-                data: Buffer.alloc(0),
-                isDirectory: true,
-                size: 0
-            });
-            zipEntry.autodrain();
-        }
-        else {
-            const data = await zipEntry.buffer();
-            files.set(zipEntry.path, {
-                path: zipEntry.path,
-                data,
-                isDirectory: false,
-                size: data.length
-            });
-        }
+    const parser = new zip_parser_js_1.ZipParser(zipData);
+    for (const entry of parser.getEntries()) {
+        const data = await parser.extract(entry.path);
+        files.set(entry.path, {
+            path: entry.path,
+            data: data || new Uint8Array(0),
+            isDirectory: entry.isDirectory,
+            size: entry.uncompressedSize
+        });
     }
     return files;
 }
 /**
  * Extract a single file from a ZIP buffer
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @param filePath - Path of the file to extract
- * @returns File content as Buffer, or null if not found
+ * @returns File content as Uint8Array, or null if not found
  *
  * @example
  * ```ts
@@ -72,31 +57,18 @@ async function extractAll(zipData) {
  * const zipData = fs.readFileSync("archive.zip");
  * const content = await extractFile(zipData, "readme.txt");
  * if (content) {
- *   console.log(content.toString("utf-8"));
+ *   console.log(new TextDecoder().decode(content));
  * }
  * ```
  */
 async function extractFile(zipData, filePath) {
-    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
-    const parse = (0, parse_js_1.createParse)({ forceStream: true });
-    const stream = stream_1.Readable.from([buffer]);
-    stream.pipe(parse);
-    for await (const entry of parse) {
-        const zipEntry = entry;
-        if (zipEntry.path === filePath) {
-            if (zipEntry.type === "Directory") {
-                return Buffer.alloc(0);
-            }
-            return zipEntry.buffer();
-        }
-        zipEntry.autodrain();
-    }
-    return null;
+    const parser = new zip_parser_js_1.ZipParser(zipData);
+    return parser.extract(filePath);
 }
 /**
  * List all file paths in a ZIP buffer (without extracting content)
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @returns Array of file paths
  *
  * @example
@@ -109,22 +81,13 @@ async function extractFile(zipData, filePath) {
  * ```
  */
 async function listFiles(zipData) {
-    const paths = [];
-    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
-    const parse = (0, parse_js_1.createParse)({ forceStream: true });
-    const stream = stream_1.Readable.from([buffer]);
-    stream.pipe(parse);
-    for await (const entry of parse) {
-        const zipEntry = entry;
-        paths.push(zipEntry.path);
-        zipEntry.autodrain();
-    }
-    return paths;
+    const parser = new zip_parser_js_1.ZipParser(zipData);
+    return parser.listFiles();
 }
 /**
  * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @param callback - Async callback for each entry, return false to stop iteration
  *
  * @example
@@ -134,33 +97,18 @@ async function listFiles(zipData) {
  * await forEachEntry(zipData, async (path, getData) => {
  *   if (path.endsWith(".xml")) {
  *     const content = await getData();
- *     console.log(content.toString("utf-8"));
+ *     console.log(new TextDecoder().decode(content));
  *   }
  *   return true; // continue iteration
  * });
  * ```
  */
 async function forEachEntry(zipData, callback) {
-    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
-    const parse = (0, parse_js_1.createParse)({ forceStream: true });
-    const stream = stream_1.Readable.from([buffer]);
-    stream.pipe(parse);
-    for await (const entry of parse) {
-        const zipEntry = entry;
-        let dataPromise = null;
-        const getData = () => {
-            if (!dataPromise) {
-                dataPromise = zipEntry.buffer();
-            }
-            return dataPromise;
-        };
-        const shouldContinue = await callback(zipEntry.path, getData, zipEntry);
-        // If callback didn't read data, drain it
-        if (!dataPromise) {
-            zipEntry.autodrain();
-        }
-        if (shouldContinue === false) {
-            break;
-        }
-    }
+    const parser = new zip_parser_js_1.ZipParser(zipData);
+    await parser.forEach(async (entry, getData) => {
+        return callback(entry.path, getData, entry);
+    });
 }
+// Re-export ZipParser for advanced usage
+var zip_parser_js_2 = require("./zip-parser");
+Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return zip_parser_js_2.ZipParser; } });

package/dist/cjs/utils/unzip/index.js

@@ -1,11 +1,26 @@
 "use strict";
 /**
  * Unzip utilities for parsing ZIP archives
+ *
+ * Two APIs are provided:
+ *
+ * 1. **Stream-based API** (Node.js only):
+ *    - `Parse`, `createParse` - Parse ZIP files as a stream
+ *    - Best for large files where you don't want to load entire file into memory
+ *    - Requires Node.js `stream` module
+ *
+ * 2. **Buffer-based API** (Browser + Node.js):
+ *    - `extractAll`, `extractFile`, `listFiles`, `forEachEntry`, `ZipParser`
+ *    - Works in both Node.js and browser environments
+ *    - Uses native `DecompressionStream` in browser, `zlib` in Node.js
+ *    - Best for files already loaded into memory (ArrayBuffer, Uint8Array)
+ *
  * Original source: https://github.com/ZJONSSON/node-unzipper
  * License: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.forEachEntry = exports.listFiles = exports.extractFile = exports.extractAll = exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
+exports.ZipParser = exports.forEachEntry = exports.listFiles = exports.extractFile = exports.extractAll = exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
+// Stream-based API (Node.js only - requires stream module)
 var parse_js_1 = require("./parse");
 Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_js_1.Parse; } });
 Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_js_1.createParse; } });
@@ -21,9 +36,10 @@ var parse_datetime_js_1 = require("./parse-datetime");
 Object.defineProperty(exports, "parseDateTime", { enumerable: true, get: function () { return parse_datetime_js_1.parseDateTime; } });
 var parse_extra_field_js_1 = require("./parse-extra-field");
 Object.defineProperty(exports, "parseExtraField", { enumerable: true, get: function () { return parse_extra_field_js_1.parseExtraField; } });
-// Simple extraction API
+// Buffer-based API (Browser + Node.js - cross-platform)
 var extract_js_1 = require("./extract");
 Object.defineProperty(exports, "extractAll", { enumerable: true, get: function () { return extract_js_1.extractAll; } });
 Object.defineProperty(exports, "extractFile", { enumerable: true, get: function () { return extract_js_1.extractFile; } });
 Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return extract_js_1.listFiles; } });
 Object.defineProperty(exports, "forEachEntry", { enumerable: true, get: function () { return extract_js_1.forEachEntry; } });
+Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return extract_js_1.ZipParser; } });

package/dist/cjs/utils/unzip/zip-parser.js

@@ -0,0 +1,458 @@
+"use strict";
+/**
+ * Pure Uint8Array-based ZIP parser
+ * Works in both Node.js and browser environments
+ * No dependency on Node.js stream module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipParser = void 0;
+exports.parseZipEntries = parseZipEntries;
+exports.extractEntryData = extractEntryData;
+exports.extractEntryDataSync = extractEntryDataSync;
+const compress_js_1 = require("../zip/compress");
+// ZIP file signatures
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+const ZIP64_END_OF_CENTRAL_DIR_SIG = 0x06064b50;
+const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50;
+// Compression methods
+const COMPRESSION_STORED = 0;
+const COMPRESSION_DEFLATE = 8;
+/**
+ * Parse DOS date/time format to JavaScript Date
+ * Dates in zip file entries are stored as DosDateTime
+ * Spec: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
+ */
+function parseDateTime(date, time) {
+    const day = date & 0x1f;
+    const month = (date >> 5) & 0x0f;
+    const year = ((date >> 9) & 0x7f) + 1980;
+    const seconds = time ? (time & 0x1f) * 2 : 0;
+    const minutes = time ? (time >> 5) & 0x3f : 0;
+    const hours = time ? time >> 11 : 0;
+    return new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
+}
+/**
+ * Parse ZIP64 extra field
+ */
+function parseZip64ExtraField(extraField, compressedSize, uncompressedSize, localHeaderOffset) {
+    const view = new DataView(extraField.buffer, extraField.byteOffset, extraField.byteLength);
+    let offset = 0;
+    while (offset + 4 <= extraField.length) {
+        const signature = view.getUint16(offset, true);
+        const partSize = view.getUint16(offset + 2, true);
+        if (signature === 0x0001) {
+            // ZIP64 extended information
+            let fieldOffset = offset + 4;
+            if (uncompressedSize === 0xffffffff && fieldOffset + 8 <= offset + 4 + partSize) {
+                uncompressedSize = Number(view.getBigUint64(fieldOffset, true));
+                fieldOffset += 8;
+            }
+            if (compressedSize === 0xffffffff && fieldOffset + 8 <= offset + 4 + partSize) {
+                compressedSize = Number(view.getBigUint64(fieldOffset, true));
+                fieldOffset += 8;
+            }
+            if (localHeaderOffset === 0xffffffff && fieldOffset + 8 <= offset + 4 + partSize) {
+                localHeaderOffset = Number(view.getBigUint64(fieldOffset, true));
+            }
+            break;
+        }
+        offset += 4 + partSize;
+    }
+    return { compressedSize, uncompressedSize, localHeaderOffset };
+}
+/**
+ * DataView helper for reading little-endian values
+ */
+class BinaryReader {
+    constructor(data, offset = 0) {
+        this.data = data;
+        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        this.offset = offset;
+    }
+    get position() {
+        return this.offset;
+    }
+    set position(value) {
+        this.offset = value;
+    }
+    get remaining() {
+        return this.data.length - this.offset;
+    }
+    readUint8() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readUint16() {
+        const value = this.view.getUint16(this.offset, true);
+        this.offset += 2;
+        return value;
+    }
+    readUint32() {
+        const value = this.view.getUint32(this.offset, true);
+        this.offset += 4;
+        return value;
+    }
+    readBigUint64() {
+        const value = this.view.getBigUint64(this.offset, true);
+        this.offset += 8;
+        return value;
+    }
+    readBytes(length) {
+        const bytes = this.data.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return bytes;
+    }
+    readString(length, utf8 = true) {
+        const bytes = this.readBytes(length);
+        if (utf8) {
+            return new TextDecoder("utf-8").decode(bytes);
+        }
+        // Fallback to ASCII/Latin-1
+        return String.fromCharCode(...bytes);
+    }
+    skip(length) {
+        this.offset += length;
+    }
+    slice(start, end) {
+        return this.data.subarray(start, end);
+    }
+    peekUint32(offset) {
+        return this.view.getUint32(offset, true);
+    }
+}
+/**
+ * Find the End of Central Directory record
+ * Searches backwards from the end of the file
+ */
+function findEndOfCentralDir(data) {
+    // EOCD is at least 22 bytes, search backwards
+    // Comment can be up to 65535 bytes
+    const minOffset = Math.max(0, data.length - 65557);
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    for (let i = data.length - 22; i >= minOffset; i--) {
+        if (view.getUint32(i, true) === END_OF_CENTRAL_DIR_SIG) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Find ZIP64 End of Central Directory Locator
+ */
+function findZip64EOCDLocator(data, eocdOffset) {
+    // ZIP64 EOCD Locator is 20 bytes and appears right before EOCD
+    const locatorOffset = eocdOffset - 20;
+    if (locatorOffset < 0) {
+        return -1;
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (view.getUint32(locatorOffset, true) === ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
+        return locatorOffset;
+    }
+    return -1;
+}
+/**
+ * Parse ZIP file entries from Central Directory
+ */
+function parseZipEntries(data, options = {}) {
+    const { decodeStrings = true } = options;
+    const entries = [];
+    // Find End of Central Directory
+    const eocdOffset = findEndOfCentralDir(data);
+    if (eocdOffset === -1) {
+        throw new Error("Invalid ZIP file: End of Central Directory not found");
+    }
+    const reader = new BinaryReader(data, eocdOffset);
+    // Read EOCD
+    // Offset  Size  Description
+    // 0       4     EOCD signature (0x06054b50)
+    // 4       2     Number of this disk
+    // 6       2     Disk where central directory starts
+    // 8       2     Number of central directory records on this disk
+    // 10      2     Total number of central directory records
+    // 12      4     Size of central directory (bytes)
+    // 16      4     Offset of start of central directory
+    // 20      2     Comment length
+    reader.skip(4); // signature
+    reader.skip(2); // disk number
+    reader.skip(2); // disk where central dir starts
+    reader.skip(2); // entries on this disk
+    let totalEntries = reader.readUint16(); // total entries
+    let centralDirSize = reader.readUint32();
+    let centralDirOffset = reader.readUint32();
+    // Check for ZIP64
+    const zip64LocatorOffset = findZip64EOCDLocator(data, eocdOffset);
+    if (zip64LocatorOffset !== -1) {
+        const locatorReader = new BinaryReader(data, zip64LocatorOffset);
+        locatorReader.skip(4); // signature
+        locatorReader.skip(4); // disk number with ZIP64 EOCD
+        const zip64EOCDOffset = Number(locatorReader.readBigUint64());
+        // Read ZIP64 EOCD
+        const zip64Reader = new BinaryReader(data, zip64EOCDOffset);
+        const zip64Sig = zip64Reader.readUint32();
+        if (zip64Sig === ZIP64_END_OF_CENTRAL_DIR_SIG) {
+            zip64Reader.skip(8); // size of ZIP64 EOCD
+            zip64Reader.skip(2); // version made by
+            zip64Reader.skip(2); // version needed
+            zip64Reader.skip(4); // disk number
+            zip64Reader.skip(4); // disk with central dir
+            const zip64TotalEntries = Number(zip64Reader.readBigUint64());
+            const zip64CentralDirSize = Number(zip64Reader.readBigUint64());
+            const zip64CentralDirOffset = Number(zip64Reader.readBigUint64());
+            // Use ZIP64 values if standard values are maxed out
+            if (totalEntries === 0xffff) {
+                totalEntries = zip64TotalEntries;
+            }
+            if (centralDirSize === 0xffffffff) {
+                centralDirSize = zip64CentralDirSize;
+            }
+            if (centralDirOffset === 0xffffffff) {
+                centralDirOffset = zip64CentralDirOffset;
+            }
+        }
+    }
+    // Read Central Directory entries
+    const centralReader = new BinaryReader(data, centralDirOffset);
+    for (let i = 0; i < totalEntries; i++) {
+        const sig = centralReader.readUint32();
+        if (sig !== CENTRAL_DIR_HEADER_SIG) {
+            throw new Error(`Invalid Central Directory header signature at entry ${i}`);
+        }
+        // Central Directory File Header format:
+        // Offset  Size  Description
+        // 0       4     Central directory file header signature (0x02014b50)
+        // 4       2     Version made by
+        // 6       2     Version needed to extract
+        // 8       2     General purpose bit flag
+        // 10      2     Compression method
+        // 12      2     File last modification time
+        // 14      2     File last modification date
+        // 16      4     CRC-32
+        // 20      4     Compressed size
+        // 24      4     Uncompressed size
+        // 28      2     File name length
+        // 30      2     Extra field length
+        // 32      2     File comment length
+        // 34      2     Disk number where file starts
+        // 36      2     Internal file attributes
+        // 38      4     External file attributes
+        // 42      4     Relative offset of local file header
+        // 46      n     File name
+        // 46+n    m     Extra field
+        // 46+n+m  k     File comment
+        centralReader.skip(2); // version made by
+        centralReader.skip(2); // version needed
+        const flags = centralReader.readUint16();
+        const compressionMethod = centralReader.readUint16();
+        const lastModTime = centralReader.readUint16();
+        const lastModDate = centralReader.readUint16();
+        const crc32 = centralReader.readUint32();
+        let compressedSize = centralReader.readUint32();
+        let uncompressedSize = centralReader.readUint32();
+        const fileNameLength = centralReader.readUint16();
+        const extraFieldLength = centralReader.readUint16();
+        const commentLength = centralReader.readUint16();
+        centralReader.skip(2); // disk number start
+        centralReader.skip(2); // internal attributes
+        const externalAttributes = centralReader.readUint32();
+        let localHeaderOffset = centralReader.readUint32();
+        // Check for UTF-8 flag (bit 11)
+        const isUtf8 = (flags & 0x800) !== 0;
+        const useUtf8 = decodeStrings && isUtf8;
+        const fileName = centralReader.readString(fileNameLength, useUtf8);
+        const extraField = centralReader.readBytes(extraFieldLength);
+        const comment = centralReader.readString(commentLength, useUtf8);
+        // Parse extra field for ZIP64 values
+        if (extraFieldLength > 0) {
+            const parsed = parseZip64ExtraField(extraField, compressedSize, uncompressedSize, localHeaderOffset);
+            compressedSize = parsed.compressedSize;
+            uncompressedSize = parsed.uncompressedSize;
+            localHeaderOffset = parsed.localHeaderOffset;
+        }
+        const isDirectory = fileName.endsWith("/") || (externalAttributes & 0x10) !== 0;
+        const isEncrypted = (flags & 0x01) !== 0;
+        entries.push({
+            path: fileName,
+            isDirectory,
+            compressedSize,
+            uncompressedSize,
+            compressionMethod,
+            crc32,
+            lastModified: parseDateTime(lastModDate, lastModTime),
+            localHeaderOffset,
+            comment,
+            externalAttributes,
+            isEncrypted
+        });
+    }
+    return entries;
+}
+/**
+ * Extract file data for a specific entry
+ */
+async function extractEntryData(data, entry) {
+    if (entry.isDirectory) {
+        return new Uint8Array(0);
+    }
+    if (entry.isEncrypted) {
+        throw new Error(`File "${entry.path}" is encrypted and cannot be extracted`);
+    }
+    const reader = new BinaryReader(data, entry.localHeaderOffset);
+    // Read local file header
+    const sig = reader.readUint32();
+    if (sig !== LOCAL_FILE_HEADER_SIG) {
+        throw new Error(`Invalid local file header signature for "${entry.path}"`);
+    }
+    reader.skip(2); // version needed
+    reader.skip(2); // flags
+    reader.skip(2); // compression method
+    reader.skip(2); // last mod time
+    reader.skip(2); // last mod date
+    reader.skip(4); // crc32
+    reader.skip(4); // compressed size
+    reader.skip(4); // uncompressed size
+    const fileNameLength = reader.readUint16();
+    const extraFieldLength = reader.readUint16();
+    reader.skip(fileNameLength);
+    reader.skip(extraFieldLength);
+    // Extract compressed data
+    const compressedData = reader.readBytes(entry.compressedSize);
+    // Decompress if needed
+    if (entry.compressionMethod === COMPRESSION_STORED) {
+        return compressedData;
+    }
+    else if (entry.compressionMethod === COMPRESSION_DEFLATE) {
+        return (0, compress_js_1.decompress)(compressedData);
+    }
+    else {
+        throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
+    }
+}
+/**
+ * Extract file data synchronously (Node.js only)
+ */
+function extractEntryDataSync(data, entry) {
+    if (entry.isDirectory) {
+        return new Uint8Array(0);
+    }
+    if (entry.isEncrypted) {
+        throw new Error(`File "${entry.path}" is encrypted and cannot be extracted`);
+    }
+    const reader = new BinaryReader(data, entry.localHeaderOffset);
+    // Read local file header
+    const sig = reader.readUint32();
+    if (sig !== LOCAL_FILE_HEADER_SIG) {
+        throw new Error(`Invalid local file header signature for "${entry.path}"`);
+    }
+    reader.skip(2); // version needed
+    reader.skip(2); // flags
+    reader.skip(2); // compression method
+    reader.skip(2); // last mod time
+    reader.skip(2); // last mod date
+    reader.skip(4); // crc32
+    reader.skip(4); // compressed size
+    reader.skip(4); // uncompressed size
+    const fileNameLength = reader.readUint16();
+    const extraFieldLength = reader.readUint16();
+    reader.skip(fileNameLength);
+    reader.skip(extraFieldLength);
+    // Extract compressed data
+    const compressedData = reader.readBytes(entry.compressedSize);
+    // Decompress if needed
+    if (entry.compressionMethod === COMPRESSION_STORED) {
+        return compressedData;
+    }
+    else if (entry.compressionMethod === COMPRESSION_DEFLATE) {
+        return (0, compress_js_1.decompressSync)(compressedData);
+    }
+    else {
+        throw new Error(`Unsupported compression method: ${entry.compressionMethod}`);
+    }
+}
+/**
+ * High-level ZIP parser class
+ */
+class ZipParser {
+    constructor(data, options = {}) {
+        this.data = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+        this.entries = parseZipEntries(this.data, options);
+        this.entryMap = new Map(this.entries.map(e => [e.path, e]));
+    }
+    /**
+     * Get all entries in the ZIP file
+     */
+    getEntries() {
+        return this.entries;
+    }
+    /**
+     * Get entry by path
+     */
+    getEntry(path) {
+        return this.entryMap.get(path);
+    }
+    /**
+     * Check if entry exists
+     */
+    hasEntry(path) {
+        return this.entryMap.has(path);
+    }
+    /**
+     * List all file paths
+     */
+    listFiles() {
+        return this.entries.map(e => e.path);
+    }
+    /**
+     * Extract a single file (async)
+     */
+    async extract(path) {
+        const entry = this.entryMap.get(path);
+        if (!entry) {
+            return null;
+        }
+        return extractEntryData(this.data, entry);
+    }
+    /**
+     * Extract a single file (sync, Node.js only)
+     */
+    extractSync(path) {
+        const entry = this.entryMap.get(path);
+        if (!entry) {
+            return null;
+        }
+        return extractEntryDataSync(this.data, entry);
+    }
+    /**
+     * Extract all files (async)
+     */
+    async extractAll() {
+        const result = new Map();
+        for (const entry of this.entries) {
+            const data = await extractEntryData(this.data, entry);
+            result.set(entry.path, data);
+        }
+        return result;
+    }
+    /**
+     * Iterate over entries with async callback
+     */
+    async forEach(callback) {
+        for (const entry of this.entries) {
+            let dataPromise = null;
+            const getData = () => {
+                if (!dataPromise) {
+                    dataPromise = extractEntryData(this.data, entry);
+                }
+                return dataPromise;
+            };
+            const shouldContinue = await callback(entry, getData);
+            if (shouldContinue === false) {
+                break;
+            }
+        }
+    }
+}
+exports.ZipParser = ZipParser;