7z-iterator 2.0.3 → 2.1.0

package/dist/cjs/sevenz/SevenZipParser.js

@@ -37,6 +37,7 @@ _export(exports, {
         return SevenZipParser;
     }
 });
+var _calloncefn = /*#__PURE__*/ _interop_require_default(require("call-once-fn"));
 var _extractbaseiterator = require("extract-base-iterator");
 var _deferts = require("../lib/defer.js");
 var _indexts = require("./codecs/index.js");
@@ -79,6 +80,18 @@ function _class_call_check(instance, Constructor) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -195,129 +208,194 @@ var SevenZipParser = /*#__PURE__*/ function() {
         this.extractedPerFolder = {};
         // Splitter cache for multi-file folder streaming (Phase 2)
         this.folderSplitters = {};
+        this.pendingFolders = {};
         this.source = source;
     }
     var _proto = SevenZipParser.prototype;
+    _proto.decodeWithCodec = function decodeWithCodec(codec, input, properties, unpackSize, callback) {
+        var done = (0, _calloncefn.default)(callback);
+        try {
+            codec.decode(input, properties, unpackSize, function(err, result) {
+                if (err) return done(err);
+                if (!result) return done((0, _constantsts.createCodedError)('Decoder returned no data', _constantsts.ErrorCode.DECOMPRESSION_FAILED));
+                done(null, result);
+            });
+        } catch (err) {
+            done(err);
+        }
+    };
     /**
    * Parse the archive structure
    * Must be called before iterating entries
-   */ _proto.parse = function parse() {
-        if (this.parsed) return;
-        // Read signature header
-        var sigBuf = this.source.read(0, _constantsts.SIGNATURE_HEADER_SIZE);
-        if (sigBuf.length < _constantsts.SIGNATURE_HEADER_SIZE) {
-            throw (0, _constantsts.createCodedError)('Archive too small', _constantsts.ErrorCode.TRUNCATED_ARCHIVE);
-        }
-        this.signature = (0, _headersts.parseSignatureHeader)(sigBuf);
-        // Read encoded header
-        var headerOffset = _constantsts.SIGNATURE_HEADER_SIZE + this.signature.nextHeaderOffset;
-        var headerBuf = this.source.read(headerOffset, this.signature.nextHeaderSize);
-        if (headerBuf.length < this.signature.nextHeaderSize) {
-            throw (0, _constantsts.createCodedError)('Truncated header', _constantsts.ErrorCode.TRUNCATED_ARCHIVE);
-        }
-        // Parse encoded header (may need decompression)
+   */ _proto.parse = function parse(callback) {
+        var _this = this;
+        if (this.parsed) {
+            if (typeof callback === 'function') {
+                callback(null);
+                return;
+            }
+            if (typeof Promise === 'undefined') {
+                return;
+            }
+            return Promise.resolve();
+        }
+        var executor = function(done) {
+            _this.parseInternal(done);
+        };
+        if (typeof callback === 'function') {
+            executor(callback);
+            return;
+        }
+        if (typeof Promise === 'undefined') {
+            throw new Error('Promises are not available in this runtime. Please provide a callback to parse().');
+        }
+        return new Promise(function(resolve, reject) {
+            executor(function(err) {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    };
+    _proto.parseInternal = function parseInternal(callback) {
+        var _this = this;
+        if (this.parsed) {
+            callback(null);
+            return;
+        }
+        var signature;
+        var headerBuf;
+        try {
+            var sigBuf = this.source.read(0, _constantsts.SIGNATURE_HEADER_SIZE);
+            if (sigBuf.length < _constantsts.SIGNATURE_HEADER_SIZE) {
+                callback((0, _constantsts.createCodedError)('Archive too small', _constantsts.ErrorCode.TRUNCATED_ARCHIVE));
+                return;
+            }
+            signature = (0, _headersts.parseSignatureHeader)(sigBuf);
+            this.signature = signature;
+            var headerOffset = _constantsts.SIGNATURE_HEADER_SIZE + signature.nextHeaderOffset;
+            headerBuf = this.source.read(headerOffset, signature.nextHeaderSize);
+            if (headerBuf.length < signature.nextHeaderSize) {
+                callback((0, _constantsts.createCodedError)('Truncated header', _constantsts.ErrorCode.TRUNCATED_ARCHIVE));
+                return;
+            }
+        } catch (err) {
+            callback(err);
+            return;
+        }
+        var finalize = function() {
+            try {
+                _this.buildEntries();
+                _this.parsed = true;
+                callback(null);
+            } catch (err) {
+                callback(err);
+            }
+        };
         try {
-            var headerResult = (0, _headersts.parseEncodedHeader)(headerBuf, this.signature.nextHeaderCRC);
+            var _ref;
+            var _this_signature;
+            var headerResult = (0, _headersts.parseEncodedHeader)(headerBuf, (_ref = (_this_signature = this.signature) === null || _this_signature === void 0 ? void 0 : _this_signature.nextHeaderCRC) !== null && _ref !== void 0 ? _ref : 0);
             this.streamsInfo = headerResult.streamsInfo || null;
             this.filesInfo = headerResult.filesInfo;
+            finalize();
         } catch (err) {
             var codedErr = err;
             if (codedErr && codedErr.code === _constantsts.ErrorCode.COMPRESSED_HEADER) {
-                // Header is compressed - need to decompress first
-                this.handleCompressedHeader(headerBuf);
+                this.handleCompressedHeader(headerBuf, function(headerErr) {
+                    if (headerErr) {
+                        callback(headerErr);
+                        return;
+                    }
+                    finalize();
+                });
             } else {
-                throw err;
+                callback(err);
             }
         }
-        // Build entries list
-        this.buildEntries();
-        this.parsed = true;
     };
     /**
    * Handle compressed header (kEncodedHeader)
-   */ _proto.handleCompressedHeader = function handleCompressedHeader(headerBuf) {
+   */ _proto.handleCompressedHeader = function handleCompressedHeader(headerBuf, callback) {
+        var _this = this;
         // Parse the encoded header info to get decompression parameters
         var offset = 1; // Skip kEncodedHeader byte
-        // Should have StreamsInfo for the header itself
         var propertyId = headerBuf[offset++];
         if (propertyId !== _constantsts.PropertyId.kMainStreamsInfo && propertyId !== _constantsts.PropertyId.kPackInfo) {
-            throw (0, _constantsts.createCodedError)('Expected StreamsInfo in encoded header', _constantsts.ErrorCode.CORRUPT_HEADER);
-        }
-        // For now, we parse the streams info from the encoded header block
-        // This tells us how to decompress the actual header
-        // Read pack info from the encoded header structure
-        var packInfoResult = this.parseEncodedHeaderStreams(headerBuf, 1);
-        // Calculate compressed header position
-        // For simple archives: header is at SIGNATURE_HEADER_SIZE + packPos
-        // For BCJ2/complex archives: header may be at the END of pack data area
-        // The pack data area ends at nextHeaderOffset (where encoded header starts)
-        var compressedStart = _constantsts.SIGNATURE_HEADER_SIZE + packInfoResult.packPos;
-        var compressedData = this.source.read(compressedStart, packInfoResult.packSize);
-        // Decompress using the specified codec
-        var codec = (0, _indexts.getCodec)(packInfoResult.codecId);
-        var decompressedHeader = null;
-        // Try decompressing from the calculated position first
+            callback((0, _constantsts.createCodedError)('Expected StreamsInfo in encoded header', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
+        var packInfoResult;
         try {
-            decompressedHeader = codec.decode(compressedData, packInfoResult.properties, packInfoResult.unpackSize);
-            // Verify CRC if present
-            if (packInfoResult.unpackCRC !== undefined) {
-                var actualCRC = (0, _extractbaseiterator.crc32)(decompressedHeader);
-                if (actualCRC !== packInfoResult.unpackCRC) {
-                    decompressedHeader = null; // CRC mismatch, need to search
-                }
-            }
-        } catch (unused) {
-            decompressedHeader = null; // Decompression failed, need to search
+            packInfoResult = this.parseEncodedHeaderStreams(headerBuf, 1);
+        } catch (err) {
+            callback(err);
+            return;
         }
-        // If initial decompression failed, search for the correct position as a fallback
-        // This handles edge cases where packPos doesn't point directly to header pack data
-        if (decompressedHeader === null && this.signature) {
+        var codec = (0, _indexts.getCodec)(packInfoResult.codecId);
+        var candidates = [];
+        var compressedStart = _constantsts.SIGNATURE_HEADER_SIZE + packInfoResult.packPos;
+        candidates.push(this.source.read(compressedStart, packInfoResult.packSize));
+        if (this.signature) {
             var packAreaEnd = _constantsts.SIGNATURE_HEADER_SIZE + this.signature.nextHeaderOffset;
             var searchStart = packAreaEnd - packInfoResult.packSize;
             var searchEnd = Math.max(_constantsts.SIGNATURE_HEADER_SIZE, compressedStart - 100000);
-            // Scan for LZMA data starting with 0x00 (range coder init)
-            // Try each candidate and validate with CRC
             var scanChunkSize = 4096;
-            searchLoop: for(var chunkStart = searchStart; chunkStart >= searchEnd; chunkStart -= scanChunkSize){
+            for(var chunkStart = searchStart; chunkStart >= searchEnd; chunkStart -= scanChunkSize){
                 var chunk = this.source.read(chunkStart, scanChunkSize + packInfoResult.packSize);
-                for(var i = 0; i < Math.min(chunk.length, scanChunkSize); i++){
+                var limit = Math.min(chunk.length, scanChunkSize);
+                for(var i = 0; i < limit; i++){
                     if (chunk[i] === 0x00) {
-                        var candidateData = chunk.subarray(i, i + packInfoResult.packSize);
-                        if (candidateData.length === packInfoResult.packSize) {
-                            try {
-                                var candidateDecompressed = codec.decode(candidateData, packInfoResult.properties, packInfoResult.unpackSize);
-                                if (packInfoResult.unpackCRC !== undefined) {
-                                    var candCRC = (0, _extractbaseiterator.crc32)(candidateDecompressed);
-                                    if (candCRC === packInfoResult.unpackCRC) {
-                                        decompressedHeader = candidateDecompressed;
-                                        break searchLoop;
-                                    }
-                                } else {
-                                    decompressedHeader = candidateDecompressed;
-                                    break searchLoop;
-                                }
-                            } catch (unused) {
-                            // Decompression failed, continue searching
+                        var end = i + packInfoResult.packSize;
+                        if (end <= chunk.length) {
+                            var candidateData = chunk.slice(i, end);
+                            if (candidateData.length === packInfoResult.packSize) {
+                                candidates.push(candidateData);
                             }
                         }
                     }
                 }
             }
         }
-        if (decompressedHeader === null) {
-            throw (0, _constantsts.createCodedError)('Failed to decompress header - could not find valid LZMA data', _constantsts.ErrorCode.CORRUPT_HEADER);
-        }
-        // Now parse the decompressed header
-        // It should start with kHeader
+        var tryCandidate = function(index) {
+            if (index >= candidates.length) {
+                callback((0, _constantsts.createCodedError)('Failed to decompress header - could not find valid LZMA data', _constantsts.ErrorCode.CORRUPT_HEADER));
+                return;
+            }
+            _this.decodeWithCodec(codec, candidates[index], packInfoResult.properties, packInfoResult.unpackSize, function(err, decompressed) {
+                if (err || !decompressed) {
+                    tryCandidate(index + 1);
+                    return;
+                }
+                if (packInfoResult.unpackCRC !== undefined) {
+                    var actualCRC = (0, _extractbaseiterator.crc32)(decompressed);
+                    if (actualCRC !== packInfoResult.unpackCRC) {
+                        tryCandidate(index + 1);
+                        return;
+                    }
+                }
+                _this.parseDecompressedHeader(decompressed, callback);
+            });
+        };
+        tryCandidate(0);
+    };
+    _proto.parseDecompressedHeader = function parseDecompressedHeader(decompressedHeader, callback) {
         var decompOffset = 0;
         var headerId = decompressedHeader[decompOffset++];
         if (headerId !== _constantsts.PropertyId.kHeader) {
-            throw (0, _constantsts.createCodedError)('Expected kHeader in decompressed header', _constantsts.ErrorCode.CORRUPT_HEADER);
+            callback((0, _constantsts.createCodedError)('Expected kHeader in decompressed header', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
+        try {
+            var result = (0, _headersts.parseHeaderContent)(decompressedHeader, decompOffset);
+            this.streamsInfo = result.streamsInfo || null;
+            this.filesInfo = result.filesInfo;
+            callback(null);
+        } catch (err) {
+            callback(err);
         }
-        // Parse the decompressed header using shared function from headers.ts
-        var result = (0, _headersts.parseHeaderContent)(decompressedHeader, decompOffset);
-        this.streamsInfo = result.streamsInfo || null;
-        this.filesInfo = result.filesInfo;
     };
     /**
    * Parse streams info from encoded header block
@@ -519,7 +597,7 @@ var SevenZipParser = /*#__PURE__*/ function() {
    * Get the list of entries
    */ _proto.getEntries = function getEntries() {
         if (!this.parsed) {
-            this.parse();
+            throw new Error('SevenZipParser has not been parsed yet. Call parse(callback) before accessing entries.');
         }
         return this.entries;
     };
@@ -646,39 +724,43 @@ var SevenZipParser = /*#__PURE__*/ function() {
                 started = true;
                 (0, _deferts.defer)(function() {
                     if (destroyed) return;
-                    try {
-                        var data = _this.getDecompressedFolder(folderIdx);
-                        var fileStart = 0;
-                        for(var m = 0; m < entry._streamIndexInFolder; m++){
-                            var prevStreamGlobalIndex = entry._streamIndex - entry._streamIndexInFolder + m;
-                            fileStart += streamsInfo.unpackSizes[prevStreamGlobalIndex];
-                        }
-                        var fileSize = entry.size;
-                        if (fileStart + fileSize > data.length) {
-                            stream.destroy((0, _constantsts.createCodedError)("File data out of bounds: offset ".concat(fileStart, " + size ").concat(fileSize, " > decompressed length ").concat(data.length), _constantsts.ErrorCode.DECOMPRESSION_FAILED));
+                    _this.getDecompressedFolder(folderIdx, function(err, data) {
+                        if (destroyed) return;
+                        if (err || !data) {
+                            stream.destroy(err || (0, _constantsts.createCodedError)('Unable to decompress folder', _constantsts.ErrorCode.DECOMPRESSION_FAILED));
                             return;
                         }
-                        var fileData = data.slice(fileStart, fileStart + fileSize);
-                        if (entry._crc !== undefined) {
-                            var actualCRC = (0, _extractbaseiterator.crc32)(fileData);
-                            if (actualCRC !== entry._crc) {
-                                stream.destroy((0, _constantsts.createCodedError)("CRC mismatch for ".concat(entry.path, ": expected ").concat(entry._crc.toString(16), ", got ").concat(actualCRC.toString(16)), _constantsts.ErrorCode.CRC_MISMATCH));
+                        try {
+                            var fileStart = 0;
+                            for(var m = 0; m < entry._streamIndexInFolder; m++){
+                                var prevStreamGlobalIndex = entry._streamIndex - entry._streamIndexInFolder + m;
+                                fileStart += streamsInfo.unpackSizes[prevStreamGlobalIndex];
+                            }
+                            var fileSize = entry.size;
+                            if (fileStart + fileSize > data.length) {
+                                stream.destroy((0, _constantsts.createCodedError)("File data out of bounds: offset ".concat(fileStart, " + size ").concat(fileSize, " > decompressed length ").concat(data.length), _constantsts.ErrorCode.DECOMPRESSION_FAILED));
                                 return;
                             }
+                            var fileData = data.slice(fileStart, fileStart + fileSize);
+                            if (entry._crc !== undefined) {
+                                var actualCRC = (0, _extractbaseiterator.crc32)(fileData);
+                                if (actualCRC !== entry._crc) {
+                                    stream.destroy((0, _constantsts.createCodedError)("CRC mismatch for ".concat(entry.path, ": expected ").concat(entry._crc.toString(16), ", got ").concat(actualCRC.toString(16)), _constantsts.ErrorCode.CRC_MISMATCH));
+                                    return;
+                                }
+                            }
+                            _this.extractedPerFolder[folderIdx] = (_this.extractedPerFolder[folderIdx] || 0) + 1;
+                            if (_this.extractedPerFolder[folderIdx] >= _this.filesPerFolder[folderIdx]) {
+                                delete _this.decompressedCache[folderIdx];
+                            }
+                            if (!destroyed) {
+                                stream.push(fileData);
+                                stream.push(null);
+                            }
+                        } catch (decodeErr) {
+                            stream.destroy(decodeErr);
                         }
-                        _this.extractedPerFolder[folderIdx] = (_this.extractedPerFolder[folderIdx] || 0) + 1;
-                        if (_this.extractedPerFolder[folderIdx] >= _this.filesPerFolder[folderIdx]) {
-                            delete _this.decompressedCache[folderIdx];
-                        }
-                        if (!destroyed) {
-                            stream.push(fileData);
-                            stream.push(null);
-                        }
-                    } catch (err) {
-                        if (!destroyed) {
-                            stream.destroy(err);
-                        }
-                    }
+                    });
                 });
             }
             return originalRead(size);
@@ -710,97 +792,140 @@ var SevenZipParser = /*#__PURE__*/ function() {
     /**
    * Get decompressed data for a folder, with smart caching for solid archives
    * Only caches when multiple files share a block, releases when last file extracted
-   */ _proto.getDecompressedFolder = function getDecompressedFolder(folderIndex) {
-        // Check cache first
+   */ _proto.getDecompressedFolder = function getDecompressedFolder(folderIndex, callback) {
+        var _this = this;
         if (this.decompressedCache[folderIndex]) {
-            return this.decompressedCache[folderIndex];
+            callback(null, this.decompressedCache[folderIndex]);
+            return;
+        }
+        if (this.pendingFolders[folderIndex]) {
+            this.pendingFolders[folderIndex].push(callback);
+            return;
         }
         if (!this.streamsInfo) {
-            throw (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
+            callback((0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
         }
-        var folder = this.streamsInfo.folders[folderIndex];
-        // Check how many files remain in this folder
+        this.pendingFolders[folderIndex] = [
+            callback
+        ];
+        this.decodeFolderData(folderIndex, function(err, data) {
+            var waiters = _this.pendingFolders[folderIndex] || [];
+            delete _this.pendingFolders[folderIndex];
+            if (err || !data) {
+                for(var i = 0; i < waiters.length; i++){
+                    waiters[i](err || (0, _constantsts.createCodedError)('Decoder returned no data', _constantsts.ErrorCode.DECOMPRESSION_FAILED));
+                }
+                return;
+            }
+            if (_this.shouldCacheFolder(folderIndex)) {
+                _this.decompressedCache[folderIndex] = data;
+            }
+            for(var i1 = 0; i1 < waiters.length; i1++){
+                waiters[i1](null, data);
+            }
+        });
+    };
+    _proto.shouldCacheFolder = function shouldCacheFolder(folderIndex) {
         var filesInFolder = this.filesPerFolder[folderIndex] || 1;
         var extractedFromFolder = this.extractedPerFolder[folderIndex] || 0;
-        var remainingFiles = filesInFolder - extractedFromFolder;
-        // Only cache if more than 1 file remains (including the current one being extracted)
-        var shouldCache = remainingFiles > 1;
-        // Check if this folder uses BCJ2 (requires special multi-stream handling)
+        return filesInFolder - extractedFromFolder > 1;
+    };
+    _proto.decodeFolderData = function decodeFolderData(folderIndex, callback) {
+        if (!this.streamsInfo) {
+            callback((0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
+        var folder = this.streamsInfo.folders[folderIndex];
+        if (!folder) {
+            callback((0, _constantsts.createCodedError)('Invalid folder index', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
         if (this.folderHasBcj2(folder)) {
-            var data = this.decompressBcj2Folder(folderIndex);
-            if (shouldCache) {
-                this.decompressedCache[folderIndex] = data;
-            }
-            return data;
+            this.decompressBcj2Folder(folderIndex, callback);
+            return;
+        }
+        var packDataResult = this.readPackedData(folderIndex);
+        if (_instanceof(packDataResult, Error)) {
+            callback(packDataResult);
+            return;
+        }
+        this.decodeFolderCoders(folder, packDataResult, 0, callback);
+    };
+    _proto.readPackedData = function readPackedData(folderIndex) {
+        if (!this.streamsInfo) {
+            return (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
+        }
+        var folder = this.streamsInfo.folders[folderIndex];
+        if (!folder) {
+            return (0, _constantsts.createCodedError)('Invalid folder index', _constantsts.ErrorCode.CORRUPT_HEADER);
         }
-        // Calculate packed data position
-        // Use Math.max to prevent 32-bit signed overflow
         var signedHeaderSize = _constantsts.SIGNATURE_HEADER_SIZE;
         var signedPackPos = this.streamsInfo.packPos;
         var packPos = Math.max(signedHeaderSize, 0) + Math.max(signedPackPos, 0);
-        // Find which pack stream this folder uses
         var packStreamIndex = 0;
         for(var j = 0; j < folderIndex; j++){
             packStreamIndex += this.streamsInfo.folders[j].packedStreams.length;
         }
-        // Calculate position of this pack stream - PREVENT OVERFLOW
         for(var k = 0; k < packStreamIndex; k++){
             var size = this.streamsInfo.packSizes[k];
             if (packPos + size < packPos) {
-                throw (0, _constantsts.createCodedError)("Pack position overflow at index ".concat(k), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
+                return (0, _constantsts.createCodedError)("Pack position overflow at index ".concat(k), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
             }
             packPos += size;
         }
         var packSize = this.streamsInfo.packSizes[packStreamIndex];
-        // Validate pack size to prevent overflow
-        // Upper bound is Number.MAX_SAFE_INTEGER (2^53-1 = 9PB) - safe for all realistic archives
         if (packSize < 0 || packSize > Number.MAX_SAFE_INTEGER) {
-            throw (0, _constantsts.createCodedError)("Invalid pack size: ".concat(packSize), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
+            return (0, _constantsts.createCodedError)("Invalid pack size: ".concat(packSize), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
         }
         if (packPos < 0 || packPos > Number.MAX_SAFE_INTEGER) {
-            throw (0, _constantsts.createCodedError)("Invalid pack position: ".concat(packPos), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
-        }
-        // Read packed data
-        var packedData = this.source.read(packPos, packSize);
-        // Decompress through codec chain
-        var data2 = packedData;
-        for(var l = 0; l < folder.coders.length; l++){
-            var coderInfo = folder.coders[l];
-            var codec = (0, _indexts.getCodec)(coderInfo.id);
-            // Get unpack size for this coder (needed by LZMA)
-            var unpackSize = folder.unpackSizes[l];
-            // Validate unpack size to prevent overflow
-            if (unpackSize < 0 || unpackSize > Number.MAX_SAFE_INTEGER) {
-                throw (0, _constantsts.createCodedError)("Invalid unpack size: ".concat(unpackSize), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
-            }
-            data2 = codec.decode(data2, coderInfo.properties, unpackSize);
+            return (0, _constantsts.createCodedError)("Invalid pack position: ".concat(packPos), _constantsts.ErrorCode.CORRUPT_ARCHIVE);
         }
-        // Cache only if more files remain in this folder
-        if (shouldCache) {
-            this.decompressedCache[folderIndex] = data2;
+        return this.source.read(packPos, packSize);
+    };
+    _proto.decodeFolderCoders = function decodeFolderCoders(folder, input, index, callback) {
+        var _this = this;
+        if (index >= folder.coders.length) {
+            callback(null, input);
+            return;
+        }
+        var coderInfo = folder.coders[index];
+        var codec = (0, _indexts.getCodec)(coderInfo.id);
+        var unpackSize = folder.unpackSizes[index];
+        if (unpackSize < 0 || unpackSize > Number.MAX_SAFE_INTEGER) {
+            callback((0, _constantsts.createCodedError)("Invalid unpack size: ".concat(unpackSize), _constantsts.ErrorCode.CORRUPT_ARCHIVE));
+            return;
         }
-        return data2;
+        this.decodeWithCodec(codec, input, coderInfo.properties, unpackSize, function(err, output) {
+            if (err || !output) {
+                callback(err || (0, _constantsts.createCodedError)('Decoder returned no data', _constantsts.ErrorCode.DECOMPRESSION_FAILED));
+                return;
+            }
+            _this.decodeFolderCoders(folder, output, index + 1, callback);
+        });
     };
     /**
    * Decompress a BCJ2 folder with multi-stream handling
    * BCJ2 uses 4 input streams: main, call, jump, range coder
-   */ _proto.decompressBcj2Folder = function decompressBcj2Folder(folderIndex) {
+   */ _proto.decompressBcj2Folder = function decompressBcj2Folder(folderIndex, callback) {
+        var _this = this;
         if (!this.streamsInfo) {
-            throw (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
+            callback((0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
         }
         var folder = this.streamsInfo.folders[folderIndex];
-        // Calculate starting pack position
+        if (!folder) {
+            callback((0, _constantsts.createCodedError)('Invalid folder index', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
         var packPos = _constantsts.SIGNATURE_HEADER_SIZE + this.streamsInfo.packPos;
-        // Find which pack stream index this folder starts at
         var packStreamIndex = 0;
         for(var j = 0; j < folderIndex; j++){
             packStreamIndex += this.streamsInfo.folders[j].packedStreams.length;
         }
-        // Calculate position
         for(var k = 0; k < packStreamIndex; k++){
             packPos += this.streamsInfo.packSizes[k];
         }
-        // Read all pack streams for this folder
         var numPackStreams = folder.packedStreams.length;
         var packStreams = [];
         var currentPos = packPos;
@@ -809,16 +934,7 @@ var SevenZipParser = /*#__PURE__*/ function() {
             packStreams.push(this.source.read(currentPos, size));
             currentPos += size;
         }
-        // Build a map of coder outputs
-        // For BCJ2, typical structure is:
-        //   Coder 0: LZMA2 (main stream) - 1 in, 1 out
-        //   Coder 1: LZMA (call stream) - 1 in, 1 out
-        //   Coder 2: LZMA (jump stream) - 1 in, 1 out
-        //   Coder 3: BCJ2 - 4 in, 1 out
-        // Pack streams map to: coder inputs not bound to other coder outputs
-        // First, decompress each non-BCJ2 coder
         var coderOutputs = {};
-        // Find the BCJ2 coder
         var bcj2CoderIndex = -1;
         for(var c = 0; c < folder.coders.length; c++){
             if ((0, _indexts.isBcj2Codec)(folder.coders[c].id)) {
@@ -827,56 +943,50 @@ var SevenZipParser = /*#__PURE__*/ function() {
             }
         }
         if (bcj2CoderIndex === -1) {
-            throw (0, _constantsts.createCodedError)('BCJ2 coder not found in folder', _constantsts.ErrorCode.CORRUPT_HEADER);
+            callback((0, _constantsts.createCodedError)('BCJ2 coder not found in folder', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
         }
-        // Build input stream index -> pack stream mapping
-        // folder.packedStreams tells us which input indices are unbound and their order
         var inputToPackStream = {};
         for(var pi = 0; pi < folder.packedStreams.length; pi++){
             inputToPackStream[folder.packedStreams[pi]] = pi;
         }
-        // Build output stream index -> coder mapping
-        var outputToCoder = {};
-        var totalOutputs = 0;
-        for(var co = 0; co < folder.coders.length; co++){
-            var numOut = folder.coders[co].numOutStreams;
-            for(var outp = 0; outp < numOut; outp++){
-                outputToCoder[totalOutputs + outp] = co;
-            }
-            totalOutputs += numOut;
-        }
-        // Decompress non-BCJ2 coders (LZMA, LZMA2)
-        // We need to process in dependency order
-        var processed = {};
         var processOrder = this.getCoderProcessOrder(folder, bcj2CoderIndex);
-        for(var po = 0; po < processOrder.length; po++){
-            var coderIdx = processOrder[po];
-            if (coderIdx === bcj2CoderIndex) continue;
+        var processNext = function(orderIndex) {
+            if (orderIndex >= processOrder.length) {
+                _this.finishBcj2Decode(folder, bcj2CoderIndex, coderOutputs, inputToPackStream, packStreams, callback);
+                return;
+            }
+            var coderIdx = processOrder[orderIndex];
+            if (coderIdx === bcj2CoderIndex) {
+                processNext(orderIndex + 1);
+                return;
+            }
             var coder = folder.coders[coderIdx];
             var codec = (0, _indexts.getCodec)(coder.id);
-            // Find input for this coder
             var coderInputStart = 0;
             for(var ci2 = 0; ci2 < coderIdx; ci2++){
                 coderInputStart += folder.coders[ci2].numInStreams;
             }
-            // Get input data (from pack stream)
             var inputIdx = coderInputStart;
             var packStreamIdx = inputToPackStream[inputIdx];
             var inputData = packStreams[packStreamIdx];
-            // Decompress
             var unpackSize = folder.unpackSizes[coderIdx];
-            var outputData = codec.decode(inputData, coder.properties, unpackSize);
-            // Store in coder outputs
-            var coderOutputStart = 0;
-            for(var co2 = 0; co2 < coderIdx; co2++){
-                coderOutputStart += folder.coders[co2].numOutStreams;
-            }
-            coderOutputs[coderOutputStart] = outputData;
-            processed[coderIdx] = true;
-        }
-        // Now process BCJ2
-        // BCJ2 has 4 inputs, need to map them correctly
-        // Standard order: main(LZMA2 output), call(LZMA output), jump(LZMA output), range(raw pack)
+            _this.decodeWithCodec(codec, inputData, coder.properties, unpackSize, function(err, outputData) {
+                if (err || !outputData) {
+                    callback(err || (0, _constantsts.createCodedError)('Decoder returned no data', _constantsts.ErrorCode.DECOMPRESSION_FAILED));
+                    return;
+                }
+                var coderOutputStart = 0;
+                for(var co2 = 0; co2 < coderIdx; co2++){
+                    coderOutputStart += folder.coders[co2].numOutStreams;
+                }
+                coderOutputs[coderOutputStart] = outputData;
+                processNext(orderIndex + 1);
+            });
+        };
+        processNext(0);
+    };
+    _proto.finishBcj2Decode = function finishBcj2Decode(folder, bcj2CoderIndex, coderOutputs, inputToPackStream, packStreams, callback) {
         var bcj2InputStart = 0;
         for(var ci3 = 0; ci3 < bcj2CoderIndex; ci3++){
             bcj2InputStart += folder.coders[ci3].numInStreams;
@@ -884,7 +994,6 @@ var SevenZipParser = /*#__PURE__*/ function() {
         var bcj2Inputs = [];
         for(var bi = 0; bi < 4; bi++){
             var globalIdx = bcj2InputStart + bi;
-            // Check if this input is bound to a coder output
             var boundOutput = -1;
             for(var bp2 = 0; bp2 < folder.bindPairs.length; bp2++){
                 if (folder.bindPairs[bp2].inIndex === globalIdx) {
@@ -893,29 +1002,28 @@ var SevenZipParser = /*#__PURE__*/ function() {
                 }
             }
             if (boundOutput >= 0) {
-                // Get from coder outputs
                 bcj2Inputs.push(coderOutputs[boundOutput]);
             } else {
-                // Get from pack streams
                 var psIdx = inputToPackStream[globalIdx];
                 bcj2Inputs.push(packStreams[psIdx]);
             }
         }
-        // Get BCJ2 unpack size
         var bcj2OutputStart = 0;
         for(var co3 = 0; co3 < bcj2CoderIndex; co3++){
             bcj2OutputStart += folder.coders[co3].numOutStreams;
         }
         var bcj2UnpackSize = folder.unpackSizes[bcj2OutputStart];
-        // Memory optimization: Clear intermediate buffers to help GC
-        // These are no longer needed after bcj2Inputs is built
-        for(var key in coderOutputs){
-            delete coderOutputs[key];
-        }
-        // Clear packStreams array (allows GC to free compressed data)
-        packStreams.length = 0;
-        // Decode BCJ2
-        return (0, _indexts.decodeBcj2Multi)(bcj2Inputs, undefined, bcj2UnpackSize);
+        try {
+            var result = (0, _indexts.decodeBcj2Multi)(bcj2Inputs, undefined, bcj2UnpackSize);
+            callback(null, result);
+        } catch (err) {
+            callback(err);
+        } finally{
+            for(var key in coderOutputs){
+                delete coderOutputs[key];
+            }
+            packStreams.length = 0;
+        }
     };
     /**
    * Get processing order for coders (dependency order)