7z-iterator 1.3.1 → 1.4.0

package/dist/cjs/sevenz/codecs/Lzma2.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma2.ts"],"sourcesContent":["// LZMA2 codec using TypeScript LZMA decoder\n//\n// LZMA2 format specification:\n// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md\n//\n// Control byte values:\n// 0x00         = End of stream\n// 0x01         = Uncompressed chunk, dictionary reset\n// 0x02         = Uncompressed chunk, no dictionary reset\n// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)\n\nimport type { Transform } from 'stream';\nimport { createLzma2Decoder as createLzma2Transform, decodeLzma2 as lzma2Decode } from '../../lzma/index.ts';\n\n/**\n * Decode LZMA2 compressed data to buffer\n *\n * @param input - LZMA2 compressed data\n * @param properties - Properties buffer (1 byte: dictionary size)\n * @param unpackSize - Expected output size (optional, for pre-allocation)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  return lzma2Decode(input, properties, unpackSize);\n}\n\n/**\n * Create an LZMA2 decoder Transform stream\n *\n * This is a true streaming decoder that processes LZMA2 chunks incrementally.\n * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).\n *\n * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of\n * total archive size.\n */\nexport function createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  return createLzma2Transform(properties) as Transform;\n}\n"],"names":["createLzma2Decoder","decodeLzma2","input","properties","unpackSize","length","Error","lzma2Decode","_unpackSize","createLzma2Transform"],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,8BAA8B;AAC9B,2DAA2D;AAC3D,EAAE;AACF,uBAAuB;AACvB,+BAA+B;AAC/B,sDAAsD;AACtD,yDAAyD;AACzD,0EAA0E;;;;;;;;;;;;QA8B1DA;eAAAA;;QAjBAC;eAAAA;;;uBAVuE;AAUhF,SAASA,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOC,IAAAA,oBAAW,EAACL,OAAOC,YAAYC;AACxC;AAWO,SAASJ,mBAAmBG,UAAmB,EAAEK,WAAoB;IAC1E,IAAI,CAACL,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOG,IAAAA,2BAAoB,EAACN;AAC9B"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma2.ts"],"sourcesContent":["// LZMA2 codec using TypeScript LZMA decoder\n//\n// LZMA2 format specification:\n// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md\n//\n// Control byte values:\n// 0x00         = End of stream\n// 0x01         = Uncompressed chunk, dictionary reset\n// 0x02         = Uncompressed chunk, no dictionary reset\n// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)\n\nimport type { Transform } from 'stream';\nimport { createLzma2Decoder as createLzma2Transform, decodeLzma2 as lzma2Decode } from '../../lzma/index.ts';\n\n/**\n * Decode LZMA2 compressed data to buffer\n *\n * @param input - LZMA2 compressed data\n * @param properties - Properties buffer (1 byte: dictionary size)\n * @param unpackSize - Expected output size (optional, for pre-allocation)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  return lzma2Decode(input, properties, unpackSize) as Buffer;\n}\n\n/**\n * Create an LZMA2 decoder Transform stream\n *\n * This is a true streaming decoder that processes LZMA2 chunks incrementally.\n * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).\n *\n * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of\n * total archive size.\n */\nexport function createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  return createLzma2Transform(properties) as Transform;\n}\n"],"names":["createLzma2Decoder","decodeLzma2","input","properties","unpackSize","length","Error","lzma2Decode","_unpackSize","createLzma2Transform"],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,8BAA8B;AAC9B,2DAA2D;AAC3D,EAAE;AACF,uBAAuB;AACvB,+BAA+B;AAC/B,sDAAsD;AACtD,yDAAyD;AACzD,0EAA0E;;;;;;;;;;;;QA8B1DA;eAAAA;;QAjBAC;eAAAA;;;uBAVuE;AAUhF,SAASA,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOC,IAAAA,oBAAW,EAACL,OAAOC,YAAYC;AACxC;AAWO,SAASJ,mBAAmBG,UAAmB,EAAEK,WAAoB;IAC1E,IAAI,CAACL,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOG,IAAAA,2BAAoB,EAACN;AAC9B"}

package/dist/cjs/xz/Decoder.d.cts

@@ -0,0 +1,25 @@
+/**
+ * XZ Decompression Module
+ *
+ * XZ is a container format that wraps LZMA2 compressed data.
+ * This module provides both synchronous and streaming XZ decoders.
+ *
+ * Pure JavaScript implementation, works on Node.js 0.8+
+ */
+import type { Transform as TransformType } from 'stream';
+/**
+ * Decompress XZ data synchronously
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */
+export declare function decodeXZ(input: Buffer): Buffer;
+/**
+ * Create an XZ decompression Transform stream
+ *
+ * Note: XZ buffers all input before decompressing, as it's a single-frame format.
+ * For true streaming with better performance on large files, consider using XZ directly
+ * with the sync decodeXZ() function.
+ *
+ * @returns Transform stream that decompresses XZ data
+ */
+export declare function createXZDecoder(): TransformType;

package/dist/cjs/xz/Decoder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * XZ Decompression Module
+ *
+ * XZ is a container format that wraps LZMA2 compressed data.
+ * This module provides both synchronous and streaming XZ decoders.
+ *
+ * Pure JavaScript implementation, works on Node.js 0.8+
+ */
+import type { Transform as TransformType } from 'stream';
+/**
+ * Decompress XZ data synchronously
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */
+export declare function decodeXZ(input: Buffer): Buffer;
+/**
+ * Create an XZ decompression Transform stream
+ *
+ * Note: XZ buffers all input before decompressing, as it's a single-frame format.
+ * For true streaming with better performance on large files, consider using XZ directly
+ * with the sync decodeXZ() function.
+ *
+ * @returns Transform stream that decompresses XZ data
+ */
+export declare function createXZDecoder(): TransformType;

package/dist/cjs/xz/Decoder.js

@@ -0,0 +1,194 @@
+/**
+ * XZ Decompression Module
+ *
+ * XZ is a container format that wraps LZMA2 compressed data.
+ * This module provides both synchronous and streaming XZ decoders.
+ *
+ * Pure JavaScript implementation, works on Node.js 0.8+
+ */ "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 createXZDecoder () {
+        return createXZDecoder;
+    },
+    get decodeXZ () {
+        return decodeXZ;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _indexts = require("../lzma/index.js");
+// XZ magic bytes
+var XZ_MAGIC = [
+    0xfd,
+    0x37,
+    0x7a,
+    0x58,
+    0x5a,
+    0x00
+];
+var XZ_FOOTER_MAGIC = [
+    0x59,
+    0x5a
+]; // "YZ"
+// Filter IDs
+var FILTER_LZMA2 = 0x21;
+/**
+ * Simple buffer comparison
+ */ function bufferEquals(buf, offset, expected) {
+    if (offset + expected.length > buf.length) {
+        return false;
+    }
+    for(var i = 0; i < expected.length; i++){
+        if (buf[offset + i] !== expected[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Decode variable-length integer (XZ multibyte encoding)
+ */ function decodeMultibyte(buf, offset) {
+    var value = 0;
+    var i = 0;
+    var byte;
+    do {
+        if (offset + i >= buf.length) {
+            throw new Error('Truncated multibyte integer');
+        }
+        byte = buf[offset + i];
+        value |= (byte & 0x7f) << i * 7;
+        i++;
+        if (i > 9) {
+            throw new Error('Multibyte integer too large');
+        }
+    }while (byte & 0x80);
+    return {
+        value: value,
+        bytesRead: i
+    };
+}
+function decodeXZ(input) {
+    var _checkSizes_checkType;
+    // Verify XZ magic
+    if (input.length < 12 || !bufferEquals(input, 0, XZ_MAGIC)) {
+        throw new Error('Invalid XZ magic bytes');
+    }
+    // Stream flags at offset 6-7
+    var checkType = input[7] & 0x0f;
+    // Check sizes based on check type
+    var checkSizes = {
+        0: 0,
+        1: 4,
+        4: 8,
+        10: 32
+    };
+    var checkSize = (_checkSizes_checkType = checkSizes[checkType]) !== null && _checkSizes_checkType !== void 0 ? _checkSizes_checkType : 0;
+    // Block starts at offset 12
+    var offset = 12;
+    // Block header size
+    var blockHeaderSizeRaw = input[offset];
+    if (blockHeaderSizeRaw === 0) {
+        throw new Error('Invalid block header size (index indicator found instead of block)');
+    }
+    var blockHeaderSize = (blockHeaderSizeRaw + 1) * 4;
+    // Parse block header to find LZMA2 properties
+    var blockHeaderStart = offset;
+    offset++; // skip size byte
+    var blockFlags = input[offset++];
+    var numFilters = (blockFlags & 0x03) + 1;
+    var hasCompressedSize = (blockFlags & 0x40) !== 0;
+    var hasUncompressedSize = (blockFlags & 0x80) !== 0;
+    // Skip optional sizes
+    if (hasCompressedSize) {
+        var result = decodeMultibyte(input, offset);
+        offset += result.bytesRead;
+    }
+    var _uncompressedSize;
+    if (hasUncompressedSize) {
+        var result1 = decodeMultibyte(input, offset);
+        _uncompressedSize = result1.value;
+        offset += result1.bytesRead;
+    }
+    // Parse filter (should be LZMA2)
+    var lzma2Props = null;
+    for(var i = 0; i < numFilters; i++){
+        var filterIdResult = decodeMultibyte(input, offset);
+        var filterId = filterIdResult.value;
+        offset += filterIdResult.bytesRead;
+        var propsSizeResult = decodeMultibyte(input, offset);
+        offset += propsSizeResult.bytesRead;
+        var filterProps = input.slice(offset, offset + propsSizeResult.value);
+        offset += propsSizeResult.value;
+        if (filterId === FILTER_LZMA2) {
+            lzma2Props = filterProps;
+        } else if (filterId !== 0x03 && filterId !== 0x04 && filterId !== 0x05 && filterId !== 0x06 && filterId !== 0x07 && filterId !== 0x08 && filterId !== 0x09 && filterId !== 0x0a) {
+            // BCJ filters (0x04-0x0a) and Delta (0x03) are preprocessing filters
+            // For now, only support LZMA2 alone
+            throw new Error("Unsupported filter: 0x".concat(filterId.toString(16)));
+        }
+    }
+    if (!lzma2Props) {
+        throw new Error('No LZMA2 filter found in XZ block');
+    }
+    // Skip to end of block header (align to 4 bytes + CRC32)
+    var blockDataStart = blockHeaderStart + blockHeaderSize;
+    // Find the end of compressed data (look for index from the footer)
+    // Footer is last 12 bytes: CRC32(4) + Backward Size(4) + Stream Flags(2) + Magic(2)
+    if (input.length < 12) {
+        throw new Error('XZ file too small');
+    }
+    // Verify footer magic
+    if (!bufferEquals(input, input.length - 2, XZ_FOOTER_MAGIC)) {
+        throw new Error('Invalid XZ footer magic');
+    }
+    // Get backward size (tells us where index starts)
+    // Footer: CRC32(4) at -12, Backward Size(4) at -8, Stream Flags(2) at -4, Magic(2) at -2
+    var backwardSize = (input.readUInt32LE(input.length - 8) + 1) * 4;
+    var indexStart = input.length - 12 - backwardSize;
+    // Extract all data between block header end and index start
+    var compressedDataEnd = indexStart;
+    // Account for check at end of block
+    compressedDataEnd -= checkSize;
+    // Account for padding (up to 3 bytes of 0x00)
+    while(compressedDataEnd > blockDataStart && input[compressedDataEnd - 1] === 0x00){
+        compressedDataEnd--;
+    }
+    // Add back one 0x00 for LZMA2 end marker
+    compressedDataEnd++;
+    var compressedData = input.slice(blockDataStart, compressedDataEnd);
+    // Decompress LZMA2 data using optimized output stream decoder
+    var chunks = [];
+    (0, _indexts.decodeLzma2)(compressedData, lzma2Props, undefined, {
+        write: function(chunk) {
+            return chunks.push(chunk);
+        }
+    });
+    return Buffer.concat(chunks);
+}
+function createXZDecoder() {
+    var chunks = [];
+    return new _extractbaseiterator.Transform({
+        transform: function transform(chunk, _encoding, callback) {
+            chunks.push(chunk);
+            callback();
+        },
+        flush: function flush(callback) {
+            try {
+                var input = Buffer.concat(chunks);
+                var output = decodeXZ(input);
+                callback(null, output);
+            } 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/xz/Decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/xz/Decoder.ts"],"sourcesContent":["/**\n * XZ Decompression Module\n *\n * XZ is a container format that wraps LZMA2 compressed data.\n * This module provides both synchronous and streaming XZ decoders.\n *\n * Pure JavaScript implementation, works on Node.js 0.8+\n */\n\nimport { Transform } from 'extract-base-iterator';\nimport type { Transform as TransformType } from 'stream';\nimport { decodeLzma2 } from '../lzma/index.ts';\n\n// XZ magic bytes\nconst XZ_MAGIC = [0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00];\nconst XZ_FOOTER_MAGIC = [0x59, 0x5a]; // \"YZ\"\n\n// Filter IDs\nconst FILTER_LZMA2 = 0x21;\n\n/**\n * Simple buffer comparison\n */\nfunction bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean {\n  if (offset + expected.length > buf.length) {\n    return false;\n  }\n  for (let i = 0; i < expected.length; i++) {\n    if (buf[offset + i] !== expected[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Decode variable-length integer (XZ multibyte encoding)\n */\nfunction decodeMultibyte(buf: Buffer, offset: number): { value: number; bytesRead: number } {\n  let value = 0;\n  let i = 0;\n  let byte: number;\n  do {\n    if (offset + i >= buf.length) {\n      throw new Error('Truncated multibyte integer');\n    }\n    byte = buf[offset + i];\n    value |= (byte & 0x7f) << (i * 7);\n    i++;\n    if (i > 9) {\n      throw new Error('Multibyte integer too large');\n    }\n  } while (byte & 0x80);\n  return { value, bytesRead: i };\n}\n\n/**\n * Decompress XZ data synchronously\n * @param input - XZ compressed data\n * @returns Decompressed data\n */\nexport function decodeXZ(input: Buffer): Buffer {\n  // Verify XZ magic\n  if (input.length < 12 || !bufferEquals(input, 0, XZ_MAGIC)) {\n    throw new Error('Invalid XZ magic bytes');\n  }\n\n  // Stream flags at offset 6-7\n  const checkType = input[7] & 0x0f;\n\n  // Check sizes based on check type\n  const checkSizes: { [key: number]: number } = {\n    0: 0, // None\n    1: 4, // CRC32\n    4: 8, // CRC64\n    10: 32, // SHA-256\n  };\n  const checkSize = checkSizes[checkType] ?? 0;\n\n  // Block starts at offset 12\n  let offset = 12;\n\n  // Block header size\n  const blockHeaderSizeRaw = input[offset];\n  if (blockHeaderSizeRaw === 0) {\n    throw new Error('Invalid block header size (index indicator found instead of block)');\n  }\n  const blockHeaderSize = (blockHeaderSizeRaw + 1) * 4;\n\n  // Parse block header to find LZMA2 properties\n  const blockHeaderStart = offset;\n  offset++; // skip size byte\n\n  const blockFlags = input[offset++];\n  const numFilters = (blockFlags & 0x03) + 1;\n  const hasCompressedSize = (blockFlags & 0x40) !== 0;\n  const hasUncompressedSize = (blockFlags & 0x80) !== 0;\n\n  // Skip optional sizes\n  if (hasCompressedSize) {\n    const result = decodeMultibyte(input, offset);\n    offset += result.bytesRead;\n  }\n\n  let _uncompressedSize: number | undefined;\n  if (hasUncompressedSize) {\n    const result = decodeMultibyte(input, offset);\n    _uncompressedSize = result.value;\n    offset += result.bytesRead;\n  }\n\n  // Parse filter (should be LZMA2)\n  let lzma2Props: Buffer | null = null;\n  for (let i = 0; i < numFilters; i++) {\n    const filterIdResult = decodeMultibyte(input, offset);\n    const filterId = filterIdResult.value;\n    offset += filterIdResult.bytesRead;\n\n    const propsSizeResult = decodeMultibyte(input, offset);\n    offset += propsSizeResult.bytesRead;\n\n    const filterProps = input.slice(offset, offset + propsSizeResult.value);\n    offset += propsSizeResult.value;\n\n    if (filterId === FILTER_LZMA2) {\n      lzma2Props = filterProps;\n    } else if (filterId !== 0x03 && filterId !== 0x04 && filterId !== 0x05 && filterId !== 0x06 && filterId !== 0x07 && filterId !== 0x08 && filterId !== 0x09 && filterId !== 0x0a) {\n      // BCJ filters (0x04-0x0a) and Delta (0x03) are preprocessing filters\n      // For now, only support LZMA2 alone\n      throw new Error(`Unsupported filter: 0x${filterId.toString(16)}`);\n    }\n  }\n\n  if (!lzma2Props) {\n    throw new Error('No LZMA2 filter found in XZ block');\n  }\n\n  // Skip to end of block header (align to 4 bytes + CRC32)\n  const blockDataStart = blockHeaderStart + blockHeaderSize;\n\n  // Find the end of compressed data (look for index from the footer)\n  // Footer is last 12 bytes: CRC32(4) + Backward Size(4) + Stream Flags(2) + Magic(2)\n  if (input.length < 12) {\n    throw new Error('XZ file too small');\n  }\n\n  // Verify footer magic\n  if (!bufferEquals(input, input.length - 2, XZ_FOOTER_MAGIC)) {\n    throw new Error('Invalid XZ footer magic');\n  }\n\n  // Get backward size (tells us where index starts)\n  // Footer: CRC32(4) at -12, Backward Size(4) at -8, Stream Flags(2) at -4, Magic(2) at -2\n  const backwardSize = (input.readUInt32LE(input.length - 8) + 1) * 4;\n  const indexStart = input.length - 12 - backwardSize;\n\n  // Extract all data between block header end and index start\n  let compressedDataEnd = indexStart;\n\n  // Account for check at end of block\n  compressedDataEnd -= checkSize;\n\n  // Account for padding (up to 3 bytes of 0x00)\n  while (compressedDataEnd > blockDataStart && input[compressedDataEnd - 1] === 0x00) {\n    compressedDataEnd--;\n  }\n  // Add back one 0x00 for LZMA2 end marker\n  compressedDataEnd++;\n\n  const compressedData = input.slice(blockDataStart, compressedDataEnd);\n\n  // Decompress LZMA2 data using optimized output stream decoder\n  const chunks: Buffer[] = [];\n  decodeLzma2(compressedData, lzma2Props, undefined, {\n    write: (chunk: Buffer) => chunks.push(chunk),\n  });\n\n  return Buffer.concat(chunks);\n}\n\n/**\n * Create an XZ decompression Transform stream\n *\n * Note: XZ buffers all input before decompressing, as it's a single-frame format.\n * For true streaming with better performance on large files, consider using XZ directly\n * with the sync decodeXZ() function.\n *\n * @returns Transform stream that decompresses XZ data\n */\nexport function createXZDecoder(): TransformType {\n  const chunks: Buffer[] = [];\n\n  return new Transform({\n    transform(chunk: Buffer, _encoding: string, callback: (error?: Error | null, data?: Buffer) => void) {\n      chunks.push(chunk);\n      callback();\n    },\n\n    flush(callback: (error?: Error | null, data?: Buffer) => void) {\n      try {\n        const input = Buffer.concat(chunks);\n        const output = decodeXZ(input);\n        callback(null, output);\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createXZDecoder","decodeXZ","XZ_MAGIC","XZ_FOOTER_MAGIC","FILTER_LZMA2","bufferEquals","buf","offset","expected","length","i","decodeMultibyte","value","byte","Error","bytesRead","input","checkSizes","checkType","checkSize","blockHeaderSizeRaw","blockHeaderSize","blockHeaderStart","blockFlags","numFilters","hasCompressedSize","hasUncompressedSize","result","_uncompressedSize","lzma2Props","filterIdResult","filterId","propsSizeResult","filterProps","slice","toString","blockDataStart","backwardSize","readUInt32LE","indexStart","compressedDataEnd","compressedData","chunks","decodeLzma2","undefined","write","chunk","push","Buffer","concat","Transform","transform","_encoding","callback","flush","output","err"],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -1,3 +1,5 @@
-export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, Lzma2Decoder, LzmaDecoder, } from './lzma/index.js';
+export type { OutputSink } from './lzma/index.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectFormat, Lzma2Decoder, LzmaDecoder, } from './lzma/index.js';
 export { default } from './SevenZipIterator.js';
 export * from './types.js';
+export { createXZDecoder, decodeXZ } from './xz/Decoder.js';

package/dist/esm/index.js

@@ -1,4 +1,5 @@
 // LZMA decoders for external use
-export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, Lzma2Decoder, LzmaDecoder } from './lzma/index.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectFormat, Lzma2Decoder, LzmaDecoder } from './lzma/index.js';
 export { default } from './SevenZipIterator.js';
 export * from './types.js';
+export { createXZDecoder, decodeXZ } from './xz/Decoder.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/index.ts"],"sourcesContent":["// LZMA decoders for external use\nexport {\n  createLzma2Decoder,\n  createLzmaDecoder,\n  decodeLzma,\n  decodeLzma2,\n  Lzma2Decoder,\n  LzmaDecoder,\n} from './lzma/index.ts';\nexport { default } from './SevenZipIterator.ts';\nexport * from './types.ts';\n"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","Lzma2Decoder","LzmaDecoder","default"],"mappings":"AAAA,iCAAiC;AACjC,SACEA,kBAAkB,EAClBC,iBAAiB,EACjBC,UAAU,EACVC,WAAW,EACXC,YAAY,EACZC,WAAW,QACN,kBAAkB;AACzB,SAASC,OAAO,QAAQ,wBAAwB;AAChD,cAAc,aAAa"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/index.ts"],"sourcesContent":["// LZMA decoders for external use\n\nexport type { OutputSink } from './lzma/index.ts';\nexport {\n  createLzma2Decoder,\n  createLzmaDecoder,\n  decodeLzma,\n  decodeLzma2,\n  detectFormat,\n  Lzma2Decoder,\n  LzmaDecoder,\n} from './lzma/index.ts';\nexport { default } from './SevenZipIterator.ts';\nexport * from './types.ts';\nexport { createXZDecoder, decodeXZ } from './xz/Decoder.ts';\n"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","detectFormat","Lzma2Decoder","LzmaDecoder","default","createXZDecoder","decodeXZ"],"mappings":"AAAA,iCAAiC;AAGjC,SACEA,kBAAkB,EAClBC,iBAAiB,EACjBC,UAAU,EACVC,WAAW,EACXC,YAAY,EACZC,YAAY,EACZC,WAAW,QACN,kBAAkB;AACzB,SAASC,OAAO,QAAQ,wBAAwB;AAChD,cAAc,aAAa;AAC3B,SAASC,eAAe,EAAEC,QAAQ,QAAQ,kBAAkB"}

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

@@ -5,9 +5,27 @@
  *
  * 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 detectFormat(data: Buffer): 'lzma1' | 'lzma2';

package/dist/esm/lzma/index.js

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

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/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\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"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma2","Lzma2Decoder","decodeLzma","LzmaDecoder","BitTreeDecoder","RangeDecoder"],"mappings":"AAAA;;;;;;;CAOC,GAED,yCAAyC;AACzC,SAASA,kBAAkB,EAAEC,iBAAiB,QAAQ,yBAAyB;AAC/E,SAASC,WAAW,EAAEC,YAAY,QAAQ,yBAAyB;AACnE,0CAA0C;AAC1C,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAwB;AAChE,SAASC,cAAc,EAAEC,YAAY,QAAQ,yBAAyB;AACtE,eAAe;AACf,cAAc,aAAa"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/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 detectFormat(data: Buffer): 'lzma1' | 'lzma2' {\n  if (data.length === 0) {\n    // Default to LZMA2 for empty data (matches LZMA2 decoder behavior)\n    return 'lzma2';\n  }\n\n  const firstByte = data[0];\n\n  // LZMA2 control bytes: 0x00, 0x01, 0x02, or 0x80-0xFF\n  if (firstByte === 0x00 || firstByte === 0x01 || firstByte === 0x02 || (firstByte >= 0x80 && firstByte <= 0xff)) {\n    return 'lzma2';\n  }\n\n  // All other values indicate LZMA1 (raw LZMA data)\n  return 'lzma1';\n}\n"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma2","Lzma2Decoder","decodeLzma","LzmaDecoder","BitTreeDecoder","RangeDecoder","detectFormat","data","length","firstByte"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;AACzC,SAASA,kBAAkB,EAAEC,iBAAiB,QAAQ,yBAAyB;AAC/E,SAASC,WAAW,EAAEC,YAAY,QAAQ,yBAAyB;AACnE,0CAA0C;AAC1C,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAwB;AAChE,SAASC,cAAc,EAAEC,YAAY,QAAQ,yBAAyB;AACtE,eAAe;AACf,cAAc,aAAa;AAE3B;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,aAAaC,IAAY;IACvC,IAAIA,KAAKC,MAAM,KAAK,GAAG;QACrB,mEAAmE;QACnE,OAAO;IACT;IAEA,MAAMC,YAAYF,IAAI,CAAC,EAAE;IAEzB,sDAAsD;IACtD,IAAIE,cAAc,QAAQA,cAAc,QAAQA,cAAc,QAASA,aAAa,QAAQA,aAAa,MAAO;QAC9G,OAAO;IACT;IAEA,kDAAkD;IAClD,OAAO;AACT"}

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

@@ -7,6 +7,11 @@
  * 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.
@@ -31,6 +36,9 @@ export declare function createLzma2Decoder(properties: Buffer | Uint8Array): Ins
  *
  * 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

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

@@ -7,10 +7,15 @@
  * 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';
+ */ import { allocBufferUnsafe, Transform } from 'extract-base-iterator';
 import { hasCompleteChunk } from '../Lzma2ChunkParser.js';
 import { LzmaDecoder } from '../sync/LzmaDecoder.js';
 import { parseLzma2DictionarySize } from '../types.js';
@@ -78,9 +83,13 @@ import { parseLzma2DictionarySize } from '../types.js';
                         decoder.feedUncompressed(uncompData);
                     } else {
                         // LZMA compressed chunk
+                        // Variables to store properties (used for both decoders)
+                        let lc;
+                        let lp;
+                        let pb;
                         // Apply new properties if present
                         if (chunkInfo.newProps) {
-                            const { lc, lp, pb } = chunkInfo.newProps;
+                            ({ lc, lp, pb } = chunkInfo.newProps);
                             if (!decoder.setLcLpPb(lc, lp, pb)) {
                                 throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);
                             }
@@ -96,8 +105,18 @@ import { parseLzma2DictionarySize } from '../types.js';
                         // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
                         const useSolid = !chunkInfo.stateReset || chunkInfo.stateReset && !chunkInfo.dictReset;
                         const compData = input.slice(dataOffset, dataOffset + chunkInfo.compSize);
-                        const decoded = decoder.decode(compData, 0, chunkInfo.uncompSize, useSolid);
-                        this.push(decoded);
+                        // Enhanced: Use OutputSink for direct emission (zero-copy)
+                        // Create a decoder with direct stream emission
+                        const streamDecoder = new LzmaDecoder({
+                            write: (chunk)=>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;
                 }
@@ -124,6 +143,9 @@ import { parseLzma2DictionarySize } from '../types.js';
  *
  * 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
@@ -131,16 +153,33 @@ import { parseLzma2DictionarySize } from '../types.js';
     const decoder = new LzmaDecoder();
     decoder.setDecoderProperties(properties);
     const chunks = [];
+    let totalSize = 0;
     return new Transform({
         transform: function(chunk, _encoding, callback) {
             chunks.push(chunk);
+            totalSize += chunk.length;
             callback(null);
         },
         flush: function(callback) {
             try {
-                const input = Buffer.concat(chunks);
-                const output = decoder.decode(input, 0, unpackSize, false);
-                this.push(output);
+                // Optimization: Pre-allocate single buffer instead of Buffer.concat()
+                // This reduces peak memory usage by ~50% during concatenation
+                const input = allocBufferUnsafe(totalSize);
+                let offset = 0;
+                // Copy each chunk into the pre-allocated buffer
+                for (const chunk of chunks){
+                    chunk.copy(input, offset);
+                    offset += chunk.length;
+                }
+                // Enhanced: Use OutputSink for direct emission (zero-copy)
+                // Create a decoder with direct stream emission
+                const streamDecoder = new LzmaDecoder({
+                    write: (chunk)=>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);

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

@@ -1 +1 @@
-{"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 * 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 { 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            // Apply new properties if present\n            if (chunkInfo.newProps) {\n              const { 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            const decoded = decoder.decode(compData, 0, chunkInfo.uncompSize, useSolid);\n            this.push(decoded);\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 * @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\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      callback(null);\n    },\n\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      try {\n        const input = Buffer.concat(chunks);\n        const output = decoder.decode(input, 0, unpackSize, false);\n        this.push(output);\n        callback(null);\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["Transform","hasCompleteChunk","LzmaDecoder","parseLzma2DictionarySize","createLzma2Decoder","properties","length","Error","dictSize","decoder","setDictionarySize","propsSet","pending","finished","transform","chunk","_encoding","callback","input","Buffer","concat","offset","result","success","slice","chunkInfo","totalSize","type","dictReset","resetDictionary","dataOffset","headerSize","uncompData","uncompSize","push","feedUncompressed","newProps","lc","lp","pb","setLcLpPb","stateReset","resetProbabilities","useSolid","compData","compSize","decoded","decode","err","flush","createLzmaDecoder","unpackSize","setDecoderProperties","chunks","output"],"mappings":"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"}
+{"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":["allocBufferUnsafe","Transform","hasCompleteChunk","LzmaDecoder","parseLzma2DictionarySize","createLzma2Decoder","properties","length","Error","dictSize","decoder","setDictionarySize","propsSet","pending","finished","transform","chunk","_encoding","callback","input","Buffer","concat","offset","result","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","createLzmaDecoder","unpackSize","setDecoderProperties","chunks","copy"],"mappings":"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"}

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

@@ -4,6 +4,7 @@
  * 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
  */
@@ -11,7 +12,38 @@ export declare class Lzma2Decoder {
     private lzmaDecoder;
     private dictionarySize;
     private propsSet;
-    constructor(properties: Buffer | Uint8Array);
+    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
@@ -24,7 +56,8 @@ export declare class Lzma2Decoder {
  * Decode LZMA2 data synchronously
  * @param input - LZMA2 compressed data
  * @param properties - 1-byte properties (dictionary size)
- * @param unpackSize - Expected output size (optional)
- * @returns Decompressed data
+ * @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): Buffer;
+export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number;