7z-iterator 1.3.1 → 1.4.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/types.ts"],"sourcesContent":["/**\n * LZMA Types and Constants\n *\n * Shared types, constants, and state transition functions for LZMA decoding.\n * Based on the LZMA SDK specification.\n */\n\n// LZMA State Machine Constants\nexport const kNumRepDistances = 4;\nexport const kNumStates = 12;\n\n// Position slot constants\nexport const kNumPosSlotBits = 6;\nexport const kDicLogSizeMin = 0;\nexport const kNumLenToPosStatesBits = 2;\nexport const kNumLenToPosStates = 1 << kNumLenToPosStatesBits; // 4\n\n// Match length constants\nexport const kMatchMinLen = 2;\nexport const kNumLowLenBits = 3;\nexport const kNumMidLenBits = 3;\nexport const kNumHighLenBits = 8;\nexport const kNumLowLenSymbols = 1 << kNumLowLenBits; // 8\nexport const kNumMidLenSymbols = 1 << kNumMidLenBits; // 8\nexport const kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols + (1 << kNumHighLenBits); // 272\nexport const kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1; // 273\n\n// Alignment constants\nexport const kNumAlignBits = 4;\nexport const kAlignTableSize = 1 << kNumAlignBits; // 16\nexport const kAlignMask = kAlignTableSize - 1; // 15\n\n// Position model constants\nexport const kStartPosModelIndex = 4;\nexport const kEndPosModelIndex = 14;\nexport const kNumPosModels = kEndPosModelIndex - kStartPosModelIndex; // 10\nexport const kNumFullDistances = 1 << (kEndPosModelIndex >>> 1); // 128\n\n// Literal/pos state constants\nexport const kNumLitPosStatesBitsEncodingMax = 4;\nexport const kNumLitContextBitsMax = 8;\nexport const kNumPosStatesBitsMax = 4;\nexport const kNumPosStatesMax = 1 << kNumPosStatesBitsMax; // 16\nexport const kNumPosStatesBitsEncodingMax = 4;\nexport const kNumPosStatesEncodingMax = 1 << kNumPosStatesBitsEncodingMax; // 16\n\n// Range coder probability constants\nexport const kNumBitModelTotalBits = 11;\nexport const kBitModelTotal = 1 << kNumBitModelTotalBits; // 2048\nexport const kNumMoveBits = 5;\nexport const kProbInitValue = kBitModelTotal >>> 1; // 1024\n\n/**\n * State transition: after literal byte\n */\nexport function stateUpdateChar(state: number): number {\n  if (state < 4) return 0;\n  if (state < 10) return state - 3;\n  return state - 6;\n}\n\n/**\n * State transition: after match\n */\nexport function stateUpdateMatch(state: number): number {\n  return state < 7 ? 7 : 10;\n}\n\n/**\n * State transition: after rep (repeated match)\n */\nexport function stateUpdateRep(state: number): number {\n  return state < 7 ? 8 : 11;\n}\n\n/**\n * State transition: after short rep\n */\nexport function stateUpdateShortRep(state: number): number {\n  return state < 7 ? 9 : 11;\n}\n\n/**\n * Check if state indicates previous symbol was a character (literal)\n */\nexport function stateIsCharState(state: number): boolean {\n  return state < 7;\n}\n\n/**\n * Get length-to-position state index\n */\nexport function getLenToPosState(len: number): number {\n  len -= kMatchMinLen;\n  return len < kNumLenToPosStates ? len : kNumLenToPosStates - 1;\n}\n\n/**\n * Initialize probability array with default values\n * @param probs - Array to initialize (or null to create new)\n * @param count - Number of probabilities\n * @returns Initialized probability array\n */\nexport function initBitModels(probs: Uint16Array | null, count?: number): Uint16Array {\n  if (probs === null) {\n    if (count === undefined) {\n      throw new Error('count required when probs is null');\n    }\n    probs = new Uint16Array(count);\n  }\n  for (let i = 0; i < probs.length; i++) {\n    probs[i] = kProbInitValue;\n  }\n  return probs;\n}\n\n/**\n * LZMA properties parsed from the 5-byte header\n */\nexport interface LzmaProperties {\n  /** Literal context bits (0-8) */\n  lc: number;\n  /** Literal pos bits (0-4) */\n  lp: number;\n  /** Pos bits (0-4) */\n  pb: number;\n  /** Dictionary size in bytes */\n  dictionarySize: number;\n}\n\n/**\n * Parse LZMA properties from a 5-byte buffer\n */\nexport function parseProperties(properties: Buffer | Uint8Array): LzmaProperties {\n  if (properties.length < 5) {\n    throw new Error('LZMA properties must be at least 5 bytes');\n  }\n\n  const d = properties[0] & 0xff;\n  const lc = d % 9;\n  const remainder = ~~(d / 9);\n  const lp = remainder % 5;\n  const pb = ~~(remainder / 5);\n\n  if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  let dictionarySize = 0;\n  for (let i = 0; i < 4; i++) {\n    dictionarySize |= (properties[1 + i] & 0xff) << (i * 8);\n  }\n\n  return { lc, lp, pb, dictionarySize };\n}\n\n/**\n * LZMA2 control byte meanings\n */\nexport const LZMA2_CONTROL = {\n  END: 0x00,\n  UNCOMPRESSED_RESET_DIC: 0x01,\n  UNCOMPRESSED: 0x02,\n  LZMA_RESET_STATE_NEW_PROP: 0xe0,\n} as const;\n\n/**\n * Check if LZMA2 control byte indicates reset state (new properties)\n */\nexport function lzma2NeedsNewProps(control: number): boolean {\n  return control >= 0xe0;\n}\n\n/**\n * Check if LZMA2 control byte indicates reset probabilities\n */\nexport function lzma2NeedsResetProbs(control: number): boolean {\n  return control >= 0xa0;\n}\n\n/**\n * Check if LZMA2 control byte indicates uncompressed chunk\n */\nexport function lzma2IsUncompressed(control: number): boolean {\n  return control < 0x80;\n}\n\n/**\n * Parse LZMA2 dictionary size from property byte\n */\nexport function parseLzma2DictionarySize(prop: number): number {\n  if (prop > 40) {\n    throw new Error('Invalid LZMA2 dictionary size property');\n  }\n  if (prop === 40) {\n    return 0xffffffff;\n  }\n  const base = 2 | (prop & 1);\n  const exp = (prop >>> 1) + 11;\n  return base << exp;\n}\n"],"names":["kNumRepDistances","kNumStates","kNumPosSlotBits","kDicLogSizeMin","kNumLenToPosStatesBits","kNumLenToPosStates","kMatchMinLen","kNumLowLenBits","kNumMidLenBits","kNumHighLenBits","kNumLowLenSymbols","kNumMidLenSymbols","kNumLenSymbols","kMatchMaxLen","kNumAlignBits","kAlignTableSize","kAlignMask","kStartPosModelIndex","kEndPosModelIndex","kNumPosModels","kNumFullDistances","kNumLitPosStatesBitsEncodingMax","kNumLitContextBitsMax","kNumPosStatesBitsMax","kNumPosStatesMax","kNumPosStatesBitsEncodingMax","kNumPosStatesEncodingMax","kNumBitModelTotalBits","kBitModelTotal","kNumMoveBits","kProbInitValue","stateUpdateChar","state","stateUpdateMatch","stateUpdateRep","stateUpdateShortRep","stateIsCharState","getLenToPosState","len","initBitModels","probs","count","undefined","Error","Uint16Array","i","length","parseProperties","properties","d","lc","remainder","lp","pb","dictionarySize","LZMA2_CONTROL","END","UNCOMPRESSED_RESET_DIC","UNCOMPRESSED","LZMA_RESET_STATE_NEW_PROP","lzma2NeedsNewProps","control","lzma2NeedsResetProbs","lzma2IsUncompressed","parseLzma2DictionarySize","prop","base","exp"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/types.ts"],"sourcesContent":["/**\n * LZMA Types and Constants\n *\n * Shared types, constants, and state transition functions for LZMA decoding.\n * Based on the LZMA SDK specification.\n */\n\n// LZMA State Machine Constants\nexport const kNumRepDistances = 4;\nexport const kNumStates = 12;\n\n// Position slot constants\nexport const kNumPosSlotBits = 6;\nexport const kDicLogSizeMin = 0;\nexport const kNumLenToPosStatesBits = 2;\nexport const kNumLenToPosStates = 1 << kNumLenToPosStatesBits; // 4\n\n// Match length constants\nexport const kMatchMinLen = 2;\nexport const kNumLowLenBits = 3;\nexport const kNumMidLenBits = 3;\nexport const kNumHighLenBits = 8;\nexport const kNumLowLenSymbols = 1 << kNumLowLenBits; // 8\nexport const kNumMidLenSymbols = 1 << kNumMidLenBits; // 8\nexport const kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols + (1 << kNumHighLenBits); // 272\nexport const kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1; // 273\n\n// Alignment constants\nexport const kNumAlignBits = 4;\nexport const kAlignTableSize = 1 << kNumAlignBits; // 16\nexport const kAlignMask = kAlignTableSize - 1; // 15\n\n// Position model constants\nexport const kStartPosModelIndex = 4;\nexport const kEndPosModelIndex = 14;\nexport const kNumPosModels = kEndPosModelIndex - kStartPosModelIndex; // 10\nexport const kNumFullDistances = 1 << (kEndPosModelIndex >>> 1); // 128\n\n// Literal/pos state constants\nexport const kNumLitPosStatesBitsEncodingMax = 4;\nexport const kNumLitContextBitsMax = 8;\nexport const kNumPosStatesBitsMax = 4;\nexport const kNumPosStatesMax = 1 << kNumPosStatesBitsMax; // 16\nexport const kNumPosStatesBitsEncodingMax = 4;\nexport const kNumPosStatesEncodingMax = 1 << kNumPosStatesBitsEncodingMax; // 16\n\n// Range coder probability constants\nexport const kNumBitModelTotalBits = 11;\nexport const kBitModelTotal = 1 << kNumBitModelTotalBits; // 2048\nexport const kNumMoveBits = 5;\nexport const kProbInitValue = kBitModelTotal >>> 1; // 1024\n\n/**\n * State transition: after literal byte\n */\nexport function stateUpdateChar(state: number): number {\n  if (state < 4) return 0;\n  if (state < 10) return state - 3;\n  return state - 6;\n}\n\n/**\n * State transition: after match\n */\nexport function stateUpdateMatch(state: number): number {\n  return state < 7 ? 7 : 10;\n}\n\n/**\n * State transition: after rep (repeated match)\n */\nexport function stateUpdateRep(state: number): number {\n  return state < 7 ? 8 : 11;\n}\n\n/**\n * State transition: after short rep\n */\nexport function stateUpdateShortRep(state: number): number {\n  return state < 7 ? 9 : 11;\n}\n\n/**\n * Check if state indicates previous symbol was a character (literal)\n */\nexport function stateIsCharState(state: number): boolean {\n  return state < 7;\n}\n\n/**\n * Get length-to-position state index\n */\nexport function getLenToPosState(len: number): number {\n  len -= kMatchMinLen;\n  return len < kNumLenToPosStates ? len : kNumLenToPosStates - 1;\n}\n\n/**\n * Initialize probability array with default values\n * @param probs - Array to initialize (or null to create new)\n * @param count - Number of probabilities\n * @returns Initialized probability array\n */\nexport function initBitModels(probs: Uint16Array | null, count?: number): Uint16Array {\n  if (probs === null) {\n    if (count === undefined) {\n      throw new Error('count required when probs is null');\n    }\n    probs = new Uint16Array(count);\n  }\n  for (let i = 0; i < probs.length; i++) {\n    probs[i] = kProbInitValue;\n  }\n  return probs;\n}\n\n/**\n * LZMA properties parsed from the 5-byte header\n */\nexport interface LzmaProperties {\n  /** Literal context bits (0-8) */\n  lc: number;\n  /** Literal pos bits (0-4) */\n  lp: number;\n  /** Pos bits (0-4) */\n  pb: number;\n  /** Dictionary size in bytes */\n  dictionarySize: number;\n}\n\n/**\n * Parse LZMA properties from a 5-byte buffer\n */\nexport function parseProperties(properties: Buffer | Uint8Array): LzmaProperties {\n  if (properties.length < 5) {\n    throw new Error('LZMA properties must be at least 5 bytes');\n  }\n\n  const d = properties[0] & 0xff;\n  const lc = d % 9;\n  const remainder = ~~(d / 9);\n  const lp = remainder % 5;\n  const pb = ~~(remainder / 5);\n\n  if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  let dictionarySize = 0;\n  for (let i = 0; i < 4; i++) {\n    dictionarySize |= (properties[1 + i] & 0xff) << (i * 8);\n  }\n\n  return { lc, lp, pb, dictionarySize };\n}\n\n/**\n * LZMA2 control byte meanings\n */\nexport const LZMA2_CONTROL = {\n  END: 0x00,\n  UNCOMPRESSED_RESET_DIC: 0x01,\n  UNCOMPRESSED: 0x02,\n  LZMA_RESET_STATE_NEW_PROP: 0xe0,\n} as const;\n\n/**\n * Check if LZMA2 control byte indicates reset state (new properties)\n */\nexport function lzma2NeedsNewProps(control: number): boolean {\n  return control >= 0xe0;\n}\n\n/**\n * Check if LZMA2 control byte indicates reset probabilities\n */\nexport function lzma2NeedsResetProbs(control: number): boolean {\n  return control >= 0xa0;\n}\n\n/**\n * Check if LZMA2 control byte indicates uncompressed chunk\n */\nexport function lzma2IsUncompressed(control: number): boolean {\n  return control < 0x80;\n}\n\n/**\n * Parse LZMA2 dictionary size from property byte\n */\nexport function parseLzma2DictionarySize(prop: number): number {\n  if (prop > 40) {\n    throw new Error('Invalid LZMA2 dictionary size property');\n  }\n  if (prop === 40) {\n    return 0xffffffff;\n  }\n  const base = 2 | (prop & 1);\n  const exp = (prop >>> 1) + 11;\n  return base << exp;\n}\n\n/**\n * Output sink interface for fast streaming decode\n * Can be a Buffer (with write method) or a stream with write() method\n */\nexport interface OutputSink {\n  write(buffer: Buffer): void;\n}\n"],"names":["kNumRepDistances","kNumStates","kNumPosSlotBits","kDicLogSizeMin","kNumLenToPosStatesBits","kNumLenToPosStates","kMatchMinLen","kNumLowLenBits","kNumMidLenBits","kNumHighLenBits","kNumLowLenSymbols","kNumMidLenSymbols","kNumLenSymbols","kMatchMaxLen","kNumAlignBits","kAlignTableSize","kAlignMask","kStartPosModelIndex","kEndPosModelIndex","kNumPosModels","kNumFullDistances","kNumLitPosStatesBitsEncodingMax","kNumLitContextBitsMax","kNumPosStatesBitsMax","kNumPosStatesMax","kNumPosStatesBitsEncodingMax","kNumPosStatesEncodingMax","kNumBitModelTotalBits","kBitModelTotal","kNumMoveBits","kProbInitValue","stateUpdateChar","state","stateUpdateMatch","stateUpdateRep","stateUpdateShortRep","stateIsCharState","getLenToPosState","len","initBitModels","probs","count","undefined","Error","Uint16Array","i","length","parseProperties","properties","d","lc","remainder","lp","pb","dictionarySize","LZMA2_CONTROL","END","UNCOMPRESSED_RESET_DIC","UNCOMPRESSED","LZMA_RESET_STATE_NEW_PROP","lzma2NeedsNewProps","control","lzma2NeedsResetProbs","lzma2IsUncompressed","parseLzma2DictionarySize","prop","base","exp"],"mappings":"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"}

package/dist/esm/sevenz/codecs/Lzma.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["// LZMA codec using TypeScript LZMA decoder\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n\nimport type { Transform } from 'stream';\nimport { createLzmaDecoder as createLzmaTransform, decodeLzma as lzmaDecode } from '../../lzma/index.ts';\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n\n  return lzmaDecode(input, properties, unpackSize);\n}\n\n/**\n * Create an LZMA decoder Transform stream\n *\n * Note: LZMA1 has no chunk boundaries, so this buffers all input\n * and decompresses when the stream ends.\n */\nexport function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n\n  return createLzmaTransform(properties, unpackSize) as Transform;\n}\n"],"names":["createLzmaDecoder","createLzmaTransform","decodeLzma","lzmaDecode","input","properties","unpackSize","length","Error"],"mappings":"AAAA,2CAA2C;AAC3C,+FAA+F;AAG/F,SAASA,qBAAqBC,mBAAmB,EAAEC,cAAcC,UAAU,QAAQ,sBAAsB;AAEzG;;;;;;;CAOC,GACD,OAAO,SAASD,WAAWE,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,OAAOF,eAAe,YAAYA,aAAa,GAAG;QACpD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOL,WAAWC,OAAOC,YAAYC;AACvC;AAEA;;;;;CAKC,GACD,OAAO,SAASN,kBAAkBK,UAAmB,EAAEC,UAAmB;IACxE,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,OAAOF,eAAe,YAAYA,aAAa,GAAG;QACpD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOP,oBAAoBI,YAAYC;AACzC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["// LZMA codec using TypeScript LZMA decoder\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n\nimport type { Transform } from 'stream';\nimport { createLzmaDecoder as createLzmaTransform, decodeLzma as lzmaDecode } from '../../lzma/index.ts';\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n\n  return lzmaDecode(input, properties, unpackSize) as Buffer;\n}\n\n/**\n * Create an LZMA decoder Transform stream\n *\n * Note: LZMA1 has no chunk boundaries, so this buffers all input\n * and decompresses when the stream ends.\n */\nexport function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n\n  return createLzmaTransform(properties, unpackSize) as Transform;\n}\n"],"names":["createLzmaDecoder","createLzmaTransform","decodeLzma","lzmaDecode","input","properties","unpackSize","length","Error"],"mappings":"AAAA,2CAA2C;AAC3C,+FAA+F;AAG/F,SAASA,qBAAqBC,mBAAmB,EAAEC,cAAcC,UAAU,QAAQ,sBAAsB;AAEzG;;;;;;;CAOC,GACD,OAAO,SAASD,WAAWE,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,OAAOF,eAAe,YAAYA,aAAa,GAAG;QACpD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOL,WAAWC,OAAOC,YAAYC;AACvC;AAEA;;;;;CAKC,GACD,OAAO,SAASN,kBAAkBK,UAAmB,EAAEC,UAAmB;IACxE,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,OAAOF,eAAe,YAAYA,aAAa,GAAG;QACpD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOP,oBAAoBI,YAAYC;AACzC"}

package/dist/esm/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","createLzma2Transform","decodeLzma2","lzma2Decode","input","properties","unpackSize","length","Error","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,8BAA8B;AAC9B,2DAA2D;AAC3D,EAAE;AACF,uBAAuB;AACvB,+BAA+B;AAC/B,sDAAsD;AACtD,yDAAyD;AACzD,0EAA0E;AAG1E,SAASA,sBAAsBC,oBAAoB,EAAEC,eAAeC,WAAW,QAAQ,sBAAsB;AAE7G;;;;;;;CAOC,GACD,OAAO,SAASD,YAAYE,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOL,YAAYC,OAAOC,YAAYC;AACxC;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASN,mBAAmBK,UAAmB,EAAEI,WAAoB;IAC1E,IAAI,CAACJ,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOP,qBAAqBI;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","createLzma2Transform","decodeLzma2","lzma2Decode","input","properties","unpackSize","length","Error","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,8BAA8B;AAC9B,2DAA2D;AAC3D,EAAE;AACF,uBAAuB;AACvB,+BAA+B;AAC/B,sDAAsD;AACtD,yDAAyD;AACzD,0EAA0E;AAG1E,SAASA,sBAAsBC,oBAAoB,EAAEC,eAAeC,WAAW,QAAQ,sBAAsB;AAE7G;;;;;;;CAOC,GACD,OAAO,SAASD,YAAYE,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IACjF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOL,YAAYC,OAAOC,YAAYC;AACxC;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASN,mBAAmBK,UAAmB,EAAEI,WAAoB;IAC1E,IAAI,CAACJ,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAOP,qBAAqBI;AAC9B"}

package/dist/esm/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/esm/xz/Decoder.js

@@ -0,0 +1,185 @@
+/**
+ * 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 { Transform } from 'extract-base-iterator';
+import { decodeLzma2 } from '../lzma/index.js';
+// XZ magic bytes
+const XZ_MAGIC = [
+    0xfd,
+    0x37,
+    0x7a,
+    0x58,
+    0x5a,
+    0x00
+];
+const XZ_FOOTER_MAGIC = [
+    0x59,
+    0x5a
+]; // "YZ"
+// Filter IDs
+const FILTER_LZMA2 = 0x21;
+/**
+ * Simple buffer comparison
+ */ function bufferEquals(buf, offset, expected) {
+    if (offset + expected.length > buf.length) {
+        return false;
+    }
+    for(let 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) {
+    let value = 0;
+    let i = 0;
+    let 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,
+        bytesRead: i
+    };
+}
+/**
+ * Decompress XZ data synchronously
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */ export 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
+    const checkType = input[7] & 0x0f;
+    // Check sizes based on check type
+    const checkSizes = {
+        0: 0,
+        1: 4,
+        4: 8,
+        10: 32
+    };
+    const checkSize = (_checkSizes_checkType = checkSizes[checkType]) !== null && _checkSizes_checkType !== void 0 ? _checkSizes_checkType : 0;
+    // Block starts at offset 12
+    let offset = 12;
+    // Block header size
+    const blockHeaderSizeRaw = input[offset];
+    if (blockHeaderSizeRaw === 0) {
+        throw new Error('Invalid block header size (index indicator found instead of block)');
+    }
+    const blockHeaderSize = (blockHeaderSizeRaw + 1) * 4;
+    // Parse block header to find LZMA2 properties
+    const blockHeaderStart = offset;
+    offset++; // skip size byte
+    const blockFlags = input[offset++];
+    const numFilters = (blockFlags & 0x03) + 1;
+    const hasCompressedSize = (blockFlags & 0x40) !== 0;
+    const hasUncompressedSize = (blockFlags & 0x80) !== 0;
+    // Skip optional sizes
+    if (hasCompressedSize) {
+        const result = decodeMultibyte(input, offset);
+        offset += result.bytesRead;
+    }
+    let _uncompressedSize;
+    if (hasUncompressedSize) {
+        const result = decodeMultibyte(input, offset);
+        _uncompressedSize = result.value;
+        offset += result.bytesRead;
+    }
+    // Parse filter (should be LZMA2)
+    let lzma2Props = null;
+    for(let i = 0; i < numFilters; i++){
+        const filterIdResult = decodeMultibyte(input, offset);
+        const filterId = filterIdResult.value;
+        offset += filterIdResult.bytesRead;
+        const propsSizeResult = decodeMultibyte(input, offset);
+        offset += propsSizeResult.bytesRead;
+        const 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${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)
+    const 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
+    const backwardSize = (input.readUInt32LE(input.length - 8) + 1) * 4;
+    const indexStart = input.length - 12 - backwardSize;
+    // Extract all data between block header end and index start
+    let 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++;
+    const compressedData = input.slice(blockDataStart, compressedDataEnd);
+    // Decompress LZMA2 data using optimized output stream decoder
+    const chunks = [];
+    decodeLzma2(compressedData, lzma2Props, undefined, {
+        write: (chunk)=>chunks.push(chunk)
+    });
+    return Buffer.concat(chunks);
+}
+/**
+ * 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 function createXZDecoder() {
+    const chunks = [];
+    return new Transform({
+        transform (chunk, _encoding, callback) {
+            chunks.push(chunk);
+            callback();
+        },
+        flush (callback) {
+            try {
+                const input = Buffer.concat(chunks);
+                const output = decodeXZ(input);
+                callback(null, output);
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}

package/dist/esm/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":["Transform","decodeLzma2","XZ_MAGIC","XZ_FOOTER_MAGIC","FILTER_LZMA2","bufferEquals","buf","offset","expected","length","i","decodeMultibyte","value","byte","Error","bytesRead","decodeXZ","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","undefined","write","chunk","push","Buffer","concat","createXZDecoder","transform","_encoding","callback","flush","output","err"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "7z-iterator",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Extract contents from 7z archives using an iterator API. Pure JavaScript, works on Node.js 0.8+",
   "keywords": [
     "extract",
@@ -17,6 +17,9 @@
     "stream"
   ],
   "homepage": "https://github.com/kmalakoff/7z-iterator",
+  "bugs": {
+    "url": "https://github.com/kmalakoff/7z-iterator/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/kmalakoff/7z-iterator.git"
@@ -34,11 +37,14 @@
   "main": "dist/cjs/index.js",
   "source": "src/index.ts",
   "types": "dist/cjs/index.d.ts",
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "benchmark:streaming": "node benchmark/streaming.cjs",
     "build": "tsds build",
     "format": "tsds format",
     "prepublishOnly": "tsds validate",