7z-iterator 1.4.0 → 2.0.2

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

@@ -1,209 +0,0 @@
-/**
- * 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;
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    // Copy each chunk into the pre-allocated buffer
-                    for(var _iterator = chunks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var chunk = _step.value;
-                        chunk.copy(input, offset);
-                        offset += chunk.length;
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-                // 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

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/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 (const chunk of chunks) {\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","copy"],"mappings":"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"}

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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,231 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/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":"AAAA;;;;;CAKC;;;;;;;;;;;QAUYA;eAAAA;;QA2PGC;eAAAA;;;mCAnQkB;kCACI;uBACoB;6BAC9B;;;;;;AAKrB,IAAA,AAAMD,6BAAN;;aAAMA,aAKCE,UAA+B,EAAEC,UAAuB;gCALzDH;QAMT,IAAI,CAACE,cAAcA,WAAWE,MAAM,GAAG,GAAG;YACxC,MAAM,IAAIC,MAAM;QAClB;QAEA,IAAI,CAACC,cAAc,GAAGC,IAAAA,iCAAwB,EAACL,UAAU,CAAC,EAAE;QAC5D,IAAI,CAACM,WAAW,GAAG,IAAIC,0BAAW,CAACN;QACnC,IAAI,CAACK,WAAW,CAACE,iBAAiB,CAAC,IAAI,CAACJ,cAAc;QACtD,IAAI,CAACK,QAAQ,GAAG;;iBAbPX;IAgBX;;GAEC,GACDY,OAAAA,eAEC,GAFDA,SAAAA;QACE,IAAI,CAACJ,WAAW,CAACI,eAAe;IAClC;IAEA;;GAEC,GACDC,OAAAA,kBAEC,GAFDA,SAAAA;QACE,IAAI,CAACL,WAAW,CAACK,kBAAkB;IACrC;IAEA;;GAEC,GACDC,OAAAA,SAEC,GAFDA,SAAAA,UAAUC,EAAU,EAAEC,EAAU,EAAEC,EAAU;QAC1C,OAAO,IAAI,CAACT,WAAW,CAACM,SAAS,CAACC,IAAIC,IAAIC;IAC5C;IAEA;;GAEC,GACDC,OAAAA,gBAEC,GAFDA,SAAAA,iBAAiBC,IAAY;QAC3B,IAAI,CAACX,WAAW,CAACU,gBAAgB,CAACC;IACpC;IAEA;;;;;;;GAOC,GACDC,OAAAA,cAEC,GAFDA,SAAAA,eAAeC,KAAa,EAAEC,MAAc,EAAEC,OAAe;YAAEC,QAAAA,iEAAQ;QACrE,OAAO,IAAI,CAAChB,WAAW,CAACiB,MAAM,CAACJ,OAAOC,QAAQC,SAASC;IACzD;IAEA;;;;GAIC,GACDE,OAAAA,cAyEC,GAzEDA,SAAAA,eAAeL,KAAa;QAC1B,IAAIM,aAAa;QACjB,IAAIL,SAAS;QAEb,MAAOA,SAASD,MAAMjB,MAAM,CAAE;YAC5B,IAAMwB,SAASC,IAAAA,yCAAqB,EAACR,OAAOC;YAE5C,IAAI,CAACM,OAAOE,OAAO,EAAE;gBACnB,MAAM,IAAIzB,MAAM;YAClB;YAEA,IAAM0B,QAAQH,OAAOG,KAAK;YAE1B,IAAIA,MAAMC,IAAI,KAAK,OAAO;gBACxB;YACF;YAEA,6CAA6C;YAC7C,IAAMC,WAAWF,MAAMC,IAAI,KAAK,iBAAiBD,MAAMG,UAAU,GAAGH,MAAMI,QAAQ;YAClF,IAAIb,SAASS,MAAMK,UAAU,GAAGH,WAAWZ,MAAMjB,MAAM,EAAE;gBACvD,MAAM,IAAIC,MAAM,AAAC,mBAA6B,OAAX0B,MAAMC,IAAI,EAAC;YAChD;YAEA,0BAA0B;YAC1B,IAAID,MAAMM,SAAS,EAAE;gBACnB,IAAI,CAAC7B,WAAW,CAACI,eAAe;YAClC;YAEA,IAAM0B,aAAahB,SAASS,MAAMK,UAAU;YAE5C,IAAIL,MAAMC,IAAI,KAAK,gBAAgB;gBACjC,IAAMO,aAAalB,MAAMmB,KAAK,CAACF,YAAYA,aAAaP,MAAMG,UAAU;gBAExE,kFAAkF;gBAClF,IAAI,CAAC1B,WAAW,CAACU,gBAAgB,CAACqB;gBAElCZ,cAAcY,WAAWnC,MAAM;gBAC/BkB,SAASgB,aAAaP,MAAMG,UAAU;YACxC,OAAO;gBACL,wBAAwB;gBAExB,kCAAkC;gBAClC,IAAIH,MAAMU,QAAQ,EAAE;oBAClB,IAAuBV,kBAAAA,MAAMU,QAAQ,EAA7B1B,KAAegB,gBAAfhB,IAAIC,KAAWe,gBAAXf,IAAIC,KAAOc,gBAAPd;oBAChB,IAAI,CAAC,IAAI,CAACT,WAAW,CAACM,SAAS,CAACC,IAAIC,IAAIC,KAAK;wBAC3C,MAAM,IAAIZ,MAAM,AAAC,+BAAuCW,OAATD,IAAG,QAAeE,OAATD,IAAG,QAAS,OAAHC;oBACnE;oBACA,IAAI,CAACN,QAAQ,GAAG;gBAClB;gBAEA,IAAI,CAAC,IAAI,CAACA,QAAQ,EAAE;oBAClB,MAAM,IAAIN,MAAM;gBAClB;gBAEA,qCAAqC;gBACrC,IAAI0B,MAAMW,UAAU,EAAE;oBACpB,IAAI,CAAClC,WAAW,CAACK,kBAAkB;gBACrC;gBAEA,uBAAuB;gBACvB,IAAM8B,WAAW,CAACZ,MAAMW,UAAU,IAAKX,MAAMW,UAAU,IAAI,CAACX,MAAMM,SAAS;gBAE3E,qCAAqC;gBACrCV,cAAc,IAAI,CAACnB,WAAW,CAACkB,cAAc,CAACL,OAAOiB,YAAYP,MAAMG,UAAU,EAAES;gBAEnFrB,SAASgB,aAAaP,MAAMI,QAAQ;YACtC;QACF;QAEA,4CAA4C;QAC5C,IAAI,CAAC3B,WAAW,CAACoC,cAAc;QAE/B,OAAOjB;IACT;IAEA;;;;;GAKC,GACDF,OAAAA,MAkGC,GAlGDA,SAAAA,OAAOJ,KAAa,EAAEwB,UAAmB;QACvC,8CAA8C;QAC9C,IAAIC,eAA8B;QAClC,IAAIC,YAAY;QAChB,IAAMC,eAAyB,EAAE;QAEjC,IAAIH,cAAcA,aAAa,GAAG;YAChCC,eAAeG,IAAAA,sCAAiB,EAACJ;QACnC;QAEA,IAAIvB,SAAS;QAEb,MAAOA,SAASD,MAAMjB,MAAM,CAAE;YAC5B,IAAMwB,SAASC,IAAAA,yCAAqB,EAACR,OAAOC;YAE5C,IAAI,CAACM,OAAOE,OAAO,EAAE;gBACnB,MAAM,IAAIzB,MAAM;YAClB;YAEA,IAAM0B,QAAQH,OAAOG,KAAK;YAE1B,IAAIA,MAAMC,IAAI,KAAK,OAAO;gBACxB;YACF;YAEA,6CAA6C;YAC7C,IAAMC,WAAWF,MAAMC,IAAI,KAAK,iBAAiBD,MAAMG,UAAU,GAAGH,MAAMI,QAAQ;YAClF,IAAIb,SAASS,MAAMK,UAAU,GAAGH,WAAWZ,MAAMjB,MAAM,EAAE;gBACvD,MAAM,IAAIC,MAAM,AAAC,mBAA6B,OAAX0B,MAAMC,IAAI,EAAC;YAChD;YAEA,0BAA0B;YAC1B,IAAID,MAAMM,SAAS,EAAE;gBACnB,IAAI,CAAC7B,WAAW,CAACI,eAAe;YAClC;YAEA,IAAM0B,aAAahB,SAASS,MAAMK,UAAU;YAE5C,IAAIL,MAAMC,IAAI,KAAK,gBAAgB;gBACjC,IAAMO,aAAalB,MAAMmB,KAAK,CAACF,YAAYA,aAAaP,MAAMG,UAAU;gBAExE,iBAAiB;gBACjB,IAAIY,cAAc;oBAChBP,WAAWW,IAAI,CAACJ,cAAcC;oBAC9BA,aAAaR,WAAWnC,MAAM;gBAChC,OAAO;oBACL4C,aAAaG,IAAI,CAACZ;gBACpB;gBAEA,kFAAkF;gBAClF,IAAI,CAAC/B,WAAW,CAACU,gBAAgB,CAACqB;gBAElCjB,SAASgB,aAAaP,MAAMG,UAAU;YACxC,OAAO;gBACL,wBAAwB;gBAExB,kCAAkC;gBAClC,IAAIH,MAAMU,QAAQ,EAAE;oBAClB,IAAuBV,kBAAAA,MAAMU,QAAQ,EAA7B1B,KAAegB,gBAAfhB,IAAIC,KAAWe,gBAAXf,IAAIC,KAAOc,gBAAPd;oBAChB,IAAI,CAAC,IAAI,CAACT,WAAW,CAACM,SAAS,CAACC,IAAIC,IAAIC,KAAK;wBAC3C,MAAM,IAAIZ,MAAM,AAAC,+BAAuCW,OAATD,IAAG,QAAeE,OAATD,IAAG,QAAS,OAAHC;oBACnE;oBACA,IAAI,CAACN,QAAQ,GAAG;gBAClB;gBAEA,IAAI,CAAC,IAAI,CAACA,QAAQ,EAAE;oBAClB,MAAM,IAAIN,MAAM;gBAClB;gBAEA,qCAAqC;gBACrC,IAAI0B,MAAMW,UAAU,EAAE;oBACpB,IAAI,CAAClC,WAAW,CAACK,kBAAkB;gBACrC;gBAEA,0GAA0G;gBAC1G,IAAM8B,WAAW,CAACZ,MAAMW,UAAU,IAAKX,MAAMW,UAAU,IAAI,CAACX,MAAMM,SAAS;gBAE3E,oBAAoB;gBACpB,IAAMe,YAAY/B,MAAMmB,KAAK,CAACF,YAAYA,aAAaP,MAAMI,QAAQ;gBACrE,IAAMkB,UAAU,IAAI,CAAC7C,WAAW,CAACiB,MAAM,CAAC2B,WAAW,GAAGrB,MAAMG,UAAU,EAAES;gBAExE,iBAAiB;gBACjB,IAAIG,cAAc;oBAChBO,QAAQH,IAAI,CAACJ,cAAcC;oBAC3BA,aAAaM,QAAQjD,MAAM;gBAC7B,OAAO;oBACL4C,aAAaG,IAAI,CAACE;gBACpB;gBAEA/B,SAASgB,aAAaP,MAAMI,QAAQ;YACtC;QACF;QAEA,qDAAqD;QACrD,IAAIW,cAAc;YAChB,OAAOC,YAAYD,aAAa1C,MAAM,GAAG0C,aAAaN,KAAK,CAAC,GAAGO,aAAaD;QAC9E;QACA,OAAOQ,OAAOC,MAAM,CAACP;IACvB;WAhPWhD;;AA2PN,SAASC,YAAYoB,KAAa,EAAEnB,UAA+B,EAAE2C,UAAmB,EAAE1C,UAAuB;IACtH,IAAMqD,UAAU,IAAIxD,aAAaE,YAAYC;IAC7C,IAAIA,YAAY;QACd,8CAA8C;QAC9C,OAAOqD,QAAQ9B,cAAc,CAACL;IAChC;IACA,6CAA6C;IAC7C,OAAOmC,QAAQ/B,MAAM,CAACJ,OAAOwB;AAC/B"}