7z-iterator 1.1.1 → 1.2.0

package/dist/cjs/sevenz/codecs/Lzma2.js

@@ -1,3 +1,13 @@
+// LZMA2 codec using TypeScript LZMA decoder
+//
+// LZMA2 format specification:
+// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md
+//
+// Control byte values:
+// 0x00         = End of stream
+// 0x01         = Uncompressed chunk, dictionary reset
+// 0x02         = Uncompressed chunk, no dictionary reset
+// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -16,208 +26,17 @@ _export(exports, {
         return decodeLzma2;
     }
 });
-var _module = /*#__PURE__*/ _interop_require_default(require("module"));
-var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-var _streamsts = require("./streams.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var _require = typeof require === 'undefined' ? _module.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
-// Import vendored lzma-purejs - provides raw LZMA decoder (patched for LZMA2 support)
-// Path accounts for build output in dist/esm/sevenz/codecs/
-var LZMA = _require('../../../../assets/lzma-purejs').LZMA;
-var LzmaDecoder = LZMA.Decoder;
-/**
- * Decode LZMA2 dictionary size from properties byte
- * Properties byte encodes dictionary size as: 2^(dictByte/2 + 12) or similar
- *
- * Per XZ spec, dictionary sizes are:
- * 0x00 = 4 KiB (2^12)
- * 0x01 = 6 KiB
- * 0x02 = 8 KiB (2^13)
- * ...
- * 0x28 = 1.5 GiB
- */ function decodeDictionarySize(propByte) {
-    if (propByte > 40) {
-        throw new Error("Invalid LZMA2 dictionary size property: ".concat(propByte));
-    }
-    if (propByte === 40) {
-        // Max dictionary size: 4 GiB - 1
-        return 0xffffffff;
-    }
-    // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)
-    var base = 2 | propByte & 1;
-    var shift = Math.floor(propByte / 2) + 11;
-    return base << shift;
-}
+var _indexts = require("../../lzma/index.js");
 function decodeLzma2(input, properties, unpackSize) {
     if (!properties || properties.length < 1) {
         throw new Error('LZMA2 requires properties byte');
     }
-    var dictSize = decodeDictionarySize(properties[0]);
-    // Memory optimization: pre-allocate output buffer if size is known
-    // This avoids double-memory during Buffer.concat
-    var outputBuffer = null;
-    var outputPos = 0;
-    var outputChunks = [];
-    if (unpackSize && unpackSize > 0) {
-        outputBuffer = (0, _extractbaseiterator.allocBufferUnsafe)(unpackSize);
-    }
-    var offset = 0;
-    // LZMA decoder instance - reused across chunks
-    // The vendored decoder supports setSolid() for LZMA2 state preservation
-    // The decoder also has _nowPos64 which tracks cumulative position for rep0 validation
-    // and _prevByte which is used for literal decoder context selection
-    var decoder = new LzmaDecoder();
-    decoder.setDictionarySize(dictSize);
-    var outWindow = decoder._outWindow;
-    // Track current LZMA properties (lc, lp, pb)
-    var propsSet = false;
-    while(offset < input.length){
-        var control = input[offset++];
-        if (control === 0x00) {
-            break;
-        }
-        if (control === 0x01 || control === 0x02) {
-            // Uncompressed chunk
-            // 0x01 = dictionary reset + uncompressed
-            // 0x02 = uncompressed (no reset)
-            // Handle dictionary reset for 0x01
-            if (control === 0x01) {
-                outWindow._pos = 0;
-                outWindow._streamPos = 0;
-                decoder._nowPos64 = 0;
-            }
-            if (offset + 2 > input.length) {
-                throw new Error('Truncated LZMA2 uncompressed chunk header');
-            }
-            // Size is big-endian, 16-bit, value + 1
-            var uncompSize = (input[offset] << 8 | input[offset + 1]) + 1;
-            offset += 2;
-            if (offset + uncompSize > input.length) {
-                throw new Error('Truncated LZMA2 uncompressed data');
-            }
-            // Get the uncompressed data
-            var uncompData = input.slice(offset, offset + uncompSize);
-            // Copy uncompressed data to output
-            if (outputBuffer) {
-                uncompData.copy(outputBuffer, outputPos);
-                outputPos += uncompData.length;
-            } else {
-                outputChunks === null || outputChunks === void 0 ? void 0 : outputChunks.push(uncompData);
-            }
-            // Also update the decoder's internal dictionary so subsequent LZMA chunks can reference it
-            // The decoder needs to track this data for LZ77 back-references
-            // We write directly to _buffer to avoid flush() which requires _stream to be set
-            // We must also update _streamPos to match _pos so that flush() doesn't try to write
-            for(var i = 0; i < uncompData.length; i++){
-                outWindow._buffer[outWindow._pos++] = uncompData[i];
-                // Handle circular buffer wrap-around
-                if (outWindow._pos >= outWindow._windowSize) {
-                    outWindow._pos = 0;
-                }
-            }
-            // Keep _streamPos in sync so flush() doesn't try to write these bytes
-            // (they're already in our output buffer)
-            outWindow._streamPos = outWindow._pos;
-            // Update decoder's cumulative position so subsequent LZMA chunks have correct rep0 validation
-            decoder._nowPos64 += uncompSize;
-            // Update prevByte for literal decoder context in subsequent LZMA chunks
-            decoder._prevByte = uncompData[uncompData.length - 1];
-            offset += uncompSize;
-        } else if (control >= 0x80) {
-            // LZMA compressed chunk
-            // Control byte format (bits 7-0):
-            // Bit 7: always 1 for LZMA chunk
-            // Bits 6-5: reset mode (00=nothing, 01=state, 10=state+props, 11=all)
-            // Bits 4-0: high 5 bits of uncompressed size - 1
-            // Control byte ranges (based on bits 6-5):
-            // 0x80-0x9F (00): no reset - continue existing state (solid mode)
-            // 0xA0-0xBF (01): reset state only
-            // 0xC0-0xDF (10): reset state + new properties
-            // 0xE0-0xFF (11): reset dictionary + state + new properties
-            var resetState = control >= 0xa0;
-            var newProps = control >= 0xc0;
-            var dictReset = control >= 0xe0;
-            var useSolidMode = !resetState;
-            // Handle dictionary reset for control bytes 0xE0-0xFF
-            if (dictReset) {
-                outWindow._pos = 0;
-                outWindow._streamPos = 0;
-            }
-            if (offset + 4 > input.length) {
-                throw new Error('Truncated LZMA2 LZMA chunk header');
-            }
-            // Uncompressed size: 5 bits from control + 16 bits from next 2 bytes + 1
-            var uncompHigh = control & 0x1f;
-            var uncompSize2 = (uncompHigh << 16 | input[offset] << 8 | input[offset + 1]) + 1;
-            offset += 2;
-            // Compressed size: 16 bits + 1
-            var compSize = (input[offset] << 8 | input[offset + 1]) + 1;
-            offset += 2;
-            // If new properties, read 1-byte LZMA properties
-            if (newProps) {
-                if (offset >= input.length) {
-                    throw new Error('Truncated LZMA2 properties byte');
-                }
-                var propsByte = input[offset++];
-                // Properties byte: pb * 45 + lp * 9 + lc
-                // where pb, lp, lc are LZMA parameters
-                var lc = propsByte % 9;
-                var remainder = Math.floor(propsByte / 9);
-                var lp = remainder % 5;
-                var pb = Math.floor(remainder / 5);
-                if (!decoder.setLcLpPb(lc, lp, pb)) {
-                    throw new Error("Invalid LZMA properties: lc=".concat(lc, " lp=").concat(lp, " pb=").concat(pb));
-                }
-                propsSet = true;
-            }
-            if (!propsSet) {
-                throw new Error('LZMA chunk without properties');
-            }
-            if (offset + compSize > input.length) {
-                throw new Error('Truncated LZMA2 compressed data');
-            }
-            // Decode LZMA chunk
-            var inStream = (0, _streamsts.createInputStream)(input, offset, compSize);
-            var outStream = (0, _streamsts.createOutputStream)(uncompSize2); // Pre-allocate for memory efficiency
-            // Set solid mode based on control byte - this preserves state across code() calls
-            // For state reset WITHOUT dict reset (0xa0-0xdf), use resetProbabilities() to
-            // reset probability tables while preserving _nowPos64 for dictionary references
-            if (resetState && !dictReset) {
-                decoder.resetProbabilities();
-                decoder.setSolid(true); // Preserve _nowPos64 in code()
-            } else {
-                decoder.setSolid(useSolidMode);
-            }
-            // Decode the chunk
-            var success = decoder.code(inStream, outStream, uncompSize2);
-            if (!success) {
-                throw new Error('LZMA decompression failed');
-            }
-            var chunkOutput = outStream.toBuffer();
-            if (outputBuffer) {
-                chunkOutput.copy(outputBuffer, outputPos);
-                outputPos += chunkOutput.length;
-            } else {
-                outputChunks === null || outputChunks === void 0 ? void 0 : outputChunks.push(chunkOutput);
-            }
-            offset += compSize;
-        } else {
-            throw new Error("Invalid LZMA2 control byte: 0x".concat(control.toString(16)));
-        }
-    }
-    // Return pre-allocated buffer or concatenated chunks
-    if (outputBuffer) {
-        // Return only the used portion if we didn't fill the buffer
-        return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;
-    }
-    return Buffer.concat(outputChunks);
+    return (0, _indexts.decodeLzma2)(input, properties, unpackSize);
 }
-function createLzma2Decoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeLzma2, properties, unpackSize);
+function createLzma2Decoder(properties, _unpackSize) {
+    if (!properties || properties.length < 1) {
+        throw new Error('LZMA2 requires properties byte');
+    }
+    return (0, _indexts.createLzma2Decoder)(properties);
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/sevenz/codecs/Lzma2.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma2.ts"],"sourcesContent":["import Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// LZMA2 codec using lzma-purejs\n// LZMA2 is a container format that wraps LZMA chunks with framing\n//\n// LZMA2 format specification:\n// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md\n//\n// Control byte values:\n// 0x00         = End of stream\n// 0x01         = Uncompressed chunk, dictionary reset\n// 0x02         = Uncompressed chunk, no dictionary reset\n// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createInputStream, createOutputStream } from './streams.ts';\n\n// Import vendored lzma-purejs - provides raw LZMA decoder (patched for LZMA2 support)\n// Path accounts for build output in dist/esm/sevenz/codecs/\nconst { LZMA } = _require('../../../../assets/lzma-purejs');\nconst LzmaDecoder = LZMA.Decoder;\n\n/**\n * Decode LZMA2 dictionary size from properties byte\n * Properties byte encodes dictionary size as: 2^(dictByte/2 + 12) or similar\n *\n * Per XZ spec, dictionary sizes are:\n * 0x00 = 4 KiB (2^12)\n * 0x01 = 6 KiB\n * 0x02 = 8 KiB (2^13)\n * ...\n * 0x28 = 1.5 GiB\n */\nfunction decodeDictionarySize(propByte: number): number {\n  if (propByte > 40) {\n    throw new Error(`Invalid LZMA2 dictionary size property: ${propByte}`);\n  }\n  if (propByte === 40) {\n    // Max dictionary size: 4 GiB - 1\n    return 0xffffffff;\n  }\n  // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)\n  const base = 2 | (propByte & 1);\n  const shift = Math.floor(propByte / 2) + 11;\n  return base << shift;\n}\n\n/**\n * Decode LZMA2 compressed data to buffer\n *\n * @param input - LZMA2 compressed data\n * @param properties - Properties buffer (1 byte: dictionary size)\n * @param unpackSize - Expected output size (used for pre-allocation to reduce memory)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  const dictSize = decodeDictionarySize(properties[0]);\n\n  // Memory optimization: pre-allocate output buffer if size is known\n  // This avoids double-memory during Buffer.concat\n  let outputBuffer: Buffer | null = null;\n  let outputPos = 0;\n  const outputChunks: Buffer[] = [];\n\n  if (unpackSize && unpackSize > 0) {\n    outputBuffer = allocBufferUnsafe(unpackSize);\n  }\n\n  let offset = 0;\n\n  // LZMA decoder instance - reused across chunks\n  // The vendored decoder supports setSolid() for LZMA2 state preservation\n  // The decoder also has _nowPos64 which tracks cumulative position for rep0 validation\n  // and _prevByte which is used for literal decoder context selection\n  const decoder = new LzmaDecoder() as InstanceType<typeof LzmaDecoder> & {\n    setSolid: (solid: boolean) => void;\n    resetProbabilities: () => void;\n    _nowPos64: number;\n    _prevByte: number;\n  };\n  decoder.setDictionarySize(dictSize);\n\n  // Access internal _outWindow for dictionary management\n  // We need to preserve dictionary state across LZMA2 chunks\n  type OutWindowType = {\n    _buffer: Buffer;\n    _pos: number;\n    _streamPos: number;\n    _windowSize: number;\n    init: (solid: boolean) => void;\n  };\n  const outWindow = (decoder as unknown as { _outWindow: OutWindowType })._outWindow;\n\n  // Track current LZMA properties (lc, lp, pb)\n  let propsSet = false;\n\n  while (offset < input.length) {\n    const control = input[offset++];\n\n    if (control === 0x00) {\n      // End of LZMA2 stream\n      break;\n    }\n\n    if (control === 0x01 || control === 0x02) {\n      // Uncompressed chunk\n      // 0x01 = dictionary reset + uncompressed\n      // 0x02 = uncompressed (no reset)\n\n      // Handle dictionary reset for 0x01\n      if (control === 0x01) {\n        outWindow._pos = 0;\n        outWindow._streamPos = 0;\n        decoder._nowPos64 = 0;\n      }\n\n      if (offset + 2 > input.length) {\n        throw new Error('Truncated LZMA2 uncompressed chunk header');\n      }\n\n      // Size is big-endian, 16-bit, value + 1\n      const uncompSize = ((input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      if (offset + uncompSize > input.length) {\n        throw new Error('Truncated LZMA2 uncompressed data');\n      }\n\n      // Get the uncompressed data\n      const uncompData = input.slice(offset, offset + uncompSize);\n\n      // Copy uncompressed data to output\n      if (outputBuffer) {\n        uncompData.copy(outputBuffer, outputPos);\n        outputPos += uncompData.length;\n      } else {\n        outputChunks?.push(uncompData);\n      }\n\n      // Also update the decoder's internal dictionary so subsequent LZMA chunks can reference it\n      // The decoder needs to track this data for LZ77 back-references\n      // We write directly to _buffer to avoid flush() which requires _stream to be set\n      // We must also update _streamPos to match _pos so that flush() doesn't try to write\n      for (let i = 0; i < uncompData.length; i++) {\n        outWindow._buffer[outWindow._pos++] = uncompData[i];\n        // Handle circular buffer wrap-around\n        if (outWindow._pos >= outWindow._windowSize) {\n          outWindow._pos = 0;\n        }\n      }\n      // Keep _streamPos in sync so flush() doesn't try to write these bytes\n      // (they're already in our output buffer)\n      outWindow._streamPos = outWindow._pos;\n\n      // Update decoder's cumulative position so subsequent LZMA chunks have correct rep0 validation\n      decoder._nowPos64 += uncompSize;\n\n      // Update prevByte for literal decoder context in subsequent LZMA chunks\n      decoder._prevByte = uncompData[uncompData.length - 1];\n\n      offset += uncompSize;\n    } else if (control >= 0x80) {\n      // LZMA compressed chunk\n      // Control byte format (bits 7-0):\n      // Bit 7: always 1 for LZMA chunk\n      // Bits 6-5: reset mode (00=nothing, 01=state, 10=state+props, 11=all)\n      // Bits 4-0: high 5 bits of uncompressed size - 1\n\n      // Control byte ranges (based on bits 6-5):\n      // 0x80-0x9F (00): no reset - continue existing state (solid mode)\n      // 0xA0-0xBF (01): reset state only\n      // 0xC0-0xDF (10): reset state + new properties\n      // 0xE0-0xFF (11): reset dictionary + state + new properties\n      const resetState = control >= 0xa0;\n      const newProps = control >= 0xc0;\n      const dictReset = control >= 0xe0;\n      const useSolidMode = !resetState;\n\n      // Handle dictionary reset for control bytes 0xE0-0xFF\n      if (dictReset) {\n        outWindow._pos = 0;\n        outWindow._streamPos = 0;\n      }\n\n      if (offset + 4 > input.length) {\n        throw new Error('Truncated LZMA2 LZMA chunk header');\n      }\n\n      // Uncompressed size: 5 bits from control + 16 bits from next 2 bytes + 1\n      const uncompHigh = control & 0x1f;\n      const uncompSize2 = ((uncompHigh << 16) | (input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // Compressed size: 16 bits + 1\n      const compSize = ((input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // If new properties, read 1-byte LZMA properties\n      if (newProps) {\n        if (offset >= input.length) {\n          throw new Error('Truncated LZMA2 properties byte');\n        }\n        const propsByte = input[offset++];\n\n        // Properties byte: pb * 45 + lp * 9 + lc\n        // where pb, lp, lc are LZMA parameters\n        const lc = propsByte % 9;\n        const remainder = Math.floor(propsByte / 9);\n        const lp = remainder % 5;\n        const pb = Math.floor(remainder / 5);\n\n        if (!decoder.setLcLpPb(lc, lp, pb)) {\n          throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n        }\n        propsSet = true;\n      }\n\n      if (!propsSet) {\n        throw new Error('LZMA chunk without properties');\n      }\n\n      if (offset + compSize > input.length) {\n        throw new Error('Truncated LZMA2 compressed data');\n      }\n\n      // Decode LZMA chunk\n      const inStream = createInputStream(input, offset, compSize);\n      const outStream = createOutputStream(uncompSize2); // Pre-allocate for memory efficiency\n\n      // Set solid mode based on control byte - this preserves state across code() calls\n      // For state reset WITHOUT dict reset (0xa0-0xdf), use resetProbabilities() to\n      // reset probability tables while preserving _nowPos64 for dictionary references\n      if (resetState && !dictReset) {\n        decoder.resetProbabilities();\n        decoder.setSolid(true); // Preserve _nowPos64 in code()\n      } else {\n        decoder.setSolid(useSolidMode);\n      }\n\n      // Decode the chunk\n      const success = decoder.code(inStream, outStream, uncompSize2);\n      if (!success) {\n        throw new Error('LZMA decompression failed');\n      }\n\n      const chunkOutput = outStream.toBuffer();\n      if (outputBuffer) {\n        chunkOutput.copy(outputBuffer, outputPos);\n        outputPos += chunkOutput.length;\n      } else {\n        outputChunks?.push(chunkOutput);\n      }\n\n      offset += compSize;\n    } else {\n      throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n    }\n  }\n\n  // Return pre-allocated buffer or concatenated chunks\n  if (outputBuffer) {\n    // Return only the used portion if we didn't fill the buffer\n    return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;\n  }\n  return Buffer.concat(outputChunks);\n}\n\n/**\n * Create an LZMA2 decoder Transform stream\n */\nexport function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeLzma2, properties, unpackSize);\n}\n"],"names":["createLzma2Decoder","decodeLzma2","_require","require","Module","createRequire","LZMA","LzmaDecoder","Decoder","decodeDictionarySize","propByte","Error","base","shift","Math","floor","input","properties","unpackSize","length","dictSize","outputBuffer","outputPos","outputChunks","allocBufferUnsafe","offset","decoder","setDictionarySize","outWindow","_outWindow","propsSet","control","_pos","_streamPos","_nowPos64","uncompSize","uncompData","slice","copy","push","i","_buffer","_windowSize","_prevByte","resetState","newProps","dictReset","useSolidMode","uncompHigh","uncompSize2","compSize","propsByte","lc","remainder","lp","pb","setLcLpPb","inStream","createInputStream","outStream","createOutputStream","resetProbabilities","setSolid","success","code","chunkOutput","toBuffer","toString","Buffer","concat","createBufferingDecoder"],"mappings":";;;;;;;;;;;QAsRgBA;eAAAA;;QA3NAC;eAAAA;;;6DA3DG;mCAgBe;+EAEC;yBACmB;;;;;;AAjBtD,IAAMC,WAAW,OAAOC,YAAY,cAAcC,eAAM,CAACC,aAAa,CAAC,uDAAmBF;AAmB1F,sFAAsF;AACtF,4DAA4D;AAC5D,IAAM,AAAEG,OAASJ,SAAS,kCAAlBI;AACR,IAAMC,cAAcD,KAAKE,OAAO;AAEhC;;;;;;;;;;CAUC,GACD,SAASC,qBAAqBC,QAAgB;IAC5C,IAAIA,WAAW,IAAI;QACjB,MAAM,IAAIC,MAAM,AAAC,2CAAmD,OAATD;IAC7D;IACA,IAAIA,aAAa,IAAI;QACnB,iCAAiC;QACjC,OAAO;IACT;IACA,8DAA8D;IAC9D,IAAME,OAAO,IAAKF,WAAW;IAC7B,IAAMG,QAAQC,KAAKC,KAAK,CAACL,WAAW,KAAK;IACzC,OAAOE,QAAQC;AACjB;AAUO,SAASZ,YAAYe,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIR,MAAM;IAClB;IAEA,IAAMS,WAAWX,qBAAqBQ,UAAU,CAAC,EAAE;IAEnD,mEAAmE;IACnE,iDAAiD;IACjD,IAAII,eAA8B;IAClC,IAAIC,YAAY;IAChB,IAAMC,eAAyB,EAAE;IAEjC,IAAIL,cAAcA,aAAa,GAAG;QAChCG,eAAeG,IAAAA,sCAAiB,EAACN;IACnC;IAEA,IAAIO,SAAS;IAEb,+CAA+C;IAC/C,wEAAwE;IACxE,sFAAsF;IACtF,oEAAoE;IACpE,IAAMC,UAAU,IAAInB;IAMpBmB,QAAQC,iBAAiB,CAACP;IAW1B,IAAMQ,YAAY,AAACF,QAAqDG,UAAU;IAElF,6CAA6C;IAC7C,IAAIC,WAAW;IAEf,MAAOL,SAAST,MAAMG,MAAM,CAAE;QAC5B,IAAMY,UAAUf,KAAK,CAACS,SAAS;QAE/B,IAAIM,YAAY,MAAM;YAEpB;QACF;QAEA,IAAIA,YAAY,QAAQA,YAAY,MAAM;YACxC,qBAAqB;YACrB,yCAAyC;YACzC,iCAAiC;YAEjC,mCAAmC;YACnC,IAAIA,YAAY,MAAM;gBACpBH,UAAUI,IAAI,GAAG;gBACjBJ,UAAUK,UAAU,GAAG;gBACvBP,QAAQQ,SAAS,GAAG;YACtB;YAEA,IAAIT,SAAS,IAAIT,MAAMG,MAAM,EAAE;gBAC7B,MAAM,IAAIR,MAAM;YAClB;YAEA,wCAAwC;YACxC,IAAMwB,aAAa,AAAC,CAAA,AAACnB,KAAK,CAACS,OAAO,IAAI,IAAKT,KAAK,CAACS,SAAS,EAAE,AAAD,IAAK;YAChEA,UAAU;YAEV,IAAIA,SAASU,aAAanB,MAAMG,MAAM,EAAE;gBACtC,MAAM,IAAIR,MAAM;YAClB;YAEA,4BAA4B;YAC5B,IAAMyB,aAAapB,MAAMqB,KAAK,CAACZ,QAAQA,SAASU;YAEhD,mCAAmC;YACnC,IAAId,cAAc;gBAChBe,WAAWE,IAAI,CAACjB,cAAcC;gBAC9BA,aAAac,WAAWjB,MAAM;YAChC,OAAO;gBACLI,yBAAAA,mCAAAA,aAAcgB,IAAI,CAACH;YACrB;YAEA,2FAA2F;YAC3F,gEAAgE;YAChE,iFAAiF;YACjF,oFAAoF;YACpF,IAAK,IAAII,IAAI,GAAGA,IAAIJ,WAAWjB,MAAM,EAAEqB,IAAK;gBAC1CZ,UAAUa,OAAO,CAACb,UAAUI,IAAI,GAAG,GAAGI,UAAU,CAACI,EAAE;gBACnD,qCAAqC;gBACrC,IAAIZ,UAAUI,IAAI,IAAIJ,UAAUc,WAAW,EAAE;oBAC3Cd,UAAUI,IAAI,GAAG;gBACnB;YACF;YACA,sEAAsE;YACtE,yCAAyC;YACzCJ,UAAUK,UAAU,GAAGL,UAAUI,IAAI;YAErC,8FAA8F;YAC9FN,QAAQQ,SAAS,IAAIC;YAErB,wEAAwE;YACxET,QAAQiB,SAAS,GAAGP,UAAU,CAACA,WAAWjB,MAAM,GAAG,EAAE;YAErDM,UAAUU;QACZ,OAAO,IAAIJ,WAAW,MAAM;YAC1B,wBAAwB;YACxB,kCAAkC;YAClC,iCAAiC;YACjC,sEAAsE;YACtE,iDAAiD;YAEjD,2CAA2C;YAC3C,kEAAkE;YAClE,mCAAmC;YACnC,+CAA+C;YAC/C,4DAA4D;YAC5D,IAAMa,aAAab,WAAW;YAC9B,IAAMc,WAAWd,WAAW;YAC5B,IAAMe,YAAYf,WAAW;YAC7B,IAAMgB,eAAe,CAACH;YAEtB,sDAAsD;YACtD,IAAIE,WAAW;gBACblB,UAAUI,IAAI,GAAG;gBACjBJ,UAAUK,UAAU,GAAG;YACzB;YAEA,IAAIR,SAAS,IAAIT,MAAMG,MAAM,EAAE;gBAC7B,MAAM,IAAIR,MAAM;YAClB;YAEA,yEAAyE;YACzE,IAAMqC,aAAajB,UAAU;YAC7B,IAAMkB,cAAc,AAAC,CAAA,AAACD,cAAc,KAAOhC,KAAK,CAACS,OAAO,IAAI,IAAKT,KAAK,CAACS,SAAS,EAAE,AAAD,IAAK;YACtFA,UAAU;YAEV,+BAA+B;YAC/B,IAAMyB,WAAW,AAAC,CAAA,AAAClC,KAAK,CAACS,OAAO,IAAI,IAAKT,KAAK,CAACS,SAAS,EAAE,AAAD,IAAK;YAC9DA,UAAU;YAEV,iDAAiD;YACjD,IAAIoB,UAAU;gBACZ,IAAIpB,UAAUT,MAAMG,MAAM,EAAE;oBAC1B,MAAM,IAAIR,MAAM;gBAClB;gBACA,IAAMwC,YAAYnC,KAAK,CAACS,SAAS;gBAEjC,yCAAyC;gBACzC,uCAAuC;gBACvC,IAAM2B,KAAKD,YAAY;gBACvB,IAAME,YAAYvC,KAAKC,KAAK,CAACoC,YAAY;gBACzC,IAAMG,KAAKD,YAAY;gBACvB,IAAME,KAAKzC,KAAKC,KAAK,CAACsC,YAAY;gBAElC,IAAI,CAAC3B,QAAQ8B,SAAS,CAACJ,IAAIE,IAAIC,KAAK;oBAClC,MAAM,IAAI5C,MAAM,AAAC,+BAAuC2C,OAATF,IAAG,QAAeG,OAATD,IAAG,QAAS,OAAHC;gBACnE;gBACAzB,WAAW;YACb;YAEA,IAAI,CAACA,UAAU;gBACb,MAAM,IAAInB,MAAM;YAClB;YAEA,IAAIc,SAASyB,WAAWlC,MAAMG,MAAM,EAAE;gBACpC,MAAM,IAAIR,MAAM;YAClB;YAEA,oBAAoB;YACpB,IAAM8C,WAAWC,IAAAA,4BAAiB,EAAC1C,OAAOS,QAAQyB;YAClD,IAAMS,YAAYC,IAAAA,6BAAkB,EAACX,cAAc,qCAAqC;YAExF,kFAAkF;YAClF,8EAA8E;YAC9E,gFAAgF;YAChF,IAAIL,cAAc,CAACE,WAAW;gBAC5BpB,QAAQmC,kBAAkB;gBAC1BnC,QAAQoC,QAAQ,CAAC,OAAO,+BAA+B;YACzD,OAAO;gBACLpC,QAAQoC,QAAQ,CAACf;YACnB;YAEA,mBAAmB;YACnB,IAAMgB,UAAUrC,QAAQsC,IAAI,CAACP,UAAUE,WAAWV;YAClD,IAAI,CAACc,SAAS;gBACZ,MAAM,IAAIpD,MAAM;YAClB;YAEA,IAAMsD,cAAcN,UAAUO,QAAQ;YACtC,IAAI7C,cAAc;gBAChB4C,YAAY3B,IAAI,CAACjB,cAAcC;gBAC/BA,aAAa2C,YAAY9C,MAAM;YACjC,OAAO;gBACLI,yBAAAA,mCAAAA,aAAcgB,IAAI,CAAC0B;YACrB;YAEAxC,UAAUyB;QACZ,OAAO;YACL,MAAM,IAAIvC,MAAM,AAAC,iCAAqD,OAArBoB,QAAQoC,QAAQ,CAAC;QACpE;IACF;IAEA,qDAAqD;IACrD,IAAI9C,cAAc;QAChB,4DAA4D;QAC5D,OAAOC,YAAYD,aAAaF,MAAM,GAAGE,aAAagB,KAAK,CAAC,GAAGf,aAAaD;IAC9E;IACA,OAAO+C,OAAOC,MAAM,CAAC9C;AACvB;AAKO,SAASvB,mBAAmBiB,UAAmB,EAAEC,UAAmB;IACzE,OAAOoD,IAAAA,iCAAsB,EAACrE,aAAagB,YAAYC;AACzD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma2.ts"],"sourcesContent":["// LZMA2 codec using TypeScript LZMA decoder\n//\n// LZMA2 format specification:\n// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md\n//\n// Control byte values:\n// 0x00         = End of stream\n// 0x01         = Uncompressed chunk, dictionary reset\n// 0x02         = Uncompressed chunk, no dictionary reset\n// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)\n\nimport type { Transform } from 'stream';\nimport { createLzma2Decoder as createLzma2Transform, decodeLzma2 as lzma2Decode } from '../../lzma/index.ts';\n\n/**\n * Decode LZMA2 compressed data to buffer\n *\n * @param input - LZMA2 compressed data\n * @param properties - Properties buffer (1 byte: dictionary size)\n * @param unpackSize - Expected output size (optional, for pre-allocation)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  return lzma2Decode(input, properties, unpackSize);\n}\n\n/**\n * Create an LZMA2 decoder Transform stream\n *\n * This is a true streaming decoder that processes LZMA2 chunks incrementally.\n * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).\n *\n * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of\n * total archive size.\n */\nexport function createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  return createLzma2Transform(properties) as Transform;\n}\n"],"names":["createLzma2Decoder","decodeLzma2","input","properties","unpackSize","length","Error","lzma2Decode","_unpackSize","createLzma2Transform"],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,8BAA8B;AAC9B,2DAA2D;AAC3D,EAAE;AACF,uBAAuB;AACvB,+BAA+B;AAC/B,sDAAsD;AACtD,yDAAyD;AACzD,0EAA0E;;;;;;;;;;;;QA8B1DA;eAAAA;;QAjBAC;eAAAA;;;uBAVuE;AAUhF,SAASA,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOC,IAAAA,oBAAW,EAACL,OAAOC,YAAYC;AACxC;AAWO,SAASJ,mBAAmBG,UAAmB,EAAEK,WAAoB;IAC1E,IAAI,CAACL,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOG,IAAAA,2BAAoB,EAACN;AAC9B"}

package/dist/cjs/sevenz/codecs/createBufferingDecoder.d.cts

@@ -1,7 +1,7 @@
-import Stream from 'stream';
+import { Transform } from 'extract-base-iterator';
 export type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
 /**
  * Create a Transform stream that buffers all input, then decodes in flush
  * This is the common pattern for codecs that can't stream (need full input)
  */
-export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Stream.Transform;
+export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof Transform>;

package/dist/cjs/sevenz/codecs/createBufferingDecoder.d.ts

@@ -1,7 +1,7 @@
-import Stream from 'stream';
+import { Transform } from 'extract-base-iterator';
 export type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
 /**
  * Create a Transform stream that buffers all input, then decodes in flush
  * This is the common pattern for codecs that can't stream (need full input)
  */
-export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Stream.Transform;
+export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof Transform>;

package/dist/cjs/sevenz/codecs/createBufferingDecoder.js

@@ -13,23 +13,10 @@ Object.defineProperty(exports, /**
         return createBufferingDecoder;
     }
 });
-var _stream = /*#__PURE__*/ _interop_require_default(require("stream"));
-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 Transform;
-if (major > 0) {
-    Transform = _stream.default.Transform;
-} else {
-    Transform = require('readable-stream').Transform;
-}
+var _extractbaseiterator = require("extract-base-iterator");
 function createBufferingDecoder(decodeFn, properties, unpackSize) {
     var chunks = [];
-    return new Transform({
+    return new _extractbaseiterator.Transform({
         transform: function(chunk, _encoding, callback) {
             chunks.push(chunk);
             callback();

package/dist/cjs/sevenz/codecs/createBufferingDecoder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/createBufferingDecoder.ts"],"sourcesContent":["// Helper to create a Transform stream that buffers all input before decoding\n// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)\n\nimport Stream from 'stream';\n\n// Use native streams when available, readable-stream only for Node 0.x\nconst major = +process.versions.node.split('.')[0];\nlet Transform: typeof Stream.Transform;\nif (major > 0) {\n  Transform = Stream.Transform;\n} else {\n  Transform = require('readable-stream').Transform;\n}\ntype TransformCallback = (error?: Error | null, data?: Buffer) => void;\n\nexport type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Create a Transform stream that buffers all input, then decodes in flush\n * This is the common pattern for codecs that can't stream (need full input)\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Stream.Transform {\n  const chunks: Buffer[] = [];\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: TransformCallback) => {\n      chunks.push(chunk);\n      callback();\n    },\n    flush: function (callback: TransformCallback) {\n      try {\n        const input = Buffer.concat(chunks);\n        const output = decodeFn(input, properties, unpackSize);\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createBufferingDecoder","major","process","versions","node","split","Transform","Stream","require","decodeFn","properties","unpackSize","chunks","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;;;;;+BAgB1F;;;CAGC,GACD;;;eAAwBA;;;6DAlBL;;;;;;AAEnB,uEAAuE;AACvE,IAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,YAAYC,eAAM,CAACD,SAAS;AAC9B,OAAO;IACLA,YAAYE,QAAQ,mBAAmBF,SAAS;AAClD;AASe,SAASN,uBAAuBS,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,IAAMC,SAAmB,EAAE;IAE3B,OAAO,IAAIN,UAAU;QACnBO,WAAW,SAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAPA,MAAiBF,QAA2B;YAC1C,IAAI;gBACF,IAAMG,QAAQC,OAAOC,MAAM,CAACT;gBAC5B,IAAMU,SAASb,SAASU,OAAOT,YAAYC;gBAC3C,IAAI,CAACM,IAAI,CAACK;gBACVN;YACF,EAAE,OAAOO,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/createBufferingDecoder.ts"],"sourcesContent":["// Helper to create a Transform stream that buffers all input before decoding\n// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)\n\nimport { Transform } from 'extract-base-iterator';\n\ntype TransformCallback = (error?: Error | null, data?: Buffer) => void;\n\nexport type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Create a Transform stream that buffers all input, then decodes in flush\n * This is the common pattern for codecs that can't stream (need full input)\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof Transform> {\n  const chunks: Buffer[] = [];\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: TransformCallback) => {\n      chunks.push(chunk);\n      callback();\n    },\n    flush: function (callback: TransformCallback) {\n      try {\n        const input = Buffer.concat(chunks);\n        const output = decodeFn(input, properties, unpackSize);\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createBufferingDecoder","decodeFn","properties","unpackSize","chunks","Transform","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;;;;;+BAQ1F;;;CAGC,GACD;;;eAAwBA;;;mCAVE;AAUX,SAASA,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,IAAMC,SAAmB,EAAE;IAE3B,OAAO,IAAIC,8BAAS,CAAC;QACnBC,WAAW,SAACC,OAAeC,WAAmBC;YAC5CL,OAAOM,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAPA,MAAiBF,QAA2B;YAC1C,IAAI;gBACF,IAAMG,QAAQC,OAAOC,MAAM,CAACV;gBAC5B,IAAMW,SAASd,SAASW,OAAOV,YAAYC;gBAC3C,IAAI,CAACO,IAAI,CAACK;gBACVN;YACF,EAAE,OAAOO,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}

package/dist/cjs/types.d.cts

@@ -1,4 +1,6 @@
 export { DirectoryEntry, LinkEntry, Lock, SymbolicLinkEntry } from 'extract-base-iterator';
+export { default as FileEntry } from './FileEntry.js';
+export type { SevenZipEntry } from './sevenz/SevenZipParser.js';
 import type { ExtractOptions as BaseExtractOptions, DirectoryEntry, LinkEntry, SymbolicLinkEntry } from 'extract-base-iterator';
 import type FileEntry from './FileEntry.js';
 export type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;
@@ -10,21 +12,5 @@ export interface ExtractOptions extends BaseExtractOptions {
      * Password for encrypted archives
      */
     password?: string;
-    /**
-     * Memory threshold in bytes for stream input.
-     * Archives smaller than this are buffered in memory for faster processing.
-     * Archives larger than this are written to a temp file.
-     * Default: 100 MB (100 * 1024 * 1024)
-     */
-    memoryThreshold?: number;
-}
-export { default as FileEntry } from './FileEntry.js';
-import type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.js';
-export interface SevenZipFile {
-    getStream: () => NodeJS.ReadableStream;
-}
-export interface SevenZipFileIterator {
-    next: () => SevenZipEntry | null;
-    getParser: () => SevenZipParser;
 }
 export type EntryCallback = (error?: Error, result?: IteratorResult<Entry>) => void;

package/dist/cjs/types.d.ts

@@ -1,4 +1,6 @@
 export { DirectoryEntry, LinkEntry, Lock, SymbolicLinkEntry } from 'extract-base-iterator';
+export { default as FileEntry } from './FileEntry.js';
+export type { SevenZipEntry } from './sevenz/SevenZipParser.js';
 import type { ExtractOptions as BaseExtractOptions, DirectoryEntry, LinkEntry, SymbolicLinkEntry } from 'extract-base-iterator';
 import type FileEntry from './FileEntry.js';
 export type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;
@@ -10,21 +12,5 @@ export interface ExtractOptions extends BaseExtractOptions {
      * Password for encrypted archives
      */
     password?: string;
-    /**
-     * Memory threshold in bytes for stream input.
-     * Archives smaller than this are buffered in memory for faster processing.
-     * Archives larger than this are written to a temp file.
-     * Default: 100 MB (100 * 1024 * 1024)
-     */
-    memoryThreshold?: number;
-}
-export { default as FileEntry } from './FileEntry.js';
-import type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.js';
-export interface SevenZipFile {
-    getStream: () => NodeJS.ReadableStream;
-}
-export interface SevenZipFileIterator {
-    next: () => SevenZipEntry | null;
-    getParser: () => SevenZipParser;
 }
 export type EntryCallback = (error?: Error, result?: IteratorResult<Entry>) => void;

package/dist/cjs/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/types.ts"],"sourcesContent":["export { DirectoryEntry, LinkEntry, Lock, SymbolicLinkEntry } from 'extract-base-iterator';\n\nimport type { ExtractOptions as BaseExtractOptions, DirectoryEntry, LinkEntry, SymbolicLinkEntry } from 'extract-base-iterator';\nimport type FileEntry from './FileEntry.ts';\n\n// 7z-specific Entry union type with 7z-specific FileEntry\nexport type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;\n\n/**\n * Options for SevenZipIterator\n */\nexport interface ExtractOptions extends BaseExtractOptions {\n  /**\n   * Password for encrypted archives\n   */\n  password?: string;\n\n  /**\n   * Memory threshold in bytes for stream input.\n   * Archives smaller than this are buffered in memory for faster processing.\n   * Archives larger than this are written to a temp file.\n   * Default: 100 MB (100 * 1024 * 1024)\n   */\n  memoryThreshold?: number;\n}\nexport { default as FileEntry } from './FileEntry.ts';\n\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\n\nexport interface SevenZipFile {\n  getStream: () => NodeJS.ReadableStream;\n}\n\nexport interface SevenZipFileIterator {\n  next: () => SevenZipEntry | null;\n  getParser: () => SevenZipParser;\n}\n\nexport type EntryCallback = (error?: Error, result?: IteratorResult<Entry>) => void;\n"],"names":["DirectoryEntry","FileEntry","LinkEntry","Lock","SymbolicLinkEntry"],"mappings":";;;;;;;;;;;QAASA;eAAAA,mCAAc;;QAyBHC;eAAAA,oBAAS;;QAzBJC;eAAAA,8BAAS;;QAAEC;eAAAA,yBAAI;;QAAEC;eAAAA,sCAAiB;;;mCAAQ;kEAyB9B"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/types.ts"],"sourcesContent":["export { DirectoryEntry, LinkEntry, Lock, SymbolicLinkEntry } from 'extract-base-iterator';\nexport { default as FileEntry } from './FileEntry.ts';\nexport type { SevenZipEntry } from './sevenz/SevenZipParser.ts';\n\nimport type { ExtractOptions as BaseExtractOptions, DirectoryEntry, LinkEntry, SymbolicLinkEntry } from 'extract-base-iterator';\nimport type FileEntry from './FileEntry.ts';\n\n// 7z-specific Entry union type with 7z-specific FileEntry\nexport type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;\n\n/**\n * Options for SevenZipIterator\n */\nexport interface ExtractOptions extends BaseExtractOptions {\n  /**\n   * Password for encrypted archives\n   */\n  password?: string;\n}\n\nexport type EntryCallback = (error?: Error, result?: IteratorResult<Entry>) => void;\n"],"names":["DirectoryEntry","FileEntry","LinkEntry","Lock","SymbolicLinkEntry"],"mappings":";;;;;;;;;;;QAASA;eAAAA,mCAAc;;QACHC;eAAAA,oBAAS;;QADJC;eAAAA,8BAAS;;QAAEC;eAAAA,yBAAI;;QAAEC;eAAAA,sCAAiB;;;mCAAQ;kEAC9B"}

package/dist/esm/FileEntry.d.ts

@@ -1,11 +1,19 @@
+/**
+ * FileEntry for 7z archives
+ *
+ * Wraps a lazy stream - decompression happens when the stream is read.
+ * API consistent with zip-iterator and tar-iterator.
+ */
 import { type FileAttributes, FileEntry, type Lock, type NoParamCallback } from 'extract-base-iterator';
-import type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.js';
 import type { ExtractOptions } from './types.js';
 export default class SevenZipFileEntry extends FileEntry {
     private lock;
-    private entry;
-    private parser;
-    constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: Lock);
+    private stream;
+    /**
+     * Whether this entry's folder supports streaming decompression.
+     */
+    readonly _canStream: boolean;
+    constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean);
     create(dest: string, callback: NoParamCallback): void;
     create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;
     create(dest: string, options?: ExtractOptions): Promise<boolean>;

package/dist/esm/FileEntry.js

@@ -1,14 +1,17 @@
+/**
+ * FileEntry for 7z archives
+ *
+ * Wraps a lazy stream - decompression happens when the stream is read.
+ * API consistent with zip-iterator and tar-iterator.
+ */ import once from 'call-once-fn';
 import { FileEntry, waitForAccess } from 'extract-base-iterator';
 import fs from 'fs';
 import oo from 'on-one';
 let SevenZipFileEntry = class SevenZipFileEntry extends FileEntry {
     create(dest, options, callback) {
-        if (typeof options === 'function') {
-            callback = options;
-            options = null;
-        }
+        callback = typeof options === 'function' ? options : callback;
+        options = typeof options === 'function' ? {} : options || {};
         if (typeof callback === 'function') {
-            options = options || {};
             return FileEntry.prototype.create.call(this, dest, options, (err)=>{
                 callback(err);
                 if (this.lock) {
@@ -17,46 +20,69 @@ let SevenZipFileEntry = class SevenZipFileEntry extends FileEntry {
                 }
             });
         }
-        return new Promise((resolve, reject)=>{
-            this.create(dest, options, (err, done)=>{
+        return new Promise((resolve, reject)=>this.create(dest, options, (err, done)=>{
                 err ? reject(err) : resolve(done);
-            });
-        });
+            }));
     }
     _writeFile(fullPath, _options, callback) {
-        if (!this.entry || !this.parser) {
-            callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));
+        if (!this.stream) {
+            callback(new Error('7z FileEntry missing stream. Check for calling create multiple times'));
             return;
         }
-        // Use callback-based async decompression
-        this.parser.getEntryStreamAsync(this.entry, (err, stream)=>{
-            if (err) return callback(err);
-            if (!stream) return callback(new Error('No stream returned'));
-            const res = stream.pipe(fs.createWriteStream(fullPath));
-            oo(res, [
+        const stream = this.stream;
+        this.stream = null; // Prevent reuse
+        // Use once since errors can come from either stream
+        const cb = once((err)=>{
+            err ? callback(err) : waitForAccess(fullPath, callback);
+        });
+        try {
+            const writeStream = fs.createWriteStream(fullPath);
+            // Listen for errors on source stream (errors don't propagate through pipe)
+            stream.on('error', (streamErr)=>{
+                // Destroy the write stream on source error.
+                // On Node 0.8, destroy() emits 'close' before 'error'. Since on-one is listening
+                // for ['error', 'close', 'finish'], it catches 'close' first, calls our callback,
+                // and removes ALL listeners - including the 'error' listener. The subsequent EBADF
+                // error then fires with no handler, causing an uncaught exception.
+                // Adding a no-op error handler ensures there's always a listener for any error.
+                const ws = writeStream;
+                writeStream.on('error', ()=>{});
+                if (typeof ws.destroy === 'function') ws.destroy();
+                cb(streamErr);
+            });
+            // Pipe and listen for write stream completion/errors
+            stream.pipe(writeStream);
+            oo(writeStream, [
                 'error',
                 'close',
                 'finish'
-            ], (writeErr)=>{
-                writeErr ? callback(writeErr) : waitForAccess(fullPath, callback);
-            });
-        });
+            ], cb);
+        } catch (pipeErr) {
+            cb(pipeErr);
+        }
     }
     destroy() {
         FileEntry.prototype.destroy.call(this);
-        this.entry = null;
-        this.parser = null;
+        if (this.stream) {
+            // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)
+            // Fallback to resume() for older Node versions without destroy()
+            const s = this.stream;
+            if (typeof s.destroy === 'function') {
+                s.destroy();
+            }
+            this.stream = null;
+        }
         if (this.lock) {
             this.lock.release();
             this.lock = null;
         }
     }
-    constructor(attributes, entry, parser, lock){
+    constructor(attributes, stream, lock, canStream){
         super(attributes);
-        this.entry = entry;
-        this.parser = parser;
+        this.stream = stream;
         this.lock = lock;
         this.lock.retain();
+        this._canStream = canStream;
     }
 };
 export { SevenZipFileEntry as default };

package/dist/esm/FileEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["import { type FileAttributes, FileEntry, type Lock, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'fs';\nimport oo from 'on-one';\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\nimport type { ExtractOptions } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: Lock;\n  private entry: SevenZipEntry;\n  private parser: SevenZipParser;\n\n  constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: Lock) {\n    super(attributes);\n    this.entry = entry;\n    this.parser = parser;\n    this.lock = lock;\n    this.lock.retain();\n  }\n\n  create(dest: string, callback: NoParamCallback): void;\n  create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;\n  create(dest: string, options?: ExtractOptions): Promise<boolean>;\n  create(dest: string, options?: ExtractOptions | NoParamCallback, callback?: NoParamCallback): void | Promise<boolean> {\n    if (typeof options === 'function') {\n      callback = options;\n      options = null;\n    }\n\n    if (typeof callback === 'function') {\n      options = options || {};\n      return FileEntry.prototype.create.call(this, dest, options, (err?: Error) => {\n        callback(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      });\n    }\n    return new Promise((resolve, reject) => {\n      this.create(dest, options as ExtractOptions, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      });\n    });\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): void {\n    if (!this.entry || !this.parser) {\n      callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));\n      return;\n    }\n\n    // Use callback-based async decompression\n    this.parser.getEntryStreamAsync(this.entry, (err, stream) => {\n      if (err) return callback(err);\n      if (!stream) return callback(new Error('No stream returned'));\n\n      const res = stream.pipe(fs.createWriteStream(fullPath));\n      oo(res, ['error', 'close', 'finish'], (writeErr?: Error) => {\n        writeErr ? callback(writeErr) : waitForAccess(fullPath, callback);\n      });\n    });\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    this.entry = null;\n    this.parser = null;\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["FileEntry","waitForAccess","fs","oo","SevenZipFileEntry","create","dest","options","callback","prototype","call","err","lock","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","entry","parser","Error","getEntryStreamAsync","stream","res","pipe","createWriteStream","writeErr","destroy","attributes","retain"],"mappings":"AAAA,SAA8BA,SAAS,EAAmCC,aAAa,QAAQ,wBAAwB;AACvH,OAAOC,QAAQ,KAAK;AACpB,OAAOC,QAAQ,SAAS;AAIT,IAAA,AAAMC,oBAAN,MAAMA,0BAA0BJ;IAgB7CK,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B,EAA2B;QACpH,IAAI,OAAOD,YAAY,YAAY;YACjCC,WAAWD;YACXA,UAAU;QACZ;QAEA,IAAI,OAAOC,aAAa,YAAY;YAClCD,UAAUA,WAAW,CAAC;YACtB,OAAOP,UAAUS,SAAS,CAACJ,MAAM,CAACK,IAAI,CAAC,IAAI,EAAEJ,MAAMC,SAAS,CAACI;gBAC3DH,SAASG;gBACT,IAAI,IAAI,CAACC,IAAI,EAAE;oBACb,IAAI,CAACA,IAAI,CAACC,OAAO;oBACjB,IAAI,CAACD,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIE,QAAQ,CAACC,SAASC;YAC3B,IAAI,CAACX,MAAM,CAACC,MAAMC,SAA2B,CAACI,KAAaM;gBACzDN,MAAMK,OAAOL,OAAOI,QAAQE;YAC9B;QACF;IACF;IAEAC,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB,EAAQ;QACtF,IAAI,CAAC,IAAI,CAACa,KAAK,IAAI,CAAC,IAAI,CAACC,MAAM,EAAE;YAC/Bd,SAAS,IAAIe,MAAM;YACnB;QACF;QAEA,yCAAyC;QACzC,IAAI,CAACD,MAAM,CAACE,mBAAmB,CAAC,IAAI,CAACH,KAAK,EAAE,CAACV,KAAKc;YAChD,IAAId,KAAK,OAAOH,SAASG;YACzB,IAAI,CAACc,QAAQ,OAAOjB,SAAS,IAAIe,MAAM;YAEvC,MAAMG,MAAMD,OAAOE,IAAI,CAACzB,GAAG0B,iBAAiB,CAACT;YAC7ChB,GAAGuB,KAAK;gBAAC;gBAAS;gBAAS;aAAS,EAAE,CAACG;gBACrCA,WAAWrB,SAASqB,YAAY5B,cAAckB,UAAUX;YAC1D;QACF;IACF;IAEAsB,UAAU;QACR9B,UAAUS,SAAS,CAACqB,OAAO,CAACpB,IAAI,CAAC,IAAI;QACrC,IAAI,CAACW,KAAK,GAAG;QACb,IAAI,CAACC,MAAM,GAAG;QACd,IAAI,IAAI,CAACV,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACC,OAAO;YACjB,IAAI,CAACD,IAAI,GAAG;QACd;IACF;IA5DA,YAAYmB,UAA0B,EAAEV,KAAoB,EAAEC,MAAsB,EAAEV,IAAU,CAAE;QAChG,KAAK,CAACmB;QACN,IAAI,CAACV,KAAK,GAAGA;QACb,IAAI,CAACC,MAAM,GAAGA;QACd,IAAI,CAACV,IAAI,GAAGA;QACZ,IAAI,CAACA,IAAI,CAACoB,MAAM;IAClB;AAuDF;AAlEA,SAAqB5B,+BAkEpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["/**\n * FileEntry for 7z archives\n *\n * Wraps a lazy stream - decompression happens when the stream is read.\n * API consistent with zip-iterator and tar-iterator.\n */\n\nimport once from 'call-once-fn';\nimport { type FileAttributes, FileEntry, type Lock, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'fs';\nimport oo from 'on-one';\nimport type { ExtractOptions } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: Lock;\n  private stream: NodeJS.ReadableStream;\n\n  /**\n   * Whether this entry's folder supports streaming decompression.\n   */\n  readonly _canStream: boolean;\n\n  constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean) {\n    super(attributes);\n    this.stream = stream;\n    this.lock = lock;\n    this.lock.retain();\n    this._canStream = canStream;\n  }\n\n  create(dest: string, callback: NoParamCallback): void;\n  create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;\n  create(dest: string, options?: ExtractOptions): Promise<boolean>;\n  create(dest: string, options?: ExtractOptions | NoParamCallback, callback?: NoParamCallback): void | Promise<boolean> {\n    callback = typeof options === 'function' ? options : callback;\n    options = typeof options === 'function' ? {} : ((options || {}) as ExtractOptions);\n\n    if (typeof callback === 'function') {\n      return FileEntry.prototype.create.call(this, dest, options, (err?: Error) => {\n        callback(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      });\n    }\n    return new Promise((resolve, reject) =>\n      this.create(dest, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      })\n    );\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): void {\n    if (!this.stream) {\n      callback(new Error('7z FileEntry missing stream. Check for calling create multiple times'));\n      return;\n    }\n\n    const stream = this.stream;\n    this.stream = null; // Prevent reuse\n\n    // Use once since errors can come from either stream\n    const cb = once((err?: Error) => {\n      err ? callback(err) : waitForAccess(fullPath, callback);\n    });\n\n    try {\n      const writeStream = fs.createWriteStream(fullPath);\n\n      // Listen for errors on source stream (errors don't propagate through pipe)\n      stream.on('error', (streamErr: Error) => {\n        // Destroy the write stream on source error.\n        // On Node 0.8, destroy() emits 'close' before 'error'. Since on-one is listening\n        // for ['error', 'close', 'finish'], it catches 'close' first, calls our callback,\n        // and removes ALL listeners - including the 'error' listener. The subsequent EBADF\n        // error then fires with no handler, causing an uncaught exception.\n        // Adding a no-op error handler ensures there's always a listener for any error.\n        const ws = writeStream as fs.WriteStream & { destroy?: () => void };\n        writeStream.on('error', () => {});\n        if (typeof ws.destroy === 'function') ws.destroy();\n        cb(streamErr);\n      });\n\n      // Pipe and listen for write stream completion/errors\n      stream.pipe(writeStream);\n      oo(writeStream, ['error', 'close', 'finish'], cb);\n    } catch (pipeErr) {\n      cb(pipeErr);\n    }\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    if (this.stream) {\n      // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)\n      // Fallback to resume() for older Node versions without destroy()\n      const s = this.stream as NodeJS.ReadableStream & { destroy?: () => void };\n      if (typeof s.destroy === 'function') {\n        s.destroy();\n      }\n      this.stream = null;\n    }\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["once","FileEntry","waitForAccess","fs","oo","SevenZipFileEntry","create","dest","options","callback","prototype","call","err","lock","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","stream","Error","cb","writeStream","createWriteStream","on","streamErr","ws","destroy","pipe","pipeErr","s","attributes","canStream","retain","_canStream"],"mappings":"AAAA;;;;;CAKC,GAED,OAAOA,UAAU,eAAe;AAChC,SAA8BC,SAAS,EAAmCC,aAAa,QAAQ,wBAAwB;AACvH,OAAOC,QAAQ,KAAK;AACpB,OAAOC,QAAQ,SAAS;AAGT,IAAA,AAAMC,oBAAN,MAAMA,0BAA0BJ;IAoB7CK,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B,EAA2B;QACpHA,WAAW,OAAOD,YAAY,aAAaA,UAAUC;QACrDD,UAAU,OAAOA,YAAY,aAAa,CAAC,IAAMA,WAAW,CAAC;QAE7D,IAAI,OAAOC,aAAa,YAAY;YAClC,OAAOR,UAAUS,SAAS,CAACJ,MAAM,CAACK,IAAI,CAAC,IAAI,EAAEJ,MAAMC,SAAS,CAACI;gBAC3DH,SAASG;gBACT,IAAI,IAAI,CAACC,IAAI,EAAE;oBACb,IAAI,CAACA,IAAI,CAACC,OAAO;oBACjB,IAAI,CAACD,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIE,QAAQ,CAACC,SAASC,SAC3B,IAAI,CAACX,MAAM,CAACC,MAAMC,SAAS,CAACI,KAAaM;gBACvCN,MAAMK,OAAOL,OAAOI,QAAQE;YAC9B;IAEJ;IAEAC,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB,EAAQ;QACtF,IAAI,CAAC,IAAI,CAACa,MAAM,EAAE;YAChBb,SAAS,IAAIc,MAAM;YACnB;QACF;QAEA,MAAMD,SAAS,IAAI,CAACA,MAAM;QAC1B,IAAI,CAACA,MAAM,GAAG,MAAM,gBAAgB;QAEpC,oDAAoD;QACpD,MAAME,KAAKxB,KAAK,CAACY;YACfA,MAAMH,SAASG,OAAOV,cAAckB,UAAUX;QAChD;QAEA,IAAI;YACF,MAAMgB,cAActB,GAAGuB,iBAAiB,CAACN;YAEzC,2EAA2E;YAC3EE,OAAOK,EAAE,CAAC,SAAS,CAACC;gBAClB,4CAA4C;gBAC5C,iFAAiF;gBACjF,kFAAkF;gBAClF,mFAAmF;gBACnF,mEAAmE;gBACnE,gFAAgF;gBAChF,MAAMC,KAAKJ;gBACXA,YAAYE,EAAE,CAAC,SAAS,KAAO;gBAC/B,IAAI,OAAOE,GAAGC,OAAO,KAAK,YAAYD,GAAGC,OAAO;gBAChDN,GAAGI;YACL;YAEA,qDAAqD;YACrDN,OAAOS,IAAI,CAACN;YACZrB,GAAGqB,aAAa;gBAAC;gBAAS;gBAAS;aAAS,EAAED;QAChD,EAAE,OAAOQ,SAAS;YAChBR,GAAGQ;QACL;IACF;IAEAF,UAAU;QACR7B,UAAUS,SAAS,CAACoB,OAAO,CAACnB,IAAI,CAAC,IAAI;QACrC,IAAI,IAAI,CAACW,MAAM,EAAE;YACf,kGAAkG;YAClG,iEAAiE;YACjE,MAAMW,IAAI,IAAI,CAACX,MAAM;YACrB,IAAI,OAAOW,EAAEH,OAAO,KAAK,YAAY;gBACnCG,EAAEH,OAAO;YACX;YACA,IAAI,CAACR,MAAM,GAAG;QAChB;QACA,IAAI,IAAI,CAACT,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACC,OAAO;YACjB,IAAI,CAACD,IAAI,GAAG;QACd;IACF;IArFA,YAAYqB,UAA0B,EAAEZ,MAA6B,EAAET,IAAU,EAAEsB,SAAkB,CAAE;QACrG,KAAK,CAACD;QACN,IAAI,CAACZ,MAAM,GAAGA;QACd,IAAI,CAACT,IAAI,GAAGA;QACZ,IAAI,CAACA,IAAI,CAACuB,MAAM;QAChB,IAAI,CAACC,UAAU,GAAGF;IACpB;AAgFF;AA/FA,SAAqB9B,+BA+FpB"}

package/dist/esm/SevenZipIterator.d.ts

@@ -1,8 +1,31 @@
 import BaseIterator, { Lock } from 'extract-base-iterator';
-import type { Entry, ExtractOptions, SevenZipFileIterator } from './types.js';
+import { type SevenZipEntry } from './sevenz/SevenZipParser.js';
+import type { Entry, ExtractOptions } from './types.js';
 export default class SevenZipIterator extends BaseIterator<Entry> {
     lock: Lock | null;
-    iterator: SevenZipFileIterator;
+    /** @internal - Do not use directly */
+    _iterator: unknown;
     constructor(source: string | NodeJS.ReadableStream, options?: ExtractOptions);
     end(err?: Error): void;
+    /**
+     * Check if streaming extraction is available for any folder in this archive.
+     * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy
+     * that can decompress incrementally without buffering the entire input.
+     *
+     * @returns true if at least one folder supports streaming
+     */
+    canStream(): boolean;
+    /**
+     * Get entries sorted for optimal streaming extraction.
+     *
+     * Entries are sorted by:
+     * 1. Folder index (process one folder at a time)
+     * 2. Stream index within folder (for solid block streaming)
+     *
+     * This ordering allows multi-file solid folders to stream with
+     * O(largest file) memory instead of O(folder size).
+     *
+     * @returns Array of entries in streaming order
+     */
+    getStreamingOrder(): SevenZipEntry[];
 }