7z-iterator 1.3.1 → 2.0.0

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

@@ -1,16 +0,0 @@
-import { Transform } from 'extract-base-iterator';
-/**
- * Decode BCJ (x86) filtered data (synchronous, for buffered use)
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * @param input - BCJ filtered data
- * @param _properties - Unused for BCJ
- * @param _unpackSize - Unused for BCJ
- * @returns Unfiltered data
- */
-export declare function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create a streaming BCJ decoder Transform.
- * Processes data chunk by chunk, buffering incomplete instructions.
- */
-export declare function createBcjDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -1,16 +0,0 @@
-import { Transform } from 'extract-base-iterator';
-/**
- * Decode BCJ (x86) filtered data (synchronous, for buffered use)
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * @param input - BCJ filtered data
- * @param _properties - Unused for BCJ
- * @param _unpackSize - Unused for BCJ
- * @returns Unfiltered data
- */
-export declare function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create a streaming BCJ decoder Transform.
- * Processes data chunk by chunk, buffering incomplete instructions.
- */
-export declare function createBcjDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -1,183 +0,0 @@
-// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses
-// This is a simple filter that makes executables more compressible by LZMA
-//
-// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions
-// to absolute addresses, which creates more repetitive patterns for compression.
-//
-// Reference: https://github.com/jljusten/LZMA-SDK/blob/master/C/Bra86.c
-//
-// This implementation uses true streaming - processes data chunk by chunk
-// while buffering incomplete instructions across chunk boundaries.
-"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 createBcjDecoder () {
-        return createBcjDecoder;
-    },
-    get decodeBcj () {
-        return decodeBcj;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-function decodeBcj(input, _properties, _unpackSize) {
-    // BCJ filter state
-    var pos = 0;
-    var prevMask = 0;
-    var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
-    while(pos < output.length - 4){
-        var b = output[pos];
-        // Check for CALL (0xE8) or JMP (0xE9) opcode
-        if (b !== 0xe8 && b !== 0xe9) {
-            pos++;
-            prevMask = 0;
-            continue;
-        }
-        // Check mask to avoid false positives in data
-        var offset = pos + 5;
-        if (offset > output.length) {
-            break;
-        }
-        // Skip if in masked region (previous conversion affected this area)
-        if ((prevMask & 1) !== 0) {
-            prevMask = prevMask >> 1 | 4;
-            pos++;
-            continue;
-        }
-        // Read the 32-bit address (little-endian)
-        var addr = output[pos + 1] | output[pos + 2] << 8 | output[pos + 3] << 16 | output[pos + 4] << 24 >>> 0;
-        // Check if this looks like a converted address
-        // High byte should be 0x00 or 0xFF for typical code
-        var highByte = output[pos + 4];
-        if (highByte === 0x00 || highByte === 0xff) {
-            // Convert absolute to relative
-            var newAddr = void 0;
-            if (highByte === 0x00) {
-                // Positive offset - subtract position
-                newAddr = addr - pos;
-            } else {
-                // Negative offset (0xFF high byte)
-                newAddr = addr + pos;
-            }
-            // Write back as little-endian
-            output[pos + 1] = newAddr & 0xff;
-            output[pos + 2] = newAddr >>> 8 & 0xff;
-            output[pos + 3] = newAddr >>> 16 & 0xff;
-            output[pos + 4] = newAddr >>> 24 & 0xff;
-            pos += 5;
-            prevMask = 0;
-        } else {
-            pos++;
-            prevMask = 0;
-        }
-    }
-    return output;
-}
-function createBcjDecoder(_properties, _unpackSize) {
-    // State that persists across chunks
-    var globalPos = 0; // Position in the overall stream
-    var prevMask = 0;
-    var pending = null; // Bytes pending from previous chunk
-    var transform = new _extractbaseiterator.Transform({
-        transform: function(chunk, _encoding, callback) {
-            // Combine pending bytes with new chunk
-            var data;
-            if (pending && pending.length > 0) {
-                data = Buffer.concat([
-                    pending,
-                    chunk
-                ]);
-            } else {
-                data = chunk;
-            }
-            // We need at least 5 bytes to process an instruction
-            // Keep the last 4 bytes as pending in case an instruction spans chunks
-            var safeEnd = data.length - 4;
-            if (safeEnd <= 0) {
-                // Not enough data yet, keep it all pending
-                pending = data;
-                callback(null, (0, _extractbaseiterator.allocBuffer)(0));
-                return;
-            }
-            var output = (0, _extractbaseiterator.bufferFrom)(data.slice(0, safeEnd)); // Copy the portion we'll process
-            pending = data.slice(safeEnd); // Keep last 4 bytes for next chunk
-            var localPos = 0;
-            while(localPos < output.length){
-                var b = output[localPos];
-                // Check for CALL (0xE8) or JMP (0xE9) opcode
-                if (b !== 0xe8 && b !== 0xe9) {
-                    localPos++;
-                    globalPos++;
-                    prevMask = 0;
-                    continue;
-                }
-                // Check if we have enough bytes for the full instruction
-                if (localPos + 5 > output.length + pending.length) {
-                    break;
-                }
-                // Skip if in masked region
-                if ((prevMask & 1) !== 0) {
-                    prevMask = prevMask >> 1 | 4;
-                    localPos++;
-                    globalPos++;
-                    continue;
-                }
-                // Get the 4 address bytes (might span into pending)
-                var addr = void 0;
-                var highByte = void 0;
-                if (localPos + 5 <= output.length) {
-                    addr = output[localPos + 1] | output[localPos + 2] << 8 | output[localPos + 3] << 16 | output[localPos + 4] << 24 >>> 0;
-                    highByte = output[localPos + 4];
-                } else {
-                    // Address spans output and pending - shouldn't happen with safeEnd
-                    localPos++;
-                    globalPos++;
-                    prevMask = 0;
-                    continue;
-                }
-                if (highByte === 0x00 || highByte === 0xff) {
-                    // Convert absolute to relative
-                    var newAddr = void 0;
-                    if (highByte === 0x00) {
-                        newAddr = addr - globalPos;
-                    } else {
-                        newAddr = addr + globalPos;
-                    }
-                    // Write back as little-endian
-                    output[localPos + 1] = newAddr & 0xff;
-                    output[localPos + 2] = newAddr >>> 8 & 0xff;
-                    output[localPos + 3] = newAddr >>> 16 & 0xff;
-                    output[localPos + 4] = newAddr >>> 24 & 0xff;
-                    localPos += 5;
-                    globalPos += 5;
-                    prevMask = 0;
-                } else {
-                    localPos++;
-                    globalPos++;
-                    prevMask = 0;
-                }
-            }
-            callback(null, output);
-        },
-        flush: function flush(callback) {
-            // Output any remaining pending bytes
-            if (pending && pending.length > 0) {
-                // Process the final bytes - no need to worry about spanning
-                var output = (0, _extractbaseiterator.bufferFrom)(pending);
-                // Don't convert anything in the final bytes since we can't know
-                // if they're complete instructions
-                this.push(output);
-            }
-            callback(null);
-        }
-    });
-    return transform;
-}
-/* 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/Bcj.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Bcj.ts"],"sourcesContent":["// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses\n// This is a simple filter that makes executables more compressible by LZMA\n//\n// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions\n// to absolute addresses, which creates more repetitive patterns for compression.\n//\n// Reference: https://github.com/jljusten/LZMA-SDK/blob/master/C/Bra86.c\n//\n// This implementation uses true streaming - processes data chunk by chunk\n// while buffering incomplete instructions across chunk boundaries.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode BCJ (x86) filtered data (synchronous, for buffered use)\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - BCJ filtered data\n * @param _properties - Unused for BCJ\n * @param _unpackSize - Unused for BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  // BCJ filter state\n  let pos = 0;\n  let prevMask = 0;\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  while (pos < output.length - 4) {\n    const b = output[pos];\n\n    // Check for CALL (0xE8) or JMP (0xE9) opcode\n    if (b !== 0xe8 && b !== 0xe9) {\n      pos++;\n      prevMask = 0;\n      continue;\n    }\n\n    // Check mask to avoid false positives in data\n    const offset = pos + 5;\n    if (offset > output.length) {\n      break;\n    }\n\n    // Skip if in masked region (previous conversion affected this area)\n    if ((prevMask & 1) !== 0) {\n      prevMask = (prevMask >> 1) | 4;\n      pos++;\n      continue;\n    }\n\n    // Read the 32-bit address (little-endian)\n    const addr = output[pos + 1] | (output[pos + 2] << 8) | (output[pos + 3] << 16) | ((output[pos + 4] << 24) >>> 0);\n\n    // Check if this looks like a converted address\n    // High byte should be 0x00 or 0xFF for typical code\n    const highByte = output[pos + 4];\n\n    if (highByte === 0x00 || highByte === 0xff) {\n      // Convert absolute to relative\n      let newAddr: number;\n      if (highByte === 0x00) {\n        // Positive offset - subtract position\n        newAddr = addr - pos;\n      } else {\n        // Negative offset (0xFF high byte)\n        newAddr = addr + pos;\n      }\n\n      // Write back as little-endian\n      output[pos + 1] = newAddr & 0xff;\n      output[pos + 2] = (newAddr >>> 8) & 0xff;\n      output[pos + 3] = (newAddr >>> 16) & 0xff;\n      output[pos + 4] = (newAddr >>> 24) & 0xff;\n\n      pos += 5;\n      prevMask = 0;\n    } else {\n      pos++;\n      prevMask = 0;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming BCJ decoder Transform.\n * Processes data chunk by chunk, buffering incomplete instructions.\n */\nexport function createBcjDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // State that persists across chunks\n  let globalPos = 0; // Position in the overall stream\n  let prevMask = 0;\n  let pending: Buffer | null = null; // Bytes pending from previous chunk\n\n  const transform = new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      // Combine pending bytes with new chunk\n      let data: Buffer;\n      if (pending && pending.length > 0) {\n        data = Buffer.concat([pending, chunk]);\n      } else {\n        data = chunk;\n      }\n\n      // We need at least 5 bytes to process an instruction\n      // Keep the last 4 bytes as pending in case an instruction spans chunks\n      const safeEnd = data.length - 4;\n      if (safeEnd <= 0) {\n        // Not enough data yet, keep it all pending\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      const output = bufferFrom(data.slice(0, safeEnd)); // Copy the portion we'll process\n      pending = data.slice(safeEnd); // Keep last 4 bytes for next chunk\n\n      let localPos = 0;\n      while (localPos < output.length) {\n        const b = output[localPos];\n\n        // Check for CALL (0xE8) or JMP (0xE9) opcode\n        if (b !== 0xe8 && b !== 0xe9) {\n          localPos++;\n          globalPos++;\n          prevMask = 0;\n          continue;\n        }\n\n        // Check if we have enough bytes for the full instruction\n        if (localPos + 5 > output.length + pending.length) {\n          // Not enough bytes - need to wait for more data\n          // This shouldn't happen with our safeEnd calculation, but be safe\n          break;\n        }\n\n        // Skip if in masked region\n        if ((prevMask & 1) !== 0) {\n          prevMask = (prevMask >> 1) | 4;\n          localPos++;\n          globalPos++;\n          continue;\n        }\n\n        // Get the 4 address bytes (might span into pending)\n        let addr: number;\n        let highByte: number;\n        if (localPos + 5 <= output.length) {\n          addr = output[localPos + 1] | (output[localPos + 2] << 8) | (output[localPos + 3] << 16) | ((output[localPos + 4] << 24) >>> 0);\n          highByte = output[localPos + 4];\n        } else {\n          // Address spans output and pending - shouldn't happen with safeEnd\n          localPos++;\n          globalPos++;\n          prevMask = 0;\n          continue;\n        }\n\n        if (highByte === 0x00 || highByte === 0xff) {\n          // Convert absolute to relative\n          let newAddr: number;\n          if (highByte === 0x00) {\n            newAddr = addr - globalPos;\n          } else {\n            newAddr = addr + globalPos;\n          }\n\n          // Write back as little-endian\n          output[localPos + 1] = newAddr & 0xff;\n          output[localPos + 2] = (newAddr >>> 8) & 0xff;\n          output[localPos + 3] = (newAddr >>> 16) & 0xff;\n          output[localPos + 4] = (newAddr >>> 24) & 0xff;\n\n          localPos += 5;\n          globalPos += 5;\n          prevMask = 0;\n        } else {\n          localPos++;\n          globalPos++;\n          prevMask = 0;\n        }\n      }\n\n      callback(null, output);\n    },\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      // Output any remaining pending bytes\n      if (pending && pending.length > 0) {\n        // Process the final bytes - no need to worry about spanning\n        const output = bufferFrom(pending);\n        // Don't convert anything in the final bytes since we can't know\n        // if they're complete instructions\n        this.push(output);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["createBcjDecoder","decodeBcj","input","_properties","_unpackSize","pos","prevMask","output","bufferFrom","length","b","offset","addr","highByte","newAddr","globalPos","pending","transform","Transform","chunk","_encoding","callback","data","Buffer","concat","safeEnd","allocBuffer","slice","localPos","flush","push"],"mappings":"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"}

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

@@ -1,21 +0,0 @@
-import { Transform } from 'extract-base-iterator';
-/**
- * Decode ARM BCJ filtered data (synchronous, for buffered use)
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * ARM BL instruction format:
- * - 4 bytes aligned
- * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)
- * - Lower 24 bits are signed offset (in words, not bytes)
- *
- * @param input - ARM BCJ filtered data
- * @param _properties - Unused for ARM BCJ
- * @param _unpackSize - Unused for ARM BCJ
- * @returns Unfiltered data
- */
-export declare function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create a streaming ARM BCJ decoder Transform.
- * Processes data in 4-byte aligned chunks.
- */
-export declare function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -1,21 +0,0 @@
-import { Transform } from 'extract-base-iterator';
-/**
- * Decode ARM BCJ filtered data (synchronous, for buffered use)
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * ARM BL instruction format:
- * - 4 bytes aligned
- * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)
- * - Lower 24 bits are signed offset (in words, not bytes)
- *
- * @param input - ARM BCJ filtered data
- * @param _properties - Unused for ARM BCJ
- * @param _unpackSize - Unused for ARM BCJ
- * @returns Unfiltered data
- */
-export declare function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create a streaming ARM BCJ decoder Transform.
- * Processes data in 4-byte aligned chunks.
- */
-export declare function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -1,104 +0,0 @@
-// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses
-// This filter makes ARM executables more compressible by LZMA
-//
-// ARM branch instructions (BL) use relative addressing. The filter converts
-// these to absolute addresses during compression, and back during decompression.
-//
-// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
-//
-// This implementation uses true streaming - processes data chunk by chunk.
-"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 createBcjArmDecoder () {
-        return createBcjArmDecoder;
-    },
-    get decodeBcjArm () {
-        return decodeBcjArm;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-function decodeBcjArm(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){
-        // Check for BL instruction: byte 3 is 0xEB
-        if (output[pos + 3] === 0xeb) {
-            // Read 24-bit address (little-endian in bytes 0-2)
-            var addr = output[pos] | output[pos + 1] << 8 | output[pos + 2] << 16;
-            // Sign-extend 24-bit to 32-bit
-            if (addr & 0x800000) {
-                addr |= 0xff000000;
-            }
-            // Convert absolute to relative:
-            // Subtract current position (in words, so divide by 4)
-            var relAddr = addr - (pos >>> 2);
-            // Write back lower 24 bits
-            output[pos] = relAddr & 0xff;
-            output[pos + 1] = relAddr >>> 8 & 0xff;
-            output[pos + 2] = relAddr >>> 16 & 0xff;
-        }
-        pos += 4;
-    }
-    return output;
-}
-function createBcjArmDecoder(_properties, _unpackSize) {
-    var globalPos = 0; // Position in the overall stream (in bytes)
-    var pending = null; // Incomplete 4-byte group
-    var transform = new _extractbaseiterator.Transform({
-        transform: function(chunk, _encoding, callback) {
-            // Combine pending bytes with new chunk
-            var data;
-            if (pending && pending.length > 0) {
-                data = Buffer.concat([
-                    pending,
-                    chunk
-                ]);
-            } else {
-                data = chunk;
-            }
-            // Process only complete 4-byte groups
-            var completeBytes = data.length - data.length % 4;
-            if (completeBytes === 0) {
-                pending = data;
-                callback(null, (0, _extractbaseiterator.allocBuffer)(0));
-                return;
-            }
-            var output = (0, _extractbaseiterator.bufferFrom)(data.slice(0, completeBytes));
-            pending = data.length > completeBytes ? data.slice(completeBytes) : null;
-            var pos = 0;
-            while(pos + 4 <= output.length){
-                if (output[pos + 3] === 0xeb) {
-                    var addr = output[pos] | output[pos + 1] << 8 | output[pos + 2] << 16;
-                    if (addr & 0x800000) {
-                        addr |= 0xff000000;
-                    }
-                    var relAddr = addr - (globalPos >>> 2);
-                    output[pos] = relAddr & 0xff;
-                    output[pos + 1] = relAddr >>> 8 & 0xff;
-                    output[pos + 2] = relAddr >>> 16 & 0xff;
-                }
-                pos += 4;
-                globalPos += 4;
-            }
-            callback(null, output);
-        },
-        flush: function flush(callback) {
-            if (pending && pending.length > 0) {
-                this.push(pending);
-            }
-            callback(null);
-        }
-    });
-    return transform;
-}
-/* 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/BcjArm.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n//\n// This implementation uses true streaming - processes data chunk by chunk.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode ARM BCJ filtered data (synchronous, for buffered use)\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (output[pos + 3] === 0xeb) {\n      // Read 24-bit address (little-endian in bytes 0-2)\n      let addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n\n      // Sign-extend 24-bit to 32-bit\n      if (addr & 0x800000) {\n        addr |= 0xff000000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in words, so divide by 4)\n      const relAddr = addr - (pos >>> 2);\n\n      // Write back lower 24 bits\n      output[pos] = relAddr & 0xff;\n      output[pos + 1] = (relAddr >>> 8) & 0xff;\n      output[pos + 2] = (relAddr >>> 16) & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming ARM BCJ decoder Transform.\n * Processes data in 4-byte aligned chunks.\n */\nexport function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  let globalPos = 0; // Position in the overall stream (in bytes)\n  let pending: Buffer | null = null; // Incomplete 4-byte group\n\n  const transform = new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      // Combine pending bytes with new chunk\n      let data: Buffer;\n      if (pending && pending.length > 0) {\n        data = Buffer.concat([pending, chunk]);\n      } else {\n        data = chunk;\n      }\n\n      // Process only complete 4-byte groups\n      const completeBytes = data.length - (data.length % 4);\n      if (completeBytes === 0) {\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      const output = bufferFrom(data.slice(0, completeBytes));\n      pending = data.length > completeBytes ? data.slice(completeBytes) : null;\n\n      let pos = 0;\n      while (pos + 4 <= output.length) {\n        if (output[pos + 3] === 0xeb) {\n          let addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n          if (addr & 0x800000) {\n            addr |= 0xff000000;\n          }\n          const relAddr = addr - (globalPos >>> 2);\n          output[pos] = relAddr & 0xff;\n          output[pos + 1] = (relAddr >>> 8) & 0xff;\n          output[pos + 2] = (relAddr >>> 16) & 0xff;\n        }\n        pos += 4;\n        globalPos += 4;\n      }\n\n      callback(null, output);\n    },\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      if (pending && pending.length > 0) {\n        this.push(pending);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["createBcjArmDecoder","decodeBcjArm","input","_properties","_unpackSize","output","bufferFrom","pos","length","addr","relAddr","globalPos","pending","transform","Transform","chunk","_encoding","callback","data","Buffer","concat","completeBytes","allocBuffer","slice","flush","push"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;AAC/D,EAAE;AACF,2EAA2E;;;;;;;;;;;;QAqD3DA;eAAAA;;QAnCAC;eAAAA;;;mCAhBmC;AAgB5C,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,IAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BF,MAAM,CAACE,IAAI,GAAGG,UAAU;YACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOF;AACT;AAMO,SAASL,oBAAoBG,WAAoB,EAAEC,WAAoB;IAC5E,IAAIO,YAAY,GAAG,4CAA4C;IAC/D,IAAIC,UAAyB,MAAM,0BAA0B;IAE7D,IAAMC,YAAY,IAAIC,8BAAS,CAAC;QAC9BD,WAAW,SAACE,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIN,WAAWA,QAAQJ,MAAM,GAAG,GAAG;gBACjCU,OAAOC,OAAOC,MAAM,CAAC;oBAACR;oBAASG;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,sCAAsC;YACtC,IAAMM,gBAAgBH,KAAKV,MAAM,GAAIU,KAAKV,MAAM,GAAG;YACnD,IAAIa,kBAAkB,GAAG;gBACvBT,UAAUM;gBACVD,SAAS,MAAMK,IAAAA,gCAAW,EAAC;gBAC3B;YACF;YAEA,IAAMjB,SAASC,IAAAA,+BAAU,EAACY,KAAKK,KAAK,CAAC,GAAGF;YACxCT,UAAUM,KAAKV,MAAM,GAAGa,gBAAgBH,KAAKK,KAAK,CAACF,iBAAiB;YAEpE,IAAId,MAAM;YACV,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;gBAC/B,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;oBAC5B,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;oBACtE,IAAIE,OAAO,UAAU;wBACnBA,QAAQ;oBACV;oBACA,IAAMC,UAAUD,OAAQE,CAAAA,cAAc,CAAA;oBACtCN,MAAM,CAACE,IAAI,GAAGG,UAAU;oBACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;oBACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;gBACvC;gBACAH,OAAO;gBACPI,aAAa;YACf;YAEAM,SAAS,MAAMZ;QACjB;QACAmB,OAAO,SAAPA,MAAuDP,QAAsC;YAC3F,IAAIL,WAAWA,QAAQJ,MAAM,GAAG,GAAG;gBACjC,IAAI,CAACiB,IAAI,CAACb;YACZ;YACAK,SAAS;QACX;IACF;IAEA,OAAOJ;AACT"}

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

@@ -1,21 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * Decode ARM64 BCJ filtered data
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * ARM64 B/BL instruction format (little-endian):
- * - 4 bytes aligned
- * - B: opcode 0x14 (000101xx)
- * - BL: opcode 0x94 (100101xx)
- * - Bits 0-25 are 26-bit signed offset (in words)
- *
- * @param input - ARM64 BCJ filtered data
- * @param _properties - Unused for ARM64 BCJ
- * @param _unpackSize - Unused for ARM64 BCJ
- * @returns Unfiltered data
- */
-export declare function decodeBcjArm64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create an ARM64 BCJ decoder Transform stream
- */
-export declare function createBcjArm64Decoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -1,21 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * Decode ARM64 BCJ filtered data
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * ARM64 B/BL instruction format (little-endian):
- * - 4 bytes aligned
- * - B: opcode 0x14 (000101xx)
- * - BL: opcode 0x94 (100101xx)
- * - Bits 0-25 are 26-bit signed offset (in words)
- *
- * @param input - ARM64 BCJ filtered data
- * @param _properties - Unused for ARM64 BCJ
- * @param _unpackSize - Unused for ARM64 BCJ
- * @returns Unfiltered data
- */
-export declare function decodeBcjArm64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create an ARM64 BCJ decoder Transform stream
- */
-export declare function createBcjArm64Decoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -1,65 +0,0 @@
-// BCJ (ARM64/AArch64) filter codec - converts ARM64 branch instruction addresses
-// This filter makes ARM64 executables more compressible by LZMA
-//
-// ARM64 uses 32-bit fixed-width instructions. 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 createBcjArm64Decoder () {
-        return createBcjArm64Decoder;
-    },
-    get decodeBcjArm64 () {
-        return decodeBcjArm64;
-    }
-});
-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 decodeBcjArm64(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 (little-endian)
-        var instr = output[pos] | output[pos + 1] << 8 | output[pos + 2] << 16 | output[pos + 3] << 24 >>> 0;
-        // Check for B/BL instruction: (instr & 0x7C000000) === 0x14000000
-        // This matches both B (0x14000000) and BL (0x94000000)
-        if ((instr & 0x7c000000) === 0x14000000) {
-            // Extract 26-bit offset
-            var addr = instr & 0x03ffffff;
-            // Sign-extend 26-bit to 32-bit
-            if (addr & 0x02000000) {
-                addr |= 0xfc000000;
-            }
-            // Convert absolute to relative: subtract current position (in words)
-            var relAddr = addr - (pos >>> 2);
-            // Clear old offset and write new one, preserve opcode
-            instr = instr & 0xfc000000 | relAddr & 0x03ffffff;
-            // Write back (little-endian)
-            output[pos] = instr & 0xff;
-            output[pos + 1] = instr >>> 8 & 0xff;
-            output[pos + 2] = instr >>> 16 & 0xff;
-            output[pos + 3] = instr >>> 24 & 0xff;
-        }
-        pos += 4;
-    }
-    return output;
-}
-function createBcjArm64Decoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeBcjArm64, 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/BcjArm64.js.map

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

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

@@ -1,19 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * 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 declare function decodeBcjArmt(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create an ARM Thumb BCJ decoder Transform stream
- */
-export declare function createBcjArmtDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -1,19 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * 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 declare function decodeBcjArmt(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-/**
- * Create an ARM Thumb BCJ decoder Transform stream
- */
-export declare function createBcjArmtDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -1,76 +0,0 @@
-// 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
-"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 createBcjArmtDecoder () {
-        return createBcjArmtDecoder;
-    },
-    get decodeBcjArmt () {
-        return decodeBcjArmt;
-    }
-});
-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 decodeBcjArmt(input, _properties, _unpackSize) {
-    var output = (0, _extractbaseiterator.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;
-}
-function createBcjArmtDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeBcjArmt, 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; }