7z-iterator 1.4.0 → 2.0.2

package/dist/cjs/xz/Decoder.js

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

@@ -1 +0,0 @@
-{"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":"AAAA;;;;;;;CAOC;;;;;;;;;;;QAsLeA;eAAAA;;QAhIAC;eAAAA;;;mCApDU;uBAEE;AAE5B,iBAAiB;AACjB,IAAMC,WAAW;IAAC;IAAM;IAAM;IAAM;IAAM;IAAM;CAAK;AACrD,IAAMC,kBAAkB;IAAC;IAAM;CAAK,EAAE,OAAO;AAE7C,aAAa;AACb,IAAMC,eAAe;AAErB;;CAEC,GACD,SAASC,aAAaC,GAAW,EAAEC,MAAc,EAAEC,QAAkB;IACnE,IAAID,SAASC,SAASC,MAAM,GAAGH,IAAIG,MAAM,EAAE;QACzC,OAAO;IACT;IACA,IAAK,IAAIC,IAAI,GAAGA,IAAIF,SAASC,MAAM,EAAEC,IAAK;QACxC,IAAIJ,GAAG,CAACC,SAASG,EAAE,KAAKF,QAAQ,CAACE,EAAE,EAAE;YACnC,OAAO;QACT;IACF;IACA,OAAO;AACT;AAEA;;CAEC,GACD,SAASC,gBAAgBL,GAAW,EAAEC,MAAc;IAClD,IAAIK,QAAQ;IACZ,IAAIF,IAAI;IACR,IAAIG;IACJ,GAAG;QACD,IAAIN,SAASG,KAAKJ,IAAIG,MAAM,EAAE;YAC5B,MAAM,IAAIK,MAAM;QAClB;QACAD,OAAOP,GAAG,CAACC,SAASG,EAAE;QACtBE,SAAS,AAACC,CAAAA,OAAO,IAAG,KAAOH,IAAI;QAC/BA;QACA,IAAIA,IAAI,GAAG;YACT,MAAM,IAAII,MAAM;QAClB;IACF,QAASD,OAAO,MAAM;IACtB,OAAO;QAAED,OAAAA;QAAOG,WAAWL;IAAE;AAC/B;AAOO,SAAST,SAASe,KAAa;QAgBlBC;IAflB,kBAAkB;IAClB,IAAID,MAAMP,MAAM,GAAG,MAAM,CAACJ,aAAaW,OAAO,GAAGd,WAAW;QAC1D,MAAM,IAAIY,MAAM;IAClB;IAEA,6BAA6B;IAC7B,IAAMI,YAAYF,KAAK,CAAC,EAAE,GAAG;IAE7B,kCAAkC;IAClC,IAAMC,aAAwC;QAC5C,GAAG;QACH,GAAG;QACH,GAAG;QACH,IAAI;IACN;IACA,IAAME,aAAYF,wBAAAA,UAAU,CAACC,UAAU,cAArBD,mCAAAA,wBAAyB;IAE3C,4BAA4B;IAC5B,IAAIV,SAAS;IAEb,oBAAoB;IACpB,IAAMa,qBAAqBJ,KAAK,CAACT,OAAO;IACxC,IAAIa,uBAAuB,GAAG;QAC5B,MAAM,IAAIN,MAAM;IAClB;IACA,IAAMO,kBAAkB,AAACD,CAAAA,qBAAqB,CAAA,IAAK;IAEnD,8CAA8C;IAC9C,IAAME,mBAAmBf;IACzBA,UAAU,iBAAiB;IAE3B,IAAMgB,aAAaP,KAAK,CAACT,SAAS;IAClC,IAAMiB,aAAa,AAACD,CAAAA,aAAa,IAAG,IAAK;IACzC,IAAME,oBAAoB,AAACF,CAAAA,aAAa,IAAG,MAAO;IAClD,IAAMG,sBAAsB,AAACH,CAAAA,aAAa,IAAG,MAAO;IAEpD,sBAAsB;IACtB,IAAIE,mBAAmB;QACrB,IAAME,SAAShB,gBAAgBK,OAAOT;QACtCA,UAAUoB,OAAOZ,SAAS;IAC5B;IAEA,IAAIa;IACJ,IAAIF,qBAAqB;QACvB,IAAMC,UAAShB,gBAAgBK,OAAOT;QACtCqB,oBAAoBD,QAAOf,KAAK;QAChCL,UAAUoB,QAAOZ,SAAS;IAC5B;IAEA,iCAAiC;IACjC,IAAIc,aAA4B;IAChC,IAAK,IAAInB,IAAI,GAAGA,IAAIc,YAAYd,IAAK;QACnC,IAAMoB,iBAAiBnB,gBAAgBK,OAAOT;QAC9C,IAAMwB,WAAWD,eAAelB,KAAK;QACrCL,UAAUuB,eAAef,SAAS;QAElC,IAAMiB,kBAAkBrB,gBAAgBK,OAAOT;QAC/CA,UAAUyB,gBAAgBjB,SAAS;QAEnC,IAAMkB,cAAcjB,MAAMkB,KAAK,CAAC3B,QAAQA,SAASyB,gBAAgBpB,KAAK;QACtEL,UAAUyB,gBAAgBpB,KAAK;QAE/B,IAAImB,aAAa3B,cAAc;YAC7ByB,aAAaI;QACf,OAAO,IAAIF,aAAa,QAAQA,aAAa,QAAQA,aAAa,QAAQA,aAAa,QAAQA,aAAa,QAAQA,aAAa,QAAQA,aAAa,QAAQA,aAAa,MAAM;YAC/K,qEAAqE;YACrE,oCAAoC;YACpC,MAAM,IAAIjB,MAAM,AAAC,yBAA8C,OAAtBiB,SAASI,QAAQ,CAAC;QAC7D;IACF;IAEA,IAAI,CAACN,YAAY;QACf,MAAM,IAAIf,MAAM;IAClB;IAEA,yDAAyD;IACzD,IAAMsB,iBAAiBd,mBAAmBD;IAE1C,mEAAmE;IACnE,oFAAoF;IACpF,IAAIL,MAAMP,MAAM,GAAG,IAAI;QACrB,MAAM,IAAIK,MAAM;IAClB;IAEA,sBAAsB;IACtB,IAAI,CAACT,aAAaW,OAAOA,MAAMP,MAAM,GAAG,GAAGN,kBAAkB;QAC3D,MAAM,IAAIW,MAAM;IAClB;IAEA,kDAAkD;IAClD,yFAAyF;IACzF,IAAMuB,eAAe,AAACrB,CAAAA,MAAMsB,YAAY,CAACtB,MAAMP,MAAM,GAAG,KAAK,CAAA,IAAK;IAClE,IAAM8B,aAAavB,MAAMP,MAAM,GAAG,KAAK4B;IAEvC,4DAA4D;IAC5D,IAAIG,oBAAoBD;IAExB,oCAAoC;IACpCC,qBAAqBrB;IAErB,8CAA8C;IAC9C,MAAOqB,oBAAoBJ,kBAAkBpB,KAAK,CAACwB,oBAAoB,EAAE,KAAK,KAAM;QAClFA;IACF;IACA,yCAAyC;IACzCA;IAEA,IAAMC,iBAAiBzB,MAAMkB,KAAK,CAACE,gBAAgBI;IAEnD,8DAA8D;IAC9D,IAAME,SAAmB,EAAE;IAC3BC,IAAAA,oBAAW,EAACF,gBAAgBZ,YAAYe,WAAW;QACjDC,OAAO,SAACC;mBAAkBJ,OAAOK,IAAI,CAACD;;IACxC;IAEA,OAAOE,OAAOC,MAAM,CAACP;AACvB;AAWO,SAAS1C;IACd,IAAM0C,SAAmB,EAAE;IAE3B,OAAO,IAAIQ,8BAAS,CAAC;QACnBC,WAAAA,SAAAA,UAAUL,KAAa,EAAEM,SAAiB,EAAEC,QAAuD;YACjGX,OAAOK,IAAI,CAACD;YACZO;QACF;QAEAC,OAAAA,SAAAA,MAAMD,QAAuD;YAC3D,IAAI;gBACF,IAAMrC,QAAQgC,OAAOC,MAAM,CAACP;gBAC5B,IAAMa,SAAStD,SAASe;gBACxBqC,SAAS,MAAME;YACjB,EAAE,OAAOC,KAAK;gBACZH,SAASG;YACX;QACF;IACF;AACF"}

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

@@ -1,73 +0,0 @@
-/**
- * LZMA2 Chunk Parser
- *
- * Shared parsing logic for LZMA2 chunk headers.
- * Used by both synchronous and streaming decoders.
- *
- * LZMA2 control byte ranges:
- * 0x00         = End of stream
- * 0x01         = Uncompressed chunk, dictionary reset
- * 0x02         = Uncompressed chunk, no dictionary reset
- * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
- * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
- * 0xC0-0xDF    = LZMA chunk, reset state + new properties
- * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
- */
-/**
- * LZMA properties extracted from chunk header
- */
-export interface LzmaChunkProps {
-    lc: number;
-    lp: number;
-    pb: number;
-}
-/**
- * Parsed LZMA2 chunk information
- */
-export interface Lzma2Chunk {
-    /** Chunk type */
-    type: 'end' | 'uncompressed' | 'lzma';
-    /** Total bytes consumed by header (including control byte) */
-    headerSize: number;
-    /** Whether to reset dictionary */
-    dictReset: boolean;
-    /** Whether to reset state/probabilities */
-    stateReset: boolean;
-    /** New LZMA properties (only for control >= 0xC0) */
-    newProps: LzmaChunkProps | null;
-    /** Uncompressed data size */
-    uncompSize: number;
-    /** Compressed data size (0 for uncompressed chunks) */
-    compSize: number;
-}
-/**
- * Result of parsing attempt
- */
-export type ParseResult = {
-    success: true;
-    chunk: Lzma2Chunk;
-} | {
-    success: false;
-    needBytes: number;
-};
-/**
- * Parse an LZMA2 chunk header
- *
- * @param input - Input buffer
- * @param offset - Offset to start parsing
- * @returns Parsed chunk info or number of bytes needed
- */
-export declare function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult;
-/** Result type for hasCompleteChunk with totalSize included on success */
-export type CompleteChunkResult = {
-    success: true;
-    chunk: Lzma2Chunk;
-    totalSize: number;
-} | {
-    success: false;
-    needBytes: number;
-};
-/**
- * Check if we have enough data for the complete chunk (header + data)
- */
-export declare function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult;

package/dist/esm/lzma/Lzma2ChunkParser.js

@@ -1,137 +0,0 @@
-/**
- * LZMA2 Chunk Parser
- *
- * Shared parsing logic for LZMA2 chunk headers.
- * Used by both synchronous and streaming decoders.
- *
- * LZMA2 control byte ranges:
- * 0x00         = End of stream
- * 0x01         = Uncompressed chunk, dictionary reset
- * 0x02         = Uncompressed chunk, no dictionary reset
- * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
- * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
- * 0xC0-0xDF    = LZMA chunk, reset state + new properties
- * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
- */ /**
- * LZMA properties extracted from chunk header
- */ /**
- * Parse an LZMA2 chunk header
- *
- * @param input - Input buffer
- * @param offset - Offset to start parsing
- * @returns Parsed chunk info or number of bytes needed
- */ export function parseLzma2ChunkHeader(input, offset) {
-    if (offset >= input.length) {
-        return {
-            success: false,
-            needBytes: 1
-        };
-    }
-    const control = input[offset];
-    // End of stream
-    if (control === 0x00) {
-        return {
-            success: true,
-            chunk: {
-                type: 'end',
-                headerSize: 1,
-                dictReset: false,
-                stateReset: false,
-                newProps: null,
-                uncompSize: 0,
-                compSize: 0
-            }
-        };
-    }
-    // Uncompressed chunk
-    if (control === 0x01 || control === 0x02) {
-        // Need 3 bytes: control + 2 size bytes
-        if (offset + 3 > input.length) {
-            return {
-                success: false,
-                needBytes: 3 - (input.length - offset)
-            };
-        }
-        const uncompSize = (input[offset + 1] << 8 | input[offset + 2]) + 1;
-        return {
-            success: true,
-            chunk: {
-                type: 'uncompressed',
-                headerSize: 3,
-                dictReset: control === 0x01,
-                stateReset: false,
-                newProps: null,
-                uncompSize,
-                compSize: 0
-            }
-        };
-    }
-    // LZMA compressed chunk
-    if (control >= 0x80) {
-        const hasNewProps = control >= 0xc0;
-        const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)
-        if (offset + minHeaderSize > input.length) {
-            return {
-                success: false,
-                needBytes: minHeaderSize - (input.length - offset)
-            };
-        }
-        // Parse sizes
-        const uncompHigh = control & 0x1f;
-        const uncompSize = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
-        const compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
-        // Parse properties if present
-        let newProps = null;
-        if (hasNewProps) {
-            const propsByte = input[offset + 5];
-            const lc = propsByte % 9;
-            const remainder = ~~(propsByte / 9);
-            const lp = remainder % 5;
-            const pb = ~~(remainder / 5);
-            newProps = {
-                lc,
-                lp,
-                pb
-            };
-        }
-        return {
-            success: true,
-            chunk: {
-                type: 'lzma',
-                headerSize: minHeaderSize,
-                dictReset: control >= 0xe0,
-                stateReset: control >= 0xa0,
-                newProps,
-                uncompSize,
-                compSize
-            }
-        };
-    }
-    // Invalid control byte
-    throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);
-}
-/**
- * Check if we have enough data for the complete chunk (header + data)
- */ export function hasCompleteChunk(input, offset) {
-    const result = parseLzma2ChunkHeader(input, offset);
-    if (result.success === false) {
-        return {
-            success: false,
-            needBytes: result.needBytes
-        };
-    }
-    const { chunk } = result;
-    const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
-    const totalSize = chunk.headerSize + dataSize;
-    if (offset + totalSize > input.length) {
-        return {
-            success: false,
-            needBytes: totalSize - (input.length - offset)
-        };
-    }
-    return {
-        success: true,
-        chunk,
-        totalSize
-    };
-}

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

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

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

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

package/dist/esm/lzma/index.js

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

@@ -1,46 +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.
- */
-import { Transform } from 'extract-base-iterator';
-/**
- * Create an LZMA2 decoder Transform stream
- *
- * This is a streaming decoder that processes LZMA2 chunks incrementally.
- * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
- *
- * @param properties - 1-byte LZMA2 properties (dictionary size)
- * @returns Transform stream that decompresses LZMA2 data
- */
-export declare function createLzma2Decoder(properties: Buffer | Uint8Array): InstanceType<typeof Transform>;
-/**
- * Create an LZMA1 decoder Transform stream
- *
- * Note: LZMA1 has no chunk boundaries, so this requires knowing the
- * uncompressed size upfront. The stream buffers all input, then
- * decompresses when complete.
- *
- * For true streaming, use LZMA2 which has built-in chunking.
- *
- * Optimization: Pre-allocates input buffer and copies chunks once,
- * avoiding the double-buffering of Buffer.concat().
- *
- * @param properties - 5-byte LZMA properties
- * @param unpackSize - Expected uncompressed size
- * @returns Transform stream that decompresses LZMA1 data
- */
-export declare function createLzmaDecoder(properties: Buffer | Uint8Array, unpackSize: number): InstanceType<typeof Transform>;