7z-iterator 1.4.0 → 2.0.0

package/dist/cjs/lzma/types.js

@@ -1,264 +0,0 @@
-/**
- * LZMA Types and Constants
- *
- * Shared types, constants, and state transition functions for LZMA decoding.
- * Based on the LZMA SDK specification.
- */ // LZMA State Machine Constants
-"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 LZMA2_CONTROL () {
-        return LZMA2_CONTROL;
-    },
-    get getLenToPosState () {
-        return getLenToPosState;
-    },
-    get initBitModels () {
-        return initBitModels;
-    },
-    get kAlignMask () {
-        return kAlignMask;
-    },
-    get kAlignTableSize () {
-        return kAlignTableSize;
-    },
-    get kBitModelTotal () {
-        return kBitModelTotal;
-    },
-    get kDicLogSizeMin () {
-        return kDicLogSizeMin;
-    },
-    get kEndPosModelIndex () {
-        return kEndPosModelIndex;
-    },
-    get kMatchMaxLen () {
-        return kMatchMaxLen;
-    },
-    get kMatchMinLen () {
-        return kMatchMinLen;
-    },
-    get kNumAlignBits () {
-        return kNumAlignBits;
-    },
-    get kNumBitModelTotalBits () {
-        return kNumBitModelTotalBits;
-    },
-    get kNumFullDistances () {
-        return kNumFullDistances;
-    },
-    get kNumHighLenBits () {
-        return kNumHighLenBits;
-    },
-    get kNumLenSymbols () {
-        return kNumLenSymbols;
-    },
-    get kNumLenToPosStates () {
-        return kNumLenToPosStates;
-    },
-    get kNumLenToPosStatesBits () {
-        return kNumLenToPosStatesBits;
-    },
-    get kNumLitContextBitsMax () {
-        return kNumLitContextBitsMax;
-    },
-    get kNumLitPosStatesBitsEncodingMax () {
-        return kNumLitPosStatesBitsEncodingMax;
-    },
-    get kNumLowLenBits () {
-        return kNumLowLenBits;
-    },
-    get kNumLowLenSymbols () {
-        return kNumLowLenSymbols;
-    },
-    get kNumMidLenBits () {
-        return kNumMidLenBits;
-    },
-    get kNumMidLenSymbols () {
-        return kNumMidLenSymbols;
-    },
-    get kNumMoveBits () {
-        return kNumMoveBits;
-    },
-    get kNumPosModels () {
-        return kNumPosModels;
-    },
-    get kNumPosSlotBits () {
-        return kNumPosSlotBits;
-    },
-    get kNumPosStatesBitsEncodingMax () {
-        return kNumPosStatesBitsEncodingMax;
-    },
-    get kNumPosStatesBitsMax () {
-        return kNumPosStatesBitsMax;
-    },
-    get kNumPosStatesEncodingMax () {
-        return kNumPosStatesEncodingMax;
-    },
-    get kNumPosStatesMax () {
-        return kNumPosStatesMax;
-    },
-    get kNumRepDistances () {
-        return kNumRepDistances;
-    },
-    get kNumStates () {
-        return kNumStates;
-    },
-    get kProbInitValue () {
-        return kProbInitValue;
-    },
-    get kStartPosModelIndex () {
-        return kStartPosModelIndex;
-    },
-    get lzma2IsUncompressed () {
-        return lzma2IsUncompressed;
-    },
-    get lzma2NeedsNewProps () {
-        return lzma2NeedsNewProps;
-    },
-    get lzma2NeedsResetProbs () {
-        return lzma2NeedsResetProbs;
-    },
-    get parseLzma2DictionarySize () {
-        return parseLzma2DictionarySize;
-    },
-    get parseProperties () {
-        return parseProperties;
-    },
-    get stateIsCharState () {
-        return stateIsCharState;
-    },
-    get stateUpdateChar () {
-        return stateUpdateChar;
-    },
-    get stateUpdateMatch () {
-        return stateUpdateMatch;
-    },
-    get stateUpdateRep () {
-        return stateUpdateRep;
-    },
-    get stateUpdateShortRep () {
-        return stateUpdateShortRep;
-    }
-});
-var kNumRepDistances = 4;
-var kNumStates = 12;
-var kNumPosSlotBits = 6;
-var kDicLogSizeMin = 0;
-var kNumLenToPosStatesBits = 2;
-var kNumLenToPosStates = 1 << kNumLenToPosStatesBits; // 4
-var kMatchMinLen = 2;
-var kNumLowLenBits = 3;
-var kNumMidLenBits = 3;
-var kNumHighLenBits = 8;
-var kNumLowLenSymbols = 1 << kNumLowLenBits; // 8
-var kNumMidLenSymbols = 1 << kNumMidLenBits; // 8
-var kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols + (1 << kNumHighLenBits); // 272
-var kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1; // 273
-var kNumAlignBits = 4;
-var kAlignTableSize = 1 << kNumAlignBits; // 16
-var kAlignMask = kAlignTableSize - 1; // 15
-var kStartPosModelIndex = 4;
-var kEndPosModelIndex = 14;
-var kNumPosModels = kEndPosModelIndex - kStartPosModelIndex; // 10
-var kNumFullDistances = 1 << (kEndPosModelIndex >>> 1); // 128
-var kNumLitPosStatesBitsEncodingMax = 4;
-var kNumLitContextBitsMax = 8;
-var kNumPosStatesBitsMax = 4;
-var kNumPosStatesMax = 1 << kNumPosStatesBitsMax; // 16
-var kNumPosStatesBitsEncodingMax = 4;
-var kNumPosStatesEncodingMax = 1 << kNumPosStatesBitsEncodingMax; // 16
-var kNumBitModelTotalBits = 11;
-var kBitModelTotal = 1 << kNumBitModelTotalBits; // 2048
-var kNumMoveBits = 5;
-var kProbInitValue = kBitModelTotal >>> 1; // 1024
-function stateUpdateChar(state) {
-    if (state < 4) return 0;
-    if (state < 10) return state - 3;
-    return state - 6;
-}
-function stateUpdateMatch(state) {
-    return state < 7 ? 7 : 10;
-}
-function stateUpdateRep(state) {
-    return state < 7 ? 8 : 11;
-}
-function stateUpdateShortRep(state) {
-    return state < 7 ? 9 : 11;
-}
-function stateIsCharState(state) {
-    return state < 7;
-}
-function getLenToPosState(len) {
-    len -= kMatchMinLen;
-    return len < kNumLenToPosStates ? len : kNumLenToPosStates - 1;
-}
-function initBitModels(probs, count) {
-    if (probs === null) {
-        if (count === undefined) {
-            throw new Error('count required when probs is null');
-        }
-        probs = new Uint16Array(count);
-    }
-    for(var i = 0; i < probs.length; i++){
-        probs[i] = kProbInitValue;
-    }
-    return probs;
-}
-function parseProperties(properties) {
-    if (properties.length < 5) {
-        throw new Error('LZMA properties must be at least 5 bytes');
-    }
-    var d = properties[0] & 0xff;
-    var lc = d % 9;
-    var remainder = ~~(d / 9);
-    var lp = remainder % 5;
-    var pb = ~~(remainder / 5);
-    if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {
-        throw new Error('Invalid LZMA properties');
-    }
-    var dictionarySize = 0;
-    for(var i = 0; i < 4; i++){
-        dictionarySize |= (properties[1 + i] & 0xff) << i * 8;
-    }
-    return {
-        lc: lc,
-        lp: lp,
-        pb: pb,
-        dictionarySize: dictionarySize
-    };
-}
-var LZMA2_CONTROL = {
-    END: 0x00,
-    UNCOMPRESSED_RESET_DIC: 0x01,
-    UNCOMPRESSED: 0x02,
-    LZMA_RESET_STATE_NEW_PROP: 0xe0
-};
-function lzma2NeedsNewProps(control) {
-    return control >= 0xe0;
-}
-function lzma2NeedsResetProbs(control) {
-    return control >= 0xa0;
-}
-function lzma2IsUncompressed(control) {
-    return control < 0x80;
-}
-function parseLzma2DictionarySize(prop) {
-    if (prop > 40) {
-        throw new Error('Invalid LZMA2 dictionary size property');
-    }
-    if (prop === 40) {
-        return 0xffffffff;
-    }
-    var base = 2 | prop & 1;
-    var exp = (prop >>> 1) + 11;
-    return base << exp;
-}
-/* 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/lzma/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/types.ts"],"sourcesContent":["/**\n * LZMA Types and Constants\n *\n * Shared types, constants, and state transition functions for LZMA decoding.\n * Based on the LZMA SDK specification.\n */\n\n// LZMA State Machine Constants\nexport const kNumRepDistances = 4;\nexport const kNumStates = 12;\n\n// Position slot constants\nexport const kNumPosSlotBits = 6;\nexport const kDicLogSizeMin = 0;\nexport const kNumLenToPosStatesBits = 2;\nexport const kNumLenToPosStates = 1 << kNumLenToPosStatesBits; // 4\n\n// Match length constants\nexport const kMatchMinLen = 2;\nexport const kNumLowLenBits = 3;\nexport const kNumMidLenBits = 3;\nexport const kNumHighLenBits = 8;\nexport const kNumLowLenSymbols = 1 << kNumLowLenBits; // 8\nexport const kNumMidLenSymbols = 1 << kNumMidLenBits; // 8\nexport const kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols + (1 << kNumHighLenBits); // 272\nexport const kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1; // 273\n\n// Alignment constants\nexport const kNumAlignBits = 4;\nexport const kAlignTableSize = 1 << kNumAlignBits; // 16\nexport const kAlignMask = kAlignTableSize - 1; // 15\n\n// Position model constants\nexport const kStartPosModelIndex = 4;\nexport const kEndPosModelIndex = 14;\nexport const kNumPosModels = kEndPosModelIndex - kStartPosModelIndex; // 10\nexport const kNumFullDistances = 1 << (kEndPosModelIndex >>> 1); // 128\n\n// Literal/pos state constants\nexport const kNumLitPosStatesBitsEncodingMax = 4;\nexport const kNumLitContextBitsMax = 8;\nexport const kNumPosStatesBitsMax = 4;\nexport const kNumPosStatesMax = 1 << kNumPosStatesBitsMax; // 16\nexport const kNumPosStatesBitsEncodingMax = 4;\nexport const kNumPosStatesEncodingMax = 1 << kNumPosStatesBitsEncodingMax; // 16\n\n// Range coder probability constants\nexport const kNumBitModelTotalBits = 11;\nexport const kBitModelTotal = 1 << kNumBitModelTotalBits; // 2048\nexport const kNumMoveBits = 5;\nexport const kProbInitValue = kBitModelTotal >>> 1; // 1024\n\n/**\n * State transition: after literal byte\n */\nexport function stateUpdateChar(state: number): number {\n  if (state < 4) return 0;\n  if (state < 10) return state - 3;\n  return state - 6;\n}\n\n/**\n * State transition: after match\n */\nexport function stateUpdateMatch(state: number): number {\n  return state < 7 ? 7 : 10;\n}\n\n/**\n * State transition: after rep (repeated match)\n */\nexport function stateUpdateRep(state: number): number {\n  return state < 7 ? 8 : 11;\n}\n\n/**\n * State transition: after short rep\n */\nexport function stateUpdateShortRep(state: number): number {\n  return state < 7 ? 9 : 11;\n}\n\n/**\n * Check if state indicates previous symbol was a character (literal)\n */\nexport function stateIsCharState(state: number): boolean {\n  return state < 7;\n}\n\n/**\n * Get length-to-position state index\n */\nexport function getLenToPosState(len: number): number {\n  len -= kMatchMinLen;\n  return len < kNumLenToPosStates ? len : kNumLenToPosStates - 1;\n}\n\n/**\n * Initialize probability array with default values\n * @param probs - Array to initialize (or null to create new)\n * @param count - Number of probabilities\n * @returns Initialized probability array\n */\nexport function initBitModels(probs: Uint16Array | null, count?: number): Uint16Array {\n  if (probs === null) {\n    if (count === undefined) {\n      throw new Error('count required when probs is null');\n    }\n    probs = new Uint16Array(count);\n  }\n  for (let i = 0; i < probs.length; i++) {\n    probs[i] = kProbInitValue;\n  }\n  return probs;\n}\n\n/**\n * LZMA properties parsed from the 5-byte header\n */\nexport interface LzmaProperties {\n  /** Literal context bits (0-8) */\n  lc: number;\n  /** Literal pos bits (0-4) */\n  lp: number;\n  /** Pos bits (0-4) */\n  pb: number;\n  /** Dictionary size in bytes */\n  dictionarySize: number;\n}\n\n/**\n * Parse LZMA properties from a 5-byte buffer\n */\nexport function parseProperties(properties: Buffer | Uint8Array): LzmaProperties {\n  if (properties.length < 5) {\n    throw new Error('LZMA properties must be at least 5 bytes');\n  }\n\n  const d = properties[0] & 0xff;\n  const lc = d % 9;\n  const remainder = ~~(d / 9);\n  const lp = remainder % 5;\n  const pb = ~~(remainder / 5);\n\n  if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  let dictionarySize = 0;\n  for (let i = 0; i < 4; i++) {\n    dictionarySize |= (properties[1 + i] & 0xff) << (i * 8);\n  }\n\n  return { lc, lp, pb, dictionarySize };\n}\n\n/**\n * LZMA2 control byte meanings\n */\nexport const LZMA2_CONTROL = {\n  END: 0x00,\n  UNCOMPRESSED_RESET_DIC: 0x01,\n  UNCOMPRESSED: 0x02,\n  LZMA_RESET_STATE_NEW_PROP: 0xe0,\n} as const;\n\n/**\n * Check if LZMA2 control byte indicates reset state (new properties)\n */\nexport function lzma2NeedsNewProps(control: number): boolean {\n  return control >= 0xe0;\n}\n\n/**\n * Check if LZMA2 control byte indicates reset probabilities\n */\nexport function lzma2NeedsResetProbs(control: number): boolean {\n  return control >= 0xa0;\n}\n\n/**\n * Check if LZMA2 control byte indicates uncompressed chunk\n */\nexport function lzma2IsUncompressed(control: number): boolean {\n  return control < 0x80;\n}\n\n/**\n * Parse LZMA2 dictionary size from property byte\n */\nexport function parseLzma2DictionarySize(prop: number): number {\n  if (prop > 40) {\n    throw new Error('Invalid LZMA2 dictionary size property');\n  }\n  if (prop === 40) {\n    return 0xffffffff;\n  }\n  const base = 2 | (prop & 1);\n  const exp = (prop >>> 1) + 11;\n  return base << exp;\n}\n\n/**\n * Output sink interface for fast streaming decode\n * Can be a Buffer (with write method) or a stream with write() method\n */\nexport interface OutputSink {\n  write(buffer: Buffer): void;\n}\n"],"names":["LZMA2_CONTROL","getLenToPosState","initBitModels","kAlignMask","kAlignTableSize","kBitModelTotal","kDicLogSizeMin","kEndPosModelIndex","kMatchMaxLen","kMatchMinLen","kNumAlignBits","kNumBitModelTotalBits","kNumFullDistances","kNumHighLenBits","kNumLenSymbols","kNumLenToPosStates","kNumLenToPosStatesBits","kNumLitContextBitsMax","kNumLitPosStatesBitsEncodingMax","kNumLowLenBits","kNumLowLenSymbols","kNumMidLenBits","kNumMidLenSymbols","kNumMoveBits","kNumPosModels","kNumPosSlotBits","kNumPosStatesBitsEncodingMax","kNumPosStatesBitsMax","kNumPosStatesEncodingMax","kNumPosStatesMax","kNumRepDistances","kNumStates","kProbInitValue","kStartPosModelIndex","lzma2IsUncompressed","lzma2NeedsNewProps","lzma2NeedsResetProbs","parseLzma2DictionarySize","parseProperties","stateIsCharState","stateUpdateChar","stateUpdateMatch","stateUpdateRep","stateUpdateShortRep","state","len","probs","count","undefined","Error","Uint16Array","i","length","properties","d","lc","remainder","lp","pb","dictionarySize","END","UNCOMPRESSED_RESET_DIC","UNCOMPRESSED","LZMA_RESET_STATE_NEW_PROP","control","prop","base","exp"],"mappings":"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"}

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>;