7z-iterator 1.3.1 → 2.0.0

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

@@ -1 +0,0 @@
-{"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 '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.d.cts

@@ -1,15 +0,0 @@
-import type { Transform } from '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/cjs/sevenz/codecs/BcjIa64.d.ts

@@ -1,15 +0,0 @@
-import type { Transform } from '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/cjs/sevenz/codecs/BcjIa64.js

@@ -1,141 +0,0 @@
-// 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
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createBcjIa64Decoder () {
-        return createBcjIa64Decoder;
-    },
-    get decodeBcjIa64 () {
-        return decodeBcjIa64;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// 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
-];
-function decodeBcjIa64(input, _properties, _unpackSize) {
-    var output = (0, _extractbaseiterator.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;
-}
-function createBcjIa64Decoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeBcjIa64, properties, unpackSize);
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +0,0 @@
-{"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 '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.d.cts

@@ -1,20 +0,0 @@
-import type { Transform } from '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/cjs/sevenz/codecs/BcjPpc.d.ts

@@ -1,20 +0,0 @@
-import type { Transform } from '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/cjs/sevenz/codecs/BcjPpc.js

@@ -1,64 +0,0 @@
-// 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
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createBcjPpcDecoder () {
-        return createBcjPpcDecoder;
-    },
-    get decodeBcjPpc () {
-        return decodeBcjPpc;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function decodeBcjPpc(input, _properties, _unpackSize) {
-    var output = (0, _extractbaseiterator.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;
-}
-function createBcjPpcDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeBcjPpc, properties, unpackSize);
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +0,0 @@
-{"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 '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.d.cts

@@ -1,19 +0,0 @@
-import type { Transform } from '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/cjs/sevenz/codecs/BcjSparc.d.ts

@@ -1,19 +0,0 @@
-import type { Transform } from '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/cjs/sevenz/codecs/BcjSparc.js

@@ -1,69 +0,0 @@
-// 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
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createBcjSparcDecoder () {
-        return createBcjSparcDecoder;
-    },
-    get decodeBcjSparc () {
-        return decodeBcjSparc;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function decodeBcjSparc(input, _properties, _unpackSize) {
-    var output = (0, _extractbaseiterator.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;
-}
-function createBcjSparcDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeBcjSparc, properties, unpackSize);
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +0,0 @@
-{"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 '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.d.cts

@@ -1,16 +0,0 @@
-import { Transform } from 'extract-base-iterator';
-/**
- * Decode Delta filtered data (synchronous, for buffered use)
- * Reverses the delta transformation by adding previous values
- *
- * @param input - Delta filtered data
- * @param properties - Optional 1-byte properties (distance - 1)
- * @param _unpackSize - Unused for Delta
- * @returns Unfiltered data
- */
-export declare function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create a streaming Delta decoder Transform.
- * Processes data chunk by chunk, maintaining state between chunks.
- */
-export declare function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -1,16 +0,0 @@
-import { Transform } from 'extract-base-iterator';
-/**
- * Decode Delta filtered data (synchronous, for buffered use)
- * Reverses the delta transformation by adding previous values
- *
- * @param input - Delta filtered data
- * @param properties - Optional 1-byte properties (distance - 1)
- * @param _unpackSize - Unused for Delta
- * @returns Unfiltered data
- */
-export declare function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create a streaming Delta decoder Transform.
- * Processes data chunk by chunk, maintaining state between chunks.
- */
-export declare function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -1,74 +0,0 @@
-// Delta filter codec - stores differences between consecutive bytes
-// Useful for data with gradual changes (images, audio, sensor data)
-//
-// The Delta filter stores the difference between each byte and the byte
-// N positions before it, where N is the "distance" parameter (default 1).
-// This makes data with regular patterns more compressible.
-//
-// This implementation uses true streaming - processes data chunk by chunk
-// while maintaining state between chunks.
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createDeltaDecoder () {
-        return createDeltaDecoder;
-    },
-    get decodeDelta () {
-        return decodeDelta;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-function decodeDelta(input, properties, _unpackSize) {
-    // Distance parameter: default is 1
-    var distance = 1;
-    if (properties && properties.length >= 1) {
-        // Properties byte contains (distance - 1)
-        distance = properties[0] + 1;
-    }
-    var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
-    // State buffer for multi-byte distance
-    var state = [];
-    for(var i = 0; i < distance; i++){
-        state.push(0);
-    }
-    for(var j = 0; j < output.length; j++){
-        var idx = j % distance;
-        state[idx] = state[idx] + output[j] & 0xff;
-        output[j] = state[idx];
-    }
-    return output;
-}
-function createDeltaDecoder(properties, _unpackSize) {
-    // Distance parameter: default is 1
-    var distance = 1;
-    if (properties && properties.length >= 1) {
-        distance = properties[0] + 1;
-    }
-    // State buffer for multi-byte distance
-    var state = [];
-    for(var i = 0; i < distance; i++){
-        state.push(0);
-    }
-    var byteIndex = 0;
-    return new _extractbaseiterator.Transform({
-        transform: function(chunk, _encoding, callback) {
-            var output = (0, _extractbaseiterator.allocBuffer)(chunk.length);
-            for(var j = 0; j < chunk.length; j++){
-                var idx = byteIndex % distance;
-                state[idx] = state[idx] + chunk[j] & 0xff;
-                output[j] = state[idx];
-                byteIndex++;
-            }
-            callback(null, output);
-        }
-    });
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +0,0 @@
-{"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//\n// This implementation uses true streaming - processes data chunk by chunk\n// while maintaining state between chunks.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode Delta filtered data (synchronous, for buffered use)\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: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(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 streaming Delta decoder Transform.\n * Processes data chunk by chunk, maintaining state between chunks.\n */\nexport function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    distance = properties[0] + 1;\n  }\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  let byteIndex = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      const output = allocBuffer(chunk.length);\n\n      for (let j = 0; j < chunk.length; j++) {\n        const idx = byteIndex % distance;\n        state[idx] = (state[idx] + chunk[j]) & 0xff;\n        output[j] = state[idx];\n        byteIndex++;\n      }\n\n      callback(null, output);\n    },\n  });\n}\n"],"names":["createDeltaDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","bufferFrom","state","i","push","j","idx","byteIndex","Transform","transform","chunk","_encoding","callback","allocBuffer"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;;;;;;;;;;;;QA0C1BA;eAAAA;;QA7BAC;eAAAA;;;mCAXmC;AAW5C,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,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCD,MAAME,IAAI,CAAC;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;AAMO,SAASP,mBAAmBG,UAAmB,EAAEC,WAAoB;IAC1E,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxCD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,uCAAuC;IACvC,IAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAIG,YAAY;IAEhB,OAAO,IAAIC,8BAAS,CAAC;QACnBC,WAAW,SAACC,OAAeC,WAAmBC;YAC5C,IAAMZ,SAASa,IAAAA,gCAAW,EAACH,MAAMX,MAAM;YAEvC,IAAK,IAAIM,IAAI,GAAGA,IAAIK,MAAMX,MAAM,EAAEM,IAAK;gBACrC,IAAMC,MAAMC,YAAYT;gBACxBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBC;YACF;YAEAK,SAAS,MAAMZ;QACjB;IACF;AACF"}

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

@@ -1,17 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * Decode LZMA compressed data to buffer
- *
- * @param input - LZMA compressed data
- * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)
- * @param unpackSize - Expected output size
- * @returns Decompressed data
- */
-export declare function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
-/**
- * Create an LZMA decoder Transform stream
- *
- * Note: LZMA1 has no chunk boundaries, so this buffers all input
- * and decompresses when the stream ends.
- */
-export declare function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -1,17 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * Decode LZMA compressed data to buffer
- *
- * @param input - LZMA compressed data
- * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)
- * @param unpackSize - Expected output size
- * @returns Decompressed data
- */
-export declare function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
-/**
- * Create an LZMA decoder Transform stream
- *
- * Note: LZMA1 has no chunk boundaries, so this buffers all input
- * and decompresses when the stream ends.
- */
-export declare function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -1,40 +0,0 @@
-// LZMA codec using TypeScript LZMA decoder
-// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createLzmaDecoder () {
-        return createLzmaDecoder;
-    },
-    get decodeLzma () {
-        return decodeLzma;
-    }
-});
-var _indexts = require("../../lzma/index.js");
-function decodeLzma(input, properties, unpackSize) {
-    if (!properties || properties.length < 5) {
-        throw new Error('LZMA requires 5-byte properties');
-    }
-    if (typeof unpackSize !== 'number' || unpackSize < 0) {
-        throw new Error('LZMA requires known unpack size');
-    }
-    return (0, _indexts.decodeLzma)(input, properties, unpackSize);
-}
-function createLzmaDecoder(properties, unpackSize) {
-    if (!properties || properties.length < 5) {
-        throw new Error('LZMA requires 5-byte properties');
-    }
-    if (typeof unpackSize !== 'number' || unpackSize < 0) {
-        throw new Error('LZMA requires known unpack size');
-    }
-    return (0, _indexts.createLzmaDecoder)(properties, unpackSize);
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }