7z-iterator 1.4.0 → 2.0.2

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

@@ -1,175 +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.
-import { allocBuffer, bufferFrom, 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 function decodeBcj(input, _properties, _unpackSize) {
-    // BCJ filter state
-    let pos = 0;
-    let prevMask = 0;
-    const output = bufferFrom(input); // Copy since we modify in place
-    while(pos < output.length - 4){
-        const 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
-        const 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)
-        const 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
-        const highByte = output[pos + 4];
-        if (highByte === 0x00 || highByte === 0xff) {
-            // Convert absolute to relative
-            let newAddr;
-            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;
-}
-/**
- * Create a streaming BCJ decoder Transform.
- * Processes data chunk by chunk, buffering incomplete instructions.
- */ export function createBcjDecoder(_properties, _unpackSize) {
-    // State that persists across chunks
-    let globalPos = 0; // Position in the overall stream
-    let prevMask = 0;
-    let pending = null; // Bytes pending from previous chunk
-    const transform = new Transform({
-        transform: (chunk, _encoding, callback)=>{
-            // Combine pending bytes with new chunk
-            let 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
-            const safeEnd = data.length - 4;
-            if (safeEnd <= 0) {
-                // Not enough data yet, keep it all pending
-                pending = data;
-                callback(null, allocBuffer(0));
-                return;
-            }
-            const output = bufferFrom(data.slice(0, safeEnd)); // Copy the portion we'll process
-            pending = data.slice(safeEnd); // Keep last 4 bytes for next chunk
-            let localPos = 0;
-            while(localPos < output.length){
-                const 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)
-                let addr;
-                let highByte;
-                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
-                    let newAddr;
-                    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(callback) {
-            // Output any remaining pending bytes
-            if (pending && pending.length > 0) {
-                // Process the final bytes - no need to worry about spanning
-                const output = 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;
-}

package/dist/esm/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":["allocBuffer","bufferFrom","Transform","decodeBcj","input","_properties","_unpackSize","pos","prevMask","output","length","b","offset","addr","highByte","newAddr","createBcjDecoder","globalPos","pending","transform","chunk","_encoding","callback","data","Buffer","concat","safeEnd","slice","localPos","flush","push"],"mappings":"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"}

package/dist/esm/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/esm/sevenz/codecs/BcjArm.js

@@ -1,101 +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.
-import { allocBuffer, bufferFrom, 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 function decodeBcjArm(input, _properties, _unpackSize) {
-    const output = bufferFrom(input); // Copy since we modify in place
-    let 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)
-            let 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)
-            const 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;
-}
-/**
- * Create a streaming ARM BCJ decoder Transform.
- * Processes data in 4-byte aligned chunks.
- */ export function createBcjArmDecoder(_properties, _unpackSize) {
-    let globalPos = 0; // Position in the overall stream (in bytes)
-    let pending = null; // Incomplete 4-byte group
-    const transform = new Transform({
-        transform: (chunk, _encoding, callback)=>{
-            // Combine pending bytes with new chunk
-            let data;
-            if (pending && pending.length > 0) {
-                data = Buffer.concat([
-                    pending,
-                    chunk
-                ]);
-            } else {
-                data = chunk;
-            }
-            // Process only complete 4-byte groups
-            const completeBytes = data.length - data.length % 4;
-            if (completeBytes === 0) {
-                pending = data;
-                callback(null, allocBuffer(0));
-                return;
-            }
-            const output = bufferFrom(data.slice(0, completeBytes));
-            pending = data.length > completeBytes ? data.slice(completeBytes) : null;
-            let pos = 0;
-            while(pos + 4 <= output.length){
-                if (output[pos + 3] === 0xeb) {
-                    let addr = output[pos] | output[pos + 1] << 8 | output[pos + 2] << 16;
-                    if (addr & 0x800000) {
-                        addr |= 0xff000000;
-                    }
-                    const 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(callback) {
-            if (pending && pending.length > 0) {
-                this.push(pending);
-            }
-            callback(null);
-        }
-    });
-    return transform;
-}

package/dist/esm/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":["allocBuffer","bufferFrom","Transform","decodeBcjArm","input","_properties","_unpackSize","output","pos","length","addr","relAddr","createBcjArmDecoder","globalPos","pending","transform","chunk","_encoding","callback","data","Buffer","concat","completeBytes","slice","flush","push"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;AAC/D,EAAE;AACF,2EAA2E;AAE3E,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIF,MAAM,CAACC,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,MAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BD,MAAM,CAACC,IAAI,GAAGG,UAAU;YACxBJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;;CAGC,GACD,OAAO,SAASK,oBAAoBP,WAAoB,EAAEC,WAAoB;IAC5E,IAAIO,YAAY,GAAG,4CAA4C;IAC/D,IAAIC,UAAyB,MAAM,0BAA0B;IAE7D,MAAMC,YAAY,IAAIb,UAAU;QAC9Ba,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIL,WAAWA,QAAQL,MAAM,GAAG,GAAG;gBACjCU,OAAOC,OAAOC,MAAM,CAAC;oBAACP;oBAASE;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,sCAAsC;YACtC,MAAMM,gBAAgBH,KAAKV,MAAM,GAAIU,KAAKV,MAAM,GAAG;YACnD,IAAIa,kBAAkB,GAAG;gBACvBR,UAAUK;gBACVD,SAAS,MAAMlB,YAAY;gBAC3B;YACF;YAEA,MAAMO,SAASN,WAAWkB,KAAKI,KAAK,CAAC,GAAGD;YACxCR,UAAUK,KAAKV,MAAM,GAAGa,gBAAgBH,KAAKI,KAAK,CAACD,iBAAiB;YAEpE,IAAId,MAAM;YACV,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;gBAC/B,IAAIF,MAAM,CAACC,MAAM,EAAE,KAAK,MAAM;oBAC5B,IAAIE,OAAOH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI;oBACtE,IAAIE,OAAO,UAAU;wBACnBA,QAAQ;oBACV;oBACA,MAAMC,UAAUD,OAAQG,CAAAA,cAAc,CAAA;oBACtCN,MAAM,CAACC,IAAI,GAAGG,UAAU;oBACxBJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;oBACpCJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;gBACvC;gBACAH,OAAO;gBACPK,aAAa;YACf;YAEAK,SAAS,MAAMX;QACjB;QACAiB,OAAO,SAAgDN,QAAsC;YAC3F,IAAIJ,WAAWA,QAAQL,MAAM,GAAG,GAAG;gBACjC,IAAI,CAACgB,IAAI,CAACX;YACZ;YACAI,SAAS;QACX;IACF;IAEA,OAAOH;AACT"}

package/dist/esm/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/esm/sevenz/codecs/BcjArm64.js

@@ -1,57 +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
-import { bufferFrom } from 'extract-base-iterator';
-import createBufferingDecoder from './createBufferingDecoder.js';
-/**
- * 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 function decodeBcjArm64(input, _properties, _unpackSize) {
-    const output = bufferFrom(input); // Copy since we modify in place
-    let pos = 0;
-    // Process 4-byte aligned positions
-    while(pos + 4 <= output.length){
-        // Read 32-bit value (little-endian)
-        let 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
-            let addr = instr & 0x03ffffff;
-            // Sign-extend 26-bit to 32-bit
-            if (addr & 0x02000000) {
-                addr |= 0xfc000000;
-            }
-            // Convert absolute to relative: subtract current position (in words)
-            const 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;
-}
-/**
- * Create an ARM64 BCJ decoder Transform stream
- */ export function createBcjArm64Decoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeBcjArm64, properties, unpackSize);
-}

package/dist/esm/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":["bufferFrom","createBufferingDecoder","decodeBcjArm64","input","_properties","_unpackSize","output","pos","length","instr","addr","relAddr","createBcjArm64Decoder","properties","unpackSize"],"mappings":"AAAA,iFAAiF;AACjF,gEAAgE;AAChE,EAAE;AACF,6FAA6F;AAC7F,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,oCAAoC;QACpC,IAAIC,QAAQH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI,KAAO,AAACD,MAAM,CAACC,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,MAAMC,UAAUD,OAAQH,CAAAA,QAAQ,CAAA;YAEhC,sDAAsD;YACtDE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,6BAA6B;YAC7BL,MAAM,CAACC,IAAI,GAAGE,QAAQ;YACtBH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;QACrC;QAEAF,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOb,uBAAuBC,gBAAgBW,YAAYC;AAC5D"}

package/dist/esm/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/esm/sevenz/codecs/BcjArmt.js

@@ -1,66 +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
-import { bufferFrom } from 'extract-base-iterator';
-import createBufferingDecoder from './createBufferingDecoder.js';
-/**
- * Decode ARM Thumb BCJ filtered data
- * Reverses the BCJ transformation by converting absolute addresses back to relative
- *
- * ARM Thumb BL instruction format (2 x 16-bit):
- * - First half-word: 1111 0xxx xxxx xxxx (high bits of offset)
- * - Second half-word: 1111 1xxx xxxx xxxx (low bits of offset)
- *
- * @param input - ARM Thumb BCJ filtered data
- * @param _properties - Unused for ARM Thumb BCJ
- * @param _unpackSize - Unused for ARM Thumb BCJ
- * @returns Unfiltered data
- */ export function decodeBcjArmt(input, _properties, _unpackSize) {
-    const output = bufferFrom(input); // Copy since we modify in place
-    let pos = 0;
-    // Process 2-byte aligned positions
-    while(pos + 4 <= output.length){
-        // Read two 16-bit values (little-endian)
-        const w0 = output[pos] | output[pos + 1] << 8;
-        const 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
-            const hi = w0 & 0x7ff;
-            const lo = w1 & 0x7ff;
-            // Combine into 22-bit offset (in half-words)
-            let 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
-            const relAddr = addr - (pos >>> 1);
-            // Write back
-            const newHi = relAddr >>> 11 & 0x7ff;
-            const newLo = relAddr & 0x7ff;
-            output[pos] = newHi & 0xff;
-            output[pos + 1] = 0xf0 | newHi >>> 8 & 0x07;
-            output[pos + 2] = newLo & 0xff;
-            output[pos + 3] = 0xf8 | newLo >>> 8 & 0x07;
-            pos += 4;
-        } else {
-            pos += 2;
-        }
-    }
-    return output;
-}
-/**
- * Create an ARM Thumb BCJ decoder Transform stream
- */ export function createBcjArmtDecoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeBcjArmt, properties, unpackSize);
-}

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

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

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

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