neozipkit 0.2.1 → 0.3.0

package/dist/node/ZipDecompressNode.d.ts

@@ -0,0 +1,120 @@
+import ZipkitNode from './ZipkitNode';
+import ZipEntry from '../core/ZipEntry';
+/**
+ * ZipDecompressNode - Node.js file-based decompression operations
+ *
+ * Independent decompression implementation for Node.js environments.
+ * All decompression logic is implemented directly without delegating to ZipDecompress.
+ *
+ * @example
+ * ```typescript
+ * const zipkitNode = new ZipkitNode();
+ * const decompressNode = new ZipDecompressNode(zipkitNode);
+ * await decompressNode.extractToFile(entry, './output/file.txt');
+ * ```
+ */
+export declare class ZipDecompressNode {
+    private zipkitNode;
+    private zstdCodec;
+    private static loggingEnabled;
+    /**
+     * Creates a new ZipDecompressNode instance
+     * @param zipkitNode - ZipkitNode instance to use for ZIP operations
+     */
+    constructor(zipkitNode: ZipkitNode);
+    /**
+     * Internal logging method - only logs if class logging is enabled
+     */
+    private log;
+    /**
+     * Extract file directly to disk with true streaming (no memory buffering)
+     * Public method that validates file mode and extracts entry to file
+     *
+     * This method processes chunks as they are decompressed and writes them
+     * directly to disk, maintaining minimal memory footprint regardless of file size.
+     * This is the recommended method for file extraction to avoid memory issues.
+     *
+     * @param entry ZIP entry to extract
+     * @param outputPath Path where the file should be written
+     * @param options Optional extraction options including progress callback
+     * @throws Error if not a File-based ZIP
+     */
+    extractToFile(entry: ZipEntry, outputPath: string, options?: {
+        skipHashCheck?: boolean;
+        onProgress?: (bytes: number) => void;
+    }): Promise<void>;
+    /**
+     * Read compressed data from file and yield one block at a time
+     *
+     * MEMORY EFFICIENCY: Yields compressed data chunks one at a time without accumulation.
+     * Each chunk is read from disk and yielded immediately, allowing downstream processing
+     * (decryption, decompression) to handle one block at a time.
+     *
+     * @param fileHandle - File handle to read from
+     * @param entry - ZIP entry to read compressed data for
+     * @param chunkSize - Optional chunk size override (defaults to ZipkitServer's bufferSize)
+     * @returns Async generator yielding compressed data chunks one at a time
+     */
+    private readCompressedDataStream;
+    /**
+     * Handles: reading compressed data, optional decryption, decompression, hashing, and writing
+     * Internal method that takes fileHandle as parameter
+     */
+    private extractToFileInternal;
+    /**
+     * Decompress data stream and write to file
+     *
+     * MEMORY EFFICIENCY: Processes decompressed chunks one at a time.
+     * Pipeline: compressedStream → decompressStream() → hashCalc → writeStream
+     * - Each decompressed chunk is written immediately without accumulation
+     * - Hash calculation is incremental (HashCalculator)
+     * - Progress callbacks are invoked per chunk
+     *
+     * Handles decompression, hash calculation, file writing, and verification.
+     * Internal method only
+     */
+    private unCompressToFile;
+    /**
+     * Decompress data stream chunk by chunk
+     *
+     * MEMORY EFFICIENCY: Processes compressed data one block at a time.
+     * - For STORED: Passes through chunks unchanged (no accumulation)
+     * - For DEFLATED: Uses pako streaming inflate (maintains state across chunks)
+     * - For ZSTD: Collects all chunks (ZSTD limitation - requires full buffer)
+     *
+     * Pipeline: readCompressedDataStream() → DecryptionStream.decrypt() → decompressStream() → writeStream
+     *
+     * Internal method only
+     */
+    private decompressStream;
+    /**
+     * Streaming deflate decompression using pako
+     *
+     * MEMORY EFFICIENCY: Processes compressed chunks one at a time.
+     * - Inflator maintains decompression state across chunks
+     * - Decompressed chunks are yielded immediately after processing each compressed chunk
+     * - No accumulation of compressed data (except in pako's internal buffers)
+     */
+    private inflateStream;
+    /**
+     * Streaming ZSTD decompression
+     */
+    private zstdDecompressStream;
+    /**
+     * Inflate data using pako (internal use only)
+     */
+    private inflate;
+    /**
+     * Synchronous zstd decompress method for in-memory mode
+     * ZSTD codec is guaranteed to be initialized via factory method
+     * Internal method only
+     */
+    private zstdDecompressSync;
+    /**
+     * Uncompress compressed data buffer (synchronous for in-memory mode)
+     * Handles decompression and hash verification
+     * Internal method only
+     */
+    private unCompress;
+}
+//# sourceMappingURL=ZipDecompressNode.d.ts.map

package/dist/node/ZipDecompressNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZipDecompressNode.d.ts","sourceRoot":"","sources":["../../src/node/ZipDecompressNode.ts"],"names":[],"mappings":"AAiBA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,OAAO,QAAQ,MAAM,kBAAkB,CAAC;AAoBxC;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAkD;IAGnE,OAAO,CAAC,MAAM,CAAC,cAAc,CAAkB;IAE/C;;;OAGG;gBACS,UAAU,EAAE,UAAU;IAQlC;;OAEG;IACH,OAAO,CAAC,GAAG;IAUX;;;;;;;;;;;;OAYG;IACG,aAAa,CACjB,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;KACtC,GACA,OAAO,CAAC,IAAI,CAAC;IAkBhB;;;;;;;;;;;OAWG;YACY,wBAAwB;IAqCvC;;;OAGG;YACW,qBAAqB;IAyDnC;;;;;;;;;;;OAWG;YACW,gBAAgB;IA8E9B;;;;;;;;;;;OAWG;YACY,gBAAgB;IAsB/B;;;;;;;OAOG;YACY,aAAa;IA6B5B;;OAEG;YACY,oBAAoB;IAiCnC;;OAEG;IACH,OAAO,CAAC,OAAO;IAMf;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;;;OAIG;IACH,OAAO,CAAC,UAAU;CAyCnB"}

package/dist/node/ZipDecompressNode.js

@@ -0,0 +1,461 @@
+"use strict";
+// ======================================
+//	ZipDecompressNode.ts - Node.js File-Based Decompression
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+//
+// LOGGING INSTRUCTIONS:
+// ---------------------
+// To enable/disable logging, set loggingEnabled to true/false in the class:
+//   private static loggingEnabled: boolean = true;  // Enable logging
+//   private static loggingEnabled: boolean = false; // Disable logging
+//
+// Logging respects the global Logger level (debug, info, warn, error, silent).
+// Logger level is automatically set to 'debug' when loggingEnabled is true.
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) 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 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    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") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipDecompressNode = void 0;
+const pako = require('pako');
+const zstd_js_1 = require("@oneidentity/zstd-js");
+const Logger_1 = require("../core/components/Logger");
+const Errors_1 = __importDefault(require("../core/constants/Errors"));
+const Headers_1 = require("../core/constants/Headers");
+const HashCalculator_1 = require("../core/components/HashCalculator");
+const ZipCrypto_1 = require("../core/encryption/ZipCrypto");
+const types_1 = require("../core/encryption/types");
+const fs = __importStar(require("fs"));
+// Module-level singleton for ZSTD (shared across all instances)
+let zstdCodec = null;
+// Async initialization function for zstd
+async function initZstd() {
+    if (!zstdCodec) {
+        zstdCodec = await (0, zstd_js_1.ZstdInit)();
+    }
+    return zstdCodec;
+}
+/**
+ * ZipDecompressNode - Node.js file-based decompression operations
+ *
+ * Independent decompression implementation for Node.js environments.
+ * All decompression logic is implemented directly without delegating to ZipDecompress.
+ *
+ * @example
+ * ```typescript
+ * const zipkitNode = new ZipkitNode();
+ * const decompressNode = new ZipDecompressNode(zipkitNode);
+ * await decompressNode.extractToFile(entry, './output/file.txt');
+ * ```
+ */
+class ZipDecompressNode {
+    /**
+     * Creates a new ZipDecompressNode instance
+     * @param zipkitNode - ZipkitNode instance to use for ZIP operations
+     */
+    constructor(zipkitNode) {
+        this.zstdCodec = null;
+        this.zipkitNode = zipkitNode;
+        // If logging is enabled, ensure Logger level is set to debug
+        if (ZipDecompressNode.loggingEnabled) {
+            Logger_1.Logger.setLevel('debug');
+        }
+    }
+    /**
+     * Internal logging method - only logs if class logging is enabled
+     */
+    log(...args) {
+        if (ZipDecompressNode.loggingEnabled) {
+            Logger_1.Logger.debug(`[ZipDecompressNode]`, ...args);
+        }
+    }
+    // ============================================================================
+    // File-Based Extraction Methods
+    // ============================================================================
+    /**
+     * Extract file directly to disk with true streaming (no memory buffering)
+     * Public method that validates file mode and extracts entry to file
+     *
+     * This method processes chunks as they are decompressed and writes them
+     * directly to disk, maintaining minimal memory footprint regardless of file size.
+     * This is the recommended method for file extraction to avoid memory issues.
+     *
+     * @param entry ZIP entry to extract
+     * @param outputPath Path where the file should be written
+     * @param options Optional extraction options including progress callback
+     * @throws Error if not a File-based ZIP
+     */
+    async extractToFile(entry, outputPath, options) {
+        // Lazy ZSTD initialization
+        // Note: ZSTD codec is lazily initialized on first use (module-level singleton)
+        if (entry.cmpMethod === Headers_1.CMP_METHOD.ZSTD && !this.zstdCodec) {
+            this.zstdCodec = await initZstd();
+        }
+        // Get fileHandle from zipkitNode (merged from ZipLoadEntriesServer)
+        const fileHandle = this.zipkitNode.getFileHandle();
+        // Call internal method with fileHandle
+        await this.extractToFileInternal(fileHandle, entry, outputPath, options);
+    }
+    // ============================================================================
+    // Internal File-Based Methods
+    // ============================================================================
+    /**
+     * Read compressed data from file and yield one block at a time
+     *
+     * MEMORY EFFICIENCY: Yields compressed data chunks one at a time without accumulation.
+     * Each chunk is read from disk and yielded immediately, allowing downstream processing
+     * (decryption, decompression) to handle one block at a time.
+     *
+     * @param fileHandle - File handle to read from
+     * @param entry - ZIP entry to read compressed data for
+     * @param chunkSize - Optional chunk size override (defaults to ZipkitServer's bufferSize)
+     * @returns Async generator yielding compressed data chunks one at a time
+     */
+    async *readCompressedDataStream(fileHandle, entry, chunkSize) {
+        // Use provided chunkSize or ZipkitServer's default bufferSize
+        const effectiveChunkSize = chunkSize || this.zipkitNode.getBufferSize();
+        // Read local file header
+        const localHeaderBuffer = Buffer.alloc(30);
+        await fileHandle.read(localHeaderBuffer, 0, 30, entry.localHdrOffset);
+        if (localHeaderBuffer.readUInt32LE(0) !== 0x04034b50) { // LOCAL_HDR.SIGNATURE
+            throw new Error(Errors_1.default.INVALID_CEN);
+        }
+        // Calculate data start position
+        const filenameLength = localHeaderBuffer.readUInt16LE(26);
+        const extraFieldLength = localHeaderBuffer.readUInt16LE(28);
+        const dataStart = entry.localHdrOffset + 30 + filenameLength + extraFieldLength;
+        // Yield compressed data in chunks - one block at a time
+        let remaining = entry.compressedSize;
+        let position = dataStart;
+        while (remaining > 0) {
+            const currentChunkSize = Math.min(effectiveChunkSize, remaining);
+            const chunk = Buffer.alloc(currentChunkSize);
+            await fileHandle.read(chunk, 0, currentChunkSize, position);
+            this.log(`readCompressedDataStream: Yielding compressed chunk: ${chunk.length} bytes (${remaining} bytes remaining)`);
+            yield chunk;
+            position += currentChunkSize;
+            remaining -= currentChunkSize;
+        }
+    }
+    /**
+     * Handles: reading compressed data, optional decryption, decompression, hashing, and writing
+     * Internal method that takes fileHandle as parameter
+     */
+    async extractToFileInternal(fileHandle, entry, outputPath, options) {
+        this.log(`extractToFileInternal called for entry: ${entry.filename}`);
+        this.log(`Entry isEncrypted: ${entry.isEncrypted}, has password: ${!!this.zipkitNode?.password}`);
+        try {
+            // Create output stream with overwrite flag to truncate existing files
+            const writeStream = fs.createWriteStream(outputPath, { flags: 'w' });
+            // Build compressed data stream - yields one block at a time
+            let dataStream = this.readCompressedDataStream(fileHandle, entry);
+            // Decrypt if needed using password on zipkitNode instance
+            // Decryption maintains state across blocks via updateKeys()
+            const isEncrypted = entry.isEncrypted && this.zipkitNode?.password;
+            if (isEncrypted) {
+                this.log(`Starting decryption for entry: ${entry.filename}`);
+                // Prepare entry for decryption by parsing local header
+                await ZipCrypto_1.DecryptionStream.prepareEntryForDecryption(fileHandle, entry);
+                const encryptionMethod = entry.encryptionMethod || types_1.EncryptionMethod.ZIP_CRYPTO;
+                this.log(`Creating DecryptionStream with method: ${encryptionMethod}`);
+                const decryptor = new ZipCrypto_1.DecryptionStream({
+                    password: this.zipkitNode.password,
+                    method: encryptionMethod,
+                    entry: entry
+                });
+                this.log(`DecryptionStream created, calling decrypt()...`);
+                // Decryption processes one block at a time, maintaining state across blocks
+                dataStream = decryptor.decrypt(dataStream);
+                this.log(`decrypt() returned, dataStream is now a generator that yields one decrypted block at a time`);
+            }
+            // Pipeline: readCompressedDataStream() → DecryptionStream.decrypt() → decompressStream() → writeStream
+            // Each stage processes one block at a time without accumulation
+            await this.unCompressToFile(dataStream, entry, writeStream, {
+                skipHashCheck: options?.skipHashCheck,
+                onProgress: options?.onProgress,
+                outputPath
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Decompress data stream and write to file
+     *
+     * MEMORY EFFICIENCY: Processes decompressed chunks one at a time.
+     * Pipeline: compressedStream → decompressStream() → hashCalc → writeStream
+     * - Each decompressed chunk is written immediately without accumulation
+     * - Hash calculation is incremental (HashCalculator)
+     * - Progress callbacks are invoked per chunk
+     *
+     * Handles decompression, hash calculation, file writing, and verification.
+     * Internal method only
+     */
+    async unCompressToFile(compressedStream, entry, writeStream, // Node.js WriteStream
+    options) {
+        this.log(`unCompressToFile() called for entry: ${entry.filename}, method: ${entry.cmpMethod}`);
+        // Decompress stream - processes one block at a time
+        const decompressedStream = this.decompressStream(compressedStream, entry.cmpMethod);
+        // Process and write chunks - one block at a time
+        const hashCalc = new HashCalculator_1.HashCalculator({ useSHA256: !!entry.sha256 });
+        let totalBytes = 0;
+        try {
+            for await (const chunk of decompressedStream) {
+                this.log(`unCompressToFile: Processing decompressed chunk: ${chunk.length} bytes`);
+                hashCalc.update(chunk);
+                writeStream.write(chunk);
+                totalBytes += chunk.length;
+                if (options?.onProgress) {
+                    options.onProgress(totalBytes);
+                }
+            }
+            // Close stream
+            await new Promise((resolve, reject) => {
+                writeStream.end(() => resolve(undefined));
+                writeStream.on('error', reject);
+            });
+            // Verify hash
+            if (!options?.skipHashCheck) {
+                if (entry.sha256) {
+                    const calculatedHash = hashCalc.finalizeSHA256();
+                    this.log(`SHA-256 comparison: calculated=${calculatedHash}, stored=${entry.sha256}`);
+                    if (calculatedHash !== entry.sha256) {
+                        if (options?.outputPath && fs) {
+                            fs.unlinkSync(options.outputPath);
+                        }
+                        throw new Error(Errors_1.default.INVALID_SHA256);
+                    }
+                    this.log(`SHA-256 comparison: calculated=${calculatedHash}, stored=${entry.sha256}`);
+                }
+                else {
+                    const calculatedCRC = hashCalc.finalizeCRC32();
+                    this.log(`CRC-32 comparison: calculated=${calculatedCRC}, stored=${entry.crc}`);
+                    if (calculatedCRC !== entry.crc) {
+                        if (options?.outputPath && fs) {
+                            fs.unlinkSync(options.outputPath);
+                        }
+                        throw new Error(Errors_1.default.INVALID_CRC);
+                    }
+                    this.log(`CRC-32 comparison: calculated=${calculatedCRC}, stored=${entry.crc}`);
+                }
+            }
+        }
+        catch (error) {
+            // Cleanup file on error
+            if (options?.outputPath && fs) {
+                try {
+                    fs.unlinkSync(options.outputPath);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            throw error;
+        }
+    }
+    // ============================================================================
+    // Decompression Methods
+    // ============================================================================
+    /**
+     * Decompress data stream chunk by chunk
+     *
+     * MEMORY EFFICIENCY: Processes compressed data one block at a time.
+     * - For STORED: Passes through chunks unchanged (no accumulation)
+     * - For DEFLATED: Uses pako streaming inflate (maintains state across chunks)
+     * - For ZSTD: Collects all chunks (ZSTD limitation - requires full buffer)
+     *
+     * Pipeline: readCompressedDataStream() → DecryptionStream.decrypt() → decompressStream() → writeStream
+     *
+     * Internal method only
+     */
+    async *decompressStream(compressedStream, method, chunkSize) {
+        // chunkSize parameter is currently unused but kept for API consistency
+        if (method === Headers_1.CMP_METHOD.STORED) {
+            // Pass through unchanged - one block at a time
+            for await (const chunk of compressedStream) {
+                yield chunk;
+            }
+        }
+        else if (method === Headers_1.CMP_METHOD.DEFLATED) {
+            // Use pako streaming inflate - maintains state across chunks
+            yield* this.inflateStream(compressedStream);
+        }
+        else if (method === Headers_1.CMP_METHOD.ZSTD) {
+            // Use ZSTD streaming decompression - note: ZSTD requires full buffer
+            yield* this.zstdDecompressStream(compressedStream);
+        }
+        else {
+            throw new Error(`Unsupported compression method: ${method}`);
+        }
+    }
+    /**
+     * Streaming deflate decompression using pako
+     *
+     * MEMORY EFFICIENCY: Processes compressed chunks one at a time.
+     * - Inflator maintains decompression state across chunks
+     * - Decompressed chunks are yielded immediately after processing each compressed chunk
+     * - No accumulation of compressed data (except in pako's internal buffers)
+     */
+    async *inflateStream(compressedStream) {
+        const inflator = new pako.Inflate({ raw: true });
+        const decompressedChunks = [];
+        inflator.onData = (chunk) => {
+            decompressedChunks.push(Buffer.from(chunk));
+        };
+        // Process each compressed chunk one at a time
+        for await (const compressedChunk of compressedStream) {
+            this.log(`inflateStream: Processing compressed chunk: ${compressedChunk.length} bytes`);
+            inflator.push(compressedChunk, false);
+            // Yield accumulated decompressed chunks immediately (no accumulation)
+            for (const chunk of decompressedChunks) {
+                yield chunk;
+            }
+            decompressedChunks.length = 0;
+        }
+        // Finalize decompression
+        inflator.push(new Uint8Array(0), true);
+        for (const chunk of decompressedChunks) {
+            yield chunk;
+        }
+    }
+    /**
+     * Streaming ZSTD decompression
+     */
+    async *zstdDecompressStream(compressedStream) {
+        // ZSTD is guaranteed to be initialized via factory method
+        // Collect all compressed chunks first (ZSTD needs complete data)
+        const compressedChunks = [];
+        for await (const chunk of compressedStream) {
+            compressedChunks.push(chunk);
+        }
+        const compressedData = Buffer.concat(compressedChunks);
+        try {
+            if (!this.zstdCodec) {
+                throw new Error('ZSTD codec not initialized.');
+            }
+            const decompressed = this.zstdCodec.ZstdSimple.decompress(compressedData);
+            const decompressedBuffer = Buffer.from(decompressed);
+            // Yield decompressed data in chunks using ZipkitServer's bufferSize
+            const chunkSize = this.zipkitNode.getBufferSize();
+            let offset = 0;
+            while (offset < decompressedBuffer.length) {
+                const end = Math.min(offset + chunkSize, decompressedBuffer.length);
+                yield decompressedBuffer.slice(offset, end);
+                offset = end;
+            }
+        }
+        catch (error) {
+            throw new Error(`ZSTD streaming decompression failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 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 {
+            // Ensure ZSTD is initialized
+            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) {
+            // Use synchronous inflate for deflate
+            outBuf = this.inflate(compressedData);
+        }
+        else if (entry.cmpMethod === Headers_1.CMP_METHOD.ZSTD) {
+            // Use synchronous ZSTD decompression for in-memory mode
+            outBuf = this.zstdDecompressSync(compressedData);
+        }
+        else {
+            throw new Error(`Unsupported compression method: ${entry.cmpMethod}`);
+        }
+        // Verify hash
+        if (!skipHashCheck) {
+            if (entry.sha256) {
+                const isValid = this.zipkitNode.testSHA256(entry, outBuf);
+                if (!isValid) {
+                    throw new Error(Errors_1.default.INVALID_SHA256);
+                }
+            }
+            else {
+                const isValid = this.zipkitNode.testCRC32(entry, outBuf);
+                if (!isValid) {
+                    throw new Error(Errors_1.default.INVALID_CRC);
+                }
+            }
+        }
+        return outBuf;
+    }
+}
+exports.ZipDecompressNode = ZipDecompressNode;
+// Class-level logging control - set to true to enable logging
+ZipDecompressNode.loggingEnabled = false;
+//# sourceMappingURL=ZipDecompressNode.js.map

package/dist/node/ZipDecompressNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZipDecompressNode.js","sourceRoot":"","sources":["../../src/node/ZipDecompressNode.ts"],"names":[],"mappings":"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"}