7z-iterator 0.2.9 → 0.2.10

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

@@ -61,7 +61,7 @@ function decodeBcj(input, _properties, _unpackSize) {
         var highByte = output[pos + 4];
         if (highByte === 0x00 || highByte === 0xff) {
             // Convert absolute to relative
-            var newAddr;
+            var newAddr = void 0;
             if (highByte === 0x00) {
                 // Positive offset - subtract position
                 newAddr = addr - pos;

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Bcj.ts"],"sourcesContent":["// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses\n// This is a simple filter that makes executables more compressible by LZMA\n//\n// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions\n// to absolute addresses, which creates more repetitive patterns for compression.\n//\n// Reference: https://github.com/jljusten/LZMA-SDK/blob/master/C/Bra86.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode BCJ (x86) filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - BCJ filtered data\n * @param _properties - Unused for BCJ\n * @param _unpackSize - Unused for BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  // BCJ filter state\n  var pos = 0;\n  var prevMask = 0;\n  var output = bufferFrom(input); // Copy since we modify in place\n\n  while (pos < output.length - 4) {\n    var b = output[pos];\n\n    // Check for CALL (0xE8) or JMP (0xE9) opcode\n    if (b !== 0xe8 && b !== 0xe9) {\n      pos++;\n      prevMask = 0;\n      continue;\n    }\n\n    // Check mask to avoid false positives in data\n    var offset = pos + 5;\n    if (offset > output.length) {\n      break;\n    }\n\n    // Skip if in masked region (previous conversion affected this area)\n    if ((prevMask & 1) !== 0) {\n      prevMask = (prevMask >> 1) | 4;\n      pos++;\n      continue;\n    }\n\n    // Read the 32-bit address (little-endian)\n    var addr = output[pos + 1] | (output[pos + 2] << 8) | (output[pos + 3] << 16) | ((output[pos + 4] << 24) >>> 0);\n\n    // Check if this looks like a converted address\n    // High byte should be 0x00 or 0xFF for typical code\n    var highByte = output[pos + 4];\n\n    if (highByte === 0x00 || highByte === 0xff) {\n      // Convert absolute to relative\n      var newAddr: number;\n      if (highByte === 0x00) {\n        // Positive offset - subtract position\n        newAddr = addr - pos;\n      } else {\n        // Negative offset (0xFF high byte)\n        newAddr = addr + pos;\n      }\n\n      // Write back as little-endian\n      output[pos + 1] = newAddr & 0xff;\n      output[pos + 2] = (newAddr >>> 8) & 0xff;\n      output[pos + 3] = (newAddr >>> 16) & 0xff;\n      output[pos + 4] = (newAddr >>> 24) & 0xff;\n\n      pos += 5;\n      prevMask = 0;\n    } else {\n      pos++;\n      prevMask = 0;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create a BCJ decoder Transform stream\n */\nexport function createBcjDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcj, properties, unpackSize);\n}\n"],"names":["createBcjDecoder","decodeBcj","input","_properties","_unpackSize","pos","prevMask","output","bufferFrom","length","b","offset","addr","highByte","newAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,oEAAoE;AACpE,2EAA2E;AAC3E,EAAE;AACF,mFAAmF;AACnF,iFAAiF;AACjF,EAAE;AACF,wEAAwE;;;;;;;;;;;;QAkFxDA;eAAAA;;QAnEAC;eAAAA;;;mCAbW;+EAEQ;;;;;;AAW5B,SAASA,UAAUC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACjF,mBAAmB;IACnB,IAAIC,MAAM;IACV,IAAIC,WAAW;IACf,IAAIC,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAEhE,MAAOG,MAAME,OAAOE,MAAM,GAAG,EAAG;QAC9B,IAAIC,IAAIH,MAAM,CAACF,IAAI;QAEnB,6CAA6C;QAC7C,IAAIK,MAAM,QAAQA,MAAM,MAAM;YAC5BL;YACAC,WAAW;YACX;QACF;QAEA,8CAA8C;QAC9C,IAAIK,SAASN,MAAM;QACnB,IAAIM,SAASJ,OAAOE,MAAM,EAAE;YAC1B;QACF;QAEA,oEAAoE;QACpE,IAAI,AAACH,CAAAA,WAAW,CAAA,MAAO,GAAG;YACxBA,WAAW,AAACA,YAAY,IAAK;YAC7BD;YACA;QACF;QAEA,0CAA0C;QAC1C,IAAIO,OAAOL,MAAM,CAACF,MAAM,EAAE,GAAIE,MAAM,CAACF,MAAM,EAAE,IAAI,IAAME,MAAM,CAACF,MAAM,EAAE,IAAI,KAAO,AAACE,MAAM,CAACF,MAAM,EAAE,IAAI,OAAQ;QAE7G,+CAA+C;QAC/C,oDAAoD;QACpD,IAAIQ,WAAWN,MAAM,CAACF,MAAM,EAAE;QAE9B,IAAIQ,aAAa,QAAQA,aAAa,MAAM;YAC1C,+BAA+B;YAC/B,IAAIC;YACJ,IAAID,aAAa,MAAM;gBACrB,sCAAsC;gBACtCC,UAAUF,OAAOP;YACnB,OAAO;gBACL,mCAAmC;gBACnCS,UAAUF,OAAOP;YACnB;YAEA,8BAA8B;YAC9BE,MAAM,CAACF,MAAM,EAAE,GAAGS,UAAU;YAC5BP,MAAM,CAACF,MAAM,EAAE,GAAG,AAACS,YAAY,IAAK;YACpCP,MAAM,CAACF,MAAM,EAAE,GAAG,AAACS,YAAY,KAAM;YACrCP,MAAM,CAACF,MAAM,EAAE,GAAG,AAACS,YAAY,KAAM;YAErCT,OAAO;YACPC,WAAW;QACb,OAAO;YACLD;YACAC,WAAW;QACb;IACF;IAEA,OAAOC;AACT;AAKO,SAASP,iBAAiBe,UAAmB,EAAEC,UAAmB;IACvE,OAAOC,IAAAA,iCAAsB,EAAChB,WAAWc,YAAYC;AACvD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Bcj.ts"],"sourcesContent":["// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses\n// This is a simple filter that makes executables more compressible by LZMA\n//\n// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions\n// to absolute addresses, which creates more repetitive patterns for compression.\n//\n// Reference: https://github.com/jljusten/LZMA-SDK/blob/master/C/Bra86.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode BCJ (x86) filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - BCJ filtered data\n * @param _properties - Unused for BCJ\n * @param _unpackSize - Unused for BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  // BCJ filter state\n  let pos = 0;\n  let prevMask = 0;\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  while (pos < output.length - 4) {\n    const b = output[pos];\n\n    // Check for CALL (0xE8) or JMP (0xE9) opcode\n    if (b !== 0xe8 && b !== 0xe9) {\n      pos++;\n      prevMask = 0;\n      continue;\n    }\n\n    // Check mask to avoid false positives in data\n    const offset = pos + 5;\n    if (offset > output.length) {\n      break;\n    }\n\n    // Skip if in masked region (previous conversion affected this area)\n    if ((prevMask & 1) !== 0) {\n      prevMask = (prevMask >> 1) | 4;\n      pos++;\n      continue;\n    }\n\n    // Read the 32-bit address (little-endian)\n    const addr = output[pos + 1] | (output[pos + 2] << 8) | (output[pos + 3] << 16) | ((output[pos + 4] << 24) >>> 0);\n\n    // Check if this looks like a converted address\n    // High byte should be 0x00 or 0xFF for typical code\n    const highByte = output[pos + 4];\n\n    if (highByte === 0x00 || highByte === 0xff) {\n      // Convert absolute to relative\n      let newAddr: number;\n      if (highByte === 0x00) {\n        // Positive offset - subtract position\n        newAddr = addr - pos;\n      } else {\n        // Negative offset (0xFF high byte)\n        newAddr = addr + pos;\n      }\n\n      // Write back as little-endian\n      output[pos + 1] = newAddr & 0xff;\n      output[pos + 2] = (newAddr >>> 8) & 0xff;\n      output[pos + 3] = (newAddr >>> 16) & 0xff;\n      output[pos + 4] = (newAddr >>> 24) & 0xff;\n\n      pos += 5;\n      prevMask = 0;\n    } else {\n      pos++;\n      prevMask = 0;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create a BCJ decoder Transform stream\n */\nexport function createBcjDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcj, properties, unpackSize);\n}\n"],"names":["createBcjDecoder","decodeBcj","input","_properties","_unpackSize","pos","prevMask","output","bufferFrom","length","b","offset","addr","highByte","newAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,oEAAoE;AACpE,2EAA2E;AAC3E,EAAE;AACF,mFAAmF;AACnF,iFAAiF;AACjF,EAAE;AACF,wEAAwE;;;;;;;;;;;;QAkFxDA;eAAAA;;QAnEAC;eAAAA;;;mCAbW;+EAEQ;;;;;;AAW5B,SAASA,UAAUC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACjF,mBAAmB;IACnB,IAAIC,MAAM;IACV,IAAIC,WAAW;IACf,IAAMC,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAElE,MAAOG,MAAME,OAAOE,MAAM,GAAG,EAAG;QAC9B,IAAMC,IAAIH,MAAM,CAACF,IAAI;QAErB,6CAA6C;QAC7C,IAAIK,MAAM,QAAQA,MAAM,MAAM;YAC5BL;YACAC,WAAW;YACX;QACF;QAEA,8CAA8C;QAC9C,IAAMK,SAASN,MAAM;QACrB,IAAIM,SAASJ,OAAOE,MAAM,EAAE;YAC1B;QACF;QAEA,oEAAoE;QACpE,IAAI,AAACH,CAAAA,WAAW,CAAA,MAAO,GAAG;YACxBA,WAAW,AAACA,YAAY,IAAK;YAC7BD;YACA;QACF;QAEA,0CAA0C;QAC1C,IAAMO,OAAOL,MAAM,CAACF,MAAM,EAAE,GAAIE,MAAM,CAACF,MAAM,EAAE,IAAI,IAAME,MAAM,CAACF,MAAM,EAAE,IAAI,KAAO,AAACE,MAAM,CAACF,MAAM,EAAE,IAAI,OAAQ;QAE/G,+CAA+C;QAC/C,oDAAoD;QACpD,IAAMQ,WAAWN,MAAM,CAACF,MAAM,EAAE;QAEhC,IAAIQ,aAAa,QAAQA,aAAa,MAAM;YAC1C,+BAA+B;YAC/B,IAAIC,UAAAA,KAAAA;YACJ,IAAID,aAAa,MAAM;gBACrB,sCAAsC;gBACtCC,UAAUF,OAAOP;YACnB,OAAO;gBACL,mCAAmC;gBACnCS,UAAUF,OAAOP;YACnB;YAEA,8BAA8B;YAC9BE,MAAM,CAACF,MAAM,EAAE,GAAGS,UAAU;YAC5BP,MAAM,CAACF,MAAM,EAAE,GAAG,AAACS,YAAY,IAAK;YACpCP,MAAM,CAACF,MAAM,EAAE,GAAG,AAACS,YAAY,KAAM;YACrCP,MAAM,CAACF,MAAM,EAAE,GAAG,AAACS,YAAY,KAAM;YAErCT,OAAO;YACPC,WAAW;QACb,OAAO;YACLD;YACAC,WAAW;QACb;IACF;IAEA,OAAOC;AACT;AAKO,SAASP,iBAAiBe,UAAmB,EAAEC,UAAmB;IACvE,OAAOC,IAAAA,iCAAsB,EAAChB,WAAWc,YAAYC;AACvD"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Bcj2.ts"],"sourcesContent":["// BCJ2 (x86-64) filter codec - advanced branch/call/jump converter\n// BCJ2 uses 4 input streams and arithmetic (range) coding for better compression\n// Reference: LZMA SDK Bcj2.c\n//\n// Stream layout:\n//   Stream 0: Main data (contains literals and branch opcode markers)\n//   Stream 1: CALL addresses (for 0xE8 instructions)\n//   Stream 2: JUMP addresses (for 0xE9 instructions)\n//   Stream 3: Range coder data (probability decisions)\n\nimport { allocBuffer } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n// Range coder constants\nvar kTopValue = 1 << 24;\nvar kNumBitModelTotalBits = 11;\nvar kBitModelTotal = 1 << kNumBitModelTotalBits;\nvar kNumMoveBits = 5;\n\n// Number of probability models:\n// Index 0: conditional jumps (0x0F 0x80-0x8F)\n// Index 1: JMP (0xE9)\n// Indices 2-257: CALL (0xE8), indexed by previous byte\nvar kNumProbs = 258;\n\n/**\n * Range decoder state\n */\ninterface RangeDecoder {\n  range: number;\n  code: number;\n  stream: Buffer;\n  pos: number;\n}\n\n/**\n * Initialize range decoder\n */\nfunction initRangeDecoder(stream: Buffer): RangeDecoder {\n  var rd: RangeDecoder = {\n    range: 0xffffffff,\n    code: 0,\n    stream: stream,\n    pos: 0,\n  };\n\n  // Initialize code from first 5 bytes\n  for (var i = 0; i < 5; i++) {\n    rd.code = (rd.code << 8) | (rd.pos < stream.length ? stream[rd.pos++] : 0);\n  }\n\n  return rd;\n}\n\n/**\n * Decode a single bit using probability model\n */\nfunction decodeBit(rd: RangeDecoder, prob: number[], probIndex: number): number {\n  var ttt = prob[probIndex];\n  var bound = (rd.range >>> kNumBitModelTotalBits) * ttt;\n\n  var symbol: number;\n  if (rd.code >>> 0 < bound >>> 0) {\n    rd.range = bound;\n    prob[probIndex] = (ttt + ((kBitModelTotal - ttt) >>> kNumMoveBits)) | 0;\n    symbol = 0;\n  } else {\n    rd.range = (rd.range - bound) >>> 0;\n    rd.code = (rd.code - bound) >>> 0;\n    prob[probIndex] = (ttt - (ttt >>> kNumMoveBits)) | 0;\n    symbol = 1;\n  }\n\n  // Normalize\n  if (rd.range < kTopValue) {\n    rd.range = (rd.range << 8) >>> 0;\n    rd.code = ((rd.code << 8) | (rd.pos < rd.stream.length ? rd.stream[rd.pos++] : 0)) >>> 0;\n  }\n\n  return symbol;\n}\n\n/**\n * BCJ2 multi-stream decoder\n * Takes 4 pre-decompressed streams and combines them\n */\nexport function decodeBcj2Multi(streams: Buffer[], _properties?: Buffer, unpackSize?: number): Buffer {\n  if (streams.length !== 4) {\n    throw new Error(`BCJ2 requires 4 input streams, got ${streams.length}`);\n  }\n\n  // Stream assignment (based on 7z bind pair convention):\n  // streams[0] = main data (after LZMA2)\n  // streams[1] = call stream (after LZMA)\n  // streams[2] = jump stream (after LZMA)\n  // streams[3] = range coder stream (uncompressed)\n  var mainStream = streams[0];\n  var callStream = streams[1];\n  var jumpStream = streams[2];\n  var rcStream = streams[3];\n\n  // Output buffer\n  var outSize = unpackSize || mainStream.length + callStream.length + jumpStream.length;\n  var output = allocBuffer(outSize);\n  var outPos = 0;\n\n  // Stream positions\n  var mainPos = 0;\n  var callPos = 0;\n  var jumpPos = 0;\n\n  // Initialize range decoder\n  var rd = initRangeDecoder(rcStream);\n\n  // Initialize probability models\n  var probs: number[] = [];\n  for (var i = 0; i < kNumProbs; i++) {\n    probs.push(kBitModelTotal >>> 1);\n  }\n\n  // Track previous byte for probability context\n  var prevByte = 0;\n\n  // Instruction pointer for address conversion\n  var ip = 0;\n\n  while (outPos < outSize && mainPos < mainStream.length) {\n    var b = mainStream[mainPos++];\n\n    // Check for branch opcodes\n    if (b === 0xe8 || b === 0xe9) {\n      // CALL (0xE8) or JMP (0xE9)\n      // Use range decoder to check if this should be processed\n      // Probability index: E8 uses 2 + prevByte, E9 uses 1\n      var probIndex = b === 0xe8 ? 2 + prevByte : 1;\n      var isMatch = decodeBit(rd, probs, probIndex);\n\n      if (outPos >= outSize) break;\n      output[outPos++] = b;\n      ip++;\n\n      if (isMatch) {\n        // Read 4-byte address from appropriate stream\n        var addrStream = b === 0xe8 ? callStream : jumpStream;\n        var addrPos = b === 0xe8 ? callPos : jumpPos;\n\n        if (addrPos + 4 > addrStream.length) {\n          // Not enough data, copy remaining\n          break;\n        }\n\n        // Check if we have room for 4 address bytes\n        if (outPos + 4 > outSize) break;\n\n        // Read as big-endian (BCJ2 stores addresses big-endian)\n        var addr = (addrStream[addrPos] << 24) | (addrStream[addrPos + 1] << 16) | (addrStream[addrPos + 2] << 8) | addrStream[addrPos + 3];\n\n        if (b === 0xe8) {\n          callPos += 4;\n        } else {\n          jumpPos += 4;\n        }\n\n        // Convert absolute to relative address\n        addr = (addr - (ip + 4)) | 0;\n\n        // Write as little-endian\n        output[outPos++] = addr & 0xff;\n        output[outPos++] = (addr >>> 8) & 0xff;\n        output[outPos++] = (addr >>> 16) & 0xff;\n        output[outPos++] = (addr >>> 24) & 0xff;\n        ip += 4;\n\n        prevByte = (addr >>> 24) & 0xff;\n      } else {\n        prevByte = b;\n      }\n    } else if (b === 0x0f && mainPos < mainStream.length) {\n      // Potential conditional jump (0x0F 0x8x)\n      if (outPos >= outSize) break;\n      output[outPos++] = b;\n      ip++;\n\n      var b2 = mainStream[mainPos];\n      if ((b2 & 0xf0) === 0x80) {\n        // Conditional jump\n        mainPos++;\n        // Probability index 0 for conditional jumps (since b2 != 0xE8 and b2 != 0xE9)\n        var probIndex2 = 0;\n        var isMatch2 = decodeBit(rd, probs, probIndex2);\n\n        if (outPos >= outSize) break;\n        output[outPos++] = b2;\n        ip++;\n\n        if (isMatch2) {\n          // Read 4-byte address from jump stream\n          if (jumpPos + 4 > jumpStream.length) {\n            break;\n          }\n\n          // Check if we have room for 4 address bytes\n          if (outPos + 4 > outSize) break;\n\n          var addr2 = (jumpStream[jumpPos] << 24) | (jumpStream[jumpPos + 1] << 16) | (jumpStream[jumpPos + 2] << 8) | jumpStream[jumpPos + 3];\n          jumpPos += 4;\n\n          // Convert absolute to relative\n          addr2 = (addr2 - (ip + 4)) | 0;\n\n          // Write as little-endian\n          output[outPos++] = addr2 & 0xff;\n          output[outPos++] = (addr2 >>> 8) & 0xff;\n          output[outPos++] = (addr2 >>> 16) & 0xff;\n          output[outPos++] = (addr2 >>> 24) & 0xff;\n          ip += 4;\n\n          prevByte = (addr2 >>> 24) & 0xff;\n        } else {\n          prevByte = b2;\n        }\n      } else {\n        prevByte = b;\n      }\n    } else {\n      // Regular byte\n      if (outPos >= outSize) break;\n      output[outPos++] = b;\n      ip++;\n      prevByte = b;\n    }\n  }\n\n  // Return only the used portion\n  return outPos < output.length ? output.slice(0, outPos) : output;\n}\n\n/**\n * Single-buffer decode (for API compatibility)\n * Note: BCJ2 requires multi-stream, this throws\n */\nexport function decodeBcj2(_input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  throw new Error('BCJ2 requires multi-stream decoding - use decodeBcj2Multi');\n}\n\n/**\n * Create a BCJ2 decoder Transform stream\n * Note: BCJ2 requires multi-stream, this is for API compatibility\n */\nexport function createBcj2Decoder(_properties?: Buffer, _unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcj2, _properties, _unpackSize);\n}\n"],"names":["createBcj2Decoder","decodeBcj2","decodeBcj2Multi","kTopValue","kNumBitModelTotalBits","kBitModelTotal","kNumMoveBits","kNumProbs","initRangeDecoder","stream","rd","range","code","pos","i","length","decodeBit","prob","probIndex","ttt","bound","symbol","streams","_properties","unpackSize","Error","mainStream","callStream","jumpStream","rcStream","outSize","output","allocBuffer","outPos","mainPos","callPos","jumpPos","probs","push","prevByte","ip","b","isMatch","addrStream","addrPos","addr","b2","probIndex2","isMatch2","addr2","slice","_input","_unpackSize","createBufferingDecoder"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Bcj2.ts"],"sourcesContent":["// BCJ2 (x86-64) filter codec - advanced branch/call/jump converter\n// BCJ2 uses 4 input streams and arithmetic (range) coding for better compression\n// Reference: LZMA SDK Bcj2.c\n//\n// Stream layout:\n//   Stream 0: Main data (contains literals and branch opcode markers)\n//   Stream 1: CALL addresses (for 0xE8 instructions)\n//   Stream 2: JUMP addresses (for 0xE9 instructions)\n//   Stream 3: Range coder data (probability decisions)\n\nimport { allocBuffer } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n// Range coder constants\nconst kTopValue = 1 << 24;\nconst kNumBitModelTotalBits = 11;\nconst kBitModelTotal = 1 << kNumBitModelTotalBits;\nconst kNumMoveBits = 5;\n\n// Number of probability models:\n// Index 0: conditional jumps (0x0F 0x80-0x8F)\n// Index 1: JMP (0xE9)\n// Indices 2-257: CALL (0xE8), indexed by previous byte\nconst kNumProbs = 258;\n\n/**\n * Range decoder state\n */\ninterface RangeDecoder {\n  range: number;\n  code: number;\n  stream: Buffer;\n  pos: number;\n}\n\n/**\n * Initialize range decoder\n */\nfunction initRangeDecoder(stream: Buffer): RangeDecoder {\n  const rd: RangeDecoder = {\n    range: 0xffffffff,\n    code: 0,\n    stream: stream,\n    pos: 0,\n  };\n\n  // Initialize code from first 5 bytes\n  for (let i = 0; i < 5; i++) {\n    rd.code = (rd.code << 8) | (rd.pos < stream.length ? stream[rd.pos++] : 0);\n  }\n\n  return rd;\n}\n\n/**\n * Decode a single bit using probability model\n */\nfunction decodeBit(rd: RangeDecoder, prob: number[], probIndex: number): number {\n  const ttt = prob[probIndex];\n  const bound = (rd.range >>> kNumBitModelTotalBits) * ttt;\n\n  let symbol: number;\n  if (rd.code >>> 0 < bound >>> 0) {\n    rd.range = bound;\n    prob[probIndex] = (ttt + ((kBitModelTotal - ttt) >>> kNumMoveBits)) | 0;\n    symbol = 0;\n  } else {\n    rd.range = (rd.range - bound) >>> 0;\n    rd.code = (rd.code - bound) >>> 0;\n    prob[probIndex] = (ttt - (ttt >>> kNumMoveBits)) | 0;\n    symbol = 1;\n  }\n\n  // Normalize\n  if (rd.range < kTopValue) {\n    rd.range = (rd.range << 8) >>> 0;\n    rd.code = ((rd.code << 8) | (rd.pos < rd.stream.length ? rd.stream[rd.pos++] : 0)) >>> 0;\n  }\n\n  return symbol;\n}\n\n/**\n * BCJ2 multi-stream decoder\n * Takes 4 pre-decompressed streams and combines them\n */\nexport function decodeBcj2Multi(streams: Buffer[], _properties?: Buffer, unpackSize?: number): Buffer {\n  if (streams.length !== 4) {\n    throw new Error(`BCJ2 requires 4 input streams, got ${streams.length}`);\n  }\n\n  // Stream assignment (based on 7z bind pair convention):\n  // streams[0] = main data (after LZMA2)\n  // streams[1] = call stream (after LZMA)\n  // streams[2] = jump stream (after LZMA)\n  // streams[3] = range coder stream (uncompressed)\n  const mainStream = streams[0];\n  const callStream = streams[1];\n  const jumpStream = streams[2];\n  const rcStream = streams[3];\n\n  // Output buffer\n  const outSize = unpackSize || mainStream.length + callStream.length + jumpStream.length;\n  const output = allocBuffer(outSize);\n  let outPos = 0;\n\n  // Stream positions\n  let mainPos = 0;\n  let callPos = 0;\n  let jumpPos = 0;\n\n  // Initialize range decoder\n  const rd = initRangeDecoder(rcStream);\n\n  // Initialize probability models\n  const probs: number[] = [];\n  for (let i = 0; i < kNumProbs; i++) {\n    probs.push(kBitModelTotal >>> 1);\n  }\n\n  // Track previous byte for probability context\n  let prevByte = 0;\n\n  // Instruction pointer for address conversion\n  let ip = 0;\n\n  while (outPos < outSize && mainPos < mainStream.length) {\n    const b = mainStream[mainPos++];\n\n    // Check for branch opcodes\n    if (b === 0xe8 || b === 0xe9) {\n      // CALL (0xE8) or JMP (0xE9)\n      // Use range decoder to check if this should be processed\n      // Probability index: E8 uses 2 + prevByte, E9 uses 1\n      const probIndex = b === 0xe8 ? 2 + prevByte : 1;\n      const isMatch = decodeBit(rd, probs, probIndex);\n\n      if (outPos >= outSize) break;\n      output[outPos++] = b;\n      ip++;\n\n      if (isMatch) {\n        // Read 4-byte address from appropriate stream\n        const addrStream = b === 0xe8 ? callStream : jumpStream;\n        const addrPos = b === 0xe8 ? callPos : jumpPos;\n\n        if (addrPos + 4 > addrStream.length) {\n          // Not enough data, copy remaining\n          break;\n        }\n\n        // Check if we have room for 4 address bytes\n        if (outPos + 4 > outSize) break;\n\n        // Read as big-endian (BCJ2 stores addresses big-endian)\n        let addr = (addrStream[addrPos] << 24) | (addrStream[addrPos + 1] << 16) | (addrStream[addrPos + 2] << 8) | addrStream[addrPos + 3];\n\n        if (b === 0xe8) {\n          callPos += 4;\n        } else {\n          jumpPos += 4;\n        }\n\n        // Convert absolute to relative address\n        addr = (addr - (ip + 4)) | 0;\n\n        // Write as little-endian\n        output[outPos++] = addr & 0xff;\n        output[outPos++] = (addr >>> 8) & 0xff;\n        output[outPos++] = (addr >>> 16) & 0xff;\n        output[outPos++] = (addr >>> 24) & 0xff;\n        ip += 4;\n\n        prevByte = (addr >>> 24) & 0xff;\n      } else {\n        prevByte = b;\n      }\n    } else if (b === 0x0f && mainPos < mainStream.length) {\n      // Potential conditional jump (0x0F 0x8x)\n      if (outPos >= outSize) break;\n      output[outPos++] = b;\n      ip++;\n\n      const b2 = mainStream[mainPos];\n      if ((b2 & 0xf0) === 0x80) {\n        // Conditional jump\n        mainPos++;\n        // Probability index 0 for conditional jumps (since b2 != 0xE8 and b2 != 0xE9)\n        const probIndex2 = 0;\n        const isMatch2 = decodeBit(rd, probs, probIndex2);\n\n        if (outPos >= outSize) break;\n        output[outPos++] = b2;\n        ip++;\n\n        if (isMatch2) {\n          // Read 4-byte address from jump stream\n          if (jumpPos + 4 > jumpStream.length) {\n            break;\n          }\n\n          // Check if we have room for 4 address bytes\n          if (outPos + 4 > outSize) break;\n\n          let addr2 = (jumpStream[jumpPos] << 24) | (jumpStream[jumpPos + 1] << 16) | (jumpStream[jumpPos + 2] << 8) | jumpStream[jumpPos + 3];\n          jumpPos += 4;\n\n          // Convert absolute to relative\n          addr2 = (addr2 - (ip + 4)) | 0;\n\n          // Write as little-endian\n          output[outPos++] = addr2 & 0xff;\n          output[outPos++] = (addr2 >>> 8) & 0xff;\n          output[outPos++] = (addr2 >>> 16) & 0xff;\n          output[outPos++] = (addr2 >>> 24) & 0xff;\n          ip += 4;\n\n          prevByte = (addr2 >>> 24) & 0xff;\n        } else {\n          prevByte = b2;\n        }\n      } else {\n        prevByte = b;\n      }\n    } else {\n      // Regular byte\n      if (outPos >= outSize) break;\n      output[outPos++] = b;\n      ip++;\n      prevByte = b;\n    }\n  }\n\n  // Return only the used portion\n  return outPos < output.length ? output.slice(0, outPos) : output;\n}\n\n/**\n * Single-buffer decode (for API compatibility)\n * Note: BCJ2 requires multi-stream, this throws\n */\nexport function decodeBcj2(_input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  throw new Error('BCJ2 requires multi-stream decoding - use decodeBcj2Multi');\n}\n\n/**\n * Create a BCJ2 decoder Transform stream\n * Note: BCJ2 requires multi-stream, this is for API compatibility\n */\nexport function createBcj2Decoder(_properties?: Buffer, _unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcj2, _properties, _unpackSize);\n}\n"],"names":["createBcj2Decoder","decodeBcj2","decodeBcj2Multi","kTopValue","kNumBitModelTotalBits","kBitModelTotal","kNumMoveBits","kNumProbs","initRangeDecoder","stream","rd","range","code","pos","i","length","decodeBit","prob","probIndex","ttt","bound","symbol","streams","_properties","unpackSize","Error","mainStream","callStream","jumpStream","rcStream","outSize","output","allocBuffer","outPos","mainPos","callPos","jumpPos","probs","push","prevByte","ip","b","isMatch","addrStream","addrPos","addr","b2","probIndex2","isMatch2","addr2","slice","_input","_unpackSize","createBufferingDecoder"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  var output = bufferFrom(input); // Copy since we modify in place\n  var pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (output[pos + 3] === 0xeb) {\n      // Read 24-bit address (little-endian in bytes 0-2)\n      var addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n\n      // Sign-extend 24-bit to 32-bit\n      if (addr & 0x800000) {\n        addr |= 0xff000000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in words, so divide by 4)\n      // ARM PC is 2 words (8 bytes) ahead during execution\n      var relAddr = addr - (pos >>> 2);\n\n      // Write back lower 24 bits\n      output[pos] = relAddr & 0xff;\n      output[pos + 1] = (relAddr >>> 8) & 0xff;\n      output[pos + 2] = (relAddr >>> 16) & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM BCJ decoder Transform stream\n */\nexport function createBcjArmDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm, properties, unpackSize);\n}\n"],"names":["createBcjArmDecoder","decodeBcjArm","input","_properties","_unpackSize","output","bufferFrom","pos","length","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAuD/CA;eAAAA;;QAnCAC;eAAAA;;;mCAlBW;+EAEQ;;;;;;AAgB5B,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAIC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAChE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,qDAAqD;YACrD,IAAIC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAE9B,2BAA2B;YAC3BF,MAAM,CAACE,IAAI,GAAGG,UAAU;YACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,oBAAoBW,UAAmB,EAAEC,UAAmB;IAC1E,OAAOC,IAAAA,iCAAsB,EAACZ,cAAcU,YAAYC;AAC1D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (output[pos + 3] === 0xeb) {\n      // Read 24-bit address (little-endian in bytes 0-2)\n      let addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n\n      // Sign-extend 24-bit to 32-bit\n      if (addr & 0x800000) {\n        addr |= 0xff000000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in words, so divide by 4)\n      // ARM PC is 2 words (8 bytes) ahead during execution\n      const relAddr = addr - (pos >>> 2);\n\n      // Write back lower 24 bits\n      output[pos] = relAddr & 0xff;\n      output[pos + 1] = (relAddr >>> 8) & 0xff;\n      output[pos + 2] = (relAddr >>> 16) & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM BCJ decoder Transform stream\n */\nexport function createBcjArmDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm, properties, unpackSize);\n}\n"],"names":["createBcjArmDecoder","decodeBcjArm","input","_properties","_unpackSize","output","bufferFrom","pos","length","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAuD/CA;eAAAA;;QAnCAC;eAAAA;;;mCAlBW;+EAEQ;;;;;;AAgB5B,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,qDAAqD;YACrD,IAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BF,MAAM,CAACE,IAAI,GAAGG,UAAU;YACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,oBAAoBW,UAAmB,EAAEC,UAAmB;IAC1E,OAAOC,IAAAA,iCAAsB,EAACZ,cAAcU,YAAYC;AAC1D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm64.ts"],"sourcesContent":["// BCJ (ARM64/AArch64) filter codec - converts ARM64 branch instruction addresses\n// This filter makes ARM64 executables more compressible by LZMA\n//\n// ARM64 uses 32-bit fixed-width instructions. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM64 B/BL instruction format (little-endian):\n * - 4 bytes aligned\n * - B: opcode 0x14 (000101xx)\n * - BL: opcode 0x94 (100101xx)\n * - Bits 0-25 are 26-bit signed offset (in words)\n *\n * @param input - ARM64 BCJ filtered data\n * @param _properties - Unused for ARM64 BCJ\n * @param _unpackSize - Unused for ARM64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  var output = bufferFrom(input); // Copy since we modify in place\n  var pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (little-endian)\n    var instr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16) | ((output[pos + 3] << 24) >>> 0);\n\n    // Check for B/BL instruction: (instr & 0x7C000000) === 0x14000000\n    // This matches both B (0x14000000) and BL (0x94000000)\n    if ((instr & 0x7c000000) === 0x14000000) {\n      // Extract 26-bit offset\n      var addr = instr & 0x03ffffff;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position (in words)\n      var relAddr = addr - (pos >>> 2);\n\n      // Clear old offset and write new one, preserve opcode\n      instr = (instr & 0xfc000000) | (relAddr & 0x03ffffff);\n\n      // Write back (little-endian)\n      output[pos] = instr & 0xff;\n      output[pos + 1] = (instr >>> 8) & 0xff;\n      output[pos + 2] = (instr >>> 16) & 0xff;\n      output[pos + 3] = (instr >>> 24) & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM64 BCJ decoder Transform stream\n */\nexport function createBcjArm64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm64, properties, unpackSize);\n}\n"],"names":["createBcjArm64Decoder","decodeBcjArm64","input","_properties","_unpackSize","output","bufferFrom","pos","length","instr","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,iFAAiF;AACjF,gEAAgE;AAChE,EAAE;AACF,6FAA6F;AAC7F,EAAE;AACF,+DAA+D;;;;;;;;;;;;QA+D/CA;eAAAA;;QA1CAC;eAAAA;;;mCAnBW;+EAEQ;;;;;;AAiB5B,SAASA,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,IAAIC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAChE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,oCAAoC;QACpC,IAAIC,QAAQJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI,KAAO,AAACF,MAAM,CAACE,MAAM,EAAE,IAAI,OAAQ;QAE1G,kEAAkE;QAClE,uDAAuD;QACvD,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,wBAAwB;YACxB,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,qEAAqE;YACrE,IAAIC,UAAUD,OAAQH,CAAAA,QAAQ,CAAA;YAE9B,sDAAsD;YACtDE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,6BAA6B;YAC7BN,MAAM,CAACE,IAAI,GAAGE,QAAQ;YACtBJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;QACrC;QAEAF,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,sBAAsBY,UAAmB,EAAEC,UAAmB;IAC5E,OAAOC,IAAAA,iCAAsB,EAACb,gBAAgBW,YAAYC;AAC5D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm64.ts"],"sourcesContent":["// BCJ (ARM64/AArch64) filter codec - converts ARM64 branch instruction addresses\n// This filter makes ARM64 executables more compressible by LZMA\n//\n// ARM64 uses 32-bit fixed-width instructions. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM64 B/BL instruction format (little-endian):\n * - 4 bytes aligned\n * - B: opcode 0x14 (000101xx)\n * - BL: opcode 0x94 (100101xx)\n * - Bits 0-25 are 26-bit signed offset (in words)\n *\n * @param input - ARM64 BCJ filtered data\n * @param _properties - Unused for ARM64 BCJ\n * @param _unpackSize - Unused for ARM64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (little-endian)\n    let instr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16) | ((output[pos + 3] << 24) >>> 0);\n\n    // Check for B/BL instruction: (instr & 0x7C000000) === 0x14000000\n    // This matches both B (0x14000000) and BL (0x94000000)\n    if ((instr & 0x7c000000) === 0x14000000) {\n      // Extract 26-bit offset\n      let addr = instr & 0x03ffffff;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position (in words)\n      const relAddr = addr - (pos >>> 2);\n\n      // Clear old offset and write new one, preserve opcode\n      instr = (instr & 0xfc000000) | (relAddr & 0x03ffffff);\n\n      // Write back (little-endian)\n      output[pos] = instr & 0xff;\n      output[pos + 1] = (instr >>> 8) & 0xff;\n      output[pos + 2] = (instr >>> 16) & 0xff;\n      output[pos + 3] = (instr >>> 24) & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM64 BCJ decoder Transform stream\n */\nexport function createBcjArm64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm64, properties, unpackSize);\n}\n"],"names":["createBcjArm64Decoder","decodeBcjArm64","input","_properties","_unpackSize","output","bufferFrom","pos","length","instr","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,iFAAiF;AACjF,gEAAgE;AAChE,EAAE;AACF,6FAA6F;AAC7F,EAAE;AACF,+DAA+D;;;;;;;;;;;;QA+D/CA;eAAAA;;QA1CAC;eAAAA;;;mCAnBW;+EAEQ;;;;;;AAiB5B,SAASA,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,oCAAoC;QACpC,IAAIC,QAAQJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI,KAAO,AAACF,MAAM,CAACE,MAAM,EAAE,IAAI,OAAQ;QAE1G,kEAAkE;QAClE,uDAAuD;QACvD,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,wBAAwB;YACxB,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,qEAAqE;YACrE,IAAMC,UAAUD,OAAQH,CAAAA,QAAQ,CAAA;YAEhC,sDAAsD;YACtDE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,6BAA6B;YAC7BN,MAAM,CAACE,IAAI,GAAGE,QAAQ;YACtBJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;QACrC;QAEAF,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,sBAAsBY,UAAmB,EAAEC,UAAmB;IAC5E,OAAOC,IAAAA,iCAAsB,EAACb,gBAAgBW,YAAYC;AAC5D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArmt.ts"],"sourcesContent":["// BCJ (ARM Thumb) filter codec - converts ARM Thumb branch instruction addresses\n// This filter makes ARM Thumb executables more compressible by LZMA\n//\n// ARM Thumb uses 16-bit instructions, but BL (branch with link) spans two 16-bit words.\n// The filter converts relative addresses to absolute during compression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM Thumb BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM Thumb BL instruction format (2 x 16-bit):\n * - First half-word: 1111 0xxx xxxx xxxx (high bits of offset)\n * - Second half-word: 1111 1xxx xxxx xxxx (low bits of offset)\n *\n * @param input - ARM Thumb BCJ filtered data\n * @param _properties - Unused for ARM Thumb BCJ\n * @param _unpackSize - Unused for ARM Thumb BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArmt(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  var output = bufferFrom(input); // Copy since we modify in place\n  var pos = 0;\n\n  // Process 2-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read two 16-bit values (little-endian)\n    var w0 = output[pos] | (output[pos + 1] << 8);\n    var w1 = output[pos + 2] | (output[pos + 3] << 8);\n\n    // Check for BL instruction pair:\n    // First word: 0xF000-0xF7FF (1111 0xxx xxxx xxxx)\n    // Second word: 0xF800-0xFFFF (1111 1xxx xxxx xxxx)\n    if ((w0 & 0xf800) === 0xf000 && (w1 & 0xf800) === 0xf800) {\n      // Extract and combine the offset parts\n      // High 11 bits from w0, low 11 bits from w1\n      var hi = w0 & 0x7ff;\n      var lo = w1 & 0x7ff;\n\n      // Combine into 22-bit offset (in half-words)\n      var addr = (hi << 11) | lo;\n\n      // Sign-extend 22-bit to 32-bit\n      if (addr & 0x200000) {\n        addr |= 0xffc00000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in half-words, so divide by 2)\n      // Thumb PC is 2 half-words (4 bytes) ahead\n      var relAddr = addr - (pos >>> 1);\n\n      // Write back\n      var newHi = (relAddr >>> 11) & 0x7ff;\n      var newLo = relAddr & 0x7ff;\n\n      output[pos] = newHi & 0xff;\n      output[pos + 1] = 0xf0 | ((newHi >>> 8) & 0x07);\n      output[pos + 2] = newLo & 0xff;\n      output[pos + 3] = 0xf8 | ((newLo >>> 8) & 0x07);\n\n      pos += 4;\n    } else {\n      pos += 2;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM Thumb BCJ decoder Transform stream\n */\nexport function createBcjArmtDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArmt, properties, unpackSize);\n}\n"],"names":["createBcjArmtDecoder","decodeBcjArmt","input","_properties","_unpackSize","output","bufferFrom","pos","length","w0","w1","hi","lo","addr","relAddr","newHi","newLo","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,iFAAiF;AACjF,oEAAoE;AACpE,EAAE;AACF,wFAAwF;AACxF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAwE/CA;eAAAA;;QArDAC;eAAAA;;;mCAjBW;+EAEQ;;;;;;AAe5B,SAASA,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,IAAIC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAChE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,yCAAyC;QACzC,IAAIC,KAAKJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI;QAC3C,IAAIG,KAAKL,MAAM,CAACE,MAAM,EAAE,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI;QAE/C,iCAAiC;QACjC,kDAAkD;QAClD,mDAAmD;QACnD,IAAI,AAACE,CAAAA,KAAK,MAAK,MAAO,UAAU,AAACC,CAAAA,KAAK,MAAK,MAAO,QAAQ;YACxD,uCAAuC;YACvC,4CAA4C;YAC5C,IAAIC,KAAKF,KAAK;YACd,IAAIG,KAAKF,KAAK;YAEd,6CAA6C;YAC7C,IAAIG,OAAO,AAACF,MAAM,KAAMC;YAExB,+BAA+B;YAC/B,IAAIC,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,4DAA4D;YAC5D,2CAA2C;YAC3C,IAAIC,UAAUD,OAAQN,CAAAA,QAAQ,CAAA;YAE9B,aAAa;YACb,IAAIQ,QAAQ,AAACD,YAAY,KAAM;YAC/B,IAAIE,QAAQF,UAAU;YAEtBT,MAAM,CAACE,IAAI,GAAGQ,QAAQ;YACtBV,MAAM,CAACE,MAAM,EAAE,GAAG,OAAQ,AAACQ,UAAU,IAAK;YAC1CV,MAAM,CAACE,MAAM,EAAE,GAAGS,QAAQ;YAC1BX,MAAM,CAACE,MAAM,EAAE,GAAG,OAAQ,AAACS,UAAU,IAAK;YAE1CT,OAAO;QACT,OAAO;YACLA,OAAO;QACT;IACF;IAEA,OAAOF;AACT;AAKO,SAASL,qBAAqBiB,UAAmB,EAAEC,UAAmB;IAC3E,OAAOC,IAAAA,iCAAsB,EAAClB,eAAegB,YAAYC;AAC3D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArmt.ts"],"sourcesContent":["// BCJ (ARM Thumb) filter codec - converts ARM Thumb branch instruction addresses\n// This filter makes ARM Thumb executables more compressible by LZMA\n//\n// ARM Thumb uses 16-bit instructions, but BL (branch with link) spans two 16-bit words.\n// The filter converts relative addresses to absolute during compression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM Thumb BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM Thumb BL instruction format (2 x 16-bit):\n * - First half-word: 1111 0xxx xxxx xxxx (high bits of offset)\n * - Second half-word: 1111 1xxx xxxx xxxx (low bits of offset)\n *\n * @param input - ARM Thumb BCJ filtered data\n * @param _properties - Unused for ARM Thumb BCJ\n * @param _unpackSize - Unused for ARM Thumb BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArmt(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 2-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read two 16-bit values (little-endian)\n    const w0 = output[pos] | (output[pos + 1] << 8);\n    const w1 = output[pos + 2] | (output[pos + 3] << 8);\n\n    // Check for BL instruction pair:\n    // First word: 0xF000-0xF7FF (1111 0xxx xxxx xxxx)\n    // Second word: 0xF800-0xFFFF (1111 1xxx xxxx xxxx)\n    if ((w0 & 0xf800) === 0xf000 && (w1 & 0xf800) === 0xf800) {\n      // Extract and combine the offset parts\n      // High 11 bits from w0, low 11 bits from w1\n      const hi = w0 & 0x7ff;\n      const lo = w1 & 0x7ff;\n\n      // Combine into 22-bit offset (in half-words)\n      let addr = (hi << 11) | lo;\n\n      // Sign-extend 22-bit to 32-bit\n      if (addr & 0x200000) {\n        addr |= 0xffc00000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in half-words, so divide by 2)\n      // Thumb PC is 2 half-words (4 bytes) ahead\n      const relAddr = addr - (pos >>> 1);\n\n      // Write back\n      const newHi = (relAddr >>> 11) & 0x7ff;\n      const newLo = relAddr & 0x7ff;\n\n      output[pos] = newHi & 0xff;\n      output[pos + 1] = 0xf0 | ((newHi >>> 8) & 0x07);\n      output[pos + 2] = newLo & 0xff;\n      output[pos + 3] = 0xf8 | ((newLo >>> 8) & 0x07);\n\n      pos += 4;\n    } else {\n      pos += 2;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM Thumb BCJ decoder Transform stream\n */\nexport function createBcjArmtDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArmt, properties, unpackSize);\n}\n"],"names":["createBcjArmtDecoder","decodeBcjArmt","input","_properties","_unpackSize","output","bufferFrom","pos","length","w0","w1","hi","lo","addr","relAddr","newHi","newLo","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,iFAAiF;AACjF,oEAAoE;AACpE,EAAE;AACF,wFAAwF;AACxF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAwE/CA;eAAAA;;QArDAC;eAAAA;;;mCAjBW;+EAEQ;;;;;;AAe5B,SAASA,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,yCAAyC;QACzC,IAAMC,KAAKJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI;QAC7C,IAAMG,KAAKL,MAAM,CAACE,MAAM,EAAE,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI;QAEjD,iCAAiC;QACjC,kDAAkD;QAClD,mDAAmD;QACnD,IAAI,AAACE,CAAAA,KAAK,MAAK,MAAO,UAAU,AAACC,CAAAA,KAAK,MAAK,MAAO,QAAQ;YACxD,uCAAuC;YACvC,4CAA4C;YAC5C,IAAMC,KAAKF,KAAK;YAChB,IAAMG,KAAKF,KAAK;YAEhB,6CAA6C;YAC7C,IAAIG,OAAO,AAACF,MAAM,KAAMC;YAExB,+BAA+B;YAC/B,IAAIC,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,4DAA4D;YAC5D,2CAA2C;YAC3C,IAAMC,UAAUD,OAAQN,CAAAA,QAAQ,CAAA;YAEhC,aAAa;YACb,IAAMQ,QAAQ,AAACD,YAAY,KAAM;YACjC,IAAME,QAAQF,UAAU;YAExBT,MAAM,CAACE,IAAI,GAAGQ,QAAQ;YACtBV,MAAM,CAACE,MAAM,EAAE,GAAG,OAAQ,AAACQ,UAAU,IAAK;YAC1CV,MAAM,CAACE,MAAM,EAAE,GAAGS,QAAQ;YAC1BX,MAAM,CAACE,MAAM,EAAE,GAAG,OAAQ,AAACS,UAAU,IAAK;YAE1CT,OAAO;QACT,OAAO;YACLA,OAAO;QACT;IACF;IAEA,OAAOF;AACT;AAKO,SAASL,qBAAqBiB,UAAmB,EAAEC,UAAmB;IAC3E,OAAOC,IAAAA,iCAAsB,EAAClB,eAAegB,YAAYC;AAC3D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjIa64.ts"],"sourcesContent":["// BCJ (IA64/Itanium) filter codec - converts IA64 branch instruction addresses\n// This filter makes IA64 executables more compressible by LZMA\n//\n// IA64 uses 128-bit instruction bundles with 3 instructions per bundle.\n// Branch instructions use 21-bit signed offsets (in bundles).\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n// IA64 branch instruction slot mask\n// Each bundle has a 5-bit template and 3 x 41-bit instruction slots\nvar kBranchTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0, 7, 7, 4, 4, 0, 0, 4, 4, 0, 0];\n\n/**\n * Decode IA64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - IA64 BCJ filtered data\n * @param _properties - Unused for IA64 BCJ\n * @param _unpackSize - Unused for IA64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjIa64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  var output = bufferFrom(input); // Copy since we modify in place\n  var pos = 0;\n\n  // Process 16-byte aligned bundles\n  while (pos + 16 <= output.length) {\n    // Get template (low 5 bits of first byte)\n    var template = output[pos] & 0x1f;\n    var mask = kBranchTable[template];\n\n    // Check each instruction slot (3 slots per bundle)\n    for (var slot = 0; slot < 3; slot++) {\n      if ((mask & (1 << slot)) === 0) {\n        continue;\n      }\n\n      // Calculate bit position for this slot\n      // Slot 0: bits 5-45, Slot 1: bits 46-86, Slot 2: bits 87-127\n      var bitPos = 5 + slot * 41;\n      var bytePos = bitPos >>> 3;\n      var bitOffset = bitPos & 7;\n\n      // Read 8 bytes to get the instruction (may span bytes)\n      // We need at least 6 bytes for a 41-bit instruction\n      if (pos + bytePos + 6 > output.length) {\n        break;\n      }\n\n      // Extract instruction bytes\n      var instr0 = output[pos + bytePos];\n      var instr1 = output[pos + bytePos + 1];\n      var instr2 = output[pos + bytePos + 2];\n      var instr3 = output[pos + bytePos + 3];\n      var instr4 = output[pos + bytePos + 4];\n      var instr5 = output[pos + bytePos + 5];\n\n      // Build instruction value (we only need the immediate field)\n      // The immediate is in bits 13-32 of the instruction (20 bits)\n      // Plus bit 36 as the sign bit\n\n      // For decoding, we extract the address that was encoded and convert back\n      var instrLo = (instr0 >>> bitOffset) | (instr1 << (8 - bitOffset)) | (instr2 << (16 - bitOffset)) | (instr3 << (24 - bitOffset));\n\n      var instrHi = (instr4 >>> bitOffset) | (instr5 << (8 - bitOffset));\n\n      // Check opcode for branch (opcode 4 or 5 in bits 37-40)\n      var opcode = (instrHi >>> (37 - 32 - bitOffset)) & 0xf;\n      if (opcode !== 4 && opcode !== 5) {\n        continue;\n      }\n\n      // Extract 21-bit immediate (bits 13-32 + sign bit 36)\n      var imm20 = (instrLo >>> 13) & 0xfffff;\n      var sign = (instrHi >>> (36 - 32)) & 1;\n\n      // Combine into 21-bit signed value\n      var addr = imm20 | (sign << 20);\n      if (sign) {\n        addr |= 0xffe00000; // Sign-extend\n      }\n\n      // Convert absolute to relative: subtract current position (in bundles)\n      var relAddr = addr - (pos >>> 4);\n\n      // Write back\n      var newImm20 = relAddr & 0xfffff;\n      var newSign = (relAddr >>> 20) & 1;\n\n      // Clear old immediate and write new one\n      instrLo = (instrLo & ~(0xfffff << 13)) | (newImm20 << 13);\n      instrHi = (instrHi & ~(1 << (36 - 32))) | (newSign << (36 - 32));\n\n      // Write back bytes\n      output[pos + bytePos] = (output[pos + bytePos] & ((1 << bitOffset) - 1)) | ((instrLo & 0xff) << bitOffset);\n      output[pos + bytePos + 1] = (instrLo >>> (8 - bitOffset)) & 0xff;\n      output[pos + bytePos + 2] = (instrLo >>> (16 - bitOffset)) & 0xff;\n      output[pos + bytePos + 3] = (instrLo >>> (24 - bitOffset)) & 0xff;\n      output[pos + bytePos + 4] = ((instrLo >>> (32 - bitOffset)) & ((1 << bitOffset) - 1)) | ((instrHi & 0xff) << bitOffset);\n      output[pos + bytePos + 5] = (output[pos + bytePos + 5] & ~((1 << bitOffset) - 1)) | ((instrHi >>> (8 - bitOffset)) & ((1 << bitOffset) - 1));\n    }\n\n    pos += 16;\n  }\n\n  return output;\n}\n\n/**\n * Create an IA64 BCJ decoder Transform stream\n */\nexport function createBcjIa64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjIa64, properties, unpackSize);\n}\n"],"names":["createBcjIa64Decoder","decodeBcjIa64","kBranchTable","input","_properties","_unpackSize","output","bufferFrom","pos","length","template","mask","slot","bitPos","bytePos","bitOffset","instr0","instr1","instr2","instr3","instr4","instr5","instrLo","instrHi","opcode","imm20","sign","addr","relAddr","newImm20","newSign","properties","unpackSize","createBufferingDecoder"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjIa64.ts"],"sourcesContent":["// BCJ (IA64/Itanium) filter codec - converts IA64 branch instruction addresses\n// This filter makes IA64 executables more compressible by LZMA\n//\n// IA64 uses 128-bit instruction bundles with 3 instructions per bundle.\n// Branch instructions use 21-bit signed offsets (in bundles).\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n// IA64 branch instruction slot mask\n// Each bundle has a 5-bit template and 3 x 41-bit instruction slots\nconst kBranchTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0, 7, 7, 4, 4, 0, 0, 4, 4, 0, 0];\n\n/**\n * Decode IA64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - IA64 BCJ filtered data\n * @param _properties - Unused for IA64 BCJ\n * @param _unpackSize - Unused for IA64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjIa64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 16-byte aligned bundles\n  while (pos + 16 <= output.length) {\n    // Get template (low 5 bits of first byte)\n    const template = output[pos] & 0x1f;\n    const mask = kBranchTable[template];\n\n    // Check each instruction slot (3 slots per bundle)\n    for (let slot = 0; slot < 3; slot++) {\n      if ((mask & (1 << slot)) === 0) {\n        continue;\n      }\n\n      // Calculate bit position for this slot\n      // Slot 0: bits 5-45, Slot 1: bits 46-86, Slot 2: bits 87-127\n      const bitPos = 5 + slot * 41;\n      const bytePos = bitPos >>> 3;\n      const bitOffset = bitPos & 7;\n\n      // Read 8 bytes to get the instruction (may span bytes)\n      // We need at least 6 bytes for a 41-bit instruction\n      if (pos + bytePos + 6 > output.length) {\n        break;\n      }\n\n      // Extract instruction bytes\n      const instr0 = output[pos + bytePos];\n      const instr1 = output[pos + bytePos + 1];\n      const instr2 = output[pos + bytePos + 2];\n      const instr3 = output[pos + bytePos + 3];\n      const instr4 = output[pos + bytePos + 4];\n      const instr5 = output[pos + bytePos + 5];\n\n      // Build instruction value (we only need the immediate field)\n      // The immediate is in bits 13-32 of the instruction (20 bits)\n      // Plus bit 36 as the sign bit\n\n      // For decoding, we extract the address that was encoded and convert back\n      let instrLo = (instr0 >>> bitOffset) | (instr1 << (8 - bitOffset)) | (instr2 << (16 - bitOffset)) | (instr3 << (24 - bitOffset));\n\n      let instrHi = (instr4 >>> bitOffset) | (instr5 << (8 - bitOffset));\n\n      // Check opcode for branch (opcode 4 or 5 in bits 37-40)\n      const opcode = (instrHi >>> (37 - 32 - bitOffset)) & 0xf;\n      if (opcode !== 4 && opcode !== 5) {\n        continue;\n      }\n\n      // Extract 21-bit immediate (bits 13-32 + sign bit 36)\n      const imm20 = (instrLo >>> 13) & 0xfffff;\n      const sign = (instrHi >>> (36 - 32)) & 1;\n\n      // Combine into 21-bit signed value\n      let addr = imm20 | (sign << 20);\n      if (sign) {\n        addr |= 0xffe00000; // Sign-extend\n      }\n\n      // Convert absolute to relative: subtract current position (in bundles)\n      const relAddr = addr - (pos >>> 4);\n\n      // Write back\n      const newImm20 = relAddr & 0xfffff;\n      const newSign = (relAddr >>> 20) & 1;\n\n      // Clear old immediate and write new one\n      instrLo = (instrLo & ~(0xfffff << 13)) | (newImm20 << 13);\n      instrHi = (instrHi & ~(1 << (36 - 32))) | (newSign << (36 - 32));\n\n      // Write back bytes\n      output[pos + bytePos] = (output[pos + bytePos] & ((1 << bitOffset) - 1)) | ((instrLo & 0xff) << bitOffset);\n      output[pos + bytePos + 1] = (instrLo >>> (8 - bitOffset)) & 0xff;\n      output[pos + bytePos + 2] = (instrLo >>> (16 - bitOffset)) & 0xff;\n      output[pos + bytePos + 3] = (instrLo >>> (24 - bitOffset)) & 0xff;\n      output[pos + bytePos + 4] = ((instrLo >>> (32 - bitOffset)) & ((1 << bitOffset) - 1)) | ((instrHi & 0xff) << bitOffset);\n      output[pos + bytePos + 5] = (output[pos + bytePos + 5] & ~((1 << bitOffset) - 1)) | ((instrHi >>> (8 - bitOffset)) & ((1 << bitOffset) - 1));\n    }\n\n    pos += 16;\n  }\n\n  return output;\n}\n\n/**\n * Create an IA64 BCJ decoder Transform stream\n */\nexport function createBcjIa64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjIa64, properties, unpackSize);\n}\n"],"names":["createBcjIa64Decoder","decodeBcjIa64","kBranchTable","input","_properties","_unpackSize","output","bufferFrom","pos","length","template","mask","slot","bitPos","bytePos","bitOffset","instr0","instr1","instr2","instr3","instr4","instr5","instrLo","instrHi","opcode","imm20","sign","addr","relAddr","newImm20","newSign","properties","unpackSize","createBufferingDecoder"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjPpc.ts"],"sourcesContent":["// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses\n// This filter makes PowerPC executables more compressible by LZMA\n//\n// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode PowerPC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * PowerPC B/BL instruction format (big-endian):\n * - 4 bytes aligned\n * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)\n * - Bits 6-29 are 24-bit signed offset (in words)\n *\n * @param input - PowerPC BCJ filtered data\n * @param _properties - Unused for PowerPC BCJ\n * @param _unpackSize - Unused for PowerPC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjPpc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  var output = bufferFrom(input); // Copy since we modify in place\n  var pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (big-endian)\n    var instr = (output[pos] << 24) | (output[pos + 1] << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n    // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001\n    if ((instr & 0xfc000003) === 0x48000001) {\n      // Extract 26-bit offset (bits 2-27, the LI field)\n      var addr = instr & 0x03fffffc;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position\n      var relAddr = addr - pos;\n\n      // Clear old offset and write new one\n      instr = (instr & 0xfc000003) | (relAddr & 0x03fffffc);\n\n      // Write back (big-endian)\n      output[pos] = (instr >>> 24) & 0xff;\n      output[pos + 1] = (instr >>> 16) & 0xff;\n      output[pos + 2] = (instr >>> 8) & 0xff;\n      output[pos + 3] = instr & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a PowerPC BCJ decoder Transform stream\n */\nexport function createBcjPpcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjPpc, properties, unpackSize);\n}\n"],"names":["createBcjPpcDecoder","decodeBcjPpc","input","_properties","_unpackSize","output","bufferFrom","pos","length","instr","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,6EAA6E;AAC7E,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,EAAE;AACF,+DAA+D;;;;;;;;;;;;QA4D/CA;eAAAA;;QAxCAC;eAAAA;;;mCAlBW;+EAEQ;;;;;;AAgB5B,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAIC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAChE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,iCAAiC;QACjC,IAAIC,QAAQ,AAACJ,MAAM,CAACE,IAAI,IAAI,KAAOF,MAAM,CAACE,MAAM,EAAE,IAAI,KAAOF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAKF,MAAM,CAACE,MAAM,EAAE;QAEpG,kEAAkE;QAClE,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,kDAAkD;YAClD,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,0DAA0D;YAC1D,IAAIC,UAAUD,OAAOH;YAErB,qCAAqC;YACrCE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,0BAA0B;YAC1BN,MAAM,CAACE,IAAI,GAAG,AAACE,UAAU,KAAM;YAC/BJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCJ,MAAM,CAACE,MAAM,EAAE,GAAGE,QAAQ;QAC5B;QACAF,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,oBAAoBY,UAAmB,EAAEC,UAAmB;IAC1E,OAAOC,IAAAA,iCAAsB,EAACb,cAAcW,YAAYC;AAC1D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjPpc.ts"],"sourcesContent":["// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses\n// This filter makes PowerPC executables more compressible by LZMA\n//\n// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode PowerPC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * PowerPC B/BL instruction format (big-endian):\n * - 4 bytes aligned\n * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)\n * - Bits 6-29 are 24-bit signed offset (in words)\n *\n * @param input - PowerPC BCJ filtered data\n * @param _properties - Unused for PowerPC BCJ\n * @param _unpackSize - Unused for PowerPC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjPpc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (big-endian)\n    let instr = (output[pos] << 24) | (output[pos + 1] << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n    // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001\n    if ((instr & 0xfc000003) === 0x48000001) {\n      // Extract 26-bit offset (bits 2-27, the LI field)\n      let addr = instr & 0x03fffffc;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position\n      const relAddr = addr - pos;\n\n      // Clear old offset and write new one\n      instr = (instr & 0xfc000003) | (relAddr & 0x03fffffc);\n\n      // Write back (big-endian)\n      output[pos] = (instr >>> 24) & 0xff;\n      output[pos + 1] = (instr >>> 16) & 0xff;\n      output[pos + 2] = (instr >>> 8) & 0xff;\n      output[pos + 3] = instr & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a PowerPC BCJ decoder Transform stream\n */\nexport function createBcjPpcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjPpc, properties, unpackSize);\n}\n"],"names":["createBcjPpcDecoder","decodeBcjPpc","input","_properties","_unpackSize","output","bufferFrom","pos","length","instr","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,6EAA6E;AAC7E,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,EAAE;AACF,+DAA+D;;;;;;;;;;;;QA4D/CA;eAAAA;;QAxCAC;eAAAA;;;mCAlBW;+EAEQ;;;;;;AAgB5B,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,iCAAiC;QACjC,IAAIC,QAAQ,AAACJ,MAAM,CAACE,IAAI,IAAI,KAAOF,MAAM,CAACE,MAAM,EAAE,IAAI,KAAOF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAKF,MAAM,CAACE,MAAM,EAAE;QAEpG,kEAAkE;QAClE,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,kDAAkD;YAClD,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,0DAA0D;YAC1D,IAAMC,UAAUD,OAAOH;YAEvB,qCAAqC;YACrCE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,0BAA0B;YAC1BN,MAAM,CAACE,IAAI,GAAG,AAACE,UAAU,KAAM;YAC/BJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCJ,MAAM,CAACE,MAAM,EAAE,GAAGE,QAAQ;QAC5B;QACAF,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,oBAAoBY,UAAmB,EAAEC,UAAmB;IAC1E,OAAOC,IAAAA,iCAAsB,EAACb,cAAcW,YAAYC;AAC1D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjSparc.ts"],"sourcesContent":["// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses\n// This filter makes SPARC executables more compressible by LZMA\n//\n// SPARC is big-endian. CALL instructions use 30-bit signed offsets.\n// The filter only transforms CALL instructions with specific byte patterns.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode SPARC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * SPARC CALL instruction matching (big-endian):\n * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR\n * - First byte 0x7F and (second byte & 0xC0) == 0xC0\n *\n * @param input - SPARC BCJ filtered data\n * @param _properties - Unused for SPARC BCJ\n * @param _unpackSize - Unused for SPARC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  var output = bufferFrom(input); // Copy since we modify in place\n  var pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    var b0 = output[pos];\n    var b1 = output[pos + 1];\n\n    // Check for CALL instruction with specific byte patterns:\n    // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)\n    if ((b0 === 0x40 && (b1 & 0xc0) === 0x00) || (b0 === 0x7f && (b1 & 0xc0) === 0xc0)) {\n      // Read 32-bit value (big-endian)\n      var src = (b0 << 24) | (b1 << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n      // Shift left by 2 (multiply by 4 for word addressing)\n      src <<= 2;\n\n      // Decoding: subtract position\n      var dest = src - pos;\n\n      // Shift right by 2\n      dest >>>= 2;\n\n      // Reconstruct with sign extension and opcode\n      // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000\n      var signBit = (dest >>> 22) & 1;\n      var signExtend = signBit ? 0x3fc00000 : 0;\n      dest = signExtend | (dest & 0x3fffff) | 0x40000000;\n\n      // Write back (big-endian)\n      output[pos] = (dest >>> 24) & 0xff;\n      output[pos + 1] = (dest >>> 16) & 0xff;\n      output[pos + 2] = (dest >>> 8) & 0xff;\n      output[pos + 3] = dest & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a SPARC BCJ decoder Transform stream\n */\nexport function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);\n}\n"],"names":["createBcjSparcDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","bufferFrom","pos","length","b0","b1","src","dest","signBit","signExtend","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAiE/CA;eAAAA;;QA9CAC;eAAAA;;;mCAjBW;+EAEQ;;;;;;AAe5B,SAASA,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,IAAIC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAChE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,IAAIC,KAAKJ,MAAM,CAACE,IAAI;QACpB,IAAIG,KAAKL,MAAM,CAACE,MAAM,EAAE;QAExB,0DAA0D;QAC1D,6EAA6E;QAC7E,IAAI,AAACE,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,QAAUD,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,MAAO;YAClF,iCAAiC;YACjC,IAAIC,MAAM,AAACF,MAAM,KAAOC,MAAM,KAAOL,MAAM,CAACE,MAAM,EAAE,IAAI,IAAKF,MAAM,CAACE,MAAM,EAAE;YAE5E,sDAAsD;YACtDI,QAAQ;YAER,8BAA8B;YAC9B,IAAIC,OAAOD,MAAMJ;YAEjB,mBAAmB;YACnBK,UAAU;YAEV,6CAA6C;YAC7C,mFAAmF;YACnF,IAAIC,UAAU,AAACD,SAAS,KAAM;YAC9B,IAAIE,aAAaD,UAAU,aAAa;YACxCD,OAAOE,aAAcF,OAAO,WAAY;YAExC,0BAA0B;YAC1BP,MAAM,CAACE,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BP,MAAM,CAACE,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCP,MAAM,CAACE,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCP,MAAM,CAACE,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,sBAAsBe,UAAmB,EAAEC,UAAmB;IAC5E,OAAOC,IAAAA,iCAAsB,EAAChB,gBAAgBc,YAAYC;AAC5D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjSparc.ts"],"sourcesContent":["// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses\n// This filter makes SPARC executables more compressible by LZMA\n//\n// SPARC is big-endian. CALL instructions use 30-bit signed offsets.\n// The filter only transforms CALL instructions with specific byte patterns.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode SPARC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * SPARC CALL instruction matching (big-endian):\n * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR\n * - First byte 0x7F and (second byte & 0xC0) == 0xC0\n *\n * @param input - SPARC BCJ filtered data\n * @param _properties - Unused for SPARC BCJ\n * @param _unpackSize - Unused for SPARC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    const b0 = output[pos];\n    const b1 = output[pos + 1];\n\n    // Check for CALL instruction with specific byte patterns:\n    // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)\n    if ((b0 === 0x40 && (b1 & 0xc0) === 0x00) || (b0 === 0x7f && (b1 & 0xc0) === 0xc0)) {\n      // Read 32-bit value (big-endian)\n      let src = (b0 << 24) | (b1 << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n      // Shift left by 2 (multiply by 4 for word addressing)\n      src <<= 2;\n\n      // Decoding: subtract position\n      let dest = src - pos;\n\n      // Shift right by 2\n      dest >>>= 2;\n\n      // Reconstruct with sign extension and opcode\n      // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000\n      const signBit = (dest >>> 22) & 1;\n      const signExtend = signBit ? 0x3fc00000 : 0;\n      dest = signExtend | (dest & 0x3fffff) | 0x40000000;\n\n      // Write back (big-endian)\n      output[pos] = (dest >>> 24) & 0xff;\n      output[pos + 1] = (dest >>> 16) & 0xff;\n      output[pos + 2] = (dest >>> 8) & 0xff;\n      output[pos + 3] = dest & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a SPARC BCJ decoder Transform stream\n */\nexport function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);\n}\n"],"names":["createBcjSparcDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","bufferFrom","pos","length","b0","b1","src","dest","signBit","signExtend","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAiE/CA;eAAAA;;QA9CAC;eAAAA;;;mCAjBW;+EAEQ;;;;;;AAe5B,SAASA,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,IAAMC,KAAKJ,MAAM,CAACE,IAAI;QACtB,IAAMG,KAAKL,MAAM,CAACE,MAAM,EAAE;QAE1B,0DAA0D;QAC1D,6EAA6E;QAC7E,IAAI,AAACE,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,QAAUD,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,MAAO;YAClF,iCAAiC;YACjC,IAAIC,MAAM,AAACF,MAAM,KAAOC,MAAM,KAAOL,MAAM,CAACE,MAAM,EAAE,IAAI,IAAKF,MAAM,CAACE,MAAM,EAAE;YAE5E,sDAAsD;YACtDI,QAAQ;YAER,8BAA8B;YAC9B,IAAIC,OAAOD,MAAMJ;YAEjB,mBAAmB;YACnBK,UAAU;YAEV,6CAA6C;YAC7C,mFAAmF;YACnF,IAAMC,UAAU,AAACD,SAAS,KAAM;YAChC,IAAME,aAAaD,UAAU,aAAa;YAC1CD,OAAOE,aAAcF,OAAO,WAAY;YAExC,0BAA0B;YAC1BP,MAAM,CAACE,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BP,MAAM,CAACE,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCP,MAAM,CAACE,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCP,MAAM,CAACE,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,sBAAsBe,UAAmB,EAAEC,UAAmB;IAC5E,OAAOC,IAAAA,iCAAsB,EAAChB,gBAAgBc,YAAYC;AAC5D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode Delta filtered data\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  var distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  var output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  var state = new Array(distance);\n  for (var i = 0; i < distance; i++) {\n    state[i] = 0;\n  }\n\n  for (var j = 0; j < output.length; j++) {\n    var idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a Delta decoder Transform stream\n */\nexport function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeDelta, properties, unpackSize);\n}\n"],"names":["createDeltaDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","bufferFrom","state","Array","i","j","idx","unpackSize","createBufferingDecoder"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;;;;;;;;;;;;QA2C3CA;eAAAA;;QA5BAC;eAAAA;;;mCAbW;+EAEQ;;;;;;AAW5B,SAASA,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,IAAII,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAEhE,uCAAuC;IACvC,IAAIO,QAAQ,IAAIC,MAAML;IACtB,IAAK,IAAIM,IAAI,GAAGA,IAAIN,UAAUM,IAAK;QACjCF,KAAK,CAACE,EAAE,GAAG;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOD,MAAM,EAAEM,IAAK;QACtC,IAAIC,MAAMD,IAAIP;QACdI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGN,MAAM,CAACK,EAAE,GAAI;QACxCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAON;AACT;AAKO,SAASP,mBAAmBG,UAAmB,EAAEW,UAAmB;IACzE,OAAOC,IAAAA,iCAAsB,EAACd,aAAaE,YAAYW;AACzD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode Delta filtered data\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  const state = new Array(distance);\n  for (let i = 0; i < distance; i++) {\n    state[i] = 0;\n  }\n\n  for (let j = 0; j < output.length; j++) {\n    const idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a Delta decoder Transform stream\n */\nexport function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeDelta, properties, unpackSize);\n}\n"],"names":["createDeltaDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","bufferFrom","state","Array","i","j","idx","unpackSize","createBufferingDecoder"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;;;;;;;;;;;;QA2C3CA;eAAAA;;QA5BAC;eAAAA;;;mCAbW;+EAEQ;;;;;;AAW5B,SAASA,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,IAAMI,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,IAAMO,QAAQ,IAAIC,MAAML;IACxB,IAAK,IAAIM,IAAI,GAAGA,IAAIN,UAAUM,IAAK;QACjCF,KAAK,CAACE,EAAE,GAAG;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOD,MAAM,EAAEM,IAAK;QACtC,IAAMC,MAAMD,IAAIP;QAChBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGN,MAAM,CAACK,EAAE,GAAI;QACxCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAON;AACT;AAKO,SAASP,mBAAmBG,UAAmB,EAAEW,UAAmB;IACzE,OAAOC,IAAAA,iCAAsB,EAACd,aAAaE,YAAYW;AACzD"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["import Module from 'module';\n\nvar _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// LZMA codec - uses native lzma-native when available, falls back to lzma-purejs\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n//\n// Native optimization: On Node.js 8+, lzma-native provides liblzma bindings\n// that decode LZMA1 streams natively for better performance.\n// Falls back to lzma-purejs for Node.js 0.8-7.x compatibility.\n\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createNativeLzma1Decoder, hasNativeLzma } from './lzmaCompat.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/\nvar { LZMA } = _require('../../../../assets/lzma-purejs');\nvar LzmaDecoder = LZMA.Decoder;\n\n/**\n * Parse LZMA properties from 5-byte buffer\n * First byte: lc + lp*9 + pb*45\n * Next 4 bytes: dictionary size (little-endian)\n */\nfunction parseLzmaProperties(properties: Buffer): { lc: number; lp: number; pb: number; dictSize: number } {\n  var propByte = properties[0];\n  var lc = propByte % 9;\n  var remainder = Math.floor(propByte / 9);\n  var lp = remainder % 5;\n  var pb = Math.floor(remainder / 5);\n  var dictSize = properties.readUInt32LE(1);\n  return { lc: lc, lp: lp, pb: pb, dictSize: dictSize };\n}\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size (optional, -1 for unknown)\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  var decoder = new LzmaDecoder();\n\n  // setDecoderProperties expects array-like with 5 bytes\n  if (!decoder.setDecoderProperties(properties)) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  var inStream = createInputStream(input, 0, input.length);\n\n  // Use -1 for unknown size (decoder will use end marker)\n  var size = typeof unpackSize === 'number' ? unpackSize : -1;\n\n  // Pre-allocate output stream if size is known (memory optimization)\n  var outStream = createOutputStream(size > 0 ? size : undefined);\n\n  var success = decoder.code(inStream, outStream, size);\n  if (!success) {\n    throw new Error('LZMA decompression failed');\n  }\n\n  return outStream.toBuffer();\n}\n\n/**\n * Create an LZMA decoder Transform stream\n *\n * Uses native lzma-native when available for better performance,\n * falls back to lzma-purejs buffering decoder for Node.js 0.8+ compatibility.\n */\nexport function createLzmaDecoder(properties?: Buffer, _unpackSize?: number): Transform {\n  // Try native decoder first (available on Node.js 8+ with lzma-native installed)\n  if (hasNativeLzma && properties && properties.length >= 5) {\n    var props = parseLzmaProperties(properties);\n    var nativeDecoder = createNativeLzma1Decoder(props.lc, props.lp, props.pb, props.dictSize);\n    if (nativeDecoder) {\n      return nativeDecoder;\n    }\n  }\n\n  // Fall back to buffering decoder with pure JS implementation\n  return createBufferingDecoder(decodeLzma, properties, _unpackSize);\n}\n"],"names":["createLzmaDecoder","decodeLzma","_require","require","Module","createRequire","LZMA","LzmaDecoder","Decoder","parseLzmaProperties","properties","propByte","lc","remainder","Math","floor","lp","pb","dictSize","readUInt32LE","input","unpackSize","length","Error","decoder","setDecoderProperties","inStream","createInputStream","size","outStream","createOutputStream","undefined","success","code","toBuffer","_unpackSize","hasNativeLzma","props","nativeDecoder","createNativeLzma1Decoder","createBufferingDecoder"],"mappings":";;;;;;;;;;;QA8EgBA;eAAAA;;QAlCAC;eAAAA;;;6DA5CG;+EAYgB;4BACqB;yBACF;;;;;;AAZtD,IAAIC,WAAW,OAAOC,YAAY,cAAcC,eAAM,CAACC,aAAa,CAAC,uDAAmBF;AAcxF,sFAAsF;AACtF,4DAA4D;AAC5D,IAAI,AAAEG,OAASJ,SAAS,kCAAlBI;AACN,IAAIC,cAAcD,KAAKE,OAAO;AAE9B;;;;CAIC,GACD,SAASC,oBAAoBC,UAAkB;IAC7C,IAAIC,WAAWD,UAAU,CAAC,EAAE;IAC5B,IAAIE,KAAKD,WAAW;IACpB,IAAIE,YAAYC,KAAKC,KAAK,CAACJ,WAAW;IACtC,IAAIK,KAAKH,YAAY;IACrB,IAAII,KAAKH,KAAKC,KAAK,CAACF,YAAY;IAChC,IAAIK,WAAWR,WAAWS,YAAY,CAAC;IACvC,OAAO;QAAEP,IAAIA;QAAII,IAAIA;QAAIC,IAAIA;QAAIC,UAAUA;IAAS;AACtD;AAUO,SAASjB,WAAWmB,KAAa,EAAEV,UAAmB,EAAEW,UAAmB;IAChF,IAAI,CAACX,cAAcA,WAAWY,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAIC,UAAU,IAAIjB;IAElB,uDAAuD;IACvD,IAAI,CAACiB,QAAQC,oBAAoB,CAACf,aAAa;QAC7C,MAAM,IAAIa,MAAM;IAClB;IAEA,IAAIG,WAAWC,IAAAA,4BAAiB,EAACP,OAAO,GAAGA,MAAME,MAAM;IAEvD,wDAAwD;IACxD,IAAIM,OAAO,OAAOP,eAAe,WAAWA,aAAa,CAAC;IAE1D,oEAAoE;IACpE,IAAIQ,YAAYC,IAAAA,6BAAkB,EAACF,OAAO,IAAIA,OAAOG;IAErD,IAAIC,UAAUR,QAAQS,IAAI,CAACP,UAAUG,WAAWD;IAChD,IAAI,CAACI,SAAS;QACZ,MAAM,IAAIT,MAAM;IAClB;IAEA,OAAOM,UAAUK,QAAQ;AAC3B;AAQO,SAASlC,kBAAkBU,UAAmB,EAAEyB,WAAoB;IACzE,gFAAgF;IAChF,IAAIC,2BAAa,IAAI1B,cAAcA,WAAWY,MAAM,IAAI,GAAG;QACzD,IAAIe,QAAQ5B,oBAAoBC;QAChC,IAAI4B,gBAAgBC,IAAAA,sCAAwB,EAACF,MAAMzB,EAAE,EAAEyB,MAAMrB,EAAE,EAAEqB,MAAMpB,EAAE,EAAEoB,MAAMnB,QAAQ;QACzF,IAAIoB,eAAe;YACjB,OAAOA;QACT;IACF;IAEA,6DAA6D;IAC7D,OAAOE,IAAAA,iCAAsB,EAACvC,YAAYS,YAAYyB;AACxD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["import Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// LZMA codec - uses native lzma-native when available, falls back to lzma-purejs\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n//\n// Native optimization: On Node.js 8+, lzma-native provides liblzma bindings\n// that decode LZMA1 streams natively for better performance.\n// Falls back to lzma-purejs for Node.js 0.8-7.x compatibility.\n\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createNativeLzma1Decoder, hasNativeLzma } from './lzmaCompat.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 * Parse LZMA properties from 5-byte buffer\n * First byte: lc + lp*9 + pb*45\n * Next 4 bytes: dictionary size (little-endian)\n */\nfunction parseLzmaProperties(properties: Buffer): { lc: number; lp: number; pb: number; dictSize: number } {\n  const propByte = properties[0];\n  const lc = propByte % 9;\n  const remainder = Math.floor(propByte / 9);\n  const lp = remainder % 5;\n  const pb = Math.floor(remainder / 5);\n  const dictSize = properties.readUInt32LE(1);\n  return { lc: lc, lp: lp, pb: pb, dictSize: dictSize };\n}\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size (optional, -1 for unknown)\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  const decoder = new LzmaDecoder();\n\n  // setDecoderProperties expects array-like with 5 bytes\n  if (!decoder.setDecoderProperties(properties)) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  const inStream = createInputStream(input, 0, input.length);\n\n  // Use -1 for unknown size (decoder will use end marker)\n  const size = typeof unpackSize === 'number' ? unpackSize : -1;\n\n  // Pre-allocate output stream if size is known (memory optimization)\n  const outStream = createOutputStream(size > 0 ? size : undefined);\n\n  const success = decoder.code(inStream, outStream, size);\n  if (!success) {\n    throw new Error('LZMA decompression failed');\n  }\n\n  return outStream.toBuffer();\n}\n\n/**\n * Create an LZMA decoder Transform stream\n *\n * Uses native lzma-native when available for better performance,\n * falls back to lzma-purejs buffering decoder for Node.js 0.8+ compatibility.\n */\nexport function createLzmaDecoder(properties?: Buffer, _unpackSize?: number): Transform {\n  // Try native decoder first (available on Node.js 8+ with lzma-native installed)\n  if (hasNativeLzma && properties && properties.length >= 5) {\n    const props = parseLzmaProperties(properties);\n    const nativeDecoder = createNativeLzma1Decoder(props.lc, props.lp, props.pb, props.dictSize);\n    if (nativeDecoder) {\n      return nativeDecoder;\n    }\n  }\n\n  // Fall back to buffering decoder with pure JS implementation\n  return createBufferingDecoder(decodeLzma, properties, _unpackSize);\n}\n"],"names":["createLzmaDecoder","decodeLzma","_require","require","Module","createRequire","LZMA","LzmaDecoder","Decoder","parseLzmaProperties","properties","propByte","lc","remainder","Math","floor","lp","pb","dictSize","readUInt32LE","input","unpackSize","length","Error","decoder","setDecoderProperties","inStream","createInputStream","size","outStream","createOutputStream","undefined","success","code","toBuffer","_unpackSize","hasNativeLzma","props","nativeDecoder","createNativeLzma1Decoder","createBufferingDecoder"],"mappings":";;;;;;;;;;;QA8EgBA;eAAAA;;QAlCAC;eAAAA;;;6DA5CG;+EAYgB;4BACqB;yBACF;;;;;;AAZtD,IAAMC,WAAW,OAAOC,YAAY,cAAcC,eAAM,CAACC,aAAa,CAAC,uDAAmBF;AAc1F,sFAAsF;AACtF,4DAA4D;AAC5D,IAAM,AAAEG,OAASJ,SAAS,kCAAlBI;AACR,IAAMC,cAAcD,KAAKE,OAAO;AAEhC;;;;CAIC,GACD,SAASC,oBAAoBC,UAAkB;IAC7C,IAAMC,WAAWD,UAAU,CAAC,EAAE;IAC9B,IAAME,KAAKD,WAAW;IACtB,IAAME,YAAYC,KAAKC,KAAK,CAACJ,WAAW;IACxC,IAAMK,KAAKH,YAAY;IACvB,IAAMI,KAAKH,KAAKC,KAAK,CAACF,YAAY;IAClC,IAAMK,WAAWR,WAAWS,YAAY,CAAC;IACzC,OAAO;QAAEP,IAAIA;QAAII,IAAIA;QAAIC,IAAIA;QAAIC,UAAUA;IAAS;AACtD;AAUO,SAASjB,WAAWmB,KAAa,EAAEV,UAAmB,EAAEW,UAAmB;IAChF,IAAI,CAACX,cAAcA,WAAWY,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAMC,UAAU,IAAIjB;IAEpB,uDAAuD;IACvD,IAAI,CAACiB,QAAQC,oBAAoB,CAACf,aAAa;QAC7C,MAAM,IAAIa,MAAM;IAClB;IAEA,IAAMG,WAAWC,IAAAA,4BAAiB,EAACP,OAAO,GAAGA,MAAME,MAAM;IAEzD,wDAAwD;IACxD,IAAMM,OAAO,OAAOP,eAAe,WAAWA,aAAa,CAAC;IAE5D,oEAAoE;IACpE,IAAMQ,YAAYC,IAAAA,6BAAkB,EAACF,OAAO,IAAIA,OAAOG;IAEvD,IAAMC,UAAUR,QAAQS,IAAI,CAACP,UAAUG,WAAWD;IAClD,IAAI,CAACI,SAAS;QACZ,MAAM,IAAIT,MAAM;IAClB;IAEA,OAAOM,UAAUK,QAAQ;AAC3B;AAQO,SAASlC,kBAAkBU,UAAmB,EAAEyB,WAAoB;IACzE,gFAAgF;IAChF,IAAIC,2BAAa,IAAI1B,cAAcA,WAAWY,MAAM,IAAI,GAAG;QACzD,IAAMe,QAAQ5B,oBAAoBC;QAClC,IAAM4B,gBAAgBC,IAAAA,sCAAwB,EAACF,MAAMzB,EAAE,EAAEyB,MAAMrB,EAAE,EAAEqB,MAAMpB,EAAE,EAAEoB,MAAMnB,QAAQ;QAC3F,IAAIoB,eAAe;YACjB,OAAOA;QACT;IACF;IAEA,6DAA6D;IAC7D,OAAOE,IAAAA,iCAAsB,EAACvC,YAAYS,YAAYyB;AACxD"}

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\nvar _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// LZMA2 codec - uses native lzma-native when available, falls back to 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//\n// Native optimization: On Node.js 8+, lzma-native provides liblzma bindings\n// that decode LZMA2 streams natively for better performance.\n// Falls back to lzma-purejs for Node.js 0.8-7.x compatibility.\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createNativeLzma2Decoder, hasNativeLzma } from './lzmaCompat.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/\nvar { LZMA } = _require('../../../../assets/lzma-purejs');\nvar 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  var base = 2 | (propByte & 1);\n  var 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  var 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  var outputBuffer: Buffer | null = null;\n  var outputPos = 0;\n  var outputChunks: Buffer[] = [];\n\n  if (unpackSize && unpackSize > 0) {\n    outputBuffer = allocBufferUnsafe(unpackSize);\n  }\n\n  var 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  var decoder = new LzmaDecoder() as InstanceType<typeof LzmaDecoder> & {\n    setSolid: (solid: boolean) => 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  var outWindow = (decoder as unknown as { _outWindow: OutWindowType })._outWindow;\n\n  // Track current LZMA properties (lc, lp, pb)\n  var propsSet = false;\n\n  while (offset < input.length) {\n    var 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      var 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      var 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 (var 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      var resetState = control >= 0xa0;\n      var newProps = control >= 0xc0;\n      var dictReset = control >= 0xe0;\n      var 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      var uncompHigh = control & 0x1f;\n      var uncompSize2 = ((uncompHigh << 16) | (input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // Compressed size: 16 bits + 1\n      var 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        var propsByte = input[offset++];\n\n        // Properties byte: pb * 45 + lp * 9 + lc\n        // where pb, lp, lc are LZMA parameters\n        var lc = propsByte % 9;\n        var remainder = Math.floor(propsByte / 9);\n        var lp = remainder % 5;\n        var 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      var inStream = createInputStream(input, offset, compSize);\n      var outStream = createOutputStream(uncompSize2); // Pre-allocate for memory efficiency\n\n      // Set solid mode based on control byte - this preserves state across code() calls\n      decoder.setSolid(useSolidMode);\n\n      // Decode the chunk\n      var success = decoder.code(inStream, outStream, uncompSize2);\n      if (!success) {\n        throw new Error('LZMA decompression failed');\n      }\n\n      var 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 *\n * Uses native lzma-native when available for better performance,\n * falls back to lzma-purejs buffering decoder for Node.js 0.8+ compatibility.\n */\nexport function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  // Try native decoder first (available on Node.js 8+ with lzma-native installed)\n  if (hasNativeLzma && properties && properties.length >= 1) {\n    var dictSize = decodeDictionarySize(properties[0]);\n    var nativeDecoder = createNativeLzma2Decoder(dictSize);\n    if (nativeDecoder) {\n      return nativeDecoder;\n    }\n  }\n\n  // Fall back to buffering decoder with pure JS implementation\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","setSolid","success","code","chunkOutput","toBuffer","toString","Buffer","concat","hasNativeLzma","nativeDecoder","createNativeLzma2Decoder","createBufferingDecoder"],"mappings":"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"}
+{"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 - uses native lzma-native when available, falls back to 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//\n// Native optimization: On Node.js 8+, lzma-native provides liblzma bindings\n// that decode LZMA2 streams natively for better performance.\n// Falls back to lzma-purejs for Node.js 0.8-7.x compatibility.\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createNativeLzma2Decoder, hasNativeLzma } from './lzmaCompat.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    _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      decoder.setSolid(useSolidMode);\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 *\n * Uses native lzma-native when available for better performance,\n * falls back to lzma-purejs buffering decoder for Node.js 0.8+ compatibility.\n */\nexport function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  // Try native decoder first (available on Node.js 8+ with lzma-native installed)\n  if (hasNativeLzma && properties && properties.length >= 1) {\n    const dictSize = decodeDictionarySize(properties[0]);\n    const nativeDecoder = createNativeLzma2Decoder(dictSize);\n    if (nativeDecoder) {\n      return nativeDecoder;\n    }\n  }\n\n  // Fall back to buffering decoder with pure JS implementation\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","setSolid","success","code","chunkOutput","toBuffer","toString","Buffer","concat","hasNativeLzma","nativeDecoder","createNativeLzma2Decoder","createBufferingDecoder"],"mappings":"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"}

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  var 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        var input = Buffer.concat(chunks);\n        var 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,IAAIC,SAAmB,EAAE;IAEzB,OAAO,IAAIN,UAAU;QACnBO,WAAW,SAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAPA,MAAiBF,QAA2B;YAC1C,IAAI;gBACF,IAAIG,QAAQC,OAAOC,MAAM,CAACT;gBAC1B,IAAIU,SAASb,SAASU,OAAOT,YAAYC;gBACzC,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 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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/index.ts"],"sourcesContent":["// Codec registry for 7z decompression\n// Each codec provides a decode function and optionally a streaming decoder\n\nimport type { Transform } from 'readable-stream';\nimport { CodecId, createCodedError, ErrorCode } from '../constants.ts';\nimport { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.ts';\nimport { createBcjDecoder, decodeBcj } from './Bcj.ts';\nimport { createBcj2Decoder, decodeBcj2, decodeBcj2Multi } from './Bcj2.ts';\nimport { createBcjArmDecoder, decodeBcjArm } from './BcjArm.ts';\nimport { createBcjArm64Decoder, decodeBcjArm64 } from './BcjArm64.ts';\nimport { createBcjArmtDecoder, decodeBcjArmt } from './BcjArmt.ts';\nimport { createBcjIa64Decoder, decodeBcjIa64 } from './BcjIa64.ts';\nimport { createBcjPpcDecoder, decodeBcjPpc } from './BcjPpc.ts';\nimport { createBcjSparcDecoder, decodeBcjSparc } from './BcjSparc.ts';\nimport { createBzip2Decoder, decodeBzip2 } from './BZip2.ts';\nimport { createCopyDecoder, decodeCopy } from './Copy.ts';\nimport { createDeflateDecoder, decodeDeflate } from './Deflate.ts';\nimport { createDeltaDecoder, decodeDelta } from './Delta.ts';\nimport { createLzmaDecoder, decodeLzma } from './Lzma.ts';\nimport { createLzma2Decoder, decodeLzma2 } from './Lzma2.ts';\n\n// Re-export password functions for API access\nexport { getPassword, setPassword };\n\nexport interface Codec {\n  decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n  createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;\n}\n\n// Registry of supported codecs\nvar codecs: { [key: string]: Codec } = {};\n\n/**\n * Convert codec ID bytes to a string key\n */\nfunction codecIdToKey(id: number[]): string {\n  var parts: string[] = [];\n  for (var i = 0; i < id.length; i++) {\n    parts.push(id[i].toString(16).toUpperCase());\n  }\n  return parts.join('-');\n}\n\n/**\n * Check if two codec IDs match\n */\nfunction codecIdEquals(a: number[], b: number[]): boolean {\n  if (a.length !== b.length) return false;\n  for (var i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Register a codec\n */\nexport function registerCodec(id: number[], codec: Codec): void {\n  codecs[codecIdToKey(id)] = codec;\n}\n\n/**\n * Get a codec by ID\n * @throws Error if codec is not supported\n */\nexport function getCodec(id: number[]): Codec {\n  var key = codecIdToKey(id);\n  var codec = codecs[key];\n  if (!codec) {\n    throw createCodedError(`Unsupported codec: ${key}`, ErrorCode.UNSUPPORTED_CODEC);\n  }\n  return codec;\n}\n\n/**\n * Check if a codec is supported\n */\nexport function isCodecSupported(id: number[]): boolean {\n  return codecs[codecIdToKey(id)] !== undefined;\n}\n\n/**\n * Get human-readable codec name\n */\nexport function getCodecName(id: number[]): string {\n  if (codecIdEquals(id, CodecId.COPY)) return 'Copy';\n  if (codecIdEquals(id, CodecId.LZMA)) return 'LZMA';\n  if (codecIdEquals(id, CodecId.LZMA2)) return 'LZMA2';\n  if (codecIdEquals(id, CodecId.BCJ_X86)) return 'BCJ (x86)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM)) return 'BCJ (ARM)';\n  if (codecIdEquals(id, CodecId.BCJ_ARMT)) return 'BCJ (ARM Thumb)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM64)) return 'BCJ (ARM64)';\n  if (codecIdEquals(id, CodecId.BCJ_PPC)) return 'BCJ (PowerPC)';\n  if (codecIdEquals(id, CodecId.BCJ_IA64)) return 'BCJ (IA64)';\n  if (codecIdEquals(id, CodecId.BCJ_SPARC)) return 'BCJ (SPARC)';\n  if (codecIdEquals(id, CodecId.BCJ2)) return 'BCJ2';\n  if (codecIdEquals(id, CodecId.PPMD)) return 'PPMd';\n  if (codecIdEquals(id, CodecId.DELTA)) return 'Delta';\n  if (codecIdEquals(id, CodecId.DEFLATE)) return 'Deflate';\n  if (codecIdEquals(id, CodecId.BZIP2)) return 'BZip2';\n  if (codecIdEquals(id, CodecId.AES)) return 'AES-256';\n  return `Unknown (${codecIdToKey(id)})`;\n}\n\n/**\n * Check if a codec ID matches BCJ2\n */\nexport function isBcj2Codec(id: number[]): boolean {\n  return codecIdEquals(id, CodecId.BCJ2);\n}\n\n// Re-export BCJ2 multi-stream decoder for special handling\nexport { decodeBcj2Multi };\n\n// Register built-in codecs\n\n// Copy codec (no compression)\nregisterCodec(CodecId.COPY, {\n  decode: decodeCopy,\n  createDecoder: createCopyDecoder,\n});\n\n// LZMA codec\nregisterCodec(CodecId.LZMA, {\n  decode: decodeLzma,\n  createDecoder: createLzmaDecoder,\n});\n\n// LZMA2 codec\nregisterCodec(CodecId.LZMA2, {\n  decode: decodeLzma2,\n  createDecoder: createLzma2Decoder,\n});\n\n// BCJ (x86) filter\nregisterCodec(CodecId.BCJ_X86, {\n  decode: decodeBcj,\n  createDecoder: createBcjDecoder,\n});\n\n// BCJ (ARM) filter\nregisterCodec(CodecId.BCJ_ARM, {\n  decode: decodeBcjArm,\n  createDecoder: createBcjArmDecoder,\n});\n\n// BCJ (ARM Thumb) filter\nregisterCodec(CodecId.BCJ_ARMT, {\n  decode: decodeBcjArmt,\n  createDecoder: createBcjArmtDecoder,\n});\n\n// BCJ (ARM64) filter\nregisterCodec(CodecId.BCJ_ARM64, {\n  decode: decodeBcjArm64,\n  createDecoder: createBcjArm64Decoder,\n});\n\n// BCJ (PowerPC) filter\nregisterCodec(CodecId.BCJ_PPC, {\n  decode: decodeBcjPpc,\n  createDecoder: createBcjPpcDecoder,\n});\n\n// BCJ (IA64) filter\nregisterCodec(CodecId.BCJ_IA64, {\n  decode: decodeBcjIa64,\n  createDecoder: createBcjIa64Decoder,\n});\n\n// BCJ (SPARC) filter\nregisterCodec(CodecId.BCJ_SPARC, {\n  decode: decodeBcjSparc,\n  createDecoder: createBcjSparcDecoder,\n});\n\n// Delta filter\nregisterCodec(CodecId.DELTA, {\n  decode: decodeDelta,\n  createDecoder: createDeltaDecoder,\n});\n\n// Deflate codec\nregisterCodec(CodecId.DEFLATE, {\n  decode: decodeDeflate,\n  createDecoder: createDeflateDecoder,\n});\n\n// BZip2 codec\nregisterCodec(CodecId.BZIP2, {\n  decode: decodeBzip2,\n  createDecoder: createBzip2Decoder,\n});\n\n// AES-256-CBC codec (encryption)\nregisterCodec(CodecId.AES, {\n  decode: decodeAes,\n  createDecoder: createAesDecoder,\n});\n\n// BCJ2 (x86-64) filter - multi-stream\n// Note: BCJ2 requires special handling in SevenZipParser due to 4-stream architecture\nregisterCodec(CodecId.BCJ2, {\n  decode: decodeBcj2,\n  createDecoder: createBcj2Decoder,\n});\n\n// Note: PPMd codec is not implemented. See FUTURE_ENHANCEMENTS.md\n"],"names":["decodeBcj2Multi","getCodec","getCodecName","getPassword","isBcj2Codec","isCodecSupported","registerCodec","setPassword","codecs","codecIdToKey","id","parts","i","length","push","toString","toUpperCase","join","codecIdEquals","a","b","codec","key","createCodedError","ErrorCode","UNSUPPORTED_CODEC","undefined","CodecId","COPY","LZMA","LZMA2","BCJ_X86","BCJ_ARM","BCJ_ARMT","BCJ_ARM64","BCJ_PPC","BCJ_IA64","BCJ_SPARC","BCJ2","PPMD","DELTA","DEFLATE","BZIP2","AES","decode","decodeCopy","createDecoder","createCopyDecoder","decodeLzma","createLzmaDecoder","decodeLzma2","createLzma2Decoder","decodeBcj","createBcjDecoder","decodeBcjArm","createBcjArmDecoder","decodeBcjArmt","createBcjArmtDecoder","decodeBcjArm64","createBcjArm64Decoder","decodeBcjPpc","createBcjPpcDecoder","decodeBcjIa64","createBcjIa64Decoder","decodeBcjSparc","createBcjSparcDecoder","decodeDelta","createDeltaDecoder","decodeDeflate","createDeflateDecoder","decodeBzip2","createBzip2Decoder","decodeAes","createAesDecoder","decodeBcj2","createBcj2Decoder"],"mappings":"AAAA,sCAAsC;AACtC,2EAA2E;;;;;;;;;;;;QA+GlEA;eAAAA,uBAAe;;QA/CRC;eAAAA;;QAmBAC;eAAAA;;QA9DPC;eAAAA,kBAAW;;QAqFJC;eAAAA;;QA9BAC;eAAAA;;QApBAC;eAAAA;;QAnCMC;eAAAA,kBAAW;;;2BAlBoB;qBACiB;qBAC1B;sBACmB;wBACb;0BACI;yBACF;yBACA;wBACF;0BACI;uBACN;sBACF;yBACM;uBACJ;sBACF;uBACE;AAUhD,+BAA+B;AAC/B,IAAIC,SAAmC,CAAC;AAExC;;CAEC,GACD,SAASC,aAAaC,EAAY;IAChC,IAAIC,QAAkB,EAAE;IACxB,IAAK,IAAIC,IAAI,GAAGA,IAAIF,GAAGG,MAAM,EAAED,IAAK;QAClCD,MAAMG,IAAI,CAACJ,EAAE,CAACE,EAAE,CAACG,QAAQ,CAAC,IAAIC,WAAW;IAC3C;IACA,OAAOL,MAAMM,IAAI,CAAC;AACpB;AAEA;;CAEC,GACD,SAASC,cAAcC,CAAW,EAAEC,CAAW;IAC7C,IAAID,EAAEN,MAAM,KAAKO,EAAEP,MAAM,EAAE,OAAO;IAClC,IAAK,IAAID,IAAI,GAAGA,IAAIO,EAAEN,MAAM,EAAED,IAAK;QACjC,IAAIO,CAAC,CAACP,EAAE,KAAKQ,CAAC,CAACR,EAAE,EAAE,OAAO;IAC5B;IACA,OAAO;AACT;AAKO,SAASN,cAAcI,EAAY,EAAEW,KAAY;IACtDb,MAAM,CAACC,aAAaC,IAAI,GAAGW;AAC7B;AAMO,SAASpB,SAASS,EAAY;IACnC,IAAIY,MAAMb,aAAaC;IACvB,IAAIW,QAAQb,MAAM,CAACc,IAAI;IACvB,IAAI,CAACD,OAAO;QACV,MAAME,IAAAA,6BAAgB,EAAC,AAAC,sBAAyB,OAAJD,MAAOE,sBAAS,CAACC,iBAAiB;IACjF;IACA,OAAOJ;AACT;AAKO,SAAShB,iBAAiBK,EAAY;IAC3C,OAAOF,MAAM,CAACC,aAAaC,IAAI,KAAKgB;AACtC;AAKO,SAASxB,aAAaQ,EAAY;IACvC,IAAIQ,cAAcR,IAAIiB,oBAAO,CAACC,IAAI,GAAG,OAAO;IAC5C,IAAIV,cAAcR,IAAIiB,oBAAO,CAACE,IAAI,GAAG,OAAO;IAC5C,IAAIX,cAAcR,IAAIiB,oBAAO,CAACG,KAAK,GAAG,OAAO;IAC7C,IAAIZ,cAAcR,IAAIiB,oBAAO,CAACI,OAAO,GAAG,OAAO;IAC/C,IAAIb,cAAcR,IAAIiB,oBAAO,CAACK,OAAO,GAAG,OAAO;IAC/C,IAAId,cAAcR,IAAIiB,oBAAO,CAACM,QAAQ,GAAG,OAAO;IAChD,IAAIf,cAAcR,IAAIiB,oBAAO,CAACO,SAAS,GAAG,OAAO;IACjD,IAAIhB,cAAcR,IAAIiB,oBAAO,CAACQ,OAAO,GAAG,OAAO;IAC/C,IAAIjB,cAAcR,IAAIiB,oBAAO,CAACS,QAAQ,GAAG,OAAO;IAChD,IAAIlB,cAAcR,IAAIiB,oBAAO,CAACU,SAAS,GAAG,OAAO;IACjD,IAAInB,cAAcR,IAAIiB,oBAAO,CAACW,IAAI,GAAG,OAAO;IAC5C,IAAIpB,cAAcR,IAAIiB,oBAAO,CAACY,IAAI,GAAG,OAAO;IAC5C,IAAIrB,cAAcR,IAAIiB,oBAAO,CAACa,KAAK,GAAG,OAAO;IAC7C,IAAItB,cAAcR,IAAIiB,oBAAO,CAACc,OAAO,GAAG,OAAO;IAC/C,IAAIvB,cAAcR,IAAIiB,oBAAO,CAACe,KAAK,GAAG,OAAO;IAC7C,IAAIxB,cAAcR,IAAIiB,oBAAO,CAACgB,GAAG,GAAG,OAAO;IAC3C,OAAO,AAAC,YAA4B,OAAjBlC,aAAaC,KAAI;AACtC;AAKO,SAASN,YAAYM,EAAY;IACtC,OAAOQ,cAAcR,IAAIiB,oBAAO,CAACW,IAAI;AACvC;AAKA,2BAA2B;AAE3B,8BAA8B;AAC9BhC,cAAcqB,oBAAO,CAACC,IAAI,EAAE;IAC1BgB,QAAQC,kBAAU;IAClBC,eAAeC,yBAAiB;AAClC;AAEA,aAAa;AACbzC,cAAcqB,oBAAO,CAACE,IAAI,EAAE;IAC1Be,QAAQI,kBAAU;IAClBF,eAAeG,yBAAiB;AAClC;AAEA,cAAc;AACd3C,cAAcqB,oBAAO,CAACG,KAAK,EAAE;IAC3Bc,QAAQM,oBAAW;IACnBJ,eAAeK,2BAAkB;AACnC;AAEA,mBAAmB;AACnB7C,cAAcqB,oBAAO,CAACI,OAAO,EAAE;IAC7Ba,QAAQQ,gBAAS;IACjBN,eAAeO,uBAAgB;AACjC;AAEA,mBAAmB;AACnB/C,cAAcqB,oBAAO,CAACK,OAAO,EAAE;IAC7BY,QAAQU,sBAAY;IACpBR,eAAeS,6BAAmB;AACpC;AAEA,yBAAyB;AACzBjD,cAAcqB,oBAAO,CAACM,QAAQ,EAAE;IAC9BW,QAAQY,wBAAa;IACrBV,eAAeW,+BAAoB;AACrC;AAEA,qBAAqB;AACrBnD,cAAcqB,oBAAO,CAACO,SAAS,EAAE;IAC/BU,QAAQc,0BAAc;IACtBZ,eAAea,iCAAqB;AACtC;AAEA,uBAAuB;AACvBrD,cAAcqB,oBAAO,CAACQ,OAAO,EAAE;IAC7BS,QAAQgB,sBAAY;IACpBd,eAAee,6BAAmB;AACpC;AAEA,oBAAoB;AACpBvD,cAAcqB,oBAAO,CAACS,QAAQ,EAAE;IAC9BQ,QAAQkB,wBAAa;IACrBhB,eAAeiB,+BAAoB;AACrC;AAEA,qBAAqB;AACrBzD,cAAcqB,oBAAO,CAACU,SAAS,EAAE;IAC/BO,QAAQoB,0BAAc;IACtBlB,eAAemB,iCAAqB;AACtC;AAEA,eAAe;AACf3D,cAAcqB,oBAAO,CAACa,KAAK,EAAE;IAC3BI,QAAQsB,oBAAW;IACnBpB,eAAeqB,2BAAkB;AACnC;AAEA,gBAAgB;AAChB7D,cAAcqB,oBAAO,CAACc,OAAO,EAAE;IAC7BG,QAAQwB,wBAAa;IACrBtB,eAAeuB,+BAAoB;AACrC;AAEA,cAAc;AACd/D,cAAcqB,oBAAO,CAACe,KAAK,EAAE;IAC3BE,QAAQ0B,oBAAW;IACnBxB,eAAeyB,2BAAkB;AACnC;AAEA,iCAAiC;AACjCjE,cAAcqB,oBAAO,CAACgB,GAAG,EAAE;IACzBC,QAAQ4B,gBAAS;IACjB1B,eAAe2B,uBAAgB;AACjC;AAEA,sCAAsC;AACtC,sFAAsF;AACtFnE,cAAcqB,oBAAO,CAACW,IAAI,EAAE;IAC1BM,QAAQ8B,kBAAU;IAClB5B,eAAe6B,yBAAiB;AAClC,IAEA,kEAAkE"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/index.ts"],"sourcesContent":["// Codec registry for 7z decompression\n// Each codec provides a decode function and optionally a streaming decoder\n\nimport type { Transform } from 'readable-stream';\nimport { CodecId, createCodedError, ErrorCode } from '../constants.ts';\nimport { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.ts';\nimport { createBcjDecoder, decodeBcj } from './Bcj.ts';\nimport { createBcj2Decoder, decodeBcj2, decodeBcj2Multi } from './Bcj2.ts';\nimport { createBcjArmDecoder, decodeBcjArm } from './BcjArm.ts';\nimport { createBcjArm64Decoder, decodeBcjArm64 } from './BcjArm64.ts';\nimport { createBcjArmtDecoder, decodeBcjArmt } from './BcjArmt.ts';\nimport { createBcjIa64Decoder, decodeBcjIa64 } from './BcjIa64.ts';\nimport { createBcjPpcDecoder, decodeBcjPpc } from './BcjPpc.ts';\nimport { createBcjSparcDecoder, decodeBcjSparc } from './BcjSparc.ts';\nimport { createBzip2Decoder, decodeBzip2 } from './BZip2.ts';\nimport { createCopyDecoder, decodeCopy } from './Copy.ts';\nimport { createDeflateDecoder, decodeDeflate } from './Deflate.ts';\nimport { createDeltaDecoder, decodeDelta } from './Delta.ts';\nimport { createLzmaDecoder, decodeLzma } from './Lzma.ts';\nimport { createLzma2Decoder, decodeLzma2 } from './Lzma2.ts';\n\n// Re-export password functions for API access\nexport { getPassword, setPassword };\n\nexport interface Codec {\n  decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n  createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;\n}\n\n// Registry of supported codecs\nconst codecs: { [key: string]: Codec } = {};\n\n/**\n * Convert codec ID bytes to a string key\n */\nfunction codecIdToKey(id: number[]): string {\n  const parts: string[] = [];\n  for (let i = 0; i < id.length; i++) {\n    parts.push(id[i].toString(16).toUpperCase());\n  }\n  return parts.join('-');\n}\n\n/**\n * Check if two codec IDs match\n */\nfunction codecIdEquals(a: number[], b: number[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Register a codec\n */\nexport function registerCodec(id: number[], codec: Codec): void {\n  codecs[codecIdToKey(id)] = codec;\n}\n\n/**\n * Get a codec by ID\n * @throws Error if codec is not supported\n */\nexport function getCodec(id: number[]): Codec {\n  const key = codecIdToKey(id);\n  const codec = codecs[key];\n  if (!codec) {\n    throw createCodedError(`Unsupported codec: ${key}`, ErrorCode.UNSUPPORTED_CODEC);\n  }\n  return codec;\n}\n\n/**\n * Check if a codec is supported\n */\nexport function isCodecSupported(id: number[]): boolean {\n  return codecs[codecIdToKey(id)] !== undefined;\n}\n\n/**\n * Get human-readable codec name\n */\nexport function getCodecName(id: number[]): string {\n  if (codecIdEquals(id, CodecId.COPY)) return 'Copy';\n  if (codecIdEquals(id, CodecId.LZMA)) return 'LZMA';\n  if (codecIdEquals(id, CodecId.LZMA2)) return 'LZMA2';\n  if (codecIdEquals(id, CodecId.BCJ_X86)) return 'BCJ (x86)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM)) return 'BCJ (ARM)';\n  if (codecIdEquals(id, CodecId.BCJ_ARMT)) return 'BCJ (ARM Thumb)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM64)) return 'BCJ (ARM64)';\n  if (codecIdEquals(id, CodecId.BCJ_PPC)) return 'BCJ (PowerPC)';\n  if (codecIdEquals(id, CodecId.BCJ_IA64)) return 'BCJ (IA64)';\n  if (codecIdEquals(id, CodecId.BCJ_SPARC)) return 'BCJ (SPARC)';\n  if (codecIdEquals(id, CodecId.BCJ2)) return 'BCJ2';\n  if (codecIdEquals(id, CodecId.PPMD)) return 'PPMd';\n  if (codecIdEquals(id, CodecId.DELTA)) return 'Delta';\n  if (codecIdEquals(id, CodecId.DEFLATE)) return 'Deflate';\n  if (codecIdEquals(id, CodecId.BZIP2)) return 'BZip2';\n  if (codecIdEquals(id, CodecId.AES)) return 'AES-256';\n  return `Unknown (${codecIdToKey(id)})`;\n}\n\n/**\n * Check if a codec ID matches BCJ2\n */\nexport function isBcj2Codec(id: number[]): boolean {\n  return codecIdEquals(id, CodecId.BCJ2);\n}\n\n// Re-export BCJ2 multi-stream decoder for special handling\nexport { decodeBcj2Multi };\n\n// Register built-in codecs\n\n// Copy codec (no compression)\nregisterCodec(CodecId.COPY, {\n  decode: decodeCopy,\n  createDecoder: createCopyDecoder,\n});\n\n// LZMA codec\nregisterCodec(CodecId.LZMA, {\n  decode: decodeLzma,\n  createDecoder: createLzmaDecoder,\n});\n\n// LZMA2 codec\nregisterCodec(CodecId.LZMA2, {\n  decode: decodeLzma2,\n  createDecoder: createLzma2Decoder,\n});\n\n// BCJ (x86) filter\nregisterCodec(CodecId.BCJ_X86, {\n  decode: decodeBcj,\n  createDecoder: createBcjDecoder,\n});\n\n// BCJ (ARM) filter\nregisterCodec(CodecId.BCJ_ARM, {\n  decode: decodeBcjArm,\n  createDecoder: createBcjArmDecoder,\n});\n\n// BCJ (ARM Thumb) filter\nregisterCodec(CodecId.BCJ_ARMT, {\n  decode: decodeBcjArmt,\n  createDecoder: createBcjArmtDecoder,\n});\n\n// BCJ (ARM64) filter\nregisterCodec(CodecId.BCJ_ARM64, {\n  decode: decodeBcjArm64,\n  createDecoder: createBcjArm64Decoder,\n});\n\n// BCJ (PowerPC) filter\nregisterCodec(CodecId.BCJ_PPC, {\n  decode: decodeBcjPpc,\n  createDecoder: createBcjPpcDecoder,\n});\n\n// BCJ (IA64) filter\nregisterCodec(CodecId.BCJ_IA64, {\n  decode: decodeBcjIa64,\n  createDecoder: createBcjIa64Decoder,\n});\n\n// BCJ (SPARC) filter\nregisterCodec(CodecId.BCJ_SPARC, {\n  decode: decodeBcjSparc,\n  createDecoder: createBcjSparcDecoder,\n});\n\n// Delta filter\nregisterCodec(CodecId.DELTA, {\n  decode: decodeDelta,\n  createDecoder: createDeltaDecoder,\n});\n\n// Deflate codec\nregisterCodec(CodecId.DEFLATE, {\n  decode: decodeDeflate,\n  createDecoder: createDeflateDecoder,\n});\n\n// BZip2 codec\nregisterCodec(CodecId.BZIP2, {\n  decode: decodeBzip2,\n  createDecoder: createBzip2Decoder,\n});\n\n// AES-256-CBC codec (encryption)\nregisterCodec(CodecId.AES, {\n  decode: decodeAes,\n  createDecoder: createAesDecoder,\n});\n\n// BCJ2 (x86-64) filter - multi-stream\n// Note: BCJ2 requires special handling in SevenZipParser due to 4-stream architecture\nregisterCodec(CodecId.BCJ2, {\n  decode: decodeBcj2,\n  createDecoder: createBcj2Decoder,\n});\n\n// Note: PPMd codec is not implemented. See FUTURE_ENHANCEMENTS.md\n"],"names":["decodeBcj2Multi","getCodec","getCodecName","getPassword","isBcj2Codec","isCodecSupported","registerCodec","setPassword","codecs","codecIdToKey","id","parts","i","length","push","toString","toUpperCase","join","codecIdEquals","a","b","codec","key","createCodedError","ErrorCode","UNSUPPORTED_CODEC","undefined","CodecId","COPY","LZMA","LZMA2","BCJ_X86","BCJ_ARM","BCJ_ARMT","BCJ_ARM64","BCJ_PPC","BCJ_IA64","BCJ_SPARC","BCJ2","PPMD","DELTA","DEFLATE","BZIP2","AES","decode","decodeCopy","createDecoder","createCopyDecoder","decodeLzma","createLzmaDecoder","decodeLzma2","createLzma2Decoder","decodeBcj","createBcjDecoder","decodeBcjArm","createBcjArmDecoder","decodeBcjArmt","createBcjArmtDecoder","decodeBcjArm64","createBcjArm64Decoder","decodeBcjPpc","createBcjPpcDecoder","decodeBcjIa64","createBcjIa64Decoder","decodeBcjSparc","createBcjSparcDecoder","decodeDelta","createDeltaDecoder","decodeDeflate","createDeflateDecoder","decodeBzip2","createBzip2Decoder","decodeAes","createAesDecoder","decodeBcj2","createBcj2Decoder"],"mappings":"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"}

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

@@ -9,7 +9,7 @@
  * the callback-based async pattern used throughout the iterator libraries.
  */
 import type { Transform } from 'readable-stream';
-export declare var hasNativeLzma: boolean;
+export declare const hasNativeLzma: boolean;
 /**
  * Create a native LZMA2 decoder stream
  * Returns a Transform stream that decodes LZMA2 data

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

@@ -9,7 +9,7 @@
  * the callback-based async pattern used throughout the iterator libraries.
  */
 import type { Transform } from 'readable-stream';
-export declare var hasNativeLzma: boolean;
+export declare const hasNativeLzma: boolean;
 /**
  * Create a native LZMA2 decoder stream
  * Returns a Transform stream that decodes LZMA2 data

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/lzmaCompat.ts"],"sourcesContent":["/**\n * LZMA compatibility layer - uses native lzma when available, falls back to lzma-purejs\n *\n * lzma-native provides native liblzma bindings with rawDecoder support.\n * This gives significant performance improvements on Node.js 8+ while\n * maintaining compatibility with Node.js 0.8+ via lzma-purejs fallback.\n *\n * The native decoder uses Node.js streams which integrate naturally with\n * the callback-based async pattern used throughout the iterator libraries.\n */\n\nimport Module from 'module';\nimport type { Transform } from 'readable-stream';\n\nvar _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Try to load lzma-native (only on Node 10+ where ES6 class syntax is supported)\n// Note: We must check the version BEFORE requiring because syntax errors during\n// module parsing cannot be caught by try/catch\nvar lzmaNative: typeof import('lzma-native') | null = null;\nvar _hasNativeLzmaLib = false;\nvar major = +process.versions.node.split('.')[0];\n\nif (major >= 10) {\n  try {\n    lzmaNative = _require('lzma-native');\n    // Verify rawDecoder support\n    _hasNativeLzmaLib = lzmaNative !== null && typeof lzmaNative.createStream === 'function';\n  } catch (_e) {\n    // lzma-native not available - will use lzma-purejs\n  }\n}\n\n// Export whether native lzma is available for streaming\nexport var hasNativeLzma = _hasNativeLzmaLib;\n\n/**\n * Create a native LZMA2 decoder stream\n * Returns a Transform stream that decodes LZMA2 data\n *\n * Note: Native LZMA2 decoder disabled due to LZMA_DATA_ERROR issues with\n * lzma-native's rawDecoder for LZMA2. The native decoder fails partway through\n * decompression on certain archives (e.g., Node.js Windows releases), reporting\n * \"Data is corrupt\" even when the data is valid. Falls back to lzma-purejs\n * which handles all LZMA2 streams correctly.\n *\n * @param _dictSize - Dictionary size (unused, native disabled)\n * @returns null - always falls back to pure JS decoder\n */\nexport function createNativeLzma2Decoder(_dictSize?: number): Transform | null {\n  // Native LZMA2 disabled - lzma-native's rawDecoder has issues with certain\n  // LZMA2 streams (LZMA_DATA_ERROR: Data is corrupt), even when data is valid.\n  // The pure JS lzma-purejs implementation handles all streams correctly.\n  return null;\n}\n\n/**\n * Create a native LZMA1 decoder stream\n * Returns a Transform stream that decodes LZMA1 data\n *\n * Note: Native LZMA1 decoder disabled due to LZMA_BUF_ERROR issues with\n * lzma-native's rawDecoder for LZMA1. Falls back to lzma-purejs which\n * handles 7z's LZMA1 format correctly. LZMA2 native works fine.\n *\n * @param _lc - Literal context bits (0-8)\n * @param _lp - Literal position bits (0-4)\n * @param _pb - Position bits (0-4)\n * @param _dictSize - Dictionary size\n * @returns null - always falls back to pure JS decoder\n */\nexport function createNativeLzma1Decoder(_lc: number, _lp: number, _pb: number, _dictSize: number): Transform | null {\n  // Native LZMA1 disabled - lzma-native's rawDecoder has issues with 7z's LZMA1 format\n  // (LZMA_BUF_ERROR: No progress is possible)\n  // LZMA2 native works correctly and is more common in modern 7z files\n  return null;\n}\n"],"names":["createNativeLzma1Decoder","createNativeLzma2Decoder","hasNativeLzma","_require","require","Module","createRequire","lzmaNative","_hasNativeLzmaLib","major","process","versions","node","split","createStream","_e","_dictSize","_lc","_lp","_pb"],"mappings":"AAAA;;;;;;;;;CASC;;;;;;;;;;;QA6DeA;eAAAA;;QArBAC;eAAAA;;QAfLC;eAAAA;;;6DAvBQ;;;;;;AAGnB,IAAIC,WAAW,OAAOC,YAAY,cAAcC,eAAM,CAACC,aAAa,CAAC,uDAAmBF;AAExF,iFAAiF;AACjF,gFAAgF;AAChF,+CAA+C;AAC/C,IAAIG,aAAkD;AACtD,IAAIC,oBAAoB;AACxB,IAAIC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAEhD,IAAIJ,SAAS,IAAI;IACf,IAAI;QACFF,aAAaJ,SAAS;QACtB,4BAA4B;QAC5BK,oBAAoBD,eAAe,QAAQ,OAAOA,WAAWO,YAAY,KAAK;IAChF,EAAE,OAAOC,IAAI;IACX,mDAAmD;IACrD;AACF;AAGO,IAAIb,gBAAgBM;AAepB,SAASP,yBAAyBe,SAAkB;IACzD,2EAA2E;IAC3E,6EAA6E;IAC7E,wEAAwE;IACxE,OAAO;AACT;AAgBO,SAAShB,yBAAyBiB,GAAW,EAAEC,GAAW,EAAEC,GAAW,EAAEH,SAAiB;IAC/F,qFAAqF;IACrF,4CAA4C;IAC5C,qEAAqE;IACrE,OAAO;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/lzmaCompat.ts"],"sourcesContent":["/**\n * LZMA compatibility layer - uses native lzma when available, falls back to lzma-purejs\n *\n * lzma-native provides native liblzma bindings with rawDecoder support.\n * This gives significant performance improvements on Node.js 8+ while\n * maintaining compatibility with Node.js 0.8+ via lzma-purejs fallback.\n *\n * The native decoder uses Node.js streams which integrate naturally with\n * the callback-based async pattern used throughout the iterator libraries.\n */\n\nimport Module from 'module';\nimport type { Transform } from 'readable-stream';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Try to load lzma-native (only on Node 10+ where ES6 class syntax is supported)\n// Note: We must check the version BEFORE requiring because syntax errors during\n// module parsing cannot be caught by try/catch\nlet lzmaNative: typeof import('lzma-native') | null = null;\nlet _hasNativeLzmaLib = false;\nconst major = +process.versions.node.split('.')[0];\n\nif (major >= 10) {\n  try {\n    lzmaNative = _require('lzma-native');\n    // Verify rawDecoder support\n    _hasNativeLzmaLib = lzmaNative !== null && typeof lzmaNative.createStream === 'function';\n  } catch (_e) {\n    // lzma-native not available - will use lzma-purejs\n  }\n}\n\n// Export whether native lzma is available for streaming\nexport const hasNativeLzma = _hasNativeLzmaLib;\n\n/**\n * Create a native LZMA2 decoder stream\n * Returns a Transform stream that decodes LZMA2 data\n *\n * Note: Native LZMA2 decoder disabled due to LZMA_DATA_ERROR issues with\n * lzma-native's rawDecoder for LZMA2. The native decoder fails partway through\n * decompression on certain archives (e.g., Node.js Windows releases), reporting\n * \"Data is corrupt\" even when the data is valid. Falls back to lzma-purejs\n * which handles all LZMA2 streams correctly.\n *\n * @param _dictSize - Dictionary size (unused, native disabled)\n * @returns null - always falls back to pure JS decoder\n */\nexport function createNativeLzma2Decoder(_dictSize?: number): Transform | null {\n  // Native LZMA2 disabled - lzma-native's rawDecoder has issues with certain\n  // LZMA2 streams (LZMA_DATA_ERROR: Data is corrupt), even when data is valid.\n  // The pure JS lzma-purejs implementation handles all streams correctly.\n  return null;\n}\n\n/**\n * Create a native LZMA1 decoder stream\n * Returns a Transform stream that decodes LZMA1 data\n *\n * Note: Native LZMA1 decoder disabled due to LZMA_BUF_ERROR issues with\n * lzma-native's rawDecoder for LZMA1. Falls back to lzma-purejs which\n * handles 7z's LZMA1 format correctly. LZMA2 native works fine.\n *\n * @param _lc - Literal context bits (0-8)\n * @param _lp - Literal position bits (0-4)\n * @param _pb - Position bits (0-4)\n * @param _dictSize - Dictionary size\n * @returns null - always falls back to pure JS decoder\n */\nexport function createNativeLzma1Decoder(_lc: number, _lp: number, _pb: number, _dictSize: number): Transform | null {\n  // Native LZMA1 disabled - lzma-native's rawDecoder has issues with 7z's LZMA1 format\n  // (LZMA_BUF_ERROR: No progress is possible)\n  // LZMA2 native works correctly and is more common in modern 7z files\n  return null;\n}\n"],"names":["createNativeLzma1Decoder","createNativeLzma2Decoder","hasNativeLzma","_require","require","Module","createRequire","lzmaNative","_hasNativeLzmaLib","major","process","versions","node","split","createStream","_e","_dictSize","_lc","_lp","_pb"],"mappings":"AAAA;;;;;;;;;CASC;;;;;;;;;;;QA6DeA;eAAAA;;QArBAC;eAAAA;;QAfHC;eAAAA;;;6DAvBM;;;;;;AAGnB,IAAMC,WAAW,OAAOC,YAAY,cAAcC,eAAM,CAACC,aAAa,CAAC,uDAAmBF;AAE1F,iFAAiF;AACjF,gFAAgF;AAChF,+CAA+C;AAC/C,IAAIG,aAAkD;AACtD,IAAIC,oBAAoB;AACxB,IAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAElD,IAAIJ,SAAS,IAAI;IACf,IAAI;QACFF,aAAaJ,SAAS;QACtB,4BAA4B;QAC5BK,oBAAoBD,eAAe,QAAQ,OAAOA,WAAWO,YAAY,KAAK;IAChF,EAAE,OAAOC,IAAI;IACX,mDAAmD;IACrD;AACF;AAGO,IAAMb,gBAAgBM;AAetB,SAASP,yBAAyBe,SAAkB;IACzD,2EAA2E;IAC3E,6EAA6E;IAC7E,wEAAwE;IACxE,OAAO;AACT;AAgBO,SAAShB,yBAAyBiB,GAAW,EAAEC,GAAW,EAAEC,GAAW,EAAEH,SAAiB;IAC/F,qFAAqF;IACrF,4CAA4C;IAC5C,qEAAqE;IACrE,OAAO;AACT"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/streams.ts"],"sourcesContent":["// Shared stream wrappers for lzma-purejs codec interface\n// These adapters convert between Buffer/lzma-purejs stream interfaces\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\n\n/**\n * Input stream wrapper for lzma-purejs\n * Wraps a Buffer region as a readable stream interface\n */\nexport function createInputStream(buffer: Buffer, offset: number, length: number) {\n  var pos = 0;\n  var end = Math.min(offset + length, buffer.length);\n  var start = offset;\n\n  return {\n    readByte: (): number => {\n      if (start + pos >= end) return -1;\n      return buffer[start + pos++];\n    },\n    read: (buf: number[], bufOffset: number, len: number): number => {\n      var bytesRead = 0;\n      while (bytesRead < len && start + pos < end) {\n        buf[bufOffset + bytesRead] = buffer[start + pos];\n        pos++;\n        bytesRead++;\n      }\n      return bytesRead === 0 ? -1 : bytesRead;\n    },\n  };\n}\n\n/**\n * Output stream wrapper for lzma-purejs\n * Collects output bytes into Buffer chunks\n * Uses typed arrays for memory efficiency (1 byte per element instead of 8)\n *\n * Memory optimization: If expectedSize is provided, pre-allocates a single buffer\n * to avoid double-memory during Buffer.concat.\n *\n * @param expectedSize - Optional expected output size for pre-allocation\n */\nexport function createOutputStream(expectedSize?: number) {\n  // Pre-allocation mode: single buffer, no concat needed\n  // Includes bounds checking for safety on older Node.js versions\n  if (expectedSize && expectedSize > 0) {\n    var buffer = allocBufferUnsafe(expectedSize);\n    var bufPos = 0;\n    var bufLen = buffer.length;\n\n    return {\n      writeByte: (b: number): void => {\n        if (bufPos < bufLen) {\n          buffer[bufPos++] = b;\n        }\n        // Silently ignore overflow (should not happen with correct size)\n      },\n      write: (buf: number[], bufOffset: number, len: number): number => {\n        for (var i = 0; i < len && bufPos < bufLen; i++) {\n          buffer[bufPos++] = buf[bufOffset + i];\n        }\n        return len;\n      },\n      flush: (): void => {\n        // No-op for pre-allocated buffer\n      },\n      toBuffer: (): Buffer => {\n        // Return only the used portion\n        return bufPos < buffer.length ? buffer.slice(0, bufPos) : buffer;\n      },\n    };\n  }\n\n  // Chunked mode: accumulate in 64KB chunks (fallback for unknown size)\n  var chunks: Buffer[] = [];\n  var CHUNK_SIZE = 65536; // 64KB chunks for better memory efficiency\n  var currentChunk: Buffer = allocBufferUnsafe(CHUNK_SIZE);\n  var pos = 0;\n\n  return {\n    writeByte: (b: number): void => {\n      currentChunk[pos++] = b;\n      if (pos >= CHUNK_SIZE) {\n        chunks.push(currentChunk);\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    write: function (buf: number[], bufOffset: number, len: number): number {\n      for (var i = 0; i < len; i++) {\n        this.writeByte(buf[bufOffset + i]);\n      }\n      return len;\n    },\n    flush: (): void => {\n      if (pos > 0) {\n        // Only keep the used portion of the current chunk\n        chunks.push(currentChunk.slice(0, pos));\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    toBuffer: function (): Buffer {\n      this.flush();\n      // Optimization: if single chunk, return it directly\n      if (chunks.length === 1) {\n        return chunks[0];\n      }\n      return Buffer.concat(chunks);\n    },\n  };\n}\n"],"names":["createInputStream","createOutputStream","buffer","offset","length","pos","end","Math","min","start","readByte","read","buf","bufOffset","len","bytesRead","expectedSize","allocBufferUnsafe","bufPos","bufLen","writeByte","b","write","i","flush","toBuffer","slice","chunks","CHUNK_SIZE","currentChunk","push","Buffer","concat"],"mappings":"AAAA,yDAAyD;AACzD,sEAAsE;;;;;;;;;;;;QAQtDA;eAAAA;;QAgCAC;eAAAA;;;mCAtCkB;AAM3B,SAASD,kBAAkBE,MAAc,EAAEC,MAAc,EAAEC,MAAc;IAC9E,IAAIC,MAAM;IACV,IAAIC,MAAMC,KAAKC,GAAG,CAACL,SAASC,QAAQF,OAAOE,MAAM;IACjD,IAAIK,QAAQN;IAEZ,OAAO;QACLO,UAAU;YACR,IAAID,QAAQJ,OAAOC,KAAK,OAAO,CAAC;YAChC,OAAOJ,MAAM,CAACO,QAAQJ,MAAM;QAC9B;QACAM,MAAM,SAACC,KAAeC,WAAmBC;YACvC,IAAIC,YAAY;YAChB,MAAOA,YAAYD,OAAOL,QAAQJ,MAAMC,IAAK;gBAC3CM,GAAG,CAACC,YAAYE,UAAU,GAAGb,MAAM,CAACO,QAAQJ,IAAI;gBAChDA;gBACAU;YACF;YACA,OAAOA,cAAc,IAAI,CAAC,IAAIA;QAChC;IACF;AACF;AAYO,SAASd,mBAAmBe,YAAqB;IACtD,uDAAuD;IACvD,gEAAgE;IAChE,IAAIA,gBAAgBA,eAAe,GAAG;QACpC,IAAId,SAASe,IAAAA,sCAAiB,EAACD;QAC/B,IAAIE,SAAS;QACb,IAAIC,SAASjB,OAAOE,MAAM;QAE1B,OAAO;YACLgB,WAAW,SAACC;gBACV,IAAIH,SAASC,QAAQ;oBACnBjB,MAAM,CAACgB,SAAS,GAAGG;gBACrB;YACA,iEAAiE;YACnE;YACAC,OAAO,SAACV,KAAeC,WAAmBC;gBACxC,IAAK,IAAIS,IAAI,GAAGA,IAAIT,OAAOI,SAASC,QAAQI,IAAK;oBAC/CrB,MAAM,CAACgB,SAAS,GAAGN,GAAG,CAACC,YAAYU,EAAE;gBACvC;gBACA,OAAOT;YACT;YACAU,OAAO;YACL,iCAAiC;YACnC;YACAC,UAAU;gBACR,+BAA+B;gBAC/B,OAAOP,SAAShB,OAAOE,MAAM,GAAGF,OAAOwB,KAAK,CAAC,GAAGR,UAAUhB;YAC5D;QACF;IACF;IAEA,sEAAsE;IACtE,IAAIyB,SAAmB,EAAE;IACzB,IAAIC,aAAa,OAAO,2CAA2C;IACnE,IAAIC,eAAuBZ,IAAAA,sCAAiB,EAACW;IAC7C,IAAIvB,MAAM;IAEV,OAAO;QACLe,WAAW,SAACC;YACVQ,YAAY,CAACxB,MAAM,GAAGgB;YACtB,IAAIhB,OAAOuB,YAAY;gBACrBD,OAAOG,IAAI,CAACD;gBACZA,eAAeZ,IAAAA,sCAAiB,EAACW;gBACjCvB,MAAM;YACR;QACF;QACAiB,OAAO,SAAPA,MAAiBV,GAAa,EAAEC,SAAiB,EAAEC,GAAW;YAC5D,IAAK,IAAIS,IAAI,GAAGA,IAAIT,KAAKS,IAAK;gBAC5B,IAAI,CAACH,SAAS,CAACR,GAAG,CAACC,YAAYU,EAAE;YACnC;YACA,OAAOT;QACT;QACAU,OAAO;YACL,IAAInB,MAAM,GAAG;gBACX,kDAAkD;gBAClDsB,OAAOG,IAAI,CAACD,aAAaH,KAAK,CAAC,GAAGrB;gBAClCwB,eAAeZ,IAAAA,sCAAiB,EAACW;gBACjCvB,MAAM;YACR;QACF;QACAoB,UAAU,SAAVA;YACE,IAAI,CAACD,KAAK;YACV,oDAAoD;YACpD,IAAIG,OAAOvB,MAAM,KAAK,GAAG;gBACvB,OAAOuB,MAAM,CAAC,EAAE;YAClB;YACA,OAAOI,OAAOC,MAAM,CAACL;QACvB;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/streams.ts"],"sourcesContent":["// Shared stream wrappers for lzma-purejs codec interface\n// These adapters convert between Buffer/lzma-purejs stream interfaces\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\n\n/**\n * Input stream wrapper for lzma-purejs\n * Wraps a Buffer region as a readable stream interface\n */\nexport function createInputStream(buffer: Buffer, offset: number, length: number) {\n  let pos = 0;\n  const end = Math.min(offset + length, buffer.length);\n  const start = offset;\n\n  return {\n    readByte: (): number => {\n      if (start + pos >= end) return -1;\n      return buffer[start + pos++];\n    },\n    read: (buf: number[], bufOffset: number, len: number): number => {\n      let bytesRead = 0;\n      while (bytesRead < len && start + pos < end) {\n        buf[bufOffset + bytesRead] = buffer[start + pos];\n        pos++;\n        bytesRead++;\n      }\n      return bytesRead === 0 ? -1 : bytesRead;\n    },\n  };\n}\n\n/**\n * Output stream wrapper for lzma-purejs\n * Collects output bytes into Buffer chunks\n * Uses typed arrays for memory efficiency (1 byte per element instead of 8)\n *\n * Memory optimization: If expectedSize is provided, pre-allocates a single buffer\n * to avoid double-memory during Buffer.concat.\n *\n * @param expectedSize - Optional expected output size for pre-allocation\n */\nexport function createOutputStream(expectedSize?: number) {\n  // Pre-allocation mode: single buffer, no concat needed\n  // Includes bounds checking for safety on older Node.js versions\n  if (expectedSize && expectedSize > 0) {\n    const buffer = allocBufferUnsafe(expectedSize);\n    let bufPos = 0;\n    const bufLen = buffer.length;\n\n    return {\n      writeByte: (b: number): void => {\n        if (bufPos < bufLen) {\n          buffer[bufPos++] = b;\n        }\n        // Silently ignore overflow (should not happen with correct size)\n      },\n      write: (buf: number[], bufOffset: number, len: number): number => {\n        for (let i = 0; i < len && bufPos < bufLen; i++) {\n          buffer[bufPos++] = buf[bufOffset + i];\n        }\n        return len;\n      },\n      flush: (): void => {\n        // No-op for pre-allocated buffer\n      },\n      toBuffer: (): Buffer => {\n        // Return only the used portion\n        return bufPos < buffer.length ? buffer.slice(0, bufPos) : buffer;\n      },\n    };\n  }\n\n  // Chunked mode: accumulate in 64KB chunks (fallback for unknown size)\n  const chunks: Buffer[] = [];\n  const CHUNK_SIZE = 65536; // 64KB chunks for better memory efficiency\n  let currentChunk: Buffer = allocBufferUnsafe(CHUNK_SIZE);\n  let pos = 0;\n\n  return {\n    writeByte: (b: number): void => {\n      currentChunk[pos++] = b;\n      if (pos >= CHUNK_SIZE) {\n        chunks.push(currentChunk);\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    write: function (buf: number[], bufOffset: number, len: number): number {\n      for (let i = 0; i < len; i++) {\n        this.writeByte(buf[bufOffset + i]);\n      }\n      return len;\n    },\n    flush: (): void => {\n      if (pos > 0) {\n        // Only keep the used portion of the current chunk\n        chunks.push(currentChunk.slice(0, pos));\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    toBuffer: function (): Buffer {\n      this.flush();\n      // Optimization: if single chunk, return it directly\n      if (chunks.length === 1) {\n        return chunks[0];\n      }\n      return Buffer.concat(chunks);\n    },\n  };\n}\n"],"names":["createInputStream","createOutputStream","buffer","offset","length","pos","end","Math","min","start","readByte","read","buf","bufOffset","len","bytesRead","expectedSize","allocBufferUnsafe","bufPos","bufLen","writeByte","b","write","i","flush","toBuffer","slice","chunks","CHUNK_SIZE","currentChunk","push","Buffer","concat"],"mappings":"AAAA,yDAAyD;AACzD,sEAAsE;;;;;;;;;;;;QAQtDA;eAAAA;;QAgCAC;eAAAA;;;mCAtCkB;AAM3B,SAASD,kBAAkBE,MAAc,EAAEC,MAAc,EAAEC,MAAc;IAC9E,IAAIC,MAAM;IACV,IAAMC,MAAMC,KAAKC,GAAG,CAACL,SAASC,QAAQF,OAAOE,MAAM;IACnD,IAAMK,QAAQN;IAEd,OAAO;QACLO,UAAU;YACR,IAAID,QAAQJ,OAAOC,KAAK,OAAO,CAAC;YAChC,OAAOJ,MAAM,CAACO,QAAQJ,MAAM;QAC9B;QACAM,MAAM,SAACC,KAAeC,WAAmBC;YACvC,IAAIC,YAAY;YAChB,MAAOA,YAAYD,OAAOL,QAAQJ,MAAMC,IAAK;gBAC3CM,GAAG,CAACC,YAAYE,UAAU,GAAGb,MAAM,CAACO,QAAQJ,IAAI;gBAChDA;gBACAU;YACF;YACA,OAAOA,cAAc,IAAI,CAAC,IAAIA;QAChC;IACF;AACF;AAYO,SAASd,mBAAmBe,YAAqB;IACtD,uDAAuD;IACvD,gEAAgE;IAChE,IAAIA,gBAAgBA,eAAe,GAAG;QACpC,IAAMd,SAASe,IAAAA,sCAAiB,EAACD;QACjC,IAAIE,SAAS;QACb,IAAMC,SAASjB,OAAOE,MAAM;QAE5B,OAAO;YACLgB,WAAW,SAACC;gBACV,IAAIH,SAASC,QAAQ;oBACnBjB,MAAM,CAACgB,SAAS,GAAGG;gBACrB;YACA,iEAAiE;YACnE;YACAC,OAAO,SAACV,KAAeC,WAAmBC;gBACxC,IAAK,IAAIS,IAAI,GAAGA,IAAIT,OAAOI,SAASC,QAAQI,IAAK;oBAC/CrB,MAAM,CAACgB,SAAS,GAAGN,GAAG,CAACC,YAAYU,EAAE;gBACvC;gBACA,OAAOT;YACT;YACAU,OAAO;YACL,iCAAiC;YACnC;YACAC,UAAU;gBACR,+BAA+B;gBAC/B,OAAOP,SAAShB,OAAOE,MAAM,GAAGF,OAAOwB,KAAK,CAAC,GAAGR,UAAUhB;YAC5D;QACF;IACF;IAEA,sEAAsE;IACtE,IAAMyB,SAAmB,EAAE;IAC3B,IAAMC,aAAa,OAAO,2CAA2C;IACrE,IAAIC,eAAuBZ,IAAAA,sCAAiB,EAACW;IAC7C,IAAIvB,MAAM;IAEV,OAAO;QACLe,WAAW,SAACC;YACVQ,YAAY,CAACxB,MAAM,GAAGgB;YACtB,IAAIhB,OAAOuB,YAAY;gBACrBD,OAAOG,IAAI,CAACD;gBACZA,eAAeZ,IAAAA,sCAAiB,EAACW;gBACjCvB,MAAM;YACR;QACF;QACAiB,OAAO,SAAPA,MAAiBV,GAAa,EAAEC,SAAiB,EAAEC,GAAW;YAC5D,IAAK,IAAIS,IAAI,GAAGA,IAAIT,KAAKS,IAAK;gBAC5B,IAAI,CAACH,SAAS,CAACR,GAAG,CAACC,YAAYU,EAAE;YACnC;YACA,OAAOT;QACT;QACAU,OAAO;YACL,IAAInB,MAAM,GAAG;gBACX,kDAAkD;gBAClDsB,OAAOG,IAAI,CAACD,aAAaH,KAAK,CAAC,GAAGrB;gBAClCwB,eAAeZ,IAAAA,sCAAiB,EAACW;gBACjCvB,MAAM;YACR;QACF;QACAoB,UAAU,SAAVA;YACE,IAAI,CAACD,KAAK;YACV,oDAAoD;YACpD,IAAIG,OAAOvB,MAAM,KAAK,GAAG;gBACvB,OAAOuB,MAAM,CAAC,EAAE;YAClB;YACA,OAAOI,OAAOC,MAAM,CAACL;QACvB;IACF;AACF"}