xz-compat 0.1.0

package/dist/cjs/filters/bcj/BcjPpc.js

@@ -0,0 +1,64 @@
+// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses
+// This filter makes PowerPC executables more compressible by LZMA
+//
+// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.
+//
+// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createBcjPpcDecoder () {
+        return createBcjPpcDecoder;
+    },
+    get decodeBcjPpc () {
+        return decodeBcjPpc;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("../../utils/createBufferingDecoder.js"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function decodeBcjPpc(input, _properties, _unpackSize) {
+    var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
+    var pos = 0;
+    // Process 4-byte aligned positions
+    while(pos + 4 <= output.length){
+        // Read 32-bit value (big-endian)
+        var instr = output[pos] << 24 | output[pos + 1] << 16 | output[pos + 2] << 8 | output[pos + 3];
+        // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001
+        if ((instr & 0xfc000003) === 0x48000001) {
+            // Extract 26-bit offset (bits 2-27, the LI field)
+            var addr = instr & 0x03fffffc;
+            // Sign-extend 26-bit to 32-bit
+            if (addr & 0x02000000) {
+                addr |= 0xfc000000;
+            }
+            // Convert absolute to relative: subtract current position
+            var relAddr = addr - pos;
+            // Clear old offset and write new one
+            instr = instr & 0xfc000003 | relAddr & 0x03fffffc;
+            // Write back (big-endian)
+            output[pos] = instr >>> 24 & 0xff;
+            output[pos + 1] = instr >>> 16 & 0xff;
+            output[pos + 2] = instr >>> 8 & 0xff;
+            output[pos + 3] = instr & 0xff;
+        }
+        pos += 4;
+    }
+    return output;
+}
+function createBcjPpcDecoder(properties, unpackSize) {
+    return (0, _createBufferingDecoderts.default)(decodeBcjPpc, properties, unpackSize);
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/filters/bcj/BcjPpc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjPpc.ts"],"sourcesContent":["// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses\n// This filter makes PowerPC executables more compressible by LZMA\n//\n// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode PowerPC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * PowerPC B/BL instruction format (big-endian):\n * - 4 bytes aligned\n * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)\n * - Bits 6-29 are 24-bit signed offset (in words)\n *\n * @param input - PowerPC BCJ filtered data\n * @param _properties - Unused for PowerPC BCJ\n * @param _unpackSize - Unused for PowerPC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjPpc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (big-endian)\n    let instr = (output[pos] << 24) | (output[pos + 1] << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n    // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001\n    if ((instr & 0xfc000003) === 0x48000001) {\n      // Extract 26-bit offset (bits 2-27, the LI field)\n      let addr = instr & 0x03fffffc;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position\n      const relAddr = addr - pos;\n\n      // Clear old offset and write new one\n      instr = (instr & 0xfc000003) | (relAddr & 0x03fffffc);\n\n      // Write back (big-endian)\n      output[pos] = (instr >>> 24) & 0xff;\n      output[pos + 1] = (instr >>> 16) & 0xff;\n      output[pos + 2] = (instr >>> 8) & 0xff;\n      output[pos + 3] = instr & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a PowerPC BCJ decoder Transform stream\n */\nexport function createBcjPpcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjPpc, properties, unpackSize);\n}\n"],"names":["createBcjPpcDecoder","decodeBcjPpc","input","_properties","_unpackSize","output","bufferFrom","pos","length","instr","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,6EAA6E;AAC7E,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,EAAE;AACF,+DAA+D;;;;;;;;;;;;QA4D/CA;eAAAA;;QAxCAC;eAAAA;;;mCAlBW;+EAEQ;;;;;;AAgB5B,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,iCAAiC;QACjC,IAAIC,QAAQ,AAACJ,MAAM,CAACE,IAAI,IAAI,KAAOF,MAAM,CAACE,MAAM,EAAE,IAAI,KAAOF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAKF,MAAM,CAACE,MAAM,EAAE;QAEpG,kEAAkE;QAClE,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,kDAAkD;YAClD,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,0DAA0D;YAC1D,IAAMC,UAAUD,OAAOH;YAEvB,qCAAqC;YACrCE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,0BAA0B;YAC1BN,MAAM,CAACE,IAAI,GAAG,AAACE,UAAU,KAAM;YAC/BJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCJ,MAAM,CAACE,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCJ,MAAM,CAACE,MAAM,EAAE,GAAGE,QAAQ;QAC5B;QACAF,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,oBAAoBY,UAAmB,EAAEC,UAAmB;IAC1E,OAAOC,IAAAA,iCAAsB,EAACb,cAAcW,YAAYC;AAC1D"}

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

@@ -0,0 +1,19 @@
+import type { Transform } from 'stream';
+/**
+ * Decode SPARC BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * SPARC CALL instruction matching (big-endian):
+ * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR
+ * - First byte 0x7F and (second byte & 0xC0) == 0xC0
+ *
+ * @param input - SPARC BCJ filtered data
+ * @param _properties - Unused for SPARC BCJ
+ * @param _unpackSize - Unused for SPARC BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a SPARC BCJ decoder Transform stream
+ */
+export declare function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/cjs/filters/bcj/BcjSparc.d.ts

@@ -0,0 +1,19 @@
+import type { Transform } from 'stream';
+/**
+ * Decode SPARC BCJ filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * SPARC CALL instruction matching (big-endian):
+ * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR
+ * - First byte 0x7F and (second byte & 0xC0) == 0xC0
+ *
+ * @param input - SPARC BCJ filtered data
+ * @param _properties - Unused for SPARC BCJ
+ * @param _unpackSize - Unused for SPARC BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a SPARC BCJ decoder Transform stream
+ */
+export declare function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/cjs/filters/bcj/BcjSparc.js

@@ -0,0 +1,69 @@
+// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses
+// This filter makes SPARC executables more compressible by LZMA
+//
+// SPARC is big-endian. CALL instructions use 30-bit signed offsets.
+// The filter only transforms CALL instructions with specific byte patterns.
+//
+// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createBcjSparcDecoder () {
+        return createBcjSparcDecoder;
+    },
+    get decodeBcjSparc () {
+        return decodeBcjSparc;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("../../utils/createBufferingDecoder.js"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function decodeBcjSparc(input, _properties, _unpackSize) {
+    var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
+    var pos = 0;
+    // Process 4-byte aligned positions
+    while(pos + 4 <= output.length){
+        var b0 = output[pos];
+        var b1 = output[pos + 1];
+        // Check for CALL instruction with specific byte patterns:
+        // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)
+        if (b0 === 0x40 && (b1 & 0xc0) === 0x00 || b0 === 0x7f && (b1 & 0xc0) === 0xc0) {
+            // Read 32-bit value (big-endian)
+            var src = b0 << 24 | b1 << 16 | output[pos + 2] << 8 | output[pos + 3];
+            // Shift left by 2 (multiply by 4 for word addressing)
+            src <<= 2;
+            // Decoding: subtract position
+            var dest = src - pos;
+            // Shift right by 2
+            dest >>>= 2;
+            // Reconstruct with sign extension and opcode
+            // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000
+            var signBit = dest >>> 22 & 1;
+            var signExtend = signBit ? 0x3fc00000 : 0;
+            dest = signExtend | dest & 0x3fffff | 0x40000000;
+            // Write back (big-endian)
+            output[pos] = dest >>> 24 & 0xff;
+            output[pos + 1] = dest >>> 16 & 0xff;
+            output[pos + 2] = dest >>> 8 & 0xff;
+            output[pos + 3] = dest & 0xff;
+        }
+        pos += 4;
+    }
+    return output;
+}
+function createBcjSparcDecoder(properties, unpackSize) {
+    return (0, _createBufferingDecoderts.default)(decodeBcjSparc, properties, unpackSize);
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/filters/bcj/BcjSparc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjSparc.ts"],"sourcesContent":["// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses\n// This filter makes SPARC executables more compressible by LZMA\n//\n// SPARC is big-endian. CALL instructions use 30-bit signed offsets.\n// The filter only transforms CALL instructions with specific byte patterns.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode SPARC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * SPARC CALL instruction matching (big-endian):\n * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR\n * - First byte 0x7F and (second byte & 0xC0) == 0xC0\n *\n * @param input - SPARC BCJ filtered data\n * @param _properties - Unused for SPARC BCJ\n * @param _unpackSize - Unused for SPARC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    const b0 = output[pos];\n    const b1 = output[pos + 1];\n\n    // Check for CALL instruction with specific byte patterns:\n    // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)\n    if ((b0 === 0x40 && (b1 & 0xc0) === 0x00) || (b0 === 0x7f && (b1 & 0xc0) === 0xc0)) {\n      // Read 32-bit value (big-endian)\n      let src = (b0 << 24) | (b1 << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n      // Shift left by 2 (multiply by 4 for word addressing)\n      src <<= 2;\n\n      // Decoding: subtract position\n      let dest = src - pos;\n\n      // Shift right by 2\n      dest >>>= 2;\n\n      // Reconstruct with sign extension and opcode\n      // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000\n      const signBit = (dest >>> 22) & 1;\n      const signExtend = signBit ? 0x3fc00000 : 0;\n      dest = signExtend | (dest & 0x3fffff) | 0x40000000;\n\n      // Write back (big-endian)\n      output[pos] = (dest >>> 24) & 0xff;\n      output[pos + 1] = (dest >>> 16) & 0xff;\n      output[pos + 2] = (dest >>> 8) & 0xff;\n      output[pos + 3] = dest & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a SPARC BCJ decoder Transform stream\n */\nexport function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);\n}\n"],"names":["createBcjSparcDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","bufferFrom","pos","length","b0","b1","src","dest","signBit","signExtend","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAiE/CA;eAAAA;;QA9CAC;eAAAA;;;mCAjBW;+EAEQ;;;;;;AAe5B,SAASA,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,IAAMC,KAAKJ,MAAM,CAACE,IAAI;QACtB,IAAMG,KAAKL,MAAM,CAACE,MAAM,EAAE;QAE1B,0DAA0D;QAC1D,6EAA6E;QAC7E,IAAI,AAACE,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,QAAUD,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,MAAO;YAClF,iCAAiC;YACjC,IAAIC,MAAM,AAACF,MAAM,KAAOC,MAAM,KAAOL,MAAM,CAACE,MAAM,EAAE,IAAI,IAAKF,MAAM,CAACE,MAAM,EAAE;YAE5E,sDAAsD;YACtDI,QAAQ;YAER,8BAA8B;YAC9B,IAAIC,OAAOD,MAAMJ;YAEjB,mBAAmB;YACnBK,UAAU;YAEV,6CAA6C;YAC7C,mFAAmF;YACnF,IAAMC,UAAU,AAACD,SAAS,KAAM;YAChC,IAAME,aAAaD,UAAU,aAAa;YAC1CD,OAAOE,aAAcF,OAAO,WAAY;YAExC,0BAA0B;YAC1BP,MAAM,CAACE,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BP,MAAM,CAACE,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCP,MAAM,CAACE,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCP,MAAM,CAACE,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,sBAAsBe,UAAmB,EAAEC,UAAmB;IAC5E,OAAOC,IAAAA,iCAAsB,EAAChB,gBAAgBc,YAAYC;AAC5D"}

package/dist/cjs/filters/delta/Delta.d.cts

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

package/dist/cjs/filters/delta/Delta.d.ts

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

package/dist/cjs/filters/delta/Delta.js

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

package/dist/cjs/filters/delta/Delta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/delta/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n//\n// This implementation uses true streaming - processes data chunk by chunk\n// while maintaining state between chunks.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode Delta filtered data (synchronous, for buffered use)\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  for (let j = 0; j < output.length; j++) {\n    const idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming Delta decoder Transform.\n * Processes data chunk by chunk, maintaining state between chunks.\n */\nexport function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    distance = properties[0] + 1;\n  }\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  let byteIndex = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      const output = allocBuffer(chunk.length);\n\n      for (let j = 0; j < chunk.length; j++) {\n        const idx = byteIndex % distance;\n        state[idx] = (state[idx] + chunk[j]) & 0xff;\n        output[j] = state[idx];\n        byteIndex++;\n      }\n\n      callback(null, output);\n    },\n  });\n}\n"],"names":["createDeltaDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","bufferFrom","state","i","push","j","idx","byteIndex","Transform","transform","chunk","_encoding","callback","allocBuffer"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;;;;;;;;;;;;QA0C1BA;eAAAA;;QA7BAC;eAAAA;;;mCAXmC;AAW5C,SAASA,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,IAAMI,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,IAAMO,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOD,MAAM,EAAEM,IAAK;QACtC,IAAMC,MAAMD,IAAIP;QAChBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGN,MAAM,CAACK,EAAE,GAAI;QACxCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAON;AACT;AAMO,SAASP,mBAAmBG,UAAmB,EAAEC,WAAoB;IAC1E,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxCD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,uCAAuC;IACvC,IAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAIG,YAAY;IAEhB,OAAO,IAAIC,8BAAS,CAAC;QACnBC,WAAW,SAACC,OAAeC,WAAmBC;YAC5C,IAAMZ,SAASa,IAAAA,gCAAW,EAACH,MAAMX,MAAM;YAEvC,IAAK,IAAIM,IAAI,GAAGA,IAAIK,MAAMX,MAAM,EAAEM,IAAK;gBACrC,IAAMC,MAAMC,YAAYT;gBACxBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBC;YACF;YAEAK,SAAS,MAAMZ;QACjB;IACF;AACF"}

package/dist/cjs/filters/index.d.cts

@@ -0,0 +1,8 @@
+export * from './bcj/Bcj.js';
+export * from './bcj/BcjArm.js';
+export * from './bcj/BcjArm64.js';
+export * from './bcj/BcjArmt.js';
+export * from './bcj/BcjIa64.js';
+export * from './bcj/BcjPpc.js';
+export * from './bcj/BcjSparc.js';
+export * from './delta/Delta.js';

package/dist/cjs/filters/index.d.ts

@@ -0,0 +1,8 @@
+export * from './bcj/Bcj.js';
+export * from './bcj/BcjArm.js';
+export * from './bcj/BcjArm64.js';
+export * from './bcj/BcjArmt.js';
+export * from './bcj/BcjIa64.js';
+export * from './bcj/BcjPpc.js';
+export * from './bcj/BcjSparc.js';
+export * from './delta/Delta.js';

package/dist/cjs/filters/index.js

@@ -0,0 +1,27 @@
+// Filter implementations for XZ/LZMA
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./bcj/Bcj.js"), exports);
+_export_star(require("./bcj/BcjArm.js"), exports);
+_export_star(require("./bcj/BcjArm64.js"), exports);
+_export_star(require("./bcj/BcjArmt.js"), exports);
+_export_star(require("./bcj/BcjIa64.js"), exports);
+_export_star(require("./bcj/BcjPpc.js"), exports);
+_export_star(require("./bcj/BcjSparc.js"), exports);
+_export_star(require("./delta/Delta.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+/* 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/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/index.ts"],"sourcesContent":["// Filter implementations for XZ/LZMA\n\nexport * from './bcj/Bcj.ts';\nexport * from './bcj/BcjArm.ts';\nexport * from './bcj/BcjArm64.ts';\nexport * from './bcj/BcjArmt.ts';\nexport * from './bcj/BcjIa64.ts';\nexport * from './bcj/BcjPpc.ts';\nexport * from './bcj/BcjSparc.ts';\nexport * from './delta/Delta.ts';\n"],"names":[],"mappings":"AAAA,qCAAqC;;;;;qBAEvB;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA"}

package/dist/cjs/index.d.cts

@@ -0,0 +1,4 @@
+export * from './filters/index.js';
+export type { OutputSink } from './lzma/index.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectLzmaFormat, Lzma2Decoder, LzmaDecoder, } from './lzma/index.js';
+export { createXZDecoder, decodeXZ } from './xz/Decoder.js';

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './filters/index.js';
+export type { OutputSink } from './lzma/index.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectLzmaFormat, Lzma2Decoder, LzmaDecoder, } from './lzma/index.js';
+export { createXZDecoder, decodeXZ } from './xz/Decoder.js';

package/dist/cjs/index.js

@@ -0,0 +1,58 @@
+// XZ and LZMA decoders for external use
+// Re-export filters for convenience
+"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 Lzma2Decoder () {
+        return _indexts.Lzma2Decoder;
+    },
+    get LzmaDecoder () {
+        return _indexts.LzmaDecoder;
+    },
+    get createLzma2Decoder () {
+        return _indexts.createLzma2Decoder;
+    },
+    get createLzmaDecoder () {
+        return _indexts.createLzmaDecoder;
+    },
+    get createXZDecoder () {
+        return _Decoderts.createXZDecoder;
+    },
+    get decodeLzma () {
+        return _indexts.decodeLzma;
+    },
+    get decodeLzma2 () {
+        return _indexts.decodeLzma2;
+    },
+    get decodeXZ () {
+        return _Decoderts.decodeXZ;
+    },
+    get detectLzmaFormat () {
+        return _indexts.detectLzmaFormat;
+    }
+});
+_export_star(require("./filters/index.js"), exports);
+var _indexts = require("./lzma/index.js");
+var _Decoderts = require("./xz/Decoder.js");
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+/* 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/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/index.ts"],"sourcesContent":["// XZ and LZMA decoders for external use\n\n// Re-export filters for convenience\nexport * from './filters/index.ts';\nexport type { OutputSink } from './lzma/index.ts';\nexport {\n  createLzma2Decoder,\n  createLzmaDecoder,\n  decodeLzma,\n  decodeLzma2,\n  detectLzmaFormat,\n  Lzma2Decoder,\n  LzmaDecoder,\n} from './lzma/index.ts';\nexport { createXZDecoder, decodeXZ } from './xz/Decoder.ts';\n"],"names":["Lzma2Decoder","LzmaDecoder","createLzma2Decoder","createLzmaDecoder","createXZDecoder","decodeLzma","decodeLzma2","decodeXZ","detectLzmaFormat"],"mappings":"AAAA,wCAAwC;AAExC,oCAAoC;;;;;;;;;;;;QASlCA;eAAAA,qBAAY;;QACZC;eAAAA,oBAAW;;QANXC;eAAAA,2BAAkB;;QAClBC;eAAAA,0BAAiB;;QAOVC;eAAAA,0BAAe;;QANtBC;eAAAA,mBAAU;;QACVC;eAAAA,oBAAW;;QAKaC;eAAAA,mBAAQ;;QAJhCC;eAAAA,yBAAgB;;;qBAPJ;uBAUP;yBACmC"}

package/dist/cjs/lzma/Lzma2ChunkParser.d.cts

@@ -0,0 +1,73 @@
+/**
+ * LZMA2 Chunk Parser
+ *
+ * Shared parsing logic for LZMA2 chunk headers.
+ * Used by both synchronous and streaming decoders.
+ *
+ * LZMA2 control byte ranges:
+ * 0x00         = End of stream
+ * 0x01         = Uncompressed chunk, dictionary reset
+ * 0x02         = Uncompressed chunk, no dictionary reset
+ * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
+ * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
+ * 0xC0-0xDF    = LZMA chunk, reset state + new properties
+ * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
+ */
+/**
+ * LZMA properties extracted from chunk header
+ */
+export interface LzmaChunkProps {
+    lc: number;
+    lp: number;
+    pb: number;
+}
+/**
+ * Parsed LZMA2 chunk information
+ */
+export interface Lzma2Chunk {
+    /** Chunk type */
+    type: 'end' | 'uncompressed' | 'lzma';
+    /** Total bytes consumed by header (including control byte) */
+    headerSize: number;
+    /** Whether to reset dictionary */
+    dictReset: boolean;
+    /** Whether to reset state/probabilities */
+    stateReset: boolean;
+    /** New LZMA properties (only for control >= 0xC0) */
+    newProps: LzmaChunkProps | null;
+    /** Uncompressed data size */
+    uncompSize: number;
+    /** Compressed data size (0 for uncompressed chunks) */
+    compSize: number;
+}
+/**
+ * Result of parsing attempt
+ */
+export type ParseResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Parse an LZMA2 chunk header
+ *
+ * @param input - Input buffer
+ * @param offset - Offset to start parsing
+ * @returns Parsed chunk info or number of bytes needed
+ */
+export declare function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult;
+/** Result type for hasCompleteChunk with totalSize included on success */
+export type CompleteChunkResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+    totalSize: number;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Check if we have enough data for the complete chunk (header + data)
+ */
+export declare function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult;

package/dist/cjs/lzma/Lzma2ChunkParser.d.ts

@@ -0,0 +1,73 @@
+/**
+ * LZMA2 Chunk Parser
+ *
+ * Shared parsing logic for LZMA2 chunk headers.
+ * Used by both synchronous and streaming decoders.
+ *
+ * LZMA2 control byte ranges:
+ * 0x00         = End of stream
+ * 0x01         = Uncompressed chunk, dictionary reset
+ * 0x02         = Uncompressed chunk, no dictionary reset
+ * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
+ * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
+ * 0xC0-0xDF    = LZMA chunk, reset state + new properties
+ * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
+ */
+/**
+ * LZMA properties extracted from chunk header
+ */
+export interface LzmaChunkProps {
+    lc: number;
+    lp: number;
+    pb: number;
+}
+/**
+ * Parsed LZMA2 chunk information
+ */
+export interface Lzma2Chunk {
+    /** Chunk type */
+    type: 'end' | 'uncompressed' | 'lzma';
+    /** Total bytes consumed by header (including control byte) */
+    headerSize: number;
+    /** Whether to reset dictionary */
+    dictReset: boolean;
+    /** Whether to reset state/probabilities */
+    stateReset: boolean;
+    /** New LZMA properties (only for control >= 0xC0) */
+    newProps: LzmaChunkProps | null;
+    /** Uncompressed data size */
+    uncompSize: number;
+    /** Compressed data size (0 for uncompressed chunks) */
+    compSize: number;
+}
+/**
+ * Result of parsing attempt
+ */
+export type ParseResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Parse an LZMA2 chunk header
+ *
+ * @param input - Input buffer
+ * @param offset - Offset to start parsing
+ * @returns Parsed chunk info or number of bytes needed
+ */
+export declare function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult;
+/** Result type for hasCompleteChunk with totalSize included on success */
+export type CompleteChunkResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+    totalSize: number;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Check if we have enough data for the complete chunk (header + data)
+ */
+export declare function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult;