7z-iterator 1.1.2 → 1.3.0

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

@@ -1,7 +1,4 @@
-import Module from 'module';
-const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;
-// LZMA2 codec using lzma-purejs
-// LZMA2 is a container format that wraps LZMA chunks with framing
+// LZMA2 codec using TypeScript LZMA decoder
 //
 // LZMA2 format specification:
 // https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md
@@ -11,209 +8,31 @@ const _require = typeof require === 'undefined' ? Module.createRequire(import.me
 // 0x01         = Uncompressed chunk, dictionary reset
 // 0x02         = Uncompressed chunk, no dictionary reset
 // 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)
-import { allocBufferUnsafe } from 'extract-base-iterator';
-import createBufferingDecoder from './createBufferingDecoder.js';
-import { createInputStream, createOutputStream } from './streams.js';
-// Import vendored lzma-purejs - provides raw LZMA decoder (patched for LZMA2 support)
-// Path accounts for build output in dist/esm/sevenz/codecs/
-const { LZMA } = _require('../../../../assets/lzma-purejs');
-const 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: ${propByte}`);
-    }
-    if (propByte === 40) {
-        // Max dictionary size: 4 GiB - 1
-        return 0xffffffff;
-    }
-    // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)
-    const base = 2 | propByte & 1;
-    const shift = Math.floor(propByte / 2) + 11;
-    return base << shift;
-}
+import { createLzma2Decoder as createLzma2Transform, decodeLzma2 as lzma2Decode } from '../../lzma/index.js';
 /**
  * Decode LZMA2 compressed data to buffer
  *
  * @param input - LZMA2 compressed data
  * @param properties - Properties buffer (1 byte: dictionary size)
- * @param unpackSize - Expected output size (used for pre-allocation to reduce memory)
+ * @param unpackSize - Expected output size (optional, for pre-allocation)
  * @returns Decompressed data
  */ export function decodeLzma2(input, properties, unpackSize) {
     if (!properties || properties.length < 1) {
         throw new Error('LZMA2 requires properties byte');
     }
-    const dictSize = decodeDictionarySize(properties[0]);
-    // Memory optimization: pre-allocate output buffer if size is known
-    // This avoids double-memory during Buffer.concat
-    let outputBuffer = null;
-    let outputPos = 0;
-    const outputChunks = [];
-    if (unpackSize && unpackSize > 0) {
-        outputBuffer = allocBufferUnsafe(unpackSize);
-    }
-    let 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
-    const decoder = new LzmaDecoder();
-    decoder.setDictionarySize(dictSize);
-    const outWindow = decoder._outWindow;
-    // Track current LZMA properties (lc, lp, pb)
-    let propsSet = false;
-    while(offset < input.length){
-        const 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
-            const 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
-            const 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(let 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
-            const resetState = control >= 0xa0;
-            const newProps = control >= 0xc0;
-            const dictReset = control >= 0xe0;
-            const 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
-            const uncompHigh = control & 0x1f;
-            const uncompSize2 = (uncompHigh << 16 | input[offset] << 8 | input[offset + 1]) + 1;
-            offset += 2;
-            // Compressed size: 16 bits + 1
-            const 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');
-                }
-                const propsByte = input[offset++];
-                // Properties byte: pb * 45 + lp * 9 + lc
-                // where pb, lp, lc are LZMA parameters
-                const lc = propsByte % 9;
-                const remainder = Math.floor(propsByte / 9);
-                const lp = remainder % 5;
-                const pb = Math.floor(remainder / 5);
-                if (!decoder.setLcLpPb(lc, lp, pb)) {
-                    throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${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
-            const inStream = createInputStream(input, offset, compSize);
-            const outStream = 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
-            const success = decoder.code(inStream, outStream, uncompSize2);
-            if (!success) {
-                throw new Error('LZMA decompression failed');
-            }
-            const 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${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 lzma2Decode(input, properties, unpackSize);
 }
 /**
  * Create an LZMA2 decoder Transform stream
- */ export function createLzma2Decoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeLzma2, properties, unpackSize);
+ *
+ * This is a true streaming decoder that processes LZMA2 chunks incrementally.
+ * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
+ *
+ * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of
+ * total archive size.
+ */ export function createLzma2Decoder(properties, _unpackSize) {
+    if (!properties || properties.length < 1) {
+        throw new Error('LZMA2 requires properties byte');
+    }
+    return createLzma2Transform(properties);
 }

package/dist/esm/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":["Module","_require","require","createRequire","url","allocBufferUnsafe","createBufferingDecoder","createInputStream","createOutputStream","LZMA","LzmaDecoder","Decoder","decodeDictionarySize","propByte","Error","base","shift","Math","floor","decodeLzma2","input","properties","unpackSize","length","dictSize","outputBuffer","outputPos","outputChunks","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","outStream","resetProbabilities","setSolid","success","code","chunkOutput","toBuffer","toString","Buffer","concat","createLzma2Decoder"],"mappings":"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"}
+{"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","createLzma2Transform","decodeLzma2","lzma2Decode","input","properties","unpackSize","length","Error","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,8BAA8B;AAC9B,2DAA2D;AAC3D,EAAE;AACF,uBAAuB;AACvB,+BAA+B;AAC/B,sDAAsD;AACtD,yDAAyD;AACzD,0EAA0E;AAG1E,SAASA,sBAAsBC,oBAAoB,EAAEC,eAAeC,WAAW,QAAQ,sBAAsB;AAE7G;;;;;;;CAOC,GACD,OAAO,SAASD,YAAYE,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOL,YAAYC,OAAOC,YAAYC;AACxC;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASN,mBAAmBK,UAAmB,EAAEI,WAAoB;IAC1E,IAAI,CAACJ,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOP,qBAAqBI;AAC9B"}

package/dist/esm/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/esm/sevenz/codecs/createBufferingDecoder.js

@@ -1,14 +1,6 @@
 // Helper to create a Transform stream that buffers all input before decoding
 // Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)
-import Stream from 'stream';
-// Use native streams when available, readable-stream only for Node 0.x
-const major = +process.versions.node.split('.')[0];
-let Transform;
-if (major > 0) {
-    Transform = Stream.Transform;
-} else {
-    Transform = require('readable-stream').Transform;
-}
+import { Transform } from 'extract-base-iterator';
 /**
  * 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)

package/dist/esm/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":["Stream","major","process","versions","node","split","Transform","require","createBufferingDecoder","decodeFn","properties","unpackSize","chunks","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;AAE1F,OAAOA,YAAY,SAAS;AAE5B,uEAAuE;AACvE,MAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,YAAYN,OAAOM,SAAS;AAC9B,OAAO;IACLA,YAAYC,QAAQ,mBAAmBD,SAAS;AAClD;AAKA;;;CAGC,GACD,eAAe,SAASE,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,MAAMC,SAAmB,EAAE;IAE3B,OAAO,IAAIN,UAAU;QACnBO,WAAW,CAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAUF,QAA2B;YAC1C,IAAI;gBACF,MAAMG,QAAQC,OAAOC,MAAM,CAACT;gBAC5B,MAAMU,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":["Transform","createBufferingDecoder","decodeFn","properties","unpackSize","chunks","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;AAE1F,SAASA,SAAS,QAAQ,wBAAwB;AAMlD;;;CAGC,GACD,eAAe,SAASC,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,MAAMC,SAAmB,EAAE;IAE3B,OAAO,IAAIL,UAAU;QACnBM,WAAW,CAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAUF,QAA2B;YAC1C,IAAI;gBACF,MAAMG,QAAQC,OAAOC,MAAM,CAACT;gBAC5B,MAAMU,SAASb,SAASU,OAAOT,YAAYC;gBAC3C,IAAI,CAACM,IAAI,CAACK;gBACVN;YACF,EAAE,OAAOO,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}

package/dist/esm/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/esm/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","LinkEntry","Lock","SymbolicLinkEntry","default","FileEntry"],"mappings":"AAAA,SAASA,cAAc,EAAEC,SAAS,EAAEC,IAAI,EAAEC,iBAAiB,QAAQ,wBAAwB;AAyB3F,SAASC,WAAWC,SAAS,QAAQ,iBAAiB"}
+{"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","LinkEntry","Lock","SymbolicLinkEntry","default","FileEntry"],"mappings":"AAAA,SAASA,cAAc,EAAEC,SAAS,EAAEC,IAAI,EAAEC,iBAAiB,QAAQ,wBAAwB;AAC3F,SAASC,WAAWC,SAAS,QAAQ,iBAAiB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "7z-iterator",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "Extract contents from 7z archives using an iterator API. Pure JavaScript, works on Node.js 0.8+",
   "keywords": [
     "extract",
@@ -35,10 +35,10 @@
   "source": "src/index.ts",
   "types": "dist/cjs/index.d.ts",
   "files": [
-    "dist",
-    "assets"
+    "dist"
   ],
   "scripts": {
+    "benchmark:streaming": "node benchmark/streaming.cjs",
     "build": "tsds build",
     "format": "tsds format",
     "prepublishOnly": "tsds validate",

package/assets/lzma-purejs/LICENSE

@@ -1,11 +0,0 @@
-BSD License
-
-lzma-purejs - Pure JavaScript LZMA de/compression
-https://github.com/cscott/lzma-purejs
-
-Copyright (c) Gary Linscott, Juan Mellado, C. Scott Ananian
-
-This vendored copy includes modifications to support LZMA2 solid mode
-(setSolid method for state preservation across chunks).
-
-Original package: https://www.npmjs.com/package/lzma-purejs

package/assets/lzma-purejs/index.js

@@ -1,19 +0,0 @@
-'use strict';
-var LZ = require('./lib/LZ');
-var LZMA = require('./lib/LZMA');
-var RangeCoder = require('./lib/RangeCoder');
-var Stream = require('./lib/Stream');
-var Util = require('./lib/Util');
-
-module.exports = {
-  version: "0.9.0",
-  LZ: LZ,
-  LZMA: LZMA,
-  RangeCoder: RangeCoder,
-  Stream: Stream,
-  Util: Util,
-  compress: Util.compress,
-  compressFile: Util.compressFile,
-  decompress: Util.decompress,
-  decompressFile: Util.decompressFile
-};

package/assets/lzma-purejs/lib/LZ/OutWindow.js

@@ -1,78 +0,0 @@
-'use strict';
-var makeBuffer = require('../makeBuffer');
-
-var OutWindow = function(){
-  this._windowSize = 0;
-};
-
-OutWindow.prototype.create = function(windowSize){
-  if ((!this._buffer) || (this._windowSize !== windowSize)){
-    this._buffer = makeBuffer(windowSize);
-  }
-  this._windowSize = windowSize;
-  this._pos = 0;
-  this._streamPos = 0;
-};
-
-OutWindow.prototype.flush = function(){
-  var size = this._pos - this._streamPos;
-  if (size !== 0){
-    while(size--){
-      this._stream.writeByte(this._buffer[this._streamPos++]);
-    }
-    if (this._pos >= this._windowSize){
-      this._pos = 0;
-    }
-    this._streamPos = this._pos;
-  }
-};
-
-OutWindow.prototype.releaseStream = function(){
-  this.flush();
-  this._stream = null;
-};
-
-OutWindow.prototype.setStream = function(stream){
-  this.releaseStream();
-  this._stream = stream;
-};
-
-OutWindow.prototype.init = function(solid){
-  if (!solid){
-    this._streamPos = 0;
-    this._pos = 0;
-  }
-};
-
-OutWindow.prototype.copyBlock = function(distance, len){
-  var pos = this._pos - distance - 1;
-  if (pos < 0){
-    pos += this._windowSize;
-  }
-  while(len--){
-    if (pos >= this._windowSize){
-      pos = 0;
-    }
-    this._buffer[this._pos++] = this._buffer[pos++];
-    if (this._pos >= this._windowSize){
-      this.flush();
-    }
-  }
-};
-
-OutWindow.prototype.putByte = function(b){
-  this._buffer[this._pos++] = b;
-  if (this._pos >= this._windowSize){
-    this.flush();
-  }
-};
-
-OutWindow.prototype.getByte = function(distance){
-  var pos = this._pos - distance - 1;
-  if (pos < 0){
-    pos += this._windowSize;
-  }
-  return this._buffer[pos];
-};
-
-module.exports = OutWindow;

package/assets/lzma-purejs/lib/LZ.js

@@ -1,6 +0,0 @@
-'use strict';
-var OutWindow = require('./LZ/OutWindow');
-
-module.exports = {
-  OutWindow: OutWindow
-};

package/assets/lzma-purejs/lib/LZMA/Base.js

@@ -1,48 +0,0 @@
-'use strict';
-
-var Base = {};
-Base.kNumRepDistances = 4;
-Base.kNumStates = 12;
-
-Base.stateInit = function() { return 0; };
-Base.stateUpdateChar = function(index) {
-  if (index < 4) return 0;
-  if (index < 10) return index - 3;
-  return index - 6;
-};
-Base.stateUpdateMatch = function(index) { return (index < 7 ? 7 : 10); };
-Base.stateUpdateRep = function(index) { return (index < 7 ? 8 : 11); };
-Base.stateUpdateShortRep = function(index) { return (index < 7 ? 9 : 11); };
-Base.stateIsCharState = function(index) { return index < 7; };
-
-Base.kNumPosSlotBits = 6;
-Base.kDicLogSizeMin = 0;
-Base.kNumLenToPosStatesBits = 2;
-Base.kNumLenToPosStates = 1 << Base.kNumLenToPosStatesBits;
-Base.kMatchMinLen = 2;
-Base.getLenToPosState = function(len) {
-  len -= Base.kMatchMinLen;
-  return len < Base.kNumLenToPosStates ? len : (Base.kNumLenToPosStates - 1);
-};
-Base.kNumAlignBits = 4;
-Base.kAlignTableSize = 1 << Base.kNumAlignBits;
-Base.kAlignMask = (Base.kAlignTableSize - 1);
-Base.kStartPosModelIndex = 4;
-Base.kEndPosModelIndex = 14;
-Base.kNumPosModels = Base.kEndPosModelIndex - Base.kStartPosModelIndex;
-Base.kNumFullDistances = 1 << (Base.kEndPosModelIndex / 2);
-Base.kNumLitPosStatesBitsEncodingMax = 4;
-Base.kNumLitContextBitsMax = 8;
-Base.kNumPosStatesBitsMax = 4;
-Base.kNumPosStatesMax = (1 << Base.kNumPosStatesBitsMax);
-Base.kNumPosStatesBitsEncodingMax = 4;
-Base.kNumPosStatesEncodingMax = (1 << Base.kNumPosStatesBitsEncodingMax);
-Base.kNumLowLenBits = 3;
-Base.kNumMidLenBits = 3;
-Base.kNumHighLenBits = 8;
-Base.kNumLowLenSymbols = 1 << Base.kNumLowLenBits;
-Base.kNumMidLenSymbols = 1 << Base.kNumMidLenBits;
-Base.kNumLenSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols + (1 << Base.kNumHighLenBits);
-Base.kMatchMaxLen = Base.kMatchMinLen + Base.kNumLenSymbols - 1;
-
-module.exports = Base;