xz-compat 0.1.0

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

@@ -0,0 +1,59 @@
+// 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
+import { bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from '../../utils/createBufferingDecoder.js';
+/**
+ * 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 function decodeBcjSparc(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){
+        const b0 = output[pos];
+        const 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)
+            let 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
+            let dest = src - pos;
+            // Shift right by 2
+            dest >>>= 2;
+            // Reconstruct with sign extension and opcode
+            // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000
+            const signBit = dest >>> 22 & 1;
+            const 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;
+}
+/**
+ * Create a SPARC BCJ decoder Transform stream
+ */ export function createBcjSparcDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);
+}

package/dist/esm/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":["bufferFrom","createBufferingDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","pos","length","b0","b1","src","dest","signBit","signExtend","createBcjSparcDecoder","properties","unpackSize"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;CAYC,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,MAAMC,KAAKH,MAAM,CAACC,IAAI;QACtB,MAAMG,KAAKJ,MAAM,CAACC,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,KAAOJ,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,MAAM,EAAE;YAE5E,sDAAsD;YACtDI,QAAQ;YAER,8BAA8B;YAC9B,IAAIC,OAAOD,MAAMJ;YAEjB,mBAAmB;YACnBK,UAAU;YAEV,6CAA6C;YAC7C,mFAAmF;YACnF,MAAMC,UAAU,AAACD,SAAS,KAAM;YAChC,MAAME,aAAaD,UAAU,aAAa;YAC1CD,OAAOE,aAAcF,OAAO,WAAY;YAExC,0BAA0B;YAC1BN,MAAM,CAACC,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCN,MAAM,CAACC,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASS,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOhB,uBAAuBC,gBAAgBc,YAAYC;AAC5D"}

package/dist/esm/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/esm/filters/delta/Delta.js

@@ -0,0 +1,66 @@
+// 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.
+import { allocBuffer, bufferFrom, 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 function decodeDelta(input, properties, _unpackSize) {
+    // Distance parameter: default is 1
+    let distance = 1;
+    if (properties && properties.length >= 1) {
+        // Properties byte contains (distance - 1)
+        distance = properties[0] + 1;
+    }
+    const output = bufferFrom(input); // Copy since we modify in place
+    // State buffer for multi-byte distance
+    const state = [];
+    for(let i = 0; i < distance; i++){
+        state.push(0);
+    }
+    for(let j = 0; j < output.length; j++){
+        const idx = j % distance;
+        state[idx] = state[idx] + output[j] & 0xff;
+        output[j] = state[idx];
+    }
+    return output;
+}
+/**
+ * Create a streaming Delta decoder Transform.
+ * Processes data chunk by chunk, maintaining state between chunks.
+ */ export function createDeltaDecoder(properties, _unpackSize) {
+    // Distance parameter: default is 1
+    let distance = 1;
+    if (properties && properties.length >= 1) {
+        distance = properties[0] + 1;
+    }
+    // State buffer for multi-byte distance
+    const state = [];
+    for(let i = 0; i < distance; i++){
+        state.push(0);
+    }
+    let byteIndex = 0;
+    return new Transform({
+        transform: (chunk, _encoding, callback)=>{
+            const output = allocBuffer(chunk.length);
+            for(let j = 0; j < chunk.length; j++){
+                const idx = byteIndex % distance;
+                state[idx] = state[idx] + chunk[j] & 0xff;
+                output[j] = state[idx];
+                byteIndex++;
+            }
+            callback(null, output);
+        }
+    });
+}

package/dist/esm/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":["allocBuffer","bufferFrom","Transform","decodeDelta","input","properties","_unpackSize","distance","length","output","state","i","push","j","idx","createDeltaDecoder","byteIndex","transform","chunk","_encoding","callback"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;AAE1C,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;CAQC,GACD,OAAO,SAASC,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,MAAMI,SAASR,WAAWG,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,MAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOD,MAAM,EAAEK,IAAK;QACtC,MAAMC,MAAMD,IAAIN;QAChBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGL,MAAM,CAACI,EAAE,GAAI;QACxCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAOL;AACT;AAEA;;;CAGC,GACD,OAAO,SAASM,mBAAmBV,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,MAAMK,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAII,YAAY;IAEhB,OAAO,IAAId,UAAU;QACnBe,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,MAAMX,SAAST,YAAYkB,MAAMV,MAAM;YAEvC,IAAK,IAAIK,IAAI,GAAGA,IAAIK,MAAMV,MAAM,EAAEK,IAAK;gBACrC,MAAMC,MAAME,YAAYT;gBACxBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBE;YACF;YAEAI,SAAS,MAAMX;QACjB;IACF;AACF"}

package/dist/esm/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/esm/filters/index.js

@@ -0,0 +1,9 @@
+// Filter implementations for XZ/LZMA
+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/esm/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;AAErC,cAAc,eAAe;AAC7B,cAAc,kBAAkB;AAChC,cAAc,oBAAoB;AAClC,cAAc,mBAAmB;AACjC,cAAc,mBAAmB;AACjC,cAAc,kBAAkB;AAChC,cAAc,oBAAoB;AAClC,cAAc,mBAAmB"}

package/dist/esm/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/esm/index.js

@@ -0,0 +1,5 @@
+// XZ and LZMA decoders for external use
+// Re-export filters for convenience
+export * from './filters/index.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectLzmaFormat, Lzma2Decoder, LzmaDecoder } from './lzma/index.js';
+export { createXZDecoder, decodeXZ } from './xz/Decoder.js';

package/dist/esm/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":["createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","detectLzmaFormat","Lzma2Decoder","LzmaDecoder","createXZDecoder","decodeXZ"],"mappings":"AAAA,wCAAwC;AAExC,oCAAoC;AACpC,cAAc,qBAAqB;AAEnC,SACEA,kBAAkB,EAClBC,iBAAiB,EACjBC,UAAU,EACVC,WAAW,EACXC,gBAAgB,EAChBC,YAAY,EACZC,WAAW,QACN,kBAAkB;AACzB,SAASC,eAAe,EAAEC,QAAQ,QAAQ,kBAAkB"}

package/dist/esm/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;

package/dist/esm/lzma/Lzma2ChunkParser.js

@@ -0,0 +1,137 @@
+/**
+ * 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
+ */ /**
+ * 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 function parseLzma2ChunkHeader(input, offset) {
+    if (offset >= input.length) {
+        return {
+            success: false,
+            needBytes: 1
+        };
+    }
+    const control = input[offset];
+    // End of stream
+    if (control === 0x00) {
+        return {
+            success: true,
+            chunk: {
+                type: 'end',
+                headerSize: 1,
+                dictReset: false,
+                stateReset: false,
+                newProps: null,
+                uncompSize: 0,
+                compSize: 0
+            }
+        };
+    }
+    // Uncompressed chunk
+    if (control === 0x01 || control === 0x02) {
+        // Need 3 bytes: control + 2 size bytes
+        if (offset + 3 > input.length) {
+            return {
+                success: false,
+                needBytes: 3 - (input.length - offset)
+            };
+        }
+        const uncompSize = (input[offset + 1] << 8 | input[offset + 2]) + 1;
+        return {
+            success: true,
+            chunk: {
+                type: 'uncompressed',
+                headerSize: 3,
+                dictReset: control === 0x01,
+                stateReset: false,
+                newProps: null,
+                uncompSize,
+                compSize: 0
+            }
+        };
+    }
+    // LZMA compressed chunk
+    if (control >= 0x80) {
+        const hasNewProps = control >= 0xc0;
+        const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)
+        if (offset + minHeaderSize > input.length) {
+            return {
+                success: false,
+                needBytes: minHeaderSize - (input.length - offset)
+            };
+        }
+        // Parse sizes
+        const uncompHigh = control & 0x1f;
+        const uncompSize = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
+        const compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
+        // Parse properties if present
+        let newProps = null;
+        if (hasNewProps) {
+            const propsByte = input[offset + 5];
+            const lc = propsByte % 9;
+            const remainder = ~~(propsByte / 9);
+            const lp = remainder % 5;
+            const pb = ~~(remainder / 5);
+            newProps = {
+                lc,
+                lp,
+                pb
+            };
+        }
+        return {
+            success: true,
+            chunk: {
+                type: 'lzma',
+                headerSize: minHeaderSize,
+                dictReset: control >= 0xe0,
+                stateReset: control >= 0xa0,
+                newProps,
+                uncompSize,
+                compSize
+            }
+        };
+    }
+    // Invalid control byte
+    throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);
+}
+/**
+ * Check if we have enough data for the complete chunk (header + data)
+ */ export function hasCompleteChunk(input, offset) {
+    const result = parseLzma2ChunkHeader(input, offset);
+    if (result.success === false) {
+        return {
+            success: false,
+            needBytes: result.needBytes
+        };
+    }
+    const { chunk } = result;
+    const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
+    const totalSize = chunk.headerSize + dataSize;
+    if (offset + totalSize > input.length) {
+        return {
+            success: false,
+            needBytes: totalSize - (input.length - offset)
+        };
+    }
+    return {
+        success: true,
+        chunk,
+        totalSize
+    };
+}

package/dist/esm/lzma/Lzma2ChunkParser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/Lzma2ChunkParser.ts"],"sourcesContent":["/**\n * LZMA2 Chunk Parser\n *\n * Shared parsing logic for LZMA2 chunk headers.\n * Used by both synchronous and streaming decoders.\n *\n * LZMA2 control byte ranges:\n * 0x00         = End of stream\n * 0x01         = Uncompressed chunk, dictionary reset\n * 0x02         = Uncompressed chunk, no dictionary reset\n * 0x80-0x9F    = LZMA chunk, no reset (solid mode)\n * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)\n * 0xC0-0xDF    = LZMA chunk, reset state + new properties\n * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties\n */\n\n/**\n * LZMA properties extracted from chunk header\n */\nexport interface LzmaChunkProps {\n  lc: number;\n  lp: number;\n  pb: number;\n}\n\n/**\n * Parsed LZMA2 chunk information\n */\nexport interface Lzma2Chunk {\n  /** Chunk type */\n  type: 'end' | 'uncompressed' | 'lzma';\n  /** Total bytes consumed by header (including control byte) */\n  headerSize: number;\n  /** Whether to reset dictionary */\n  dictReset: boolean;\n  /** Whether to reset state/probabilities */\n  stateReset: boolean;\n  /** New LZMA properties (only for control >= 0xC0) */\n  newProps: LzmaChunkProps | null;\n  /** Uncompressed data size */\n  uncompSize: number;\n  /** Compressed data size (0 for uncompressed chunks) */\n  compSize: number;\n}\n\n/**\n * Result of parsing attempt\n */\nexport type ParseResult = { success: true; chunk: Lzma2Chunk } | { success: false; needBytes: number };\n\n/**\n * Parse an LZMA2 chunk header\n *\n * @param input - Input buffer\n * @param offset - Offset to start parsing\n * @returns Parsed chunk info or number of bytes needed\n */\nexport function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult {\n  if (offset >= input.length) {\n    return { success: false, needBytes: 1 };\n  }\n\n  const control = input[offset];\n\n  // End of stream\n  if (control === 0x00) {\n    return {\n      success: true,\n      chunk: {\n        type: 'end',\n        headerSize: 1,\n        dictReset: false,\n        stateReset: false,\n        newProps: null,\n        uncompSize: 0,\n        compSize: 0,\n      },\n    };\n  }\n\n  // Uncompressed chunk\n  if (control === 0x01 || control === 0x02) {\n    // Need 3 bytes: control + 2 size bytes\n    if (offset + 3 > input.length) {\n      return { success: false, needBytes: 3 - (input.length - offset) };\n    }\n\n    const uncompSize = ((input[offset + 1] << 8) | input[offset + 2]) + 1;\n\n    return {\n      success: true,\n      chunk: {\n        type: 'uncompressed',\n        headerSize: 3,\n        dictReset: control === 0x01,\n        stateReset: false,\n        newProps: null,\n        uncompSize,\n        compSize: 0,\n      },\n    };\n  }\n\n  // LZMA compressed chunk\n  if (control >= 0x80) {\n    const hasNewProps = control >= 0xc0;\n    const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)\n\n    if (offset + minHeaderSize > input.length) {\n      return { success: false, needBytes: minHeaderSize - (input.length - offset) };\n    }\n\n    // Parse sizes\n    const uncompHigh = control & 0x1f;\n    const uncompSize = ((uncompHigh << 16) | (input[offset + 1] << 8) | input[offset + 2]) + 1;\n    const compSize = ((input[offset + 3] << 8) | input[offset + 4]) + 1;\n\n    // Parse properties if present\n    let newProps: LzmaChunkProps | null = null;\n    if (hasNewProps) {\n      const propsByte = input[offset + 5];\n      const lc = propsByte % 9;\n      const remainder = ~~(propsByte / 9);\n      const lp = remainder % 5;\n      const pb = ~~(remainder / 5);\n      newProps = { lc, lp, pb };\n    }\n\n    return {\n      success: true,\n      chunk: {\n        type: 'lzma',\n        headerSize: minHeaderSize,\n        dictReset: control >= 0xe0,\n        stateReset: control >= 0xa0,\n        newProps,\n        uncompSize,\n        compSize,\n      },\n    };\n  }\n\n  // Invalid control byte\n  throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n}\n\n/** Result type for hasCompleteChunk with totalSize included on success */\nexport type CompleteChunkResult = { success: true; chunk: Lzma2Chunk; totalSize: number } | { success: false; needBytes: number };\n\n/**\n * Check if we have enough data for the complete chunk (header + data)\n */\nexport function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult {\n  const result = parseLzma2ChunkHeader(input, offset);\n\n  if (result.success === false) {\n    return { success: false, needBytes: result.needBytes };\n  }\n\n  const { chunk } = result;\n  const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n  const totalSize = chunk.headerSize + dataSize;\n\n  if (offset + totalSize > input.length) {\n    return { success: false, needBytes: totalSize - (input.length - offset) };\n  }\n\n  return { success: true, chunk, totalSize };\n}\n"],"names":["parseLzma2ChunkHeader","input","offset","length","success","needBytes","control","chunk","type","headerSize","dictReset","stateReset","newProps","uncompSize","compSize","hasNewProps","minHeaderSize","uncompHigh","propsByte","lc","remainder","lp","pb","Error","toString","hasCompleteChunk","result","dataSize","totalSize"],"mappings":"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"}

package/dist/esm/lzma/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * LZMA Decoder Module
+ *
+ * Provides both synchronous and streaming LZMA1/LZMA2 decoders.
+ *
+ * Synchronous API: Use when input is a complete Buffer
+ * Streaming API: Use with Transform streams for memory-efficient decompression
+ *
+ * LZMA1 vs LZMA2:
+ * - LZMA2 is chunked and supports true streaming with bounded memory
+ * - LZMA1 has no chunk boundaries and requires buffering all input for streaming
+ */
+export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
+export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
+export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
+export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
+export * from './types.js';
+/**
+ * Detect LZMA format from compressed data
+ *
+ * LZMA2 uses chunk-based framing with control bytes:
+ * - 0x00: End of stream
+ * - 0x01-0x02: Uncompressed chunks
+ * - 0x80-0xFF: LZMA compressed chunks
+ *
+ * LZMA1 is raw LZMA-compressed data (no framing)
+ *
+ * @param data - Compressed data to analyze
+ * @returns 'lzma1' for LZMA1, 'lzma2' for LZMA2
+ */
+export declare function detectLzmaFormat(data: Buffer): 'lzma1' | 'lzma2';

package/dist/esm/lzma/index.js

@@ -0,0 +1,44 @@
+/**
+ * LZMA Decoder Module
+ *
+ * Provides both synchronous and streaming LZMA1/LZMA2 decoders.
+ *
+ * Synchronous API: Use when input is a complete Buffer
+ * Streaming API: Use with Transform streams for memory-efficient decompression
+ *
+ * LZMA1 vs LZMA2:
+ * - LZMA2 is chunked and supports true streaming with bounded memory
+ * - LZMA1 has no chunk boundaries and requires buffering all input for streaming
+ */ // Streaming decoders (Transform streams)
+export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
+export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
+// Synchronous decoders (for Buffer input)
+export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
+export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
+// Type exports
+export * from './types.js';
+/**
+ * Detect LZMA format from compressed data
+ *
+ * LZMA2 uses chunk-based framing with control bytes:
+ * - 0x00: End of stream
+ * - 0x01-0x02: Uncompressed chunks
+ * - 0x80-0xFF: LZMA compressed chunks
+ *
+ * LZMA1 is raw LZMA-compressed data (no framing)
+ *
+ * @param data - Compressed data to analyze
+ * @returns 'lzma1' for LZMA1, 'lzma2' for LZMA2
+ */ export function detectLzmaFormat(data) {
+    if (data.length === 0) {
+        // Default to LZMA2 for empty data (matches LZMA2 decoder behavior)
+        return 'lzma2';
+    }
+    const firstByte = data[0];
+    // LZMA2 control bytes: 0x00, 0x01, 0x02, or 0x80-0xFF
+    if (firstByte === 0x00 || firstByte === 0x01 || firstByte === 0x02 || firstByte >= 0x80 && firstByte <= 0xff) {
+        return 'lzma2';
+    }
+    // All other values indicate LZMA1 (raw LZMA data)
+    return 'lzma1';
+}

package/dist/esm/lzma/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/index.ts"],"sourcesContent":["/**\n * LZMA Decoder Module\n *\n * Provides both synchronous and streaming LZMA1/LZMA2 decoders.\n *\n * Synchronous API: Use when input is a complete Buffer\n * Streaming API: Use with Transform streams for memory-efficient decompression\n *\n * LZMA1 vs LZMA2:\n * - LZMA2 is chunked and supports true streaming with bounded memory\n * - LZMA1 has no chunk boundaries and requires buffering all input for streaming\n */\n\n// Streaming decoders (Transform streams)\nexport { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.ts';\nexport { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.ts';\n// Synchronous decoders (for Buffer input)\nexport { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.ts';\nexport { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.ts';\n// Type exports\nexport * from './types.ts';\n\n/**\n * Detect LZMA format from compressed data\n *\n * LZMA2 uses chunk-based framing with control bytes:\n * - 0x00: End of stream\n * - 0x01-0x02: Uncompressed chunks\n * - 0x80-0xFF: LZMA compressed chunks\n *\n * LZMA1 is raw LZMA-compressed data (no framing)\n *\n * @param data - Compressed data to analyze\n * @returns 'lzma1' for LZMA1, 'lzma2' for LZMA2\n */\nexport function detectLzmaFormat(data: Buffer): 'lzma1' | 'lzma2' {\n  if (data.length === 0) {\n    // Default to LZMA2 for empty data (matches LZMA2 decoder behavior)\n    return 'lzma2';\n  }\n\n  const firstByte = data[0];\n\n  // LZMA2 control bytes: 0x00, 0x01, 0x02, or 0x80-0xFF\n  if (firstByte === 0x00 || firstByte === 0x01 || firstByte === 0x02 || (firstByte >= 0x80 && firstByte <= 0xff)) {\n    return 'lzma2';\n  }\n\n  // All other values indicate LZMA1 (raw LZMA data)\n  return 'lzma1';\n}\n"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma2","Lzma2Decoder","decodeLzma","LzmaDecoder","BitTreeDecoder","RangeDecoder","detectLzmaFormat","data","length","firstByte"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;AACzC,SAASA,kBAAkB,EAAEC,iBAAiB,QAAQ,yBAAyB;AAC/E,SAASC,WAAW,EAAEC,YAAY,QAAQ,yBAAyB;AACnE,0CAA0C;AAC1C,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAwB;AAChE,SAASC,cAAc,EAAEC,YAAY,QAAQ,yBAAyB;AACtE,eAAe;AACf,cAAc,aAAa;AAE3B;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,iBAAiBC,IAAY;IAC3C,IAAIA,KAAKC,MAAM,KAAK,GAAG;QACrB,mEAAmE;QACnE,OAAO;IACT;IAEA,MAAMC,YAAYF,IAAI,CAAC,EAAE;IAEzB,sDAAsD;IACtD,IAAIE,cAAc,QAAQA,cAAc,QAAQA,cAAc,QAASA,aAAa,QAAQA,aAAa,MAAO;QAC9G,OAAO;IACT;IAEA,kDAAkD;IAClD,OAAO;AACT"}

package/dist/esm/lzma/stream/transforms.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LZMA Transform Stream Wrappers
+ *
+ * Provides Transform streams for LZMA1 and LZMA2 decompression.
+ *
+ * LZMA2 streaming works by buffering until a complete chunk is available,
+ * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max
+ * uncompressed), so memory usage is predictable and bounded.
+ *
+ * Performance Optimization:
+ * - Uses OutputSink pattern for zero-copy output during decode
+ * - Each decoded byte written directly to stream (not buffered then copied)
+ * - ~4x faster than previous buffering approach
+ *
+ * True byte-by-byte async LZMA streaming would require rewriting the entire
+ * decoder with continuation-passing style, which is complex and not worth
+ * the effort given LZMA2's chunked format.
+ */
+import { Transform } from 'extract-base-iterator';
+/**
+ * Create an LZMA2 decoder Transform stream
+ *
+ * This is a streaming decoder that processes LZMA2 chunks incrementally.
+ * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
+ *
+ * @param properties - 1-byte LZMA2 properties (dictionary size)
+ * @returns Transform stream that decompresses LZMA2 data
+ */
+export declare function createLzma2Decoder(properties: Buffer | Uint8Array): InstanceType<typeof Transform>;
+/**
+ * Create an LZMA1 decoder Transform stream
+ *
+ * Note: LZMA1 has no chunk boundaries, so this requires knowing the
+ * uncompressed size upfront. The stream buffers all input, then
+ * decompresses when complete.
+ *
+ * For true streaming, use LZMA2 which has built-in chunking.
+ *
+ * Optimization: Pre-allocates input buffer and copies chunks once,
+ * avoiding the double-buffering of Buffer.concat().
+ *
+ * @param properties - 5-byte LZMA properties
+ * @param unpackSize - Expected uncompressed size
+ * @returns Transform stream that decompresses LZMA1 data
+ */
+export declare function createLzmaDecoder(properties: Buffer | Uint8Array, unpackSize: number): InstanceType<typeof Transform>;