7z-iterator 0.1.10 → 0.2.0

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

@@ -0,0 +1,66 @@
+// BCJ (ARM Thumb) filter codec - converts ARM Thumb branch instruction addresses
+// This filter makes ARM Thumb executables more compressible by LZMA
+//
+// ARM Thumb uses 16-bit instructions, but BL (branch with link) spans two 16-bit words.
+// The filter converts relative addresses to absolute during compression.
+//
+// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
+import { bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode ARM Thumb BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * ARM Thumb BL instruction format (2 x 16-bit):
+ * - First half-word: 1111 0xxx xxxx xxxx (high bits of offset)
+ * - Second half-word: 1111 1xxx xxxx xxxx (low bits of offset)
+ *
+ * @param input - ARM Thumb BCJ filtered data
+ * @param _properties - Unused for ARM Thumb BCJ
+ * @param _unpackSize - Unused for ARM Thumb BCJ
+ * @returns Unfiltered data
+ */ export function decodeBcjArmt(input, _properties, _unpackSize) {
+    var output = bufferFrom(input); // Copy since we modify in place
+    var pos = 0;
+    // Process 2-byte aligned positions
+    while(pos + 4 <= output.length){
+        // Read two 16-bit values (little-endian)
+        var w0 = output[pos] | output[pos + 1] << 8;
+        var w1 = output[pos + 2] | output[pos + 3] << 8;
+        // Check for BL instruction pair:
+        // First word: 0xF000-0xF7FF (1111 0xxx xxxx xxxx)
+        // Second word: 0xF800-0xFFFF (1111 1xxx xxxx xxxx)
+        if ((w0 & 0xf800) === 0xf000 && (w1 & 0xf800) === 0xf800) {
+            // Extract and combine the offset parts
+            // High 11 bits from w0, low 11 bits from w1
+            var hi = w0 & 0x7ff;
+            var lo = w1 & 0x7ff;
+            // Combine into 22-bit offset (in half-words)
+            var addr = hi << 11 | lo;
+            // Sign-extend 22-bit to 32-bit
+            if (addr & 0x200000) {
+                addr |= 0xffc00000;
+            }
+            // Convert absolute to relative:
+            // Subtract current position (in half-words, so divide by 2)
+            // Thumb PC is 2 half-words (4 bytes) ahead
+            var relAddr = addr - (pos >>> 1);
+            // Write back
+            var newHi = relAddr >>> 11 & 0x7ff;
+            var newLo = relAddr & 0x7ff;
+            output[pos] = newHi & 0xff;
+            output[pos + 1] = 0xf0 | newHi >>> 8 & 0x07;
+            output[pos + 2] = newLo & 0xff;
+            output[pos + 3] = 0xf8 | newLo >>> 8 & 0x07;
+            pos += 4;
+        } else {
+            pos += 2;
+        }
+    }
+    return output;
+}
+/**
+ * Create an ARM Thumb BCJ decoder Transform stream
+ */ export function createBcjArmtDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeBcjArmt, properties, unpackSize);
+}

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

@@ -0,0 +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":["bufferFrom","createBufferingDecoder","decodeBcjArmt","input","_properties","_unpackSize","output","pos","length","w0","w1","hi","lo","addr","relAddr","newHi","newLo","createBcjArmtDecoder","properties","unpackSize"],"mappings":"AAAA,iFAAiF;AACjF,oEAAoE;AACpE,EAAE;AACF,wFAAwF;AACxF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,IAAIC,SAASN,WAAWG,QAAQ,gCAAgC;IAChE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,yCAAyC;QACzC,IAAIC,KAAKH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI;QAC3C,IAAIG,KAAKJ,MAAM,CAACC,MAAM,EAAE,GAAID,MAAM,CAACC,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;YAEtBR,MAAM,CAACC,IAAI,GAAGQ,QAAQ;YACtBT,MAAM,CAACC,MAAM,EAAE,GAAG,OAAQ,AAACQ,UAAU,IAAK;YAC1CT,MAAM,CAACC,MAAM,EAAE,GAAGS,QAAQ;YAC1BV,MAAM,CAACC,MAAM,EAAE,GAAG,OAAQ,AAACS,UAAU,IAAK;YAE1CT,OAAO;QACT,OAAO;YACLA,OAAO;QACT;IACF;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASW,qBAAqBC,UAAmB,EAAEC,UAAmB;IAC3E,OAAOlB,uBAAuBC,eAAegB,YAAYC;AAC3D"}

package/dist/esm/sevenz/codecs/BcjIa64.d.ts

@@ -0,0 +1,15 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode IA64 BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * @param input - IA64 BCJ filtered data
+ * @param _properties - Unused for IA64 BCJ
+ * @param _unpackSize - Unused for IA64 BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcjIa64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create an IA64 BCJ decoder Transform stream
+ */
+export declare function createBcjIa64Decoder(properties?: Buffer, unpackSize?: number): Transform;

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

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

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

@@ -0,0 +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":["bufferFrom","createBufferingDecoder","kBranchTable","decodeBcjIa64","input","_properties","_unpackSize","output","pos","length","template","mask","slot","bitPos","bytePos","bitOffset","instr0","instr1","instr2","instr3","instr4","instr5","instrLo","instrHi","opcode","imm20","sign","addr","relAddr","newImm20","newSign","createBcjIa64Decoder","properties","unpackSize"],"mappings":"AAAA,+EAA+E;AAC/E,+DAA+D;AAC/D,EAAE;AACF,wEAAwE;AACxE,8DAA8D;AAC9D,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE,oCAAoC;AACpC,oEAAoE;AACpE,IAAIC,eAAe;IAAC;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;CAAE;AAEnH;;;;;;;;CAQC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,IAAIC,SAASP,WAAWI,QAAQ,gCAAgC;IAChE,IAAII,MAAM;IAEV,kCAAkC;IAClC,MAAOA,MAAM,MAAMD,OAAOE,MAAM,CAAE;QAChC,0CAA0C;QAC1C,IAAIC,WAAWH,MAAM,CAACC,IAAI,GAAG;QAC7B,IAAIG,OAAOT,YAAY,CAACQ,SAAS;QAEjC,mDAAmD;QACnD,IAAK,IAAIE,OAAO,GAAGA,OAAO,GAAGA,OAAQ;YACnC,IAAI,AAACD,CAAAA,OAAQ,KAAKC,IAAI,MAAO,GAAG;gBAC9B;YACF;YAEA,uCAAuC;YACvC,6DAA6D;YAC7D,IAAIC,SAAS,IAAID,OAAO;YACxB,IAAIE,UAAUD,WAAW;YACzB,IAAIE,YAAYF,SAAS;YAEzB,uDAAuD;YACvD,oDAAoD;YACpD,IAAIL,MAAMM,UAAU,IAAIP,OAAOE,MAAM,EAAE;gBACrC;YACF;YAEA,4BAA4B;YAC5B,IAAIO,SAAST,MAAM,CAACC,MAAMM,QAAQ;YAClC,IAAIG,SAASV,MAAM,CAACC,MAAMM,UAAU,EAAE;YACtC,IAAII,SAASX,MAAM,CAACC,MAAMM,UAAU,EAAE;YACtC,IAAIK,SAASZ,MAAM,CAACC,MAAMM,UAAU,EAAE;YACtC,IAAIM,SAASb,MAAM,CAACC,MAAMM,UAAU,EAAE;YACtC,IAAIO,SAASd,MAAM,CAACC,MAAMM,UAAU,EAAE;YAEtC,6DAA6D;YAC7D,8DAA8D;YAC9D,8BAA8B;YAE9B,yEAAyE;YACzE,IAAIQ,UAAU,AAACN,WAAWD,YAAcE,UAAW,IAAIF,YAAeG,UAAW,KAAKH,YAAeI,UAAW,KAAKJ;YAErH,IAAIQ,UAAU,AAACH,WAAWL,YAAcM,UAAW,IAAIN;YAEvD,wDAAwD;YACxD,IAAIS,SAAS,AAACD,YAAa,KAAK,KAAKR,YAAc;YACnD,IAAIS,WAAW,KAAKA,WAAW,GAAG;gBAChC;YACF;YAEA,sDAAsD;YACtD,IAAIC,QAAQ,AAACH,YAAY,KAAM;YAC/B,IAAII,OAAO,AAACH,YAAa,KAAK,KAAO;YAErC,mCAAmC;YACnC,IAAII,OAAOF,QAASC,QAAQ;YAC5B,IAAIA,MAAM;gBACRC,QAAQ,YAAY,cAAc;YACpC;YAEA,uEAAuE;YACvE,IAAIC,UAAUD,OAAQnB,CAAAA,QAAQ,CAAA;YAE9B,aAAa;YACb,IAAIqB,WAAWD,UAAU;YACzB,IAAIE,UAAU,AAACF,YAAY,KAAM;YAEjC,wCAAwC;YACxCN,UAAU,AAACA,UAAU,CAAE,CAAA,WAAW,EAAC,IAAOO,YAAY;YACtDN,UAAU,AAACA,UAAU,CAAE,CAAA,KAAM,KAAK,EAAE,IAAOO,WAAY,KAAK;YAE5D,mBAAmB;YACnBvB,MAAM,CAACC,MAAMM,QAAQ,GAAG,AAACP,MAAM,CAACC,MAAMM,QAAQ,GAAI,AAAC,CAAA,KAAKC,SAAQ,IAAK,IAAO,AAACO,CAAAA,UAAU,IAAG,KAAMP;YAChGR,MAAM,CAACC,MAAMM,UAAU,EAAE,GAAG,AAACQ,YAAa,IAAIP,YAAc;YAC5DR,MAAM,CAACC,MAAMM,UAAU,EAAE,GAAG,AAACQ,YAAa,KAAKP,YAAc;YAC7DR,MAAM,CAACC,MAAMM,UAAU,EAAE,GAAG,AAACQ,YAAa,KAAKP,YAAc;YAC7DR,MAAM,CAACC,MAAMM,UAAU,EAAE,GAAG,AAAEQ,YAAa,KAAKP,YAAe,AAAC,CAAA,KAAKA,SAAQ,IAAK,IAAO,AAACQ,CAAAA,UAAU,IAAG,KAAMR;YAC7GR,MAAM,CAACC,MAAMM,UAAU,EAAE,GAAG,AAACP,MAAM,CAACC,MAAMM,UAAU,EAAE,GAAG,CAAE,CAAA,AAAC,CAAA,KAAKC,SAAQ,IAAK,CAAA,IAAO,AAACQ,YAAa,IAAIR,YAAe,AAAC,CAAA,KAAKA,SAAQ,IAAK;QAC3I;QAEAP,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASwB,qBAAqBC,UAAmB,EAAEC,UAAmB;IAC3E,OAAOhC,uBAAuBE,eAAe6B,YAAYC;AAC3D"}

package/dist/esm/sevenz/codecs/BcjPpc.d.ts

@@ -0,0 +1,20 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode PowerPC BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * PowerPC B/BL instruction format (big-endian):
+ * - 4 bytes aligned
+ * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)
+ * - Bits 6-29 are 24-bit signed offset (in words)
+ *
+ * @param input - PowerPC BCJ filtered data
+ * @param _properties - Unused for PowerPC BCJ
+ * @param _unpackSize - Unused for PowerPC BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcjPpc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a PowerPC BCJ decoder Transform stream
+ */
+export declare function createBcjPpcDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,55 @@
+// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses
+// This filter makes PowerPC executables more compressible by LZMA
+//
+// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.
+//
+// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
+import { bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode PowerPC BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * PowerPC B/BL instruction format (big-endian):
+ * - 4 bytes aligned
+ * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)
+ * - Bits 6-29 are 24-bit signed offset (in words)
+ *
+ * @param input - PowerPC BCJ filtered data
+ * @param _properties - Unused for PowerPC BCJ
+ * @param _unpackSize - Unused for PowerPC BCJ
+ * @returns Unfiltered data
+ */ export function decodeBcjPpc(input, _properties, _unpackSize) {
+    var output = bufferFrom(input); // Copy since we modify in place
+    var pos = 0;
+    // Process 4-byte aligned positions
+    while(pos + 4 <= output.length){
+        // Read 32-bit value (big-endian)
+        var instr = output[pos] << 24 | output[pos + 1] << 16 | output[pos + 2] << 8 | output[pos + 3];
+        // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001
+        if ((instr & 0xfc000003) === 0x48000001) {
+            // Extract 26-bit offset (bits 2-27, the LI field)
+            var addr = instr & 0x03fffffc;
+            // Sign-extend 26-bit to 32-bit
+            if (addr & 0x02000000) {
+                addr |= 0xfc000000;
+            }
+            // Convert absolute to relative: subtract current position
+            var relAddr = addr - pos;
+            // Clear old offset and write new one
+            instr = instr & 0xfc000003 | relAddr & 0x03fffffc;
+            // Write back (big-endian)
+            output[pos] = instr >>> 24 & 0xff;
+            output[pos + 1] = instr >>> 16 & 0xff;
+            output[pos + 2] = instr >>> 8 & 0xff;
+            output[pos + 3] = instr & 0xff;
+        }
+        pos += 4;
+    }
+    return output;
+}
+/**
+ * Create a PowerPC BCJ decoder Transform stream
+ */ export function createBcjPpcDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeBcjPpc, properties, unpackSize);
+}

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

@@ -0,0 +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":["bufferFrom","createBufferingDecoder","decodeBcjPpc","input","_properties","_unpackSize","output","pos","length","instr","addr","relAddr","createBcjPpcDecoder","properties","unpackSize"],"mappings":"AAAA,6EAA6E;AAC7E,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAIC,SAASN,WAAWG,QAAQ,gCAAgC;IAChE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,iCAAiC;QACjC,IAAIC,QAAQ,AAACH,MAAM,CAACC,IAAI,IAAI,KAAOD,MAAM,CAACC,MAAM,EAAE,IAAI,KAAOD,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,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;YAC1BL,MAAM,CAACC,IAAI,GAAG,AAACE,UAAU,KAAM;YAC/BH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCH,MAAM,CAACC,MAAM,EAAE,GAAGE,QAAQ;QAC5B;QACAF,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,oBAAoBC,UAAmB,EAAEC,UAAmB;IAC1E,OAAOb,uBAAuBC,cAAcW,YAAYC;AAC1D"}

package/dist/esm/sevenz/codecs/BcjSparc.d.ts

@@ -0,0 +1,19 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode SPARC BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * SPARC CALL instruction matching (big-endian):
+ * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR
+ * - First byte 0x7F and (second byte & 0xC0) == 0xC0
+ *
+ * @param input - SPARC BCJ filtered data
+ * @param _properties - Unused for SPARC BCJ
+ * @param _unpackSize - Unused for SPARC BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a SPARC BCJ decoder Transform stream
+ */
+export declare function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,59 @@
+// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses
+// This filter makes SPARC executables more compressible by LZMA
+//
+// SPARC is big-endian. CALL instructions use 30-bit signed offsets.
+// The filter only transforms CALL instructions with specific byte patterns.
+//
+// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
+import { bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode SPARC BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * SPARC CALL instruction matching (big-endian):
+ * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR
+ * - First byte 0x7F and (second byte & 0xC0) == 0xC0
+ *
+ * @param input - SPARC BCJ filtered data
+ * @param _properties - Unused for SPARC BCJ
+ * @param _unpackSize - Unused for SPARC BCJ
+ * @returns Unfiltered data
+ */ export function decodeBcjSparc(input, _properties, _unpackSize) {
+    var output = bufferFrom(input); // Copy since we modify in place
+    var pos = 0;
+    // Process 4-byte aligned positions
+    while(pos + 4 <= output.length){
+        var b0 = output[pos];
+        var b1 = output[pos + 1];
+        // Check for CALL instruction with specific byte patterns:
+        // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)
+        if (b0 === 0x40 && (b1 & 0xc0) === 0x00 || b0 === 0x7f && (b1 & 0xc0) === 0xc0) {
+            // Read 32-bit value (big-endian)
+            var src = b0 << 24 | b1 << 16 | output[pos + 2] << 8 | output[pos + 3];
+            // Shift left by 2 (multiply by 4 for word addressing)
+            src <<= 2;
+            // Decoding: subtract position
+            var dest = src - pos;
+            // Shift right by 2
+            dest >>>= 2;
+            // Reconstruct with sign extension and opcode
+            // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000
+            var signBit = dest >>> 22 & 1;
+            var signExtend = signBit ? 0x3fc00000 : 0;
+            dest = signExtend | dest & 0x3fffff | 0x40000000;
+            // Write back (big-endian)
+            output[pos] = dest >>> 24 & 0xff;
+            output[pos + 1] = dest >>> 16 & 0xff;
+            output[pos + 2] = dest >>> 8 & 0xff;
+            output[pos + 3] = dest & 0xff;
+        }
+        pos += 4;
+    }
+    return output;
+}
+/**
+ * Create a SPARC BCJ decoder Transform stream
+ */ export function createBcjSparcDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);
+}

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

@@ -0,0 +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":["bufferFrom","createBufferingDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","pos","length","b0","b1","src","dest","signBit","signExtend","createBcjSparcDecoder","properties","unpackSize"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,IAAIC,SAASN,WAAWG,QAAQ,gCAAgC;IAChE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,IAAIC,KAAKH,MAAM,CAACC,IAAI;QACpB,IAAIG,KAAKJ,MAAM,CAACC,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,KAAOJ,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,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;YAC1BN,MAAM,CAACC,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCN,MAAM,CAACC,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASS,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOhB,uBAAuBC,gBAAgBc,YAAYC;AAC5D"}

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

@@ -4,6 +4,12 @@ import { CodecId, createCodedError, ErrorCode } from '../constants.js';
 import { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.js';
 import { createBcjDecoder, decodeBcj } from './Bcj.js';
 import { createBcj2Decoder, decodeBcj2, decodeBcj2Multi } from './Bcj2.js';
+import { createBcjArmDecoder, decodeBcjArm } from './BcjArm.js';
+import { createBcjArm64Decoder, decodeBcjArm64 } from './BcjArm64.js';
+import { createBcjArmtDecoder, decodeBcjArmt } from './BcjArmt.js';
+import { createBcjIa64Decoder, decodeBcjIa64 } from './BcjIa64.js';
+import { createBcjPpcDecoder, decodeBcjPpc } from './BcjPpc.js';
+import { createBcjSparcDecoder, decodeBcjSparc } from './BcjSparc.js';
 import { createBzip2Decoder, decodeBzip2 } from './BZip2.js';
 import { createCopyDecoder, decodeCopy } from './Copy.js';
 import { createDeflateDecoder, decodeDeflate } from './Deflate.js';
@@ -60,7 +66,14 @@ var codecs = {};
     if (codecIdEquals(id, CodecId.LZMA)) return 'LZMA';
     if (codecIdEquals(id, CodecId.LZMA2)) return 'LZMA2';
     if (codecIdEquals(id, CodecId.BCJ_X86)) return 'BCJ (x86)';
+    if (codecIdEquals(id, CodecId.BCJ_ARM)) return 'BCJ (ARM)';
+    if (codecIdEquals(id, CodecId.BCJ_ARMT)) return 'BCJ (ARM Thumb)';
+    if (codecIdEquals(id, CodecId.BCJ_ARM64)) return 'BCJ (ARM64)';
+    if (codecIdEquals(id, CodecId.BCJ_PPC)) return 'BCJ (PowerPC)';
+    if (codecIdEquals(id, CodecId.BCJ_IA64)) return 'BCJ (IA64)';
+    if (codecIdEquals(id, CodecId.BCJ_SPARC)) return 'BCJ (SPARC)';
     if (codecIdEquals(id, CodecId.BCJ2)) return 'BCJ2';
+    if (codecIdEquals(id, CodecId.PPMD)) return 'PPMd';
     if (codecIdEquals(id, CodecId.DELTA)) return 'Delta';
     if (codecIdEquals(id, CodecId.DEFLATE)) return 'Deflate';
     if (codecIdEquals(id, CodecId.BZIP2)) return 'BZip2';
@@ -95,6 +108,36 @@ registerCodec(CodecId.BCJ_X86, {
     decode: decodeBcj,
     createDecoder: createBcjDecoder
 });
+// BCJ (ARM) filter
+registerCodec(CodecId.BCJ_ARM, {
+    decode: decodeBcjArm,
+    createDecoder: createBcjArmDecoder
+});
+// BCJ (ARM Thumb) filter
+registerCodec(CodecId.BCJ_ARMT, {
+    decode: decodeBcjArmt,
+    createDecoder: createBcjArmtDecoder
+});
+// BCJ (ARM64) filter
+registerCodec(CodecId.BCJ_ARM64, {
+    decode: decodeBcjArm64,
+    createDecoder: createBcjArm64Decoder
+});
+// BCJ (PowerPC) filter
+registerCodec(CodecId.BCJ_PPC, {
+    decode: decodeBcjPpc,
+    createDecoder: createBcjPpcDecoder
+});
+// BCJ (IA64) filter
+registerCodec(CodecId.BCJ_IA64, {
+    decode: decodeBcjIa64,
+    createDecoder: createBcjIa64Decoder
+});
+// BCJ (SPARC) filter
+registerCodec(CodecId.BCJ_SPARC, {
+    decode: decodeBcjSparc,
+    createDecoder: createBcjSparcDecoder
+});
 // Delta filter
 registerCodec(CodecId.DELTA, {
     decode: decodeDelta,
@@ -120,4 +163,4 @@ registerCodec(CodecId.AES, {
 registerCodec(CodecId.BCJ2, {
     decode: decodeBcj2,
     createDecoder: createBcj2Decoder
-});
+}); // Note: PPMd codec is not implemented. See FUTURE_ENHANCEMENTS.md

package/dist/esm/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 { 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.BCJ2)) return 'BCJ2';\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// 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"],"names":["CodecId","createCodedError","ErrorCode","createAesDecoder","decodeAes","getPassword","setPassword","createBcjDecoder","decodeBcj","createBcj2Decoder","decodeBcj2","decodeBcj2Multi","createBzip2Decoder","decodeBzip2","createCopyDecoder","decodeCopy","createDeflateDecoder","decodeDeflate","createDeltaDecoder","decodeDelta","createLzmaDecoder","decodeLzma","createLzma2Decoder","decodeLzma2","codecs","codecIdToKey","id","parts","i","length","push","toString","toUpperCase","join","codecIdEquals","a","b","registerCodec","codec","getCodec","key","UNSUPPORTED_CODEC","isCodecSupported","undefined","getCodecName","COPY","LZMA","LZMA2","BCJ_X86","BCJ2","DELTA","DEFLATE","BZIP2","AES","isBcj2Codec","decode","createDecoder"],"mappings":"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"}
+{"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":["CodecId","createCodedError","ErrorCode","createAesDecoder","decodeAes","getPassword","setPassword","createBcjDecoder","decodeBcj","createBcj2Decoder","decodeBcj2","decodeBcj2Multi","createBcjArmDecoder","decodeBcjArm","createBcjArm64Decoder","decodeBcjArm64","createBcjArmtDecoder","decodeBcjArmt","createBcjIa64Decoder","decodeBcjIa64","createBcjPpcDecoder","decodeBcjPpc","createBcjSparcDecoder","decodeBcjSparc","createBzip2Decoder","decodeBzip2","createCopyDecoder","decodeCopy","createDeflateDecoder","decodeDeflate","createDeltaDecoder","decodeDelta","createLzmaDecoder","decodeLzma","createLzma2Decoder","decodeLzma2","codecs","codecIdToKey","id","parts","i","length","push","toString","toUpperCase","join","codecIdEquals","a","b","registerCodec","codec","getCodec","key","UNSUPPORTED_CODEC","isCodecSupported","undefined","getCodecName","COPY","LZMA","LZMA2","BCJ_X86","BCJ_ARM","BCJ_ARMT","BCJ_ARM64","BCJ_PPC","BCJ_IA64","BCJ_SPARC","BCJ2","PPMD","DELTA","DEFLATE","BZIP2","AES","isBcj2Codec","decode","createDecoder"],"mappings":"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"}

package/dist/esm/sevenz/constants.d.ts

@@ -35,7 +35,14 @@ export declare var CodecId: {
     LZMA: number[];
     LZMA2: number[];
     BCJ_X86: number[];
+    BCJ_PPC: number[];
+    BCJ_IA64: number[];
+    BCJ_ARM: number[];
+    BCJ_ARMT: number[];
+    BCJ_SPARC: number[];
+    BCJ_ARM64: number[];
     BCJ2: number[];
+    PPMD: number[];
     DEFLATE: number[];
     BZIP2: number[];
     AES: number[];

package/dist/esm/sevenz/constants.js

@@ -43,6 +43,7 @@ export var PropertyId = {
 };
 // Codec IDs
 // 7z uses variable-length codec IDs
+// Reference: 7za i output shows hex codec IDs (e.g., 3030501 = ARM)
 export var CodecId = {
     COPY: [
         0x00
@@ -64,12 +65,53 @@ export var CodecId = {
         0x01,
         0x03
     ],
+    BCJ_PPC: [
+        0x03,
+        0x03,
+        0x02,
+        0x05
+    ],
+    BCJ_IA64: [
+        0x03,
+        0x03,
+        0x04,
+        0x01
+    ],
+    BCJ_ARM: [
+        0x03,
+        0x03,
+        0x05,
+        0x01
+    ],
+    BCJ_ARMT: [
+        0x03,
+        0x03,
+        0x07,
+        0x01
+    ],
+    BCJ_SPARC: [
+        0x03,
+        0x03,
+        0x08,
+        0x05
+    ],
+    BCJ_ARM64: [
+        0x03,
+        0x03,
+        0x0a,
+        0x01
+    ],
     BCJ2: [
         0x03,
         0x03,
         0x01,
         0x1b
     ],
+    PPMD: [
+        0x03,
+        0x04,
+        0x01
+    ],
     DEFLATE: [
         0x04,
         0x01,