7z-iterator 1.3.1 → 2.0.0

package/dist/cjs/lzma/Lzma2ChunkParser.d.cts

@@ -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/cjs/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/cjs/lzma/Lzma2ChunkParser.js

@@ -1,148 +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
- */ "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 hasCompleteChunk () {
-        return hasCompleteChunk;
-    },
-    get parseLzma2ChunkHeader () {
-        return parseLzma2ChunkHeader;
-    }
-});
-function parseLzma2ChunkHeader(input, offset) {
-    if (offset >= input.length) {
-        return {
-            success: false,
-            needBytes: 1
-        };
-    }
-    var 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)
-            };
-        }
-        var 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: uncompSize,
-                compSize: 0
-            }
-        };
-    }
-    // LZMA compressed chunk
-    if (control >= 0x80) {
-        var hasNewProps = control >= 0xc0;
-        var 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
-        var uncompHigh = control & 0x1f;
-        var uncompSize1 = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
-        var compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
-        // Parse properties if present
-        var newProps = null;
-        if (hasNewProps) {
-            var propsByte = input[offset + 5];
-            var lc = propsByte % 9;
-            var remainder = ~~(propsByte / 9);
-            var lp = remainder % 5;
-            var pb = ~~(remainder / 5);
-            newProps = {
-                lc: lc,
-                lp: lp,
-                pb: pb
-            };
-        }
-        return {
-            success: true,
-            chunk: {
-                type: 'lzma',
-                headerSize: minHeaderSize,
-                dictReset: control >= 0xe0,
-                stateReset: control >= 0xa0,
-                newProps: newProps,
-                uncompSize: uncompSize1,
-                compSize: compSize
-            }
-        };
-    }
-    // Invalid control byte
-    throw new Error("Invalid LZMA2 control byte: 0x".concat(control.toString(16)));
-}
-function hasCompleteChunk(input, offset) {
-    var result = parseLzma2ChunkHeader(input, offset);
-    if (result.success === false) {
-        return {
-            success: false,
-            needBytes: result.needBytes
-        };
-    }
-    var chunk = result.chunk;
-    var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
-    var totalSize = chunk.headerSize + dataSize;
-    if (offset + totalSize > input.length) {
-        return {
-            success: false,
-            needBytes: totalSize - (input.length - offset)
-        };
-    }
-    return {
-        success: true,
-        chunk: chunk,
-        totalSize: totalSize
-    };
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lzma/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":["hasCompleteChunk","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","result","dataSize","totalSize"],"mappings":"AAAA;;;;;;;;;;;;;;CAcC,GAED;;CAEC;;;;;;;;;;;QAsIeA;eAAAA;;QA/FAC;eAAAA;;;AAAT,SAASA,sBAAsBC,KAAa,EAAEC,MAAc;IACjE,IAAIA,UAAUD,MAAME,MAAM,EAAE;QAC1B,OAAO;YAAEC,SAAS;YAAOC,WAAW;QAAE;IACxC;IAEA,IAAMC,UAAUL,KAAK,CAACC,OAAO;IAE7B,gBAAgB;IAChB,IAAII,YAAY,MAAM;QACpB,OAAO;YACLF,SAAS;YACTG,OAAO;gBACLC,MAAM;gBACNC,YAAY;gBACZC,WAAW;gBACXC,YAAY;gBACZC,UAAU;gBACVC,YAAY;gBACZC,UAAU;YACZ;QACF;IACF;IAEA,qBAAqB;IACrB,IAAIR,YAAY,QAAQA,YAAY,MAAM;QACxC,uCAAuC;QACvC,IAAIJ,SAAS,IAAID,MAAME,MAAM,EAAE;YAC7B,OAAO;gBAAEC,SAAS;gBAAOC,WAAW,IAAKJ,CAAAA,MAAME,MAAM,GAAGD,MAAK;YAAG;QAClE;QAEA,IAAMW,aAAa,AAAC,CAAA,AAACZ,KAAK,CAACC,SAAS,EAAE,IAAI,IAAKD,KAAK,CAACC,SAAS,EAAE,AAAD,IAAK;QAEpE,OAAO;YACLE,SAAS;YACTG,OAAO;gBACLC,MAAM;gBACNC,YAAY;gBACZC,WAAWJ,YAAY;gBACvBK,YAAY;gBACZC,UAAU;gBACVC,YAAAA;gBACAC,UAAU;YACZ;QACF;IACF;IAEA,wBAAwB;IACxB,IAAIR,WAAW,MAAM;QACnB,IAAMS,cAAcT,WAAW;QAC/B,IAAMU,gBAAgBD,cAAc,IAAI,GAAG,0CAA0C;QAErF,IAAIb,SAASc,gBAAgBf,MAAME,MAAM,EAAE;YACzC,OAAO;gBAAEC,SAAS;gBAAOC,WAAWW,gBAAiBf,CAAAA,MAAME,MAAM,GAAGD,MAAK;YAAG;QAC9E;QAEA,cAAc;QACd,IAAMe,aAAaX,UAAU;QAC7B,IAAMO,cAAa,AAAC,CAAA,AAACI,cAAc,KAAOhB,KAAK,CAACC,SAAS,EAAE,IAAI,IAAKD,KAAK,CAACC,SAAS,EAAE,AAAD,IAAK;QACzF,IAAMY,WAAW,AAAC,CAAA,AAACb,KAAK,CAACC,SAAS,EAAE,IAAI,IAAKD,KAAK,CAACC,SAAS,EAAE,AAAD,IAAK;QAElE,8BAA8B;QAC9B,IAAIU,WAAkC;QACtC,IAAIG,aAAa;YACf,IAAMG,YAAYjB,KAAK,CAACC,SAAS,EAAE;YACnC,IAAMiB,KAAKD,YAAY;YACvB,IAAME,YAAY,CAAC,CAAEF,CAAAA,YAAY,CAAA;YACjC,IAAMG,KAAKD,YAAY;YACvB,IAAME,KAAK,CAAC,CAAEF,CAAAA,YAAY,CAAA;YAC1BR,WAAW;gBAAEO,IAAAA;gBAAIE,IAAAA;gBAAIC,IAAAA;YAAG;QAC1B;QAEA,OAAO;YACLlB,SAAS;YACTG,OAAO;gBACLC,MAAM;gBACNC,YAAYO;gBACZN,WAAWJ,WAAW;gBACtBK,YAAYL,WAAW;gBACvBM,UAAAA;gBACAC,YAAAA;gBACAC,UAAAA;YACF;QACF;IACF;IAEA,uBAAuB;IACvB,MAAM,IAAIS,MAAM,AAAC,iCAAqD,OAArBjB,QAAQkB,QAAQ,CAAC;AACpE;AAQO,SAASzB,iBAAiBE,KAAa,EAAEC,MAAc;IAC5D,IAAMuB,SAASzB,sBAAsBC,OAAOC;IAE5C,IAAIuB,OAAOrB,OAAO,KAAK,OAAO;QAC5B,OAAO;YAAEA,SAAS;YAAOC,WAAWoB,OAAOpB,SAAS;QAAC;IACvD;IAEA,IAAM,AAAEE,QAAUkB,OAAVlB;IACR,IAAMmB,WAAWnB,MAAMC,IAAI,KAAK,iBAAiBD,MAAMM,UAAU,GAAGN,MAAMO,QAAQ;IAClF,IAAMa,YAAYpB,MAAME,UAAU,GAAGiB;IAErC,IAAIxB,SAASyB,YAAY1B,MAAME,MAAM,EAAE;QACrC,OAAO;YAAEC,SAAS;YAAOC,WAAWsB,YAAa1B,CAAAA,MAAME,MAAM,GAAGD,MAAK;QAAG;IAC1E;IAEA,OAAO;QAAEE,SAAS;QAAMG,OAAAA;QAAOoB,WAAAA;IAAU;AAC3C"}

package/dist/cjs/lzma/index.d.cts

@@ -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/cjs/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/cjs/lzma/index.js

@@ -1,63 +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)
-"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 BitTreeDecoder () {
-        return _RangeDecoderts.BitTreeDecoder;
-    },
-    get Lzma2Decoder () {
-        return _Lzma2Decoderts.Lzma2Decoder;
-    },
-    get LzmaDecoder () {
-        return _LzmaDecoderts.LzmaDecoder;
-    },
-    get RangeDecoder () {
-        return _RangeDecoderts.RangeDecoder;
-    },
-    get createLzma2Decoder () {
-        return _transformsts.createLzma2Decoder;
-    },
-    get createLzmaDecoder () {
-        return _transformsts.createLzmaDecoder;
-    },
-    get decodeLzma () {
-        return _LzmaDecoderts.decodeLzma;
-    },
-    get decodeLzma2 () {
-        return _Lzma2Decoderts.decodeLzma2;
-    }
-});
-var _transformsts = require("./stream/transforms.js");
-var _Lzma2Decoderts = require("./sync/Lzma2Decoder.js");
-var _LzmaDecoderts = require("./sync/LzmaDecoder.js");
-var _RangeDecoderts = require("./sync/RangeDecoder.js");
-_export_star(require("./types.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lzma/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":["BitTreeDecoder","Lzma2Decoder","LzmaDecoder","RangeDecoder","createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2"],"mappings":"AAAA;;;;;;;CAOC,GAED,yCAAyC;;;;;;;;;;;;QAKhCA;eAAAA,8BAAc;;QAHDC;eAAAA,4BAAY;;QAEbC;eAAAA,0BAAW;;QACPC;eAAAA,4BAAY;;QAJ5BC;eAAAA,gCAAkB;;QAAEC;eAAAA,+BAAiB;;QAGrCC;eAAAA,yBAAU;;QAFVC;eAAAA,2BAAW;;;4BADkC;8BACZ;6BAEF;8BACK;qBAE/B"}

package/dist/cjs/lzma/stream/transforms.d.cts

@@ -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/cjs/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/cjs/lzma/stream/transforms.js

@@ -1,149 +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.
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get createLzma2Decoder () {
-        return createLzma2Decoder;
-    },
-    get createLzmaDecoder () {
-        return createLzmaDecoder;
-    }
-});
-var _extractbaseiterator = require("extract-base-iterator");
-var _Lzma2ChunkParserts = require("../Lzma2ChunkParser.js");
-var _LzmaDecoderts = require("../sync/LzmaDecoder.js");
-var _typests = require("../types.js");
-function createLzma2Decoder(properties) {
-    if (!properties || properties.length < 1) {
-        throw new Error('LZMA2 requires properties byte');
-    }
-    var dictSize = (0, _typests.parseLzma2DictionarySize)(properties[0]);
-    // LZMA decoder instance - reused across chunks for solid mode
-    var decoder = new _LzmaDecoderts.LzmaDecoder();
-    decoder.setDictionarySize(dictSize);
-    // Track current LZMA properties
-    var propsSet = false;
-    // Buffer for incomplete chunk data
-    var pending = null;
-    var finished = false;
-    return new _extractbaseiterator.Transform({
-        transform: function transform(chunk, _encoding, callback) {
-            if (finished) {
-                callback(null);
-                return;
-            }
-            // Combine with pending data
-            var input;
-            if (pending && pending.length > 0) {
-                input = Buffer.concat([
-                    pending,
-                    chunk
-                ]);
-                pending = null;
-            } else {
-                input = chunk;
-            }
-            var offset = 0;
-            try {
-                while(offset < input.length && !finished){
-                    var result = (0, _Lzma2ChunkParserts.hasCompleteChunk)(input, offset);
-                    if (!result.success) {
-                        // Need more data
-                        pending = input.slice(offset);
-                        break;
-                    }
-                    var chunkInfo = result.chunk, totalSize = result.totalSize;
-                    if (chunkInfo.type === 'end') {
-                        finished = true;
-                        break;
-                    }
-                    // Handle dictionary reset
-                    if (chunkInfo.dictReset) {
-                        decoder.resetDictionary();
-                    }
-                    var dataOffset = offset + chunkInfo.headerSize;
-                    if (chunkInfo.type === 'uncompressed') {
-                        var uncompData = input.slice(dataOffset, dataOffset + chunkInfo.uncompSize);
-                        this.push(uncompData);
-                        // Feed uncompressed data to dictionary for subsequent LZMA chunks
-                        decoder.feedUncompressed(uncompData);
-                    } else {
-                        // LZMA compressed chunk
-                        // Apply new properties if present
-                        if (chunkInfo.newProps) {
-                            var _chunkInfo_newProps = chunkInfo.newProps, lc = _chunkInfo_newProps.lc, lp = _chunkInfo_newProps.lp, pb = _chunkInfo_newProps.pb;
-                            if (!decoder.setLcLpPb(lc, lp, pb)) {
-                                throw new Error("Invalid LZMA properties: lc=".concat(lc, " lp=").concat(lp, " pb=").concat(pb));
-                            }
-                            propsSet = true;
-                        }
-                        if (!propsSet) {
-                            throw new Error('LZMA chunk without properties');
-                        }
-                        // Reset probabilities if state reset
-                        if (chunkInfo.stateReset) {
-                            decoder.resetProbabilities();
-                        }
-                        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
-                        var useSolid = !chunkInfo.stateReset || chunkInfo.stateReset && !chunkInfo.dictReset;
-                        var compData = input.slice(dataOffset, dataOffset + chunkInfo.compSize);
-                        var decoded = decoder.decode(compData, 0, chunkInfo.uncompSize, useSolid);
-                        this.push(decoded);
-                    }
-                    offset += totalSize;
-                }
-                callback(null);
-            } catch (err) {
-                callback(err);
-            }
-        },
-        flush: function flush(callback) {
-            if (pending && pending.length > 0 && !finished) {
-                callback(new Error('Truncated LZMA2 stream'));
-            } else {
-                callback(null);
-            }
-        }
-    });
-}
-function createLzmaDecoder(properties, unpackSize) {
-    var decoder = new _LzmaDecoderts.LzmaDecoder();
-    decoder.setDecoderProperties(properties);
-    var chunks = [];
-    return new _extractbaseiterator.Transform({
-        transform: function transform(chunk, _encoding, callback) {
-            chunks.push(chunk);
-            callback(null);
-        },
-        flush: function flush(callback) {
-            try {
-                var input = Buffer.concat(chunks);
-                var output = decoder.decode(input, 0, unpackSize, false);
-                this.push(output);
-                callback(null);
-            } catch (err) {
-                callback(err);
-            }
-        }
-    });
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/stream/transforms.ts"],"sourcesContent":["/**\n * LZMA Transform Stream Wrappers\n *\n * Provides Transform streams for LZMA1 and LZMA2 decompression.\n *\n * LZMA2 streaming works by buffering until a complete chunk is available,\n * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max\n * uncompressed), so memory usage is predictable and bounded.\n *\n * 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":["createLzma2Decoder","createLzmaDecoder","properties","length","Error","dictSize","parseLzma2DictionarySize","decoder","LzmaDecoder","setDictionarySize","propsSet","pending","finished","Transform","transform","chunk","_encoding","callback","input","Buffer","concat","offset","result","hasCompleteChunk","success","slice","chunkInfo","totalSize","type","dictReset","resetDictionary","dataOffset","headerSize","uncompData","uncompSize","push","feedUncompressed","newProps","lc","lp","pb","setLcLpPb","stateReset","resetProbabilities","useSolid","compData","compSize","decoded","decode","err","flush","unpackSize","setDecoderProperties","chunks","output"],"mappings":"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"}