7z-iterator 1.3.1 → 2.0.0

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

@@ -1 +0,0 @@
-{"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","decodeLzma","input","properties","unpackSize","length","Error","lzmaDecode","createLzmaTransform"],"mappings":"AAAA,2CAA2C;AAC3C,+FAA+F;;;;;;;;;;;;QA+B/EA;eAAAA;;QAlBAC;eAAAA;;;uBAVmE;AAU5E,SAASA,WAAWC,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,OAAOC,IAAAA,mBAAU,EAACL,OAAOC,YAAYC;AACvC;AAQO,SAASJ,kBAAkBG,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,OAAOE,IAAAA,0BAAmB,EAACL,YAAYC;AACzC"}

package/dist/cjs/sevenz/codecs/Lzma2.d.cts

@@ -1,20 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * Decode LZMA2 compressed data to buffer
- *
- * @param input - LZMA2 compressed data
- * @param properties - Properties buffer (1 byte: dictionary size)
- * @param unpackSize - Expected output size (optional, for pre-allocation)
- * @returns Decompressed data
- */
-export declare function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
-/**
- * Create an LZMA2 decoder Transform stream
- *
- * This is a true streaming decoder that processes LZMA2 chunks incrementally.
- * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
- *
- * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of
- * total archive size.
- */
-export declare function createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform;

package/dist/cjs/sevenz/codecs/Lzma2.d.ts

@@ -1,20 +0,0 @@
-import type { Transform } from 'stream';
-/**
- * Decode LZMA2 compressed data to buffer
- *
- * @param input - LZMA2 compressed data
- * @param properties - Properties buffer (1 byte: dictionary size)
- * @param unpackSize - Expected output size (optional, for pre-allocation)
- * @returns Decompressed data
- */
-export declare function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
-/**
- * Create an LZMA2 decoder Transform stream
- *
- * This is a true streaming decoder that processes LZMA2 chunks incrementally.
- * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
- *
- * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of
- * total archive size.
- */
-export declare function createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform;

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

@@ -1,42 +0,0 @@
-// LZMA2 codec using TypeScript LZMA decoder
-//
-// LZMA2 format specification:
-// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md
-//
-// Control byte values:
-// 0x00         = End of stream
-// 0x01         = Uncompressed chunk, dictionary reset
-// 0x02         = Uncompressed chunk, no dictionary reset
-// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createLzma2Decoder () {
-        return createLzma2Decoder;
-    },
-    get decodeLzma2 () {
-        return decodeLzma2;
-    }
-});
-var _indexts = require("../../lzma/index.js");
-function decodeLzma2(input, properties, unpackSize) {
-    if (!properties || properties.length < 1) {
-        throw new Error('LZMA2 requires properties byte');
-    }
-    return (0, _indexts.decodeLzma2)(input, properties, unpackSize);
-}
-function createLzma2Decoder(properties, _unpackSize) {
-    if (!properties || properties.length < 1) {
-        throw new Error('LZMA2 requires properties byte');
-    }
-    return (0, _indexts.createLzma2Decoder)(properties);
-}
-/* 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/sevenz/codecs/Lzma2.js.map

@@ -1 +0,0 @@
-{"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"}

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,13 +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
- */
-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';

package/dist/esm/lzma/index.js

@@ -1,15 +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
- */ // 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';

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\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"}

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

@@ -1,38 +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.
- *
- * 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.
- *
- * @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>;

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

@@ -1,150 +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.
- *
- * 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 { hasCompleteChunk } from '../Lzma2ChunkParser.js';
-import { LzmaDecoder } from '../sync/LzmaDecoder.js';
-import { parseLzma2DictionarySize } from '../types.js';
-/**
- * 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 function createLzma2Decoder(properties) {
-    if (!properties || properties.length < 1) {
-        throw new Error('LZMA2 requires properties byte');
-    }
-    const dictSize = parseLzma2DictionarySize(properties[0]);
-    // LZMA decoder instance - reused across chunks for solid mode
-    const decoder = new LzmaDecoder();
-    decoder.setDictionarySize(dictSize);
-    // Track current LZMA properties
-    let propsSet = false;
-    // Buffer for incomplete chunk data
-    let pending = null;
-    let finished = false;
-    return new Transform({
-        transform: function(chunk, _encoding, callback) {
-            if (finished) {
-                callback(null);
-                return;
-            }
-            // Combine with pending data
-            let input;
-            if (pending && pending.length > 0) {
-                input = Buffer.concat([
-                    pending,
-                    chunk
-                ]);
-                pending = null;
-            } else {
-                input = chunk;
-            }
-            let offset = 0;
-            try {
-                while(offset < input.length && !finished){
-                    const result = hasCompleteChunk(input, offset);
-                    if (!result.success) {
-                        // Need more data
-                        pending = input.slice(offset);
-                        break;
-                    }
-                    const { chunk: chunkInfo, totalSize } = result;
-                    if (chunkInfo.type === 'end') {
-                        finished = true;
-                        break;
-                    }
-                    // Handle dictionary reset
-                    if (chunkInfo.dictReset) {
-                        decoder.resetDictionary();
-                    }
-                    const dataOffset = offset + chunkInfo.headerSize;
-                    if (chunkInfo.type === 'uncompressed') {
-                        const uncompData = input.slice(dataOffset, dataOffset + chunkInfo.uncompSize);
-                        this.push(uncompData);
-                        // Feed uncompressed data to dictionary for subsequent LZMA chunks
-                        decoder.feedUncompressed(uncompData);
-                    } else {
-                        // LZMA compressed chunk
-                        // Apply new properties if present
-                        if (chunkInfo.newProps) {
-                            const { lc, lp, pb } = chunkInfo.newProps;
-                            if (!decoder.setLcLpPb(lc, lp, pb)) {
-                                throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);
-                            }
-                            propsSet = true;
-                        }
-                        if (!propsSet) {
-                            throw new Error('LZMA chunk without properties');
-                        }
-                        // Reset probabilities if state reset
-                        if (chunkInfo.stateReset) {
-                            decoder.resetProbabilities();
-                        }
-                        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
-                        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);
-                    }
-                    offset += totalSize;
-                }
-                callback(null);
-            } catch (err) {
-                callback(err);
-            }
-        },
-        flush: function(callback) {
-            if (pending && pending.length > 0 && !finished) {
-                callback(new Error('Truncated LZMA2 stream'));
-            } else {
-                callback(null);
-            }
-        }
-    });
-}
-/**
- * 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.
- *
- * @param properties - 5-byte LZMA properties
- * @param unpackSize - Expected uncompressed size
- * @returns Transform stream that decompresses LZMA1 data
- */ export function createLzmaDecoder(properties, unpackSize) {
-    const decoder = new LzmaDecoder();
-    decoder.setDecoderProperties(properties);
-    const chunks = [];
-    return new Transform({
-        transform: function(chunk, _encoding, callback) {
-            chunks.push(chunk);
-            callback(null);
-        },
-        flush: function(callback) {
-            try {
-                const input = Buffer.concat(chunks);
-                const output = decoder.decode(input, 0, unpackSize, false);
-                this.push(output);
-                callback(null);
-            } catch (err) {
-                callback(err);
-            }
-        }
-    });
-}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/stream/transforms.ts"],"sourcesContent":["/**\n * LZMA Transform Stream Wrappers\n *\n * Provides Transform streams for LZMA1 and LZMA2 decompression.\n *\n * LZMA2 streaming works by buffering until a complete chunk is available,\n * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max\n * uncompressed), so memory usage is predictable and bounded.\n *\n * 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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"}

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

@@ -1,30 +0,0 @@
-/**
- * Synchronous LZMA2 Decoder
- *
- * LZMA2 is a container format that wraps LZMA chunks with framing.
- * Decodes LZMA2 data from a buffer.
- */
-/**
- * Synchronous LZMA2 decoder
- */
-export declare class Lzma2Decoder {
-    private lzmaDecoder;
-    private dictionarySize;
-    private propsSet;
-    constructor(properties: Buffer | Uint8Array);
-    /**
-     * Decode LZMA2 data
-     * @param input - LZMA2 compressed data
-     * @param unpackSize - Expected output size (optional, for pre-allocation)
-     * @returns Decompressed data
-     */
-    decode(input: Buffer, unpackSize?: number): Buffer;
-}
-/**
- * Decode LZMA2 data synchronously
- * @param input - LZMA2 compressed data
- * @param properties - 1-byte properties (dictionary size)
- * @param unpackSize - Expected output size (optional)
- * @returns Decompressed data
- */
-export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number): Buffer;