xz-compat 0.1.0

package/LICENSE

@@ -0,0 +1,42 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Kevin Malakoff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+wof this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------zip: https://github.com/kriskowal/zip/blob/master/LICENSE
+
+Copyright 2009, 2010 Kristopher Michael Kowal. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,248 @@
+# xz-compat
+
+**XZ Decompression Library**
+
+xz-compat is a complete pure JavaScript implementation of XZ decompression with support for LZMA2 compression, BCJ filters (Branch Conversion for various CPU architectures), and Delta filtering. Compatible with Node.js 0.8+.
+
+## Features
+
+- ✅ **XZ Format Support**: Full XZ container format decoding
+- ✅ **LZMA2 Decoder**: Complete LZMA2 decompression implementation
+- ✅ **BCJ Filters**: Branch conversion for improved compression on executables
+  - x86 (32-bit)
+  - ARM (32-bit)
+  - ARM64 / AArch64
+  - ARM Thumb
+  - PowerPC
+  - SPARC
+  - IA64 / Itanium
+- ✅ **Delta Filter**: Byte-level delta encoding
+- ✅ **Streaming & Sync**: Both streaming transforms and synchronous decoding
+- ✅ **Node 0.8+**: Works on legacy Node.js versions
+- ✅ **No Native Dependencies**: Pure JavaScript, no compilation required
+
+## Installation
+
+```bash
+npm install xz-compat
+```
+
+## Quick Start
+
+### Synchronous XZ Decompression
+
+```javascript
+import { readFileSync } from 'fs';
+import { decodeXZ } from 'xz-compat';
+
+const compressedData = readFileSync('file.xz');
+const decompressedData = decodeXZ(compressedData);
+console.log('Decompressed:', decompressedData.toString());
+```
+
+### Streaming XZ Decompression
+
+```javascript
+import { createReadStream } from 'fs';
+import { createXZDecoder } from 'xz-compat';
+
+const input = createReadStream('file.xz');
+const decoder = createXZDecoder();
+
+input.pipe(decoder);
+decoder.on('data', (chunk) => {
+  console.log('Decompressed chunk:', chunk);
+});
+```
+
+### LZMA2 Decompression
+
+```javascript
+import { decodeLzma2 } from 'xz-compat';
+import { writeFileSync } from 'fs';
+
+const lzma2Data = readFileSync('data.lzma2');
+const chunks = [];
+
+decodeLzma2(lzma2Data, lzma2Properties, expectedSize, {
+  write: (chunk) => {
+    chunks.push(chunk);
+  }
+});
+
+const decompressed = Buffer.concat(chunks);
+writeFileSync('output.bin', decompressed);
+```
+
+### Using BCJ Filters Directly
+
+```javascript
+import { decodeBcj, decodeBcjArm } from 'xz-compat';
+
+// Decode x86 BCJ filtered data
+const x86Data = readFileSync('filtered-x86.bin');
+const unfiltered = decodeBcj(x86Data);
+
+// Decode ARM BCJ filtered data
+const armData = readFileSync('filtered-arm.bin');
+const unfilteredArm = decodeBcjArm(armData);
+```
+
+## API Reference
+
+### XZ Decompression
+
+#### `decodeXZ(buffer: Buffer): Buffer`
+Synchronously decompresses XZ format data.
+
+#### `createXZDecoder(): Transform`
+Creates a streaming Transform for XZ decompression.
+
+### LZMA2 Decompression
+
+#### `decodeLzma2(buffer: Buffer, properties: Buffer, unpackSize: number, sink: OutputSink): void`
+Synchronously decodes LZMA2 compressed data.
+
+#### `createLzma2Decoder(properties: Buffer, unpackSize: number): Transform`
+Creates a streaming Transform for LZMA2 decompression.
+
+### BCJ Filters
+
+Branch Conversion (BCJ) filters improve compression of executables by converting relative branch addresses to absolute addresses, creating more repetitive patterns.
+
+All BCJ filters follow the same interface:
+- `decodeBcj*(buffer: Buffer, properties?: Buffer, unpackSize?: number): Buffer`
+- `createBcj*Decoder(properties?: Buffer, unpackSize?: number): Transform`
+
+Supported BCJ filters:
+- `decodeBcj` / `createBcjDecoder` - x86 (32-bit)
+- `decodeBcjArm` / `createBcjArmDecoder` - ARM (32-bit)
+- `decodeBcjArm64` / `createBcjArm64Decoder` - ARM64 / AArch64
+- `decodeBcjArmt` / `createBcjArmtDecoder` - ARM Thumb
+- `decodeBcjPpc` / `createBcjPpcDecoder` - PowerPC
+- `decodeBcjSparc` / `createBcjSparcDecoder` - SPARC
+- `decodeBcjIa64` / `createBcjIa64Decoder` - IA64 / Itanium
+
+### Delta Filter
+
+#### `decodeDelta(buffer: Buffer, distance?: Buffer): Buffer`
+Decodes Delta filtered data (inter-byte differences).
+
+## Use Cases
+
+### 1. Decompressing XZ Archives
+
+```javascript
+import { createReadStream } from 'fs';
+import { createXZDecoder } from 'xz-compat';
+import { pipeline } from 'stream/promises';
+
+async function decompressXZ(inputPath, outputPath) {
+  await pipeline(
+    createReadStream(inputPath),
+    createXZDecoder(),
+    createWriteStream(outputPath)
+  );
+}
+```
+
+### 2. Working with LZMA Compressed Files
+
+```javascript
+import { decodeLzma2 } from 'xz-compat';
+
+// Decompress raw LZMA2 stream
+const data = readFileSync('data.lzma2');
+const chunks = [];
+
+decodeLzma2(data, propertiesBuffer, uncompressedSize, {
+  write: (chunk) => chunks.push(chunk)
+});
+
+const result = Buffer.concat(chunks);
+```
+
+### 3. Batch Processing Compressed Files
+
+```javascript
+import { decodeXZ } from 'xz-compat';
+
+function processXZFiles(filePaths) {
+  return filePaths.map(file => {
+    const compressed = readFileSync(file);
+    const decompressed = decodeXZ(compressed);
+    // Process decompressed data
+    return processData(decompressed);
+  });
+}
+```
+
+## Technical Details
+
+### XZ Format Structure
+
+XZ is a container format that wraps LZMA2 compressed data:
+1. Stream Header
+2. One or more Blocks (each with Block Header + Compressed Data)
+3. Index (records block positions)
+4. Stream Footer
+
+Each Block can contain:
+- A chain of preprocessing filters (Delta, BCJ)
+- LZMA2 compression
+
+### BCJ Filter Algorithm
+
+BCJ filters convert branch instructions in executable code:
+
+**x86 Example:**
+- Original: `E8 xx xx xx xx` (CALL with relative offset)
+- Converted: `E8 aa aa aa aa` (CALL with absolute address)
+
+This creates more repetitive patterns for better LZMA2 compression.
+
+### Reference Implementation
+
+This implementation is based on the reference XZ Utils (XZ Embedded) codebase:
+- [XZ Utils GitHub](https://github.com/tukaani-project/xz)
+- Filter algorithms match the xz embedded reference implementations
+
+## Compatibility
+
+- **Node.js**: 0.8 and above
+- **Browser**: Not tested (designed for Node.js)
+- **Dependencies**: None (pure JavaScript)
+
+## Differences from Native XZ
+
+This is a **decompression-only** implementation focused on compatibility and ease of use:
+- No compression support (only decompression)
+- Simplified streaming interface
+- Pure JavaScript (no native bindings)
+- Optimized for readability and maintainability
+
+## Performance
+
+Performance characteristics:
+- **Synchronous**: Suitable for small to medium files
+- **Streaming**: Memory-efficient for large files
+- **Trade-off**: Pure JavaScript may be slower than native implementations
+- **BCJ Decoding**: Optimized reference algorithm implementations
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions welcome! Please ensure tests pass:
+
+```bash
+npm test
+```
+
+## References
+
+- [XZ Format Specification](https://tukaani.org/xz/xz-file-format.txt)
+- [LZMA SDK](https://www.7-zip.org/sdk.html)
+- [XZ Utils](https://tukaani.org/xz/)

package/dist/cjs/compat.d.cts

@@ -0,0 +1 @@
+export declare function tmpdir(): string;

package/dist/cjs/compat.d.ts

@@ -0,0 +1 @@
+export declare function tmpdir(): string;

package/dist/cjs/compat.js

@@ -0,0 +1,23 @@
+/**
+ * Compatibility Layer for Node.js 0.8+
+ * Local to this package - contains only needed functions.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "tmpdir", {
+    enumerable: true,
+    get: function() {
+        return tmpdir;
+    }
+});
+var _os = /*#__PURE__*/ _interop_require_default(require("os"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function tmpdir() {
+    return typeof _os.default.tmpdir === 'function' ? _os.default.tmpdir() : require('os-shim').tmpdir();
+}
+/* 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/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/compat.ts"],"sourcesContent":["/**\n * Compatibility Layer for Node.js 0.8+\n * Local to this package - contains only needed functions.\n */\nimport os from 'os';\n\nexport function tmpdir(): string {\n  return typeof os.tmpdir === 'function' ? os.tmpdir() : require('os-shim').tmpdir();\n}\n"],"names":["tmpdir","os","require"],"mappings":"AAAA;;;CAGC;;;;+BAGeA;;;eAAAA;;;yDAFD;;;;;;AAER,SAASA;IACd,OAAO,OAAOC,WAAE,CAACD,MAAM,KAAK,aAAaC,WAAE,CAACD,MAAM,KAAKE,QAAQ,WAAWF,MAAM;AAClF"}

package/dist/cjs/filters/bcj/Bcj.d.cts

@@ -0,0 +1,16 @@
+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/filters/bcj/Bcj.d.ts

@@ -0,0 +1,16 @@
+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/filters/bcj/Bcj.js

@@ -0,0 +1,192 @@
+// 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/tukaani-project/xz/blob/master/src/liblzma/simple/x86.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");
+// Test if byte is 0x00 or 0xFF (valid MSB for converted addresses)
+function Test86MSByte(b) {
+    return b === 0 || b === 0xff;
+}
+// Lookup table for mask to bit number conversion (used in false positive prevention)
+var MASK_TO_BIT_NUMBER = [
+    0,
+    1,
+    2,
+    2,
+    3
+];
+/**
+ * Core x86 BCJ conversion function (matches reference x86_code)
+ * Works for both encoding and decoding based on isEncoder flag
+ *
+ * @param state - Filter state (prevMask and prevPos)
+ * @param nowPos - Current position in the overall stream
+ * @param isEncoder - true for encoding, false for decoding
+ * @param buffer - Buffer to process (modified in place)
+ * @param size - Size of buffer
+ * @returns Number of bytes processed
+ */ function x86Code(state, nowPos, isEncoder, buffer, size) {
+    var prevMask = state.prevMask;
+    var prevPos = state.prevPos;
+    if (size < 5) {
+        return 0;
+    }
+    // Decay prev_pos if too far from current position
+    if (nowPos - prevPos > 5) {
+        prevPos = nowPos - 5;
+    }
+    var limit = size - 5;
+    var bufferPos = 0;
+    while(bufferPos <= limit){
+        var opcode = buffer[bufferPos];
+        // Check for CALL (0xE8) or JMP (0xE9) opcode
+        if (opcode !== 0xe8 && opcode !== 0xe9) {
+            bufferPos++;
+            continue;
+        }
+        // Calculate offset from previous position
+        var offset = nowPos + bufferPos - prevPos;
+        prevPos = nowPos + bufferPos;
+        // Update mask based on offset
+        if (offset > 5) {
+            prevMask = 0;
+        } else {
+            for(var i = 0; i < offset; i++){
+                prevMask &= 0x77;
+                prevMask <<= 1;
+            }
+        }
+        // Get the high byte of the address
+        var b = buffer[bufferPos + 4];
+        // Check if this looks like a valid address to convert
+        if (Test86MSByte(b) && prevMask >> 1 <= 4 && prevMask >> 1 !== 3) {
+            // Read 32-bit address (big-endian style: high byte first in src)
+            var src = b << 24 | buffer[bufferPos + 3] << 16 | buffer[bufferPos + 2] << 8 | buffer[bufferPos + 1];
+            // Make src unsigned 32-bit
+            src = src >>> 0;
+            var dest = void 0;
+            // Conversion loop with false positive correction
+            while(true){
+                if (isEncoder) {
+                    dest = src + (nowPos + bufferPos + 5) >>> 0;
+                } else {
+                    dest = src - (nowPos + bufferPos + 5) >>> 0;
+                }
+                if (prevMask === 0) {
+                    break;
+                }
+                var i1 = MASK_TO_BIT_NUMBER[prevMask >> 1];
+                b = dest >>> 24 - i1 * 8 & 0xff;
+                if (!Test86MSByte(b)) {
+                    break;
+                }
+                // XOR correction for false positive prevention
+                src = (dest ^ (1 << 32 - i1 * 8) - 1) >>> 0;
+            }
+            // Write back the converted address
+            // High byte: ~(((dest >> 24) & 1) - 1) produces 0x00 or 0xFF
+            buffer[bufferPos + 4] = ~((dest >>> 24 & 1) - 1) & 0xff;
+            buffer[bufferPos + 3] = dest >>> 16 & 0xff;
+            buffer[bufferPos + 2] = dest >>> 8 & 0xff;
+            buffer[bufferPos + 1] = dest & 0xff;
+            bufferPos += 5;
+            prevMask = 0;
+        } else {
+            bufferPos++;
+            prevMask |= 1;
+            if (Test86MSByte(b)) {
+                prevMask |= 0x10;
+            }
+        }
+    }
+    // Save state
+    state.prevMask = prevMask;
+    state.prevPos = prevPos;
+    return bufferPos;
+}
+function decodeBcj(input, _properties, _unpackSize) {
+    var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
+    var state = {
+        prevMask: 0,
+        prevPos: 0xfffffffb
+    };
+    x86Code(state, 0, false, output, output.length);
+    return output;
+}
+function createBcjDecoder(_properties, _unpackSize) {
+    // State that persists across chunks
+    var state = {
+        prevMask: 0,
+        prevPos: 0xfffffffb
+    };
+    var globalPos = 0; // Position in the overall stream
+    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
+            if (data.length < 5) {
+                pending = data;
+                callback(null, (0, _extractbaseiterator.allocBuffer)(0));
+                return;
+            }
+            // Process the buffer
+            var output = (0, _extractbaseiterator.bufferFrom)(data);
+            var processed = x86Code(state, globalPos, false, output, output.length);
+            if (processed === 0) {
+                // Not enough data to process
+                pending = data;
+                callback(null, (0, _extractbaseiterator.allocBuffer)(0));
+                return;
+            }
+            // Output processed bytes, keep unprocessed as pending
+            var result = output.slice(0, processed);
+            pending = output.slice(processed);
+            globalPos += processed;
+            callback(null, result);
+        },
+        flush: function flush(callback) {
+            // Output any remaining pending bytes
+            if (pending && pending.length > 0) {
+                // Process final bytes - can't convert incomplete instructions
+                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/filters/bcj/Bcj.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/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/tukaani-project/xz/blob/master/src/liblzma/simple/x86.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// Test if byte is 0x00 or 0xFF (valid MSB for converted addresses)\nfunction Test86MSByte(b: number): boolean {\n  return b === 0 || b === 0xff;\n}\n\n// Lookup table for mask to bit number conversion (used in false positive prevention)\nconst MASK_TO_BIT_NUMBER = [0, 1, 2, 2, 3];\n\n/**\n * BCJ x86 filter state\n */\ninterface BcjX86State {\n  prevMask: number;\n  prevPos: number;\n}\n\n/**\n * Core x86 BCJ conversion function (matches reference x86_code)\n * Works for both encoding and decoding based on isEncoder flag\n *\n * @param state - Filter state (prevMask and prevPos)\n * @param nowPos - Current position in the overall stream\n * @param isEncoder - true for encoding, false for decoding\n * @param buffer - Buffer to process (modified in place)\n * @param size - Size of buffer\n * @returns Number of bytes processed\n */\nfunction x86Code(state: BcjX86State, nowPos: number, isEncoder: boolean, buffer: Buffer, size: number): number {\n  let prevMask = state.prevMask;\n  let prevPos = state.prevPos;\n\n  if (size < 5) {\n    return 0;\n  }\n\n  // Decay prev_pos if too far from current position\n  if (nowPos - prevPos > 5) {\n    prevPos = nowPos - 5;\n  }\n\n  const limit = size - 5;\n  let bufferPos = 0;\n\n  while (bufferPos <= limit) {\n    const opcode = buffer[bufferPos];\n\n    // Check for CALL (0xE8) or JMP (0xE9) opcode\n    if (opcode !== 0xe8 && opcode !== 0xe9) {\n      bufferPos++;\n      continue;\n    }\n\n    // Calculate offset from previous position\n    const offset = nowPos + bufferPos - prevPos;\n    prevPos = nowPos + bufferPos;\n\n    // Update mask based on offset\n    if (offset > 5) {\n      prevMask = 0;\n    } else {\n      for (let i = 0; i < offset; i++) {\n        prevMask &= 0x77;\n        prevMask <<= 1;\n      }\n    }\n\n    // Get the high byte of the address\n    let b = buffer[bufferPos + 4];\n\n    // Check if this looks like a valid address to convert\n    if (Test86MSByte(b) && prevMask >> 1 <= 4 && prevMask >> 1 !== 3) {\n      // Read 32-bit address (big-endian style: high byte first in src)\n      let src = (b << 24) | (buffer[bufferPos + 3] << 16) | (buffer[bufferPos + 2] << 8) | buffer[bufferPos + 1];\n\n      // Make src unsigned 32-bit\n      src = src >>> 0;\n\n      let dest: number;\n\n      // Conversion loop with false positive correction\n      while (true) {\n        if (isEncoder) {\n          dest = (src + (nowPos + bufferPos + 5)) >>> 0;\n        } else {\n          dest = (src - (nowPos + bufferPos + 5)) >>> 0;\n        }\n\n        if (prevMask === 0) {\n          break;\n        }\n\n        const i = MASK_TO_BIT_NUMBER[prevMask >> 1];\n        b = (dest >>> (24 - i * 8)) & 0xff;\n\n        if (!Test86MSByte(b)) {\n          break;\n        }\n\n        // XOR correction for false positive prevention\n        src = (dest ^ ((1 << (32 - i * 8)) - 1)) >>> 0;\n      }\n\n      // Write back the converted address\n      // High byte: ~(((dest >> 24) & 1) - 1) produces 0x00 or 0xFF\n      buffer[bufferPos + 4] = ~(((dest >>> 24) & 1) - 1) & 0xff;\n      buffer[bufferPos + 3] = (dest >>> 16) & 0xff;\n      buffer[bufferPos + 2] = (dest >>> 8) & 0xff;\n      buffer[bufferPos + 1] = dest & 0xff;\n\n      bufferPos += 5;\n      prevMask = 0;\n    } else {\n      bufferPos++;\n      prevMask |= 1;\n      if (Test86MSByte(b)) {\n        prevMask |= 0x10;\n      }\n    }\n  }\n\n  // Save state\n  state.prevMask = prevMask;\n  state.prevPos = prevPos;\n\n  return bufferPos;\n}\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  const output = bufferFrom(input); // Copy since we modify in place\n\n  const state: BcjX86State = {\n    prevMask: 0,\n    prevPos: 0xfffffffb, // (uint32_t)(-5) in C\n  };\n\n  x86Code(state, 0, false, output, output.length);\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  const state: BcjX86State = {\n    prevMask: 0,\n    prevPos: 0xfffffffb, // (uint32_t)(-5) in C\n  };\n  let globalPos = 0; // Position in the overall stream\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      if (data.length < 5) {\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      // Process the buffer\n      const output = bufferFrom(data);\n      const processed = x86Code(state, globalPos, false, output, output.length);\n\n      if (processed === 0) {\n        // Not enough data to process\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      // Output processed bytes, keep unprocessed as pending\n      const result = output.slice(0, processed);\n      pending = output.slice(processed);\n      globalPos += processed;\n\n      callback(null, result);\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 final bytes - can't convert incomplete instructions\n        this.push(pending);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["createBcjDecoder","decodeBcj","Test86MSByte","b","MASK_TO_BIT_NUMBER","x86Code","state","nowPos","isEncoder","buffer","size","prevMask","prevPos","limit","bufferPos","opcode","offset","i","src","dest","input","_properties","_unpackSize","output","bufferFrom","length","globalPos","pending","transform","Transform","chunk","_encoding","callback","data","Buffer","concat","allocBuffer","processed","result","slice","flush","push"],"mappings":"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"}

package/dist/cjs/filters/bcj/BcjArm.d.cts

@@ -0,0 +1,16 @@
+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
+ *
+ * @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/filters/bcj/BcjArm.d.ts

@@ -0,0 +1,16 @@
+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
+ *
+ * @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>;