xz-compat 0.1.0

package/dist/cjs/lzma/Lzma2ChunkParser.js

@@ -0,0 +1,148 @@
+/**
+ * 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
+ */ "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 hasCompleteChunk () {
+        return hasCompleteChunk;
+    },
+    get parseLzma2ChunkHeader () {
+        return parseLzma2ChunkHeader;
+    }
+});
+function parseLzma2ChunkHeader(input, offset) {
+    if (offset >= input.length) {
+        return {
+            success: false,
+            needBytes: 1
+        };
+    }
+    var 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)
+            };
+        }
+        var 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: uncompSize,
+                compSize: 0
+            }
+        };
+    }
+    // LZMA compressed chunk
+    if (control >= 0x80) {
+        var hasNewProps = control >= 0xc0;
+        var 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
+        var uncompHigh = control & 0x1f;
+        var uncompSize1 = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
+        var compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
+        // Parse properties if present
+        var newProps = null;
+        if (hasNewProps) {
+            var propsByte = input[offset + 5];
+            var lc = propsByte % 9;
+            var remainder = ~~(propsByte / 9);
+            var lp = remainder % 5;
+            var pb = ~~(remainder / 5);
+            newProps = {
+                lc: lc,
+                lp: lp,
+                pb: pb
+            };
+        }
+        return {
+            success: true,
+            chunk: {
+                type: 'lzma',
+                headerSize: minHeaderSize,
+                dictReset: control >= 0xe0,
+                stateReset: control >= 0xa0,
+                newProps: newProps,
+                uncompSize: uncompSize1,
+                compSize: compSize
+            }
+        };
+    }
+    // Invalid control byte
+    throw new Error("Invalid LZMA2 control byte: 0x".concat(control.toString(16)));
+}
+function hasCompleteChunk(input, offset) {
+    var result = parseLzma2ChunkHeader(input, offset);
+    if (result.success === false) {
+        return {
+            success: false,
+            needBytes: result.needBytes
+        };
+    }
+    var chunk = result.chunk;
+    var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
+    var totalSize = chunk.headerSize + dataSize;
+    if (offset + totalSize > input.length) {
+        return {
+            success: false,
+            needBytes: totalSize - (input.length - offset)
+        };
+    }
+    return {
+        success: true,
+        chunk: chunk,
+        totalSize: totalSize
+    };
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lzma/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":["hasCompleteChunk","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","result","dataSize","totalSize"],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAED;;CAEC;;;;;;;;;;;QAsIeA;eAAAA;;QA/FAC;eAAAA;;;AAAT,SAASA,sBAAsBC,KAAa,EAAEC,MAAc;IACjE,IAAIA,UAAUD,MAAME,MAAM,EAAE;QAC1B,OAAO;YAAEC,SAAS;YAAOC,WAAW;QAAE;IACxC;IAEA,IAAMC,UAAUL,KAAK,CAACC,OAAO;IAE7B,gBAAgB;IAChB,IAAII,YAAY,MAAM;QACpB,OAAO;YACLF,SAAS;YACTG,OAAO;gBACLC,MAAM;gBACNC,YAAY;gBACZC,WAAW;gBACXC,YAAY;gBACZC,UAAU;gBACVC,YAAY;gBACZC,UAAU;YACZ;QACF;IACF;IAEA,qBAAqB;IACrB,IAAIR,YAAY,QAAQA,YAAY,MAAM;QACxC,uCAAuC;QACvC,IAAIJ,SAAS,IAAID,MAAME,MAAM,EAAE;YAC7B,OAAO;gBAAEC,SAAS;gBAAOC,WAAW,IAAKJ,CAAAA,MAAME,MAAM,GAAGD,MAAK;YAAG;QAClE;QAEA,IAAMW,aAAa,AAAC,CAAA,AAACZ,KAAK,CAACC,SAAS,EAAE,IAAI,IAAKD,KAAK,CAACC,SAAS,EAAE,AAAD,IAAK;QAEpE,OAAO;YACLE,SAAS;YACTG,OAAO;gBACLC,MAAM;gBACNC,YAAY;gBACZC,WAAWJ,YAAY;gBACvBK,YAAY;gBACZC,UAAU;gBACVC,YAAAA;gBACAC,UAAU;YACZ;QACF;IACF;IAEA,wBAAwB;IACxB,IAAIR,WAAW,MAAM;QACnB,IAAMS,cAAcT,WAAW;QAC/B,IAAMU,gBAAgBD,cAAc,IAAI,GAAG,0CAA0C;QAErF,IAAIb,SAASc,gBAAgBf,MAAME,MAAM,EAAE;YACzC,OAAO;gBAAEC,SAAS;gBAAOC,WAAWW,gBAAiBf,CAAAA,MAAME,MAAM,GAAGD,MAAK;YAAG;QAC9E;QAEA,cAAc;QACd,IAAMe,aAAaX,UAAU;QAC7B,IAAMO,cAAa,AAAC,CAAA,AAACI,cAAc,KAAOhB,KAAK,CAACC,SAAS,EAAE,IAAI,IAAKD,KAAK,CAACC,SAAS,EAAE,AAAD,IAAK;QACzF,IAAMY,WAAW,AAAC,CAAA,AAACb,KAAK,CAACC,SAAS,EAAE,IAAI,IAAKD,KAAK,CAACC,SAAS,EAAE,AAAD,IAAK;QAElE,8BAA8B;QAC9B,IAAIU,WAAkC;QACtC,IAAIG,aAAa;YACf,IAAMG,YAAYjB,KAAK,CAACC,SAAS,EAAE;YACnC,IAAMiB,KAAKD,YAAY;YACvB,IAAME,YAAY,CAAC,CAAEF,CAAAA,YAAY,CAAA;YACjC,IAAMG,KAAKD,YAAY;YACvB,IAAME,KAAK,CAAC,CAAEF,CAAAA,YAAY,CAAA;YAC1BR,WAAW;gBAAEO,IAAAA;gBAAIE,IAAAA;gBAAIC,IAAAA;YAAG;QAC1B;QAEA,OAAO;YACLlB,SAAS;YACTG,OAAO;gBACLC,MAAM;gBACNC,YAAYO;gBACZN,WAAWJ,WAAW;gBACtBK,YAAYL,WAAW;gBACvBM,UAAAA;gBACAC,YAAAA;gBACAC,UAAAA;YACF;QACF;IACF;IAEA,uBAAuB;IACvB,MAAM,IAAIS,MAAM,AAAC,iCAAqD,OAArBjB,QAAQkB,QAAQ,CAAC;AACpE;AAQO,SAASzB,iBAAiBE,KAAa,EAAEC,MAAc;IAC5D,IAAMuB,SAASzB,sBAAsBC,OAAOC;IAE5C,IAAIuB,OAAOrB,OAAO,KAAK,OAAO;QAC5B,OAAO;YAAEA,SAAS;YAAOC,WAAWoB,OAAOpB,SAAS;QAAC;IACvD;IAEA,IAAM,AAAEE,QAAUkB,OAAVlB;IACR,IAAMmB,WAAWnB,MAAMC,IAAI,KAAK,iBAAiBD,MAAMM,UAAU,GAAGN,MAAMO,QAAQ;IAClF,IAAMa,YAAYpB,MAAME,UAAU,GAAGiB;IAErC,IAAIxB,SAASyB,YAAY1B,MAAME,MAAM,EAAE;QACrC,OAAO;YAAEC,SAAS;YAAOC,WAAWsB,YAAa1B,CAAAA,MAAME,MAAM,GAAGD,MAAK;QAAG;IAC1E;IAEA,OAAO;QAAEE,SAAS;QAAMG,OAAAA;QAAOoB,WAAAA;IAAU;AAC3C"}

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

@@ -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/cjs/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/cjs/lzma/index.js

@@ -0,0 +1,83 @@
+/**
+ * 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)
+"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 BitTreeDecoder () {
+        return _RangeDecoderts.BitTreeDecoder;
+    },
+    get Lzma2Decoder () {
+        return _Lzma2Decoderts.Lzma2Decoder;
+    },
+    get LzmaDecoder () {
+        return _LzmaDecoderts.LzmaDecoder;
+    },
+    get RangeDecoder () {
+        return _RangeDecoderts.RangeDecoder;
+    },
+    get createLzma2Decoder () {
+        return _transformsts.createLzma2Decoder;
+    },
+    get createLzmaDecoder () {
+        return _transformsts.createLzmaDecoder;
+    },
+    get decodeLzma () {
+        return _LzmaDecoderts.decodeLzma;
+    },
+    get decodeLzma2 () {
+        return _Lzma2Decoderts.decodeLzma2;
+    },
+    get detectLzmaFormat () {
+        return detectLzmaFormat;
+    }
+});
+var _transformsts = require("./stream/transforms.js");
+var _Lzma2Decoderts = require("./sync/Lzma2Decoder.js");
+var _LzmaDecoderts = require("./sync/LzmaDecoder.js");
+var _RangeDecoderts = require("./sync/RangeDecoder.js");
+_export_star(require("./types.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;
+}
+function detectLzmaFormat(data) {
+    if (data.length === 0) {
+        // Default to LZMA2 for empty data (matches LZMA2 decoder behavior)
+        return 'lzma2';
+    }
+    var 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';
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lzma/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":["BitTreeDecoder","Lzma2Decoder","LzmaDecoder","RangeDecoder","createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","detectLzmaFormat","data","length","firstByte"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;;;;;;;;;;;;QAKhCA;eAAAA,8BAAc;;QAHDC;eAAAA,4BAAY;;QAEbC;eAAAA,0BAAW;;QACPC;eAAAA,4BAAY;;QAJ5BC;eAAAA,gCAAkB;;QAAEC;eAAAA,+BAAiB;;QAGrCC;eAAAA,yBAAU;;QAFVC;eAAAA,2BAAW;;QAoBJC;eAAAA;;;4BArBsC;8BACZ;6BAEF;8BACK;qBAE/B;;;;;;;;;;;;;;AAeP,SAASA,iBAAiBC,IAAY;IAC3C,IAAIA,KAAKC,MAAM,KAAK,GAAG;QACrB,mEAAmE;QACnE,OAAO;IACT;IAEA,IAAMC,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/cjs/lzma/stream/transforms.d.cts

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

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

package/dist/cjs/lzma/stream/transforms.js

@@ -0,0 +1,193 @@
+/**
+ * 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.
+ */ "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 createLzma2Decoder () {
+        return createLzma2Decoder;
+    },
+    get createLzmaDecoder () {
+        return createLzmaDecoder;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _Lzma2ChunkParserts = require("../Lzma2ChunkParser.js");
+var _LzmaDecoderts = require("../sync/LzmaDecoder.js");
+var _typests = require("../types.js");
+function createLzma2Decoder(properties) {
+    if (!properties || properties.length < 1) {
+        throw new Error('LZMA2 requires properties byte');
+    }
+    var dictSize = (0, _typests.parseLzma2DictionarySize)(properties[0]);
+    // LZMA decoder instance - reused across chunks for solid mode
+    var decoder = new _LzmaDecoderts.LzmaDecoder();
+    decoder.setDictionarySize(dictSize);
+    // Track current LZMA properties
+    var propsSet = false;
+    // Buffer for incomplete chunk data
+    var pending = null;
+    var finished = false;
+    return new _extractbaseiterator.Transform({
+        transform: function transform(chunk, _encoding, callback) {
+            var _this = this;
+            if (finished) {
+                callback(null);
+                return;
+            }
+            // Combine with pending data
+            var input;
+            if (pending && pending.length > 0) {
+                input = Buffer.concat([
+                    pending,
+                    chunk
+                ]);
+                pending = null;
+            } else {
+                input = chunk;
+            }
+            var offset = 0;
+            try {
+                while(offset < input.length && !finished){
+                    var result = (0, _Lzma2ChunkParserts.hasCompleteChunk)(input, offset);
+                    if (!result.success) {
+                        // Need more data
+                        pending = input.slice(offset);
+                        break;
+                    }
+                    var chunkInfo = result.chunk, totalSize = result.totalSize;
+                    if (chunkInfo.type === 'end') {
+                        finished = true;
+                        break;
+                    }
+                    // Handle dictionary reset
+                    if (chunkInfo.dictReset) {
+                        decoder.resetDictionary();
+                    }
+                    var dataOffset = offset + chunkInfo.headerSize;
+                    if (chunkInfo.type === 'uncompressed') {
+                        var uncompData = input.slice(dataOffset, dataOffset + chunkInfo.uncompSize);
+                        this.push(uncompData);
+                        // Feed uncompressed data to dictionary for subsequent LZMA chunks
+                        decoder.feedUncompressed(uncompData);
+                    } else {
+                        // LZMA compressed chunk
+                        // Variables to store properties (used for both decoders)
+                        var lc = void 0;
+                        var lp = void 0;
+                        var pb = void 0;
+                        // Apply new properties if present
+                        if (chunkInfo.newProps) {
+                            var ref;
+                            ref = chunkInfo.newProps, lc = ref.lc, lp = ref.lp, pb = ref.pb, ref;
+                            if (!decoder.setLcLpPb(lc, lp, pb)) {
+                                throw new Error("Invalid LZMA properties: lc=".concat(lc, " lp=").concat(lp, " pb=").concat(pb));
+                            }
+                            propsSet = true;
+                        }
+                        if (!propsSet) {
+                            throw new Error('LZMA chunk without properties');
+                        }
+                        // Reset probabilities if state reset
+                        if (chunkInfo.stateReset) {
+                            decoder.resetProbabilities();
+                        }
+                        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
+                        var useSolid = !chunkInfo.stateReset || chunkInfo.stateReset && !chunkInfo.dictReset;
+                        var compData = input.slice(dataOffset, dataOffset + chunkInfo.compSize);
+                        // Enhanced: Use OutputSink for direct emission (zero-copy)
+                        // Create a decoder with direct stream emission
+                        var streamDecoder = new _LzmaDecoderts.LzmaDecoder({
+                            write: function(chunk) {
+                                return _this.push(chunk);
+                            }
+                        });
+                        streamDecoder.setDictionarySize(dictSize);
+                        // Preserve properties from main decoder
+                        streamDecoder.setLcLpPb(lc, lp, pb);
+                        // Use solid mode based on chunk properties
+                        streamDecoder.decodeWithSink(compData, 0, chunkInfo.uncompSize, useSolid);
+                        // Flush any remaining data in the OutWindow
+                        streamDecoder.flushOutWindow();
+                    }
+                    offset += totalSize;
+                }
+                callback(null);
+            } catch (err) {
+                callback(err);
+            }
+        },
+        flush: function flush(callback) {
+            if (pending && pending.length > 0 && !finished) {
+                callback(new Error('Truncated LZMA2 stream'));
+            } else {
+                callback(null);
+            }
+        }
+    });
+}
+function createLzmaDecoder(properties, unpackSize) {
+    var decoder = new _LzmaDecoderts.LzmaDecoder();
+    decoder.setDecoderProperties(properties);
+    var chunks = [];
+    var totalSize = 0;
+    return new _extractbaseiterator.Transform({
+        transform: function transform(chunk, _encoding, callback) {
+            chunks.push(chunk);
+            totalSize += chunk.length;
+            callback(null);
+        },
+        flush: function flush(callback) {
+            var _this = this;
+            try {
+                // Optimization: Pre-allocate single buffer instead of Buffer.concat()
+                // This reduces peak memory usage by ~50% during concatenation
+                var input = (0, _extractbaseiterator.allocBufferUnsafe)(totalSize);
+                var offset = 0;
+                // Copy each chunk into the pre-allocated buffer
+                for(var i = 0; i < chunks.length; i++){
+                    var chunk = chunks[i];
+                    chunk.copy(input, offset);
+                    offset += chunk.length;
+                }
+                // Enhanced: Use OutputSink for direct emission (zero-copy)
+                // Create a decoder with direct stream emission
+                var streamDecoder = new _LzmaDecoderts.LzmaDecoder({
+                    write: function(chunk) {
+                        return _this.push(chunk);
+                    }
+                });
+                streamDecoder.setDecoderProperties(properties);
+                streamDecoder.decodeWithSink(input, 0, unpackSize, false);
+                // Flush any remaining data in the OutWindow
+                streamDecoder.flushOutWindow();
+                callback(null);
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lzma/stream/transforms.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/stream/transforms.ts"],"sourcesContent":["/**\n * LZMA Transform Stream Wrappers\n *\n * Provides Transform streams for LZMA1 and LZMA2 decompression.\n *\n * LZMA2 streaming works by buffering until a complete chunk is available,\n * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max\n * uncompressed), so memory usage is predictable and bounded.\n *\n * Performance Optimization:\n * - Uses OutputSink pattern for zero-copy output during decode\n * - Each decoded byte written directly to stream (not buffered then copied)\n * - ~4x faster than previous buffering approach\n *\n * True byte-by-byte async LZMA streaming would require rewriting the entire\n * decoder with continuation-passing style, which is complex and not worth\n * the effort given LZMA2's chunked format.\n */\n\nimport { allocBufferUnsafe, Transform } from 'extract-base-iterator';\nimport { hasCompleteChunk } from '../Lzma2ChunkParser.ts';\nimport { LzmaDecoder } from '../sync/LzmaDecoder.ts';\nimport { parseLzma2DictionarySize } from '../types.ts';\n\n/**\n * Create an LZMA2 decoder Transform stream\n *\n * This is a streaming decoder that processes LZMA2 chunks incrementally.\n * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).\n *\n * @param properties - 1-byte LZMA2 properties (dictionary size)\n * @returns Transform stream that decompresses LZMA2 data\n */\nexport function createLzma2Decoder(properties: Buffer | Uint8Array): InstanceType<typeof Transform> {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  const dictSize = parseLzma2DictionarySize(properties[0]);\n\n  // LZMA decoder instance - reused across chunks for solid mode\n  const decoder = new LzmaDecoder();\n  decoder.setDictionarySize(dictSize);\n\n  // Track current LZMA properties\n  let propsSet = false;\n\n  // Buffer for incomplete chunk data\n  let pending: Buffer | null = null;\n  let finished = false;\n\n  return new Transform({\n    transform: function (this: InstanceType<typeof Transform>, chunk: Buffer, _encoding: string, callback: (err?: Error | null) => void) {\n      if (finished) {\n        callback(null);\n        return;\n      }\n\n      // Combine with pending data\n      let input: Buffer;\n      if (pending && pending.length > 0) {\n        input = Buffer.concat([pending, chunk]);\n        pending = null;\n      } else {\n        input = chunk;\n      }\n\n      let offset = 0;\n\n      try {\n        while (offset < input.length && !finished) {\n          const result = hasCompleteChunk(input, offset);\n\n          if (!result.success) {\n            // Need more data\n            pending = input.slice(offset);\n            break;\n          }\n\n          const { chunk: chunkInfo, totalSize } = result;\n\n          if (chunkInfo.type === 'end') {\n            finished = true;\n            break;\n          }\n\n          // Handle dictionary reset\n          if (chunkInfo.dictReset) {\n            decoder.resetDictionary();\n          }\n\n          const dataOffset = offset + chunkInfo.headerSize;\n\n          if (chunkInfo.type === 'uncompressed') {\n            const uncompData = input.slice(dataOffset, dataOffset + chunkInfo.uncompSize);\n            this.push(uncompData);\n\n            // Feed uncompressed data to dictionary for subsequent LZMA chunks\n            decoder.feedUncompressed(uncompData);\n          } else {\n            // LZMA compressed chunk\n\n            // Variables to store properties (used for both decoders)\n            let lc: number;\n            let lp: number;\n            let pb: number;\n\n            // Apply new properties if present\n            if (chunkInfo.newProps) {\n              ({ lc, lp, pb } = chunkInfo.newProps);\n              if (!decoder.setLcLpPb(lc, lp, pb)) {\n                throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n              }\n              propsSet = true;\n            }\n\n            if (!propsSet) {\n              throw new Error('LZMA chunk without properties');\n            }\n\n            // Reset probabilities if state reset\n            if (chunkInfo.stateReset) {\n              decoder.resetProbabilities();\n            }\n\n            // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)\n            const useSolid = !chunkInfo.stateReset || (chunkInfo.stateReset && !chunkInfo.dictReset);\n\n            const compData = input.slice(dataOffset, dataOffset + chunkInfo.compSize);\n\n            // Enhanced: Use OutputSink for direct emission (zero-copy)\n            // Create a decoder with direct stream emission\n            const streamDecoder = new LzmaDecoder({\n              write: (chunk: Buffer) => this.push(chunk),\n            });\n            streamDecoder.setDictionarySize(dictSize);\n            // Preserve properties from main decoder\n            streamDecoder.setLcLpPb(lc, lp, pb);\n\n            // Use solid mode based on chunk properties\n            streamDecoder.decodeWithSink(compData, 0, chunkInfo.uncompSize, useSolid);\n\n            // Flush any remaining data in the OutWindow\n            streamDecoder.flushOutWindow();\n          }\n\n          offset += totalSize;\n        }\n\n        callback(null);\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      if (pending && pending.length > 0 && !finished) {\n        callback(new Error('Truncated LZMA2 stream'));\n      } else {\n        callback(null);\n      }\n    },\n  });\n}\n\n/**\n * Create an LZMA1 decoder Transform stream\n *\n * Note: LZMA1 has no chunk boundaries, so this requires knowing the\n * uncompressed size upfront. The stream buffers all input, then\n * decompresses when complete.\n *\n * For true streaming, use LZMA2 which has built-in chunking.\n *\n * Optimization: Pre-allocates input buffer and copies chunks once,\n * avoiding the double-buffering of Buffer.concat().\n *\n * @param properties - 5-byte LZMA properties\n * @param unpackSize - Expected uncompressed size\n * @returns Transform stream that decompresses LZMA1 data\n */\nexport function createLzmaDecoder(properties: Buffer | Uint8Array, unpackSize: number): InstanceType<typeof Transform> {\n  const decoder = new LzmaDecoder();\n  decoder.setDecoderProperties(properties);\n\n  const chunks: Buffer[] = [];\n  let totalSize = 0;\n\n  return new Transform({\n    transform: function (this: InstanceType<typeof Transform>, chunk: Buffer, _encoding: string, callback: (err?: Error | null) => void) {\n      chunks.push(chunk);\n      totalSize += chunk.length;\n      callback(null);\n    },\n\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      try {\n        // Optimization: Pre-allocate single buffer instead of Buffer.concat()\n        // This reduces peak memory usage by ~50% during concatenation\n        const input = allocBufferUnsafe(totalSize);\n        let offset = 0;\n\n        // Copy each chunk into the pre-allocated buffer\n        for (let i = 0; i < chunks.length; i++) {\n          const chunk = chunks[i];\n          chunk.copy(input, offset);\n          offset += chunk.length;\n        }\n\n        // Enhanced: Use OutputSink for direct emission (zero-copy)\n        // Create a decoder with direct stream emission\n        const streamDecoder = new LzmaDecoder({\n          write: (chunk: Buffer) => this.push(chunk),\n        });\n        streamDecoder.setDecoderProperties(properties);\n        streamDecoder.decodeWithSink(input, 0, unpackSize, false);\n\n        // Flush any remaining data in the OutWindow\n        streamDecoder.flushOutWindow();\n\n        callback(null);\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createLzma2Decoder","createLzmaDecoder","properties","length","Error","dictSize","parseLzma2DictionarySize","decoder","LzmaDecoder","setDictionarySize","propsSet","pending","finished","Transform","transform","chunk","_encoding","callback","input","Buffer","concat","offset","result","hasCompleteChunk","success","slice","chunkInfo","totalSize","type","dictReset","resetDictionary","dataOffset","headerSize","uncompData","uncompSize","push","feedUncompressed","lc","lp","pb","newProps","setLcLpPb","stateReset","resetProbabilities","useSolid","compData","compSize","streamDecoder","write","decodeWithSink","flushOutWindow","err","flush","unpackSize","setDecoderProperties","chunks","allocBufferUnsafe","i","copy"],"mappings":"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"}