xz-compat 0.1.0

package/dist/cjs/lzma/sync/Lzma2Decoder.d.cts

@@ -0,0 +1,63 @@
+/**
+ * Synchronous LZMA2 Decoder
+ *
+ * LZMA2 is a container format that wraps LZMA chunks with framing.
+ * Decodes LZMA2 data from a buffer.
+ */
+import { type OutputSink } from '../types.js';
+/**
+ * Synchronous LZMA2 decoder
+ */
+export declare class Lzma2Decoder {
+    private lzmaDecoder;
+    private dictionarySize;
+    private propsSet;
+    constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink);
+    /**
+     * Reset the dictionary (for stream boundaries)
+     */
+    resetDictionary(): void;
+    /**
+     * Reset all probability models (for stream boundaries)
+     */
+    resetProbabilities(): void;
+    /**
+     * Set LZMA properties
+     */
+    setLcLpPb(lc: number, lp: number, pb: number): boolean;
+    /**
+     * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)
+     */
+    feedUncompressed(data: Buffer): void;
+    /**
+     * Decode raw LZMA data (used internally for LZMA2 chunks)
+     * @param input - LZMA compressed data
+     * @param offset - Input offset
+     * @param outSize - Expected output size
+     * @param solid - Use solid mode
+     * @returns Decompressed data
+     */
+    decodeLzmaData(input: Buffer, offset: number, outSize: number, solid?: boolean): Buffer;
+    /**
+     * Decode LZMA2 data with streaming output
+     * @param input - LZMA2 compressed data
+     * @returns Total number of bytes written to sink
+     */
+    decodeWithSink(input: Buffer): number;
+    /**
+     * Decode LZMA2 data
+     * @param input - LZMA2 compressed data
+     * @param unpackSize - Expected output size (optional, for pre-allocation)
+     * @returns Decompressed data
+     */
+    decode(input: Buffer, unpackSize?: number): Buffer;
+}
+/**
+ * Decode LZMA2 data synchronously
+ * @param input - LZMA2 compressed data
+ * @param properties - 1-byte properties (dictionary size)
+ * @param unpackSize - Expected output size (optional, autodetects if not provided)
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */
+export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number;

package/dist/cjs/lzma/sync/Lzma2Decoder.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Synchronous LZMA2 Decoder
+ *
+ * LZMA2 is a container format that wraps LZMA chunks with framing.
+ * Decodes LZMA2 data from a buffer.
+ */
+import { type OutputSink } from '../types.js';
+/**
+ * Synchronous LZMA2 decoder
+ */
+export declare class Lzma2Decoder {
+    private lzmaDecoder;
+    private dictionarySize;
+    private propsSet;
+    constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink);
+    /**
+     * Reset the dictionary (for stream boundaries)
+     */
+    resetDictionary(): void;
+    /**
+     * Reset all probability models (for stream boundaries)
+     */
+    resetProbabilities(): void;
+    /**
+     * Set LZMA properties
+     */
+    setLcLpPb(lc: number, lp: number, pb: number): boolean;
+    /**
+     * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)
+     */
+    feedUncompressed(data: Buffer): void;
+    /**
+     * Decode raw LZMA data (used internally for LZMA2 chunks)
+     * @param input - LZMA compressed data
+     * @param offset - Input offset
+     * @param outSize - Expected output size
+     * @param solid - Use solid mode
+     * @returns Decompressed data
+     */
+    decodeLzmaData(input: Buffer, offset: number, outSize: number, solid?: boolean): Buffer;
+    /**
+     * Decode LZMA2 data with streaming output
+     * @param input - LZMA2 compressed data
+     * @returns Total number of bytes written to sink
+     */
+    decodeWithSink(input: Buffer): number;
+    /**
+     * Decode LZMA2 data
+     * @param input - LZMA2 compressed data
+     * @param unpackSize - Expected output size (optional, for pre-allocation)
+     * @returns Decompressed data
+     */
+    decode(input: Buffer, unpackSize?: number): Buffer;
+}
+/**
+ * Decode LZMA2 data synchronously
+ * @param input - LZMA2 compressed data
+ * @param properties - 1-byte properties (dictionary size)
+ * @param unpackSize - Expected output size (optional, autodetects if not provided)
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */
+export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number;

package/dist/cjs/lzma/sync/Lzma2Decoder.js

@@ -0,0 +1,231 @@
+/**
+ * Synchronous LZMA2 Decoder
+ *
+ * LZMA2 is a container format that wraps LZMA chunks with framing.
+ * Decodes LZMA2 data from a buffer.
+ */ "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 Lzma2Decoder;
+    },
+    get decodeLzma2 () {
+        return decodeLzma2;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _Lzma2ChunkParserts = require("../Lzma2ChunkParser.js");
+var _typests = require("../types.js");
+var _LzmaDecoderts = require("./LzmaDecoder.js");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+var Lzma2Decoder = /*#__PURE__*/ function() {
+    "use strict";
+    function Lzma2Decoder(properties, outputSink) {
+        _class_call_check(this, Lzma2Decoder);
+        if (!properties || properties.length < 1) {
+            throw new Error('LZMA2 requires properties byte');
+        }
+        this.dictionarySize = (0, _typests.parseLzma2DictionarySize)(properties[0]);
+        this.lzmaDecoder = new _LzmaDecoderts.LzmaDecoder(outputSink);
+        this.lzmaDecoder.setDictionarySize(this.dictionarySize);
+        this.propsSet = false;
+    }
+    var _proto = Lzma2Decoder.prototype;
+    /**
+   * Reset the dictionary (for stream boundaries)
+   */ _proto.resetDictionary = function resetDictionary() {
+        this.lzmaDecoder.resetDictionary();
+    };
+    /**
+   * Reset all probability models (for stream boundaries)
+   */ _proto.resetProbabilities = function resetProbabilities() {
+        this.lzmaDecoder.resetProbabilities();
+    };
+    /**
+   * Set LZMA properties
+   */ _proto.setLcLpPb = function setLcLpPb(lc, lp, pb) {
+        return this.lzmaDecoder.setLcLpPb(lc, lp, pb);
+    };
+    /**
+   * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)
+   */ _proto.feedUncompressed = function feedUncompressed(data) {
+        this.lzmaDecoder.feedUncompressed(data);
+    };
+    /**
+   * Decode raw LZMA data (used internally for LZMA2 chunks)
+   * @param input - LZMA compressed data
+   * @param offset - Input offset
+   * @param outSize - Expected output size
+   * @param solid - Use solid mode
+   * @returns Decompressed data
+   */ _proto.decodeLzmaData = function decodeLzmaData(input, offset, outSize) {
+        var solid = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+        return this.lzmaDecoder.decode(input, offset, outSize, solid);
+    };
+    /**
+   * Decode LZMA2 data with streaming output
+   * @param input - LZMA2 compressed data
+   * @returns Total number of bytes written to sink
+   */ _proto.decodeWithSink = function decodeWithSink(input) {
+        var totalBytes = 0;
+        var offset = 0;
+        while(offset < input.length){
+            var result = (0, _Lzma2ChunkParserts.parseLzma2ChunkHeader)(input, offset);
+            if (!result.success) {
+                throw new Error('Truncated LZMA2 chunk header');
+            }
+            var chunk = result.chunk;
+            if (chunk.type === 'end') {
+                break;
+            }
+            // Validate we have enough data for the chunk
+            var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
+            if (offset + chunk.headerSize + dataSize > input.length) {
+                throw new Error("Truncated LZMA2 ".concat(chunk.type, " data"));
+            }
+            // Handle dictionary reset
+            if (chunk.dictReset) {
+                this.lzmaDecoder.resetDictionary();
+            }
+            var dataOffset = offset + chunk.headerSize;
+            if (chunk.type === 'uncompressed') {
+                var uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);
+                // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it
+                this.lzmaDecoder.feedUncompressed(uncompData);
+                totalBytes += uncompData.length;
+                offset = dataOffset + chunk.uncompSize;
+            } else {
+                // LZMA compressed chunk
+                // Apply new properties if present
+                if (chunk.newProps) {
+                    var _chunk_newProps = chunk.newProps, lc = _chunk_newProps.lc, lp = _chunk_newProps.lp, pb = _chunk_newProps.pb;
+                    if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {
+                        throw new Error("Invalid LZMA properties: lc=".concat(lc, " lp=").concat(lp, " pb=").concat(pb));
+                    }
+                    this.propsSet = true;
+                }
+                if (!this.propsSet) {
+                    throw new Error('LZMA chunk without properties');
+                }
+                // Reset probabilities if state reset
+                if (chunk.stateReset) {
+                    this.lzmaDecoder.resetProbabilities();
+                }
+                // Determine solid mode
+                var useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
+                // Decode LZMA chunk directly to sink
+                totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);
+                offset = dataOffset + chunk.compSize;
+            }
+        }
+        // Flush any remaining data in the OutWindow
+        this.lzmaDecoder.flushOutWindow();
+        return totalBytes;
+    };
+    /**
+   * Decode LZMA2 data
+   * @param input - LZMA2 compressed data
+   * @param unpackSize - Expected output size (optional, for pre-allocation)
+   * @returns Decompressed data
+   */ _proto.decode = function decode(input, unpackSize) {
+        // Pre-allocate output buffer if size is known
+        var outputBuffer = null;
+        var outputPos = 0;
+        var outputChunks = [];
+        if (unpackSize && unpackSize > 0) {
+            outputBuffer = (0, _extractbaseiterator.allocBufferUnsafe)(unpackSize);
+        }
+        var offset = 0;
+        while(offset < input.length){
+            var result = (0, _Lzma2ChunkParserts.parseLzma2ChunkHeader)(input, offset);
+            if (!result.success) {
+                throw new Error('Truncated LZMA2 chunk header');
+            }
+            var chunk = result.chunk;
+            if (chunk.type === 'end') {
+                break;
+            }
+            // Validate we have enough data for the chunk
+            var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
+            if (offset + chunk.headerSize + dataSize > input.length) {
+                throw new Error("Truncated LZMA2 ".concat(chunk.type, " data"));
+            }
+            // Handle dictionary reset
+            if (chunk.dictReset) {
+                this.lzmaDecoder.resetDictionary();
+            }
+            var dataOffset = offset + chunk.headerSize;
+            if (chunk.type === 'uncompressed') {
+                var uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);
+                // Copy to output
+                if (outputBuffer) {
+                    uncompData.copy(outputBuffer, outputPos);
+                    outputPos += uncompData.length;
+                } else {
+                    outputChunks.push(uncompData);
+                }
+                // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it
+                this.lzmaDecoder.feedUncompressed(uncompData);
+                offset = dataOffset + chunk.uncompSize;
+            } else {
+                // LZMA compressed chunk
+                // Apply new properties if present
+                if (chunk.newProps) {
+                    var _chunk_newProps = chunk.newProps, lc = _chunk_newProps.lc, lp = _chunk_newProps.lp, pb = _chunk_newProps.pb;
+                    if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {
+                        throw new Error("Invalid LZMA properties: lc=".concat(lc, " lp=").concat(lp, " pb=").concat(pb));
+                    }
+                    this.propsSet = true;
+                }
+                if (!this.propsSet) {
+                    throw new Error('LZMA chunk without properties');
+                }
+                // Reset probabilities if state reset
+                if (chunk.stateReset) {
+                    this.lzmaDecoder.resetProbabilities();
+                }
+                // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
+                var useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
+                // Decode LZMA chunk
+                var chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);
+                var decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);
+                // Copy to output
+                if (outputBuffer) {
+                    decoded.copy(outputBuffer, outputPos);
+                    outputPos += decoded.length;
+                } else {
+                    outputChunks.push(decoded);
+                }
+                offset = dataOffset + chunk.compSize;
+            }
+        }
+        // Return pre-allocated buffer or concatenated chunks
+        if (outputBuffer) {
+            return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;
+        }
+        return Buffer.concat(outputChunks);
+    };
+    return Lzma2Decoder;
+}();
+function decodeLzma2(input, properties, unpackSize, outputSink) {
+    var decoder = new Lzma2Decoder(properties, outputSink);
+    if (outputSink) {
+        // Zero-copy mode: write to sink during decode
+        return decoder.decodeWithSink(input);
+    }
+    // Buffering mode: returns Buffer (zero-copy)
+    return decoder.decode(input, 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/lzma/sync/Lzma2Decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/sync/Lzma2Decoder.ts"],"sourcesContent":["/**\n * Synchronous LZMA2 Decoder\n *\n * LZMA2 is a container format that wraps LZMA chunks with framing.\n * Decodes LZMA2 data from a buffer.\n */\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport { parseLzma2ChunkHeader } from '../Lzma2ChunkParser.ts';\nimport { type OutputSink, parseLzma2DictionarySize } from '../types.ts';\nimport { LzmaDecoder } from './LzmaDecoder.ts';\n\n/**\n * Synchronous LZMA2 decoder\n */\nexport class Lzma2Decoder {\n  private lzmaDecoder: LzmaDecoder;\n  private dictionarySize: number;\n  private propsSet: boolean;\n\n  constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink) {\n    if (!properties || properties.length < 1) {\n      throw new Error('LZMA2 requires properties byte');\n    }\n\n    this.dictionarySize = parseLzma2DictionarySize(properties[0]);\n    this.lzmaDecoder = new LzmaDecoder(outputSink);\n    this.lzmaDecoder.setDictionarySize(this.dictionarySize);\n    this.propsSet = false;\n  }\n\n  /**\n   * Reset the dictionary (for stream boundaries)\n   */\n  resetDictionary(): void {\n    this.lzmaDecoder.resetDictionary();\n  }\n\n  /**\n   * Reset all probability models (for stream boundaries)\n   */\n  resetProbabilities(): void {\n    this.lzmaDecoder.resetProbabilities();\n  }\n\n  /**\n   * Set LZMA properties\n   */\n  setLcLpPb(lc: number, lp: number, pb: number): boolean {\n    return this.lzmaDecoder.setLcLpPb(lc, lp, pb);\n  }\n\n  /**\n   * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)\n   */\n  feedUncompressed(data: Buffer): void {\n    this.lzmaDecoder.feedUncompressed(data);\n  }\n\n  /**\n   * Decode raw LZMA data (used internally for LZMA2 chunks)\n   * @param input - LZMA compressed data\n   * @param offset - Input offset\n   * @param outSize - Expected output size\n   * @param solid - Use solid mode\n   * @returns Decompressed data\n   */\n  decodeLzmaData(input: Buffer, offset: number, outSize: number, solid = false): Buffer {\n    return this.lzmaDecoder.decode(input, offset, outSize, solid);\n  }\n\n  /**\n   * Decode LZMA2 data with streaming output\n   * @param input - LZMA2 compressed data\n   * @returns Total number of bytes written to sink\n   */\n  decodeWithSink(input: Buffer): number {\n    let totalBytes = 0;\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        totalBytes += uncompData.length;\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk directly to sink\n        totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Flush any remaining data in the OutWindow\n    this.lzmaDecoder.flushOutWindow();\n\n    return totalBytes;\n  }\n\n  /**\n   * Decode LZMA2 data\n   * @param input - LZMA2 compressed data\n   * @param unpackSize - Expected output size (optional, for pre-allocation)\n   * @returns Decompressed data\n   */\n  decode(input: Buffer, unpackSize?: number): Buffer {\n    // Pre-allocate output buffer if size is known\n    let outputBuffer: Buffer | null = null;\n    let outputPos = 0;\n    const outputChunks: Buffer[] = [];\n\n    if (unpackSize && unpackSize > 0) {\n      outputBuffer = allocBufferUnsafe(unpackSize);\n    }\n\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Copy to output\n        if (outputBuffer) {\n          uncompData.copy(outputBuffer, outputPos);\n          outputPos += uncompData.length;\n        } else {\n          outputChunks.push(uncompData);\n        }\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk\n        const chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);\n        const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);\n\n        // Copy to output\n        if (outputBuffer) {\n          decoded.copy(outputBuffer, outputPos);\n          outputPos += decoded.length;\n        } else {\n          outputChunks.push(decoded);\n        }\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Return pre-allocated buffer or concatenated chunks\n    if (outputBuffer) {\n      return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;\n    }\n    return Buffer.concat(outputChunks);\n  }\n}\n\n/**\n * Decode LZMA2 data synchronously\n * @param input - LZMA2 compressed data\n * @param properties - 1-byte properties (dictionary size)\n * @param unpackSize - Expected output size (optional, autodetects if not provided)\n * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)\n * @returns Decompressed data (or bytes written if outputSink provided)\n */\nexport function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number {\n  const decoder = new Lzma2Decoder(properties, outputSink);\n  if (outputSink) {\n    // Zero-copy mode: write to sink during decode\n    return decoder.decodeWithSink(input);\n  }\n  // Buffering mode: returns Buffer (zero-copy)\n  return decoder.decode(input, unpackSize);\n}\n"],"names":["Lzma2Decoder","decodeLzma2","properties","outputSink","length","Error","dictionarySize","parseLzma2DictionarySize","lzmaDecoder","LzmaDecoder","setDictionarySize","propsSet","resetDictionary","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","totalBytes","result","parseLzma2ChunkHeader","success","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","dataOffset","uncompData","slice","newProps","stateReset","useSolid","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","allocBufferUnsafe","copy","push","chunkData","decoded","Buffer","concat","decoder"],"mappings":"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"}

package/dist/cjs/lzma/sync/LzmaDecoder.d.cts

@@ -0,0 +1,97 @@
+/**
+ * Synchronous LZMA1 Decoder
+ *
+ * Decodes LZMA1 compressed data from a buffer.
+ * All operations are synchronous.
+ */
+import { type OutputSink } from '../types.js';
+/**
+ * Synchronous LZMA1 decoder
+ */
+export declare class LzmaDecoder {
+    private outWindow;
+    private rangeDecoder;
+    private isMatchDecoders;
+    private isRepDecoders;
+    private isRepG0Decoders;
+    private isRepG1Decoders;
+    private isRepG2Decoders;
+    private isRep0LongDecoders;
+    private posSlotDecoder;
+    private posDecoders;
+    private posAlignDecoder;
+    private lenDecoder;
+    private repLenDecoder;
+    private literalDecoder;
+    private dictionarySize;
+    private dictionarySizeCheck;
+    private posStateMask;
+    private state;
+    private rep0;
+    private rep1;
+    private rep2;
+    private rep3;
+    private prevByte;
+    private totalPos;
+    constructor(outputSink?: OutputSink);
+    /**
+     * Set dictionary size
+     */
+    setDictionarySize(dictionarySize: number): boolean;
+    /**
+     * Set lc, lp, pb properties
+     */
+    setLcLpPb(lc: number, lp: number, pb: number): boolean;
+    /**
+     * Set decoder properties from 5-byte buffer
+     */
+    setDecoderProperties(properties: Buffer | Uint8Array): boolean;
+    /**
+     * Initialize probability tables
+     */
+    private initProbabilities;
+    /**
+     * Reset probabilities only (for LZMA2 state reset)
+     */
+    resetProbabilities(): void;
+    /**
+     * Reset dictionary position (for LZMA2 dictionary reset)
+     */
+    resetDictionary(): void;
+    /**
+     * Feed uncompressed data into the dictionary (for LZMA2 uncompressed chunks)
+     * This updates the sliding window so subsequent LZMA chunks can reference this data.
+     */
+    feedUncompressed(data: Buffer): void;
+    /**
+     * Flush any remaining data in the OutWindow to the sink
+     */
+    flushOutWindow(): void;
+    /**
+     * Decode LZMA data with streaming output (no buffer accumulation)
+     * @param input - Compressed input buffer
+     * @param inputOffset - Offset into input buffer
+     * @param outSize - Expected output size
+     * @param solid - If true, preserve state from previous decode
+     * @returns Number of bytes written to sink
+     */
+    decodeWithSink(input: Buffer, inputOffset: number, outSize: number, solid?: boolean): number;
+    /**
+     * Decode LZMA data
+     * @param input - Compressed input buffer
+     * @param inputOffset - Offset into input buffer
+     * @param outSize - Expected output size
+     * @param solid - If true, preserve state from previous decode
+     * @returns Decompressed data
+     */
+    decode(input: Buffer, inputOffset: number, outSize: number, solid?: boolean): Buffer;
+}
+/**
+ * Decode LZMA1 data synchronously
+ * @param input - Compressed data (without 5-byte properties header)
+ * @param properties - 5-byte LZMA properties
+ * @param outSize - Expected output size
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */
+export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: OutputSink): Buffer | number;

package/dist/cjs/lzma/sync/LzmaDecoder.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Synchronous LZMA1 Decoder
+ *
+ * Decodes LZMA1 compressed data from a buffer.
+ * All operations are synchronous.
+ */
+import { type OutputSink } from '../types.js';
+/**
+ * Synchronous LZMA1 decoder
+ */
+export declare class LzmaDecoder {
+    private outWindow;
+    private rangeDecoder;
+    private isMatchDecoders;
+    private isRepDecoders;
+    private isRepG0Decoders;
+    private isRepG1Decoders;
+    private isRepG2Decoders;
+    private isRep0LongDecoders;
+    private posSlotDecoder;
+    private posDecoders;
+    private posAlignDecoder;
+    private lenDecoder;
+    private repLenDecoder;
+    private literalDecoder;
+    private dictionarySize;
+    private dictionarySizeCheck;
+    private posStateMask;
+    private state;
+    private rep0;
+    private rep1;
+    private rep2;
+    private rep3;
+    private prevByte;
+    private totalPos;
+    constructor(outputSink?: OutputSink);
+    /**
+     * Set dictionary size
+     */
+    setDictionarySize(dictionarySize: number): boolean;
+    /**
+     * Set lc, lp, pb properties
+     */
+    setLcLpPb(lc: number, lp: number, pb: number): boolean;
+    /**
+     * Set decoder properties from 5-byte buffer
+     */
+    setDecoderProperties(properties: Buffer | Uint8Array): boolean;
+    /**
+     * Initialize probability tables
+     */
+    private initProbabilities;
+    /**
+     * Reset probabilities only (for LZMA2 state reset)
+     */
+    resetProbabilities(): void;
+    /**
+     * Reset dictionary position (for LZMA2 dictionary reset)
+     */
+    resetDictionary(): void;
+    /**
+     * Feed uncompressed data into the dictionary (for LZMA2 uncompressed chunks)
+     * This updates the sliding window so subsequent LZMA chunks can reference this data.
+     */
+    feedUncompressed(data: Buffer): void;
+    /**
+     * Flush any remaining data in the OutWindow to the sink
+     */
+    flushOutWindow(): void;
+    /**
+     * Decode LZMA data with streaming output (no buffer accumulation)
+     * @param input - Compressed input buffer
+     * @param inputOffset - Offset into input buffer
+     * @param outSize - Expected output size
+     * @param solid - If true, preserve state from previous decode
+     * @returns Number of bytes written to sink
+     */
+    decodeWithSink(input: Buffer, inputOffset: number, outSize: number, solid?: boolean): number;
+    /**
+     * Decode LZMA data
+     * @param input - Compressed input buffer
+     * @param inputOffset - Offset into input buffer
+     * @param outSize - Expected output size
+     * @param solid - If true, preserve state from previous decode
+     * @returns Decompressed data
+     */
+    decode(input: Buffer, inputOffset: number, outSize: number, solid?: boolean): Buffer;
+}
+/**
+ * Decode LZMA1 data synchronously
+ * @param input - Compressed data (without 5-byte properties header)
+ * @param properties - 5-byte LZMA properties
+ * @param outSize - Expected output size
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */
+export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: OutputSink): Buffer | number;