7z-iterator 1.1.1 → 1.2.0

package/dist/cjs/sevenz/SevenZipParser.js

@@ -38,30 +38,144 @@ _export(exports, {
     }
 });
 var _extractbaseiterator = require("extract-base-iterator");
-var _onone = /*#__PURE__*/ _interop_require_default(require("on-one"));
-var _stream = /*#__PURE__*/ _interop_require_default(require("stream"));
 var _indexts = require("./codecs/index.js");
+var _FolderStreamSplitterts = require("./FolderStreamSplitter.js");
 var _constantsts = require("./constants.js");
 var _headersts = require("./headers.js");
 var _NumberCodects = require("./NumberCodec.js");
 var _ArchiveSourcets = require("./ArchiveSource.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// Use native streams when available, readable-stream only for Node 0.x
-var major = +process.versions.node.split('.')[0];
-var PassThrough;
-if (major > 0) {
-    PassThrough = _stream.default.PassThrough;
-} else {
-    PassThrough = require('readable-stream').PassThrough;
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
 }
 var SevenZipParser = /*#__PURE__*/ function() {
     "use strict";
@@ -78,6 +192,8 @@ var SevenZipParser = /*#__PURE__*/ function() {
         // Track files per folder and how many have been extracted
         this.filesPerFolder = {};
         this.extractedPerFolder = {};
+        // Splitter cache for multi-file folder streaming (Phase 2)
+        this.folderSplitters = {};
         this.source = source;
     }
     var _proto = SevenZipParser.prototype;
@@ -344,6 +460,15 @@ var SevenZipParser = /*#__PURE__*/ function() {
                 }
             }
         }
+        // Set _canStream for all entries now that we have complete folder info
+        // This must be done after all entries are built because canStreamFolder
+        // relies on the folder structure being fully parsed
+        for(var i1 = 0; i1 < this.entries.length; i1++){
+            var entry1 = this.entries[i1];
+            if (entry1._hasStream && entry1._folderIndex >= 0) {
+                entry1._canStream = this.canStreamFolder(entry1._folderIndex);
+            }
+        }
     };
     /**
    * Create an entry from file info
@@ -385,7 +510,8 @@ var SevenZipParser = /*#__PURE__*/ function() {
             _folderIndex: folderIndex,
             _streamIndex: 0,
             _streamIndexInFolder: streamInFolder,
-            _hasStream: file.hasStream
+            _hasStream: file.hasStream,
+            _canStream: false
         };
     };
     /**
@@ -397,11 +523,13 @@ var SevenZipParser = /*#__PURE__*/ function() {
         return this.entries;
     };
     /**
-   * Get a readable stream for an entry's content
+   * Get a readable stream for an entry's content.
+   * Returns immediately - decompression happens when data is read (proper streaming).
+   * Uses true streaming for codecs that support it, buffered for others.
    */ _proto.getEntryStream = function getEntryStream(entry) {
         if (!entry._hasStream || entry.type === 'directory') {
             // Return empty stream for directories and empty files
-            var emptyStream = new PassThrough();
+            var emptyStream = new _extractbaseiterator.PassThrough();
             emptyStream.end();
             return emptyStream;
         }
@@ -421,107 +549,152 @@ var SevenZipParser = /*#__PURE__*/ function() {
                 throw (0, _constantsts.createCodedError)("Unsupported codec: ".concat(codecName), _constantsts.ErrorCode.UNSUPPORTED_CODEC);
             }
         }
-        // Get decompressed data for this folder (with smart caching)
-        var folderIdx = entry._folderIndex;
-        var data = this.getDecompressedFolder(folderIdx);
-        // Calculate file offset within the decompressed block
-        // For solid archives, multiple files are concatenated in the block
-        var fileStart = 0;
-        for(var m = 0; m < entry._streamIndexInFolder; m++){
-            // Sum sizes of all streams before this one in the folder
-            var prevStreamGlobalIndex = entry._streamIndex - entry._streamIndexInFolder + m;
-            fileStart += this.streamsInfo.unpackSizes[prevStreamGlobalIndex];
-        }
-        var fileSize = entry.size;
-        // Create a PassThrough stream with the file data
-        var outputStream = new PassThrough();
-        // Bounds check to prevent "oob" error on older Node versions
-        if (fileStart + fileSize > data.length) {
-            throw (0, _constantsts.createCodedError)("File data out of bounds: offset ".concat(fileStart, " + size ").concat(fileSize, " > decompressed length ").concat(data.length), _constantsts.ErrorCode.DECOMPRESSION_FAILED);
-        }
-        var fileData = data.slice(fileStart, fileStart + fileSize);
-        // Verify CRC if present
-        if (entry._crc !== undefined) {
-            var actualCRC = (0, _extractbaseiterator.crc32)(fileData);
-            if (actualCRC !== entry._crc) {
-                throw (0, _constantsts.createCodedError)("CRC mismatch for ".concat(entry.path, ": expected ").concat(entry._crc.toString(16), ", got ").concat(actualCRC.toString(16)), _constantsts.ErrorCode.CRC_MISMATCH);
-            }
-        }
-        outputStream.end(fileData);
-        // Track extraction and release cache when all files from this folder are done
-        this.extractedPerFolder[folderIdx] = (this.extractedPerFolder[folderIdx] || 0) + 1;
-        if (this.extractedPerFolder[folderIdx] >= this.filesPerFolder[folderIdx]) {
-            // All files from this folder extracted, release cache
-            delete this.decompressedCache[folderIdx];
-        }
-        return outputStream;
+        // Use true streaming for single-file folders that support it.
+        // Multi-file folders use buffered approach because streaming requires
+        // accessing files in order, which doesn't work with concurrent extraction.
+        var filesInFolder = this.filesPerFolder[entry._folderIndex] || 1;
+        if (entry._canStream && filesInFolder === 1) {
+            return this._getEntryStreamStreaming(entry);
+        }
+        return this._getEntryStreamBuffered(entry);
     };
     /**
-   * Get a readable stream for an entry's content (callback-based async version)
-   * Uses streaming decompression for non-blocking I/O
-   */ _proto.getEntryStreamAsync = function getEntryStreamAsync(entry, callback) {
+   * True streaming: data flows through without buffering entire folder.
+   * Only used for single-file folders with streamable codecs (BZip2, Deflate, LZMA2).
+   */ _proto._getEntryStreamStreaming = function _getEntryStreamStreaming(entry) {
         var _this = this;
-        if (!entry._hasStream || entry.type === 'directory') {
-            // Return empty stream for directories and empty files
-            var emptyStream = new PassThrough();
-            emptyStream.end();
-            callback(null, emptyStream);
-            return;
-        }
-        if (!this.streamsInfo) {
-            callback((0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER));
-            return;
-        }
-        // Get folder info
-        var folder = this.streamsInfo.folders[entry._folderIndex];
-        if (!folder) {
-            callback((0, _constantsts.createCodedError)('Invalid folder index', _constantsts.ErrorCode.CORRUPT_HEADER));
-            return;
-        }
-        // Check codec support
-        for(var i = 0; i < folder.coders.length; i++){
-            var coder = folder.coders[i];
-            if (!(0, _indexts.isCodecSupported)(coder.id)) {
-                var codecName = (0, _indexts.getCodecName)(coder.id);
-                callback((0, _constantsts.createCodedError)("Unsupported codec: ".concat(codecName), _constantsts.ErrorCode.UNSUPPORTED_CODEC));
-                return;
+        var started = false;
+        var destroyed = false;
+        var folderStream = null;
+        var stream = new _extractbaseiterator.PassThrough();
+        var originalRead = stream._read.bind(stream);
+        stream._read = function(size) {
+            if (!started && !destroyed) {
+                started = true;
+                setTimeout(function() {
+                    if (destroyed) return;
+                    try {
+                        var crcValue = 0;
+                        var verifyCrc = entry._crc !== undefined;
+                        folderStream = _this.streamFolder(entry._folderIndex);
+                        folderStream.output.on('data', function(chunk) {
+                            if (destroyed) return;
+                            if (verifyCrc) {
+                                crcValue = (0, _extractbaseiterator.crc32)(chunk, crcValue);
+                            }
+                            if (!stream.write(chunk)) {
+                                folderStream === null || folderStream === void 0 ? void 0 : folderStream.pause();
+                                stream.once('drain', function() {
+                                    return folderStream === null || folderStream === void 0 ? void 0 : folderStream.resume();
+                                });
+                            }
+                        });
+                        folderStream.output.on('end', function() {
+                            if (destroyed) return;
+                            if (verifyCrc && crcValue !== entry._crc) {
+                                var _entry__crc;
+                                stream.destroy((0, _constantsts.createCodedError)("CRC mismatch for ".concat(entry.path, ": expected ").concat((_entry__crc = entry._crc) === null || _entry__crc === void 0 ? void 0 : _entry__crc.toString(16), ", got ").concat(crcValue.toString(16)), _constantsts.ErrorCode.CRC_MISMATCH));
+                                return;
+                            }
+                            stream.end();
+                            _this.extractedPerFolder[entry._folderIndex] = (_this.extractedPerFolder[entry._folderIndex] || 0) + 1;
+                        });
+                        folderStream.output.on('error', function(err) {
+                            if (!destroyed) stream.destroy(err);
+                        });
+                    } catch (err) {
+                        if (!destroyed) {
+                            stream.destroy(err);
+                        }
+                    }
+                }, 0);
             }
+            return originalRead(size);
+        };
+        // Override destroy to clean up folder stream
+        // IMPORTANT: Emit error synchronously BEFORE calling original destroy.
+        // On older Node, destroy() emits 'finish' and 'end' before 'error',
+        // which causes piped streams to complete successfully before the error fires.
+        var streamWithDestroy = stream;
+        var originalDestroy = typeof streamWithDestroy.destroy === 'function' ? streamWithDestroy.destroy.bind(stream) : null;
+        streamWithDestroy.destroy = function(err) {
+            destroyed = true;
+            if (err) stream.emit('error', err);
+            if (folderStream) folderStream.destroy();
+            if (originalDestroy) return originalDestroy();
+            return stream;
+        };
+        return stream;
+    };
+    /**
+   * Buffered extraction: decompress entire folder, slice out file.
+   * Used for codecs that don't support incremental streaming (LZMA1, BCJ2).
+   */ _proto._getEntryStreamBuffered = function _getEntryStreamBuffered(entry) {
+        var _this = this;
+        if (!this.streamsInfo) {
+            throw (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
         }
-        // Get decompressed data for this folder using async method
-        var folderIdx = entry._folderIndex;
         var streamsInfo = this.streamsInfo;
-        this.getDecompressedFolderAsync(folderIdx, function(err, data) {
-            if (err) return callback(err);
-            if (!data) return callback(new Error('No data returned from decompression'));
-            // Calculate file offset within the decompressed block
-            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;
-            // Bounds check
-            if (fileStart + fileSize > data.length) {
-                return callback((0, _constantsts.createCodedError)("File data out of bounds: offset ".concat(fileStart, " + size ").concat(fileSize, " > decompressed length ").concat(data.length), _constantsts.ErrorCode.DECOMPRESSION_FAILED));
-            }
-            // Create a PassThrough stream with the file data
-            var outputStream = new PassThrough();
-            var fileData = data.slice(fileStart, fileStart + fileSize);
-            // Verify CRC if present
-            if (entry._crc !== undefined) {
-                var actualCRC = (0, _extractbaseiterator.crc32)(fileData);
-                if (actualCRC !== entry._crc) {
-                    return callback((0, _constantsts.createCodedError)("CRC mismatch for ".concat(entry.path, ": expected ").concat(entry._crc.toString(16), ", got ").concat(actualCRC.toString(16)), _constantsts.ErrorCode.CRC_MISMATCH));
-                }
-            }
-            outputStream.end(fileData);
-            // Track extraction and release cache when all files from this folder are done
-            _this.extractedPerFolder[folderIdx] = (_this.extractedPerFolder[folderIdx] || 0) + 1;
-            if (_this.extractedPerFolder[folderIdx] >= _this.filesPerFolder[folderIdx]) {
-                delete _this.decompressedCache[folderIdx];
+        var folderIdx = entry._folderIndex;
+        var started = false;
+        var destroyed = false;
+        var stream = new _extractbaseiterator.PassThrough();
+        var originalRead = stream._read.bind(stream);
+        stream._read = function(size) {
+            if (!started && !destroyed) {
+                started = true;
+                setTimeout(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));
+                            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 (err) {
+                        if (!destroyed) {
+                            stream.destroy(err);
+                        }
+                    }
+                }, 0);
             }
-            callback(null, outputStream);
-        });
+            return originalRead(size);
+        };
+        // Override destroy to set destroyed flag
+        // IMPORTANT: Emit error synchronously BEFORE calling original destroy.
+        // On older Node, destroy() emits 'finish' and 'end' before 'error',
+        // which causes piped streams to complete successfully before the error fires.
+        var streamWithDestroy = stream;
+        var originalDestroy = typeof streamWithDestroy.destroy === 'function' ? streamWithDestroy.destroy.bind(stream) : null;
+        streamWithDestroy.destroy = function(err) {
+            destroyed = true;
+            if (err) stream.emit('error', err);
+            if (originalDestroy) return originalDestroy();
+            return stream;
+        };
+        return stream;
     };
     /**
    * Check if a folder uses BCJ2 codec
@@ -589,98 +762,6 @@ var SevenZipParser = /*#__PURE__*/ function() {
         return data2;
     };
     /**
-   * Get decompressed data for a folder using streaming (callback-based async)
-   * Uses createDecoder() streams for non-blocking decompression
-   */ _proto.getDecompressedFolderAsync = function getDecompressedFolderAsync(folderIndex, callback) {
-        var self = this;
-        // Check cache first
-        if (this.decompressedCache[folderIndex]) return callback(null, this.decompressedCache[folderIndex]);
-        if (!this.streamsInfo) {
-            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
-        var filesInFolder = this.filesPerFolder[folderIndex] || 1;
-        var extractedFromFolder = this.extractedPerFolder[folderIndex] || 0;
-        var remainingFiles = filesInFolder - extractedFromFolder;
-        var shouldCache = remainingFiles > 1;
-        // BCJ2 requires special handling - use sync version for now
-        // TODO: Add async BCJ2 support
-        if (this.folderHasBcj2(folder)) {
-            try {
-                var data = this.decompressBcj2Folder(folderIndex);
-                if (shouldCache) {
-                    this.decompressedCache[folderIndex] = data;
-                }
-                callback(null, data);
-            } catch (err) {
-                callback(err);
-            }
-            return;
-        }
-        // Calculate packed data position
-        var packPos = _constantsts.SIGNATURE_HEADER_SIZE + this.streamsInfo.packPos;
-        // 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
-        for(var k = 0; k < packStreamIndex; k++){
-            packPos += this.streamsInfo.packSizes[k];
-        }
-        var packSize = this.streamsInfo.packSizes[packStreamIndex];
-        // Read packed data
-        var packedData = this.source.read(packPos, packSize);
-        // Create decoder stream chain and decompress
-        var coders = folder.coders;
-        var unpackSizes = folder.unpackSizes;
-        // Helper to decompress through a single codec stream
-        function decompressWithStream(input, coderIdx, cb) {
-            var coderInfo = coders[coderIdx];
-            var codec = (0, _indexts.getCodec)(coderInfo.id);
-            var decoder = codec.createDecoder(coderInfo.properties, unpackSizes[coderIdx]);
-            var chunks = [];
-            var errorOccurred = false;
-            decoder.on('data', function(chunk) {
-                chunks.push(chunk);
-            });
-            (0, _onone.default)(decoder, [
-                'error',
-                'end',
-                'close',
-                'finish'
-            ], function(err) {
-                if (errorOccurred) return;
-                if (err) {
-                    errorOccurred = true;
-                    return cb(err);
-                }
-                cb(null, Buffer.concat(chunks));
-            });
-            // Write input data to decoder and signal end
-            decoder.end(input);
-        }
-        // Chain decompression through all codecs
-        function decompressChain(input, idx) {
-            if (idx >= coders.length) {
-                // All done - cache and return
-                if (shouldCache) {
-                    self.decompressedCache[folderIndex] = input;
-                }
-                callback(null, input);
-                return;
-            }
-            decompressWithStream(input, idx, function(err, output) {
-                if (err) return callback(err);
-                decompressChain(output, idx + 1);
-            });
-        }
-        // Start the chain
-        decompressChain(packedData, 0);
-    };
-    /**
    * Decompress a BCJ2 folder with multi-stream handling
    * BCJ2 uses 4 input streams: main, call, jump, range coder
    */ _proto.decompressBcj2Folder = function decompressBcj2Folder(folderIndex) {
@@ -870,6 +951,296 @@ var SevenZipParser = /*#__PURE__*/ function() {
             this.source.close();
         }
     };
+    // ============================================================
+    // STREAMING METHODS (Phase 1+)
+    // ============================================================
+    /**
+   * Check if a codec supports true streaming decompression.
+   *
+   * Only codecs that process data incrementally (not buffering entire input) qualify.
+   * @param codecId - The codec ID as an array of bytes
+   * @returns true if the codec can stream
+   */ _proto.codecSupportsStreaming = function codecSupportsStreaming(codecId) {
+        // Convert to string key for comparison
+        var key = codecId.map(function(b) {
+            return b.toString(16).toUpperCase();
+        }).join('-');
+        // BZip2 - unbzip2-stream processes blocks incrementally
+        if (key === '4-2-2') return true;
+        // Copy/Store - PassThrough, obviously streams
+        if (key === '0') return true;
+        // Deflate - now uses zlib.createInflateRaw() which streams
+        if (key === '4-1-8') return true;
+        // Delta - now uses streaming Transform (Phase 2.5)
+        if (key === '3') return true;
+        // BCJ x86 - now uses streaming Transform (Phase 3.5)
+        if (key === '3-3-1-3') return true;
+        // BCJ ARM - now uses streaming Transform (Phase 3.5)
+        if (key === '3-3-1-5') return true;
+        // LZMA2 - now uses streaming Transform (Phase 5)
+        if (key === '21') return true;
+        // LZMA - still buffer-based (TODO: Phase 5 continuation)
+        // Other BCJ variants (ARM64, ARMT, IA64, PPC, SPARC) - still buffer-based
+        // BCJ2 - multi-stream architecture, never streamable
+        return false;
+    };
+    /**
+   * Check if a folder can be streamed (vs buffered).
+   *
+   * Streaming is possible when ALL codecs in the chain support streaming.
+   * BCJ2 folders are never streamable due to their 4-stream architecture.
+   *
+   * @param folderIndex - Index of the folder to check
+   * @returns true if the folder can be streamed
+   */ _proto.canStreamFolder = function canStreamFolder(folderIndex) {
+        if (!this.streamsInfo) return false;
+        var folder = this.streamsInfo.folders[folderIndex];
+        if (!folder) return false;
+        // BCJ2 requires special multi-stream handling - not streamable
+        if (this.folderHasBcj2(folder)) {
+            return false;
+        }
+        // Check if ALL codecs in chain support streaming
+        for(var i = 0; i < folder.coders.length; i++){
+            if (!this.codecSupportsStreaming(folder.coders[i].id)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    /**
+   * Stream a folder's decompression.
+   *
+   * Creates a pipeline: packed data → codec decoders → output stream
+   *
+   * @param folderIndex - Index of folder to decompress
+   * @returns Object with output stream and control methods
+   */ _proto.streamFolder = function streamFolder(folderIndex) {
+        if (!this.streamsInfo) {
+            throw (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
+        }
+        if (!this.canStreamFolder(folderIndex)) {
+            throw (0, _constantsts.createCodedError)('Folder does not support streaming', _constantsts.ErrorCode.UNSUPPORTED_CODEC);
+        }
+        var folder = this.streamsInfo.folders[folderIndex];
+        // Calculate packed data position
+        var packPos = _constantsts.SIGNATURE_HEADER_SIZE + this.streamsInfo.packPos;
+        // 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
+        for(var k = 0; k < packStreamIndex; k++){
+            packPos += this.streamsInfo.packSizes[k];
+        }
+        var packSize = this.streamsInfo.packSizes[packStreamIndex];
+        // Create readable stream from packed data
+        var packedStream = this.source.createReadStream(packPos, packSize);
+        // Build codec pipeline
+        var stream = packedStream;
+        var decoders = [];
+        for(var i = 0; i < folder.coders.length; i++){
+            var coderInfo = folder.coders[i];
+            var codec = (0, _indexts.getCodec)(coderInfo.id);
+            var unpackSize = folder.unpackSizes[i];
+            var decoder = codec.createDecoder(coderInfo.properties, unpackSize);
+            decoders.push(decoder);
+            stream = stream.pipe(decoder);
+        }
+        return {
+            output: stream,
+            pause: function() {
+                return packedStream.pause();
+            },
+            resume: function() {
+                return packedStream.resume();
+            },
+            destroy: function(err) {
+                // Check for destroy method existence (not available in Node 4 and earlier)
+                var ps = packedStream;
+                if (typeof ps.destroy === 'function') ps.destroy(err);
+                for(var i = 0; i < decoders.length; i++){
+                    var d = decoders[i];
+                    if (typeof d.destroy === 'function') d.destroy(err);
+                }
+            }
+        };
+    };
+    /**
+   * Get a streaming entry stream (Promise-based API).
+   *
+   * For streamable folders: Returns a true streaming decompression
+   * For non-streamable folders: Falls back to buffered extraction
+   *
+   * @param entry - The entry to get stream for
+   * @returns Promise resolving to readable stream
+   */ _proto.getEntryStreamStreaming = function getEntryStreamStreaming(entry) {
+        return _async_to_generator(function() {
+            var emptyStream, folderIndex, filesInFolder;
+            return _ts_generator(this, function(_state) {
+                if (!entry._hasStream || entry.type === 'directory') {
+                    emptyStream = new _extractbaseiterator.PassThrough();
+                    emptyStream.end();
+                    return [
+                        2,
+                        emptyStream
+                    ];
+                }
+                folderIndex = entry._folderIndex;
+                // Fall back to buffered if not streamable
+                if (!this.canStreamFolder(folderIndex)) {
+                    return [
+                        2,
+                        this.getEntryStream(entry)
+                    ];
+                }
+                filesInFolder = this.filesPerFolder[folderIndex] || 1;
+                if (filesInFolder === 1) {
+                    // Single file - direct streaming
+                    return [
+                        2,
+                        this.getEntryStreamDirect(entry)
+                    ];
+                }
+                // Multi-file folders use FolderStreamSplitter (Phase 2)
+                return [
+                    2,
+                    this.getEntryStreamFromSplitter(entry)
+                ];
+            });
+        }).call(this);
+    };
+    /**
+   * Direct streaming for single-file folders.
+   * Pipes folder decompression directly to output with CRC verification.
+   */ _proto.getEntryStreamDirect = function getEntryStreamDirect(entry) {
+        var _this = this;
+        return new Promise(function(resolve, reject) {
+            var outputStream = new _extractbaseiterator.PassThrough();
+            var crcValue = 0;
+            var verifyCrc = entry._crc !== undefined;
+            try {
+                var folderStream = _this.streamFolder(entry._folderIndex);
+                folderStream.output.on('data', function(chunk) {
+                    if (verifyCrc) {
+                        crcValue = (0, _extractbaseiterator.crc32)(chunk, crcValue);
+                    }
+                    // Handle backpressure
+                    if (!outputStream.write(chunk)) {
+                        folderStream.pause();
+                        outputStream.once('drain', function() {
+                            return folderStream.resume();
+                        });
+                    }
+                });
+                folderStream.output.on('end', function() {
+                    // Verify CRC
+                    if (verifyCrc && crcValue !== entry._crc) {
+                        var _entry__crc;
+                        var _$err = (0, _constantsts.createCodedError)("CRC mismatch for ".concat(entry.path, ": expected ").concat((_entry__crc = entry._crc) === null || _entry__crc === void 0 ? void 0 : _entry__crc.toString(16), ", got ").concat(crcValue.toString(16)), _constantsts.ErrorCode.CRC_MISMATCH);
+                        outputStream.destroy(_$err);
+                        return;
+                    }
+                    outputStream.end();
+                    // Track extraction
+                    _this.extractedPerFolder[entry._folderIndex] = (_this.extractedPerFolder[entry._folderIndex] || 0) + 1;
+                });
+                folderStream.output.on('error', function(err) {
+                    outputStream.destroy(err);
+                });
+                resolve(outputStream);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    };
+    /**
+   * Get stream from folder splitter (for multi-file folders).
+   * Creates splitter on first access, reuses for subsequent files in same folder.
+   */ _proto.getEntryStreamFromSplitter = function getEntryStreamFromSplitter(entry) {
+        var _this = this;
+        return new Promise(function(resolve, reject) {
+            var folderIndex = entry._folderIndex;
+            // Get or create splitter for this folder
+            var splitter = _this.folderSplitters[folderIndex];
+            if (!splitter) {
+                // Create new splitter with file sizes and CRCs
+                var folderInfo = _this.getFolderFileInfo(folderIndex);
+                splitter = new _FolderStreamSplitterts.FolderStreamSplitter({
+                    fileSizes: folderInfo.fileSizes,
+                    verifyCrc: true,
+                    expectedCrcs: folderInfo.expectedCrcs
+                });
+                _this.folderSplitters[folderIndex] = splitter;
+                // Start streaming the folder
+                var folderStream;
+                try {
+                    folderStream = _this.streamFolder(folderIndex);
+                } catch (err) {
+                    delete _this.folderSplitters[folderIndex];
+                    reject(err);
+                    return;
+                }
+                folderStream.output.on('data', function(chunk) {
+                    // Handle backpressure from splitter
+                    if (!(splitter === null || splitter === void 0 ? void 0 : splitter.write(chunk))) {
+                        folderStream.pause();
+                        splitter === null || splitter === void 0 ? void 0 : splitter.onDrain(function() {
+                            folderStream.resume();
+                        });
+                    }
+                });
+                folderStream.output.on('end', function() {
+                    splitter === null || splitter === void 0 ? void 0 : splitter.end();
+                    delete _this.folderSplitters[folderIndex];
+                });
+                folderStream.output.on('error', function(_err) {
+                    splitter === null || splitter === void 0 ? void 0 : splitter.end();
+                    delete _this.folderSplitters[folderIndex];
+                });
+            }
+            // Get this entry's stream from splitter
+            try {
+                var fileStream = splitter.getFileStream(entry._streamIndexInFolder);
+                // Track extraction when stream ends
+                fileStream.on('end', function() {
+                    _this.extractedPerFolder[folderIndex] = (_this.extractedPerFolder[folderIndex] || 0) + 1;
+                });
+                resolve(fileStream);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    };
+    /**
+   * Get file sizes and CRCs for all files in a folder (in stream order).
+   * Used by FolderStreamSplitter to know file boundaries.
+   */ _proto.getFolderFileInfo = function getFolderFileInfo(folderIndex) {
+        var fileSizes = [];
+        var expectedCrcs = [];
+        // Collect entries in this folder, sorted by stream index
+        var folderEntries = [];
+        for(var i = 0; i < this.entries.length; i++){
+            var e = this.entries[i];
+            if (e._folderIndex === folderIndex && e._hasStream) {
+                folderEntries.push(e);
+            }
+        }
+        // Sort by stream index within folder
+        folderEntries.sort(function(a, b) {
+            return a._streamIndexInFolder - b._streamIndexInFolder;
+        });
+        for(var i1 = 0; i1 < folderEntries.length; i1++){
+            var entry = folderEntries[i1];
+            fileSizes.push(entry.size);
+            expectedCrcs.push(entry._crc);
+        }
+        return {
+            fileSizes: fileSizes,
+            expectedCrcs: expectedCrcs
+        };
+    };
     return SevenZipParser;
 }();
 /**