xz-compat 0.1.0

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

@@ -0,0 +1,69 @@
+/**
+ * Synchronous Range Decoder for LZMA
+ *
+ * Decodes arithmetic-coded bits from a buffer.
+ * All operations are synchronous - for streaming use the async version.
+ */
+/**
+ * Range decoder for synchronous buffer-based LZMA decoding
+ */
+export declare class RangeDecoder {
+    private input;
+    private pos;
+    private code;
+    private range;
+    constructor();
+    /**
+     * Set input buffer and initialize decoder state
+     */
+    setInput(input: Buffer, offset?: number): void;
+    /**
+     * Initialize range decoder (reads first 5 bytes)
+     */
+    private init;
+    /**
+     * Get current position in input buffer
+     */
+    getPosition(): number;
+    /**
+     * Normalize range if needed (read more bytes)
+     */
+    private normalize;
+    /**
+     * Decode a single bit using probability model
+     * @param probs - Probability array
+     * @param index - Index into probability array
+     * @returns Decoded bit (0 or 1)
+     */
+    decodeBit(probs: Uint16Array, index: number): number;
+    /**
+     * Decode direct bits (not probability-based)
+     * @param numTotalBits - Number of bits to decode
+     * @returns Decoded value
+     */
+    decodeDirectBits(numTotalBits: number): number;
+}
+/**
+ * Bit tree decoder for multi-bit symbols
+ */
+export declare class BitTreeDecoder {
+    private numBitLevels;
+    private models;
+    constructor(numBitLevels: number);
+    /**
+     * Initialize probability models
+     */
+    init(): void;
+    /**
+     * Decode a symbol (forward bit order)
+     */
+    decode(rangeDecoder: RangeDecoder): number;
+    /**
+     * Decode a symbol (reverse bit order)
+     */
+    reverseDecode(rangeDecoder: RangeDecoder): number;
+}
+/**
+ * Static reverse decode from external probability array
+ */
+export declare function reverseDecodeFromArray(models: Uint16Array, startIndex: number, rangeDecoder: RangeDecoder, numBitLevels: number): number;

package/dist/esm/lzma/sync/RangeDecoder.js

@@ -0,0 +1,132 @@
+/**
+ * Synchronous Range Decoder for LZMA
+ *
+ * Decodes arithmetic-coded bits from a buffer.
+ * All operations are synchronous - for streaming use the async version.
+ */ import { allocBuffer } from 'extract-base-iterator';
+/**
+ * Range decoder for synchronous buffer-based LZMA decoding
+ */ export class RangeDecoder {
+    /**
+   * Set input buffer and initialize decoder state
+   */ setInput(input, offset = 0) {
+        this.input = input;
+        this.pos = offset;
+        this.init();
+    }
+    /**
+   * Initialize range decoder (reads first 5 bytes)
+   */ init() {
+        this.code = 0;
+        this.range = -1; // 0xFFFFFFFF as signed int
+        // First byte is ignored (should be 0)
+        this.pos++;
+        // Read 4 bytes into code
+        for(let i = 0; i < 4; i++){
+            this.code = this.code << 8 | this.input[this.pos++];
+        }
+    }
+    /**
+   * Get current position in input buffer
+   */ getPosition() {
+        return this.pos;
+    }
+    /**
+   * Normalize range if needed (read more bytes)
+   */ normalize() {
+        if ((this.range & 0xff000000) === 0) {
+            this.code = this.code << 8 | this.input[this.pos++];
+            this.range <<= 8;
+        }
+    }
+    /**
+   * Decode a single bit using probability model
+   * @param probs - Probability array
+   * @param index - Index into probability array
+   * @returns Decoded bit (0 or 1)
+   */ decodeBit(probs, index) {
+        const prob = probs[index];
+        const newBound = (this.range >>> 11) * prob;
+        if ((this.code ^ 0x80000000) < (newBound ^ 0x80000000)) {
+            this.range = newBound;
+            probs[index] += 2048 - prob >>> 5;
+            this.normalize();
+            return 0;
+        }
+        this.range -= newBound;
+        this.code -= newBound;
+        probs[index] -= prob >>> 5;
+        this.normalize();
+        return 1;
+    }
+    /**
+   * Decode direct bits (not probability-based)
+   * @param numTotalBits - Number of bits to decode
+   * @returns Decoded value
+   */ decodeDirectBits(numTotalBits) {
+        let result = 0;
+        for(let i = numTotalBits; i > 0; i--){
+            this.range >>>= 1;
+            const t = this.code - this.range >>> 31;
+            this.code -= this.range & t - 1;
+            result = result << 1 | 1 - t;
+            this.normalize();
+        }
+        return result;
+    }
+    constructor(){
+        this.input = allocBuffer(0); // Replaced by setInput() before use
+        this.pos = 0;
+        this.code = 0;
+        this.range = 0;
+    }
+}
+/**
+ * Bit tree decoder for multi-bit symbols
+ */ export class BitTreeDecoder {
+    /**
+   * Initialize probability models
+   */ init() {
+        for(let i = 0; i < this.models.length; i++){
+            this.models[i] = 1024; // kProbInitValue
+        }
+    }
+    /**
+   * Decode a symbol (forward bit order)
+   */ decode(rangeDecoder) {
+        let m = 1;
+        for(let i = this.numBitLevels; i > 0; i--){
+            m = m << 1 | rangeDecoder.decodeBit(this.models, m);
+        }
+        return m - (1 << this.numBitLevels);
+    }
+    /**
+   * Decode a symbol (reverse bit order)
+   */ reverseDecode(rangeDecoder) {
+        let m = 1;
+        let symbol = 0;
+        for(let i = 0; i < this.numBitLevels; i++){
+            const bit = rangeDecoder.decodeBit(this.models, m);
+            m = m << 1 | bit;
+            symbol |= bit << i;
+        }
+        return symbol;
+    }
+    constructor(numBitLevels){
+        this.numBitLevels = numBitLevels;
+        this.models = new Uint16Array(1 << numBitLevels);
+        this.init();
+    }
+}
+/**
+ * Static reverse decode from external probability array
+ */ export function reverseDecodeFromArray(models, startIndex, rangeDecoder, numBitLevels) {
+    let m = 1;
+    let symbol = 0;
+    for(let i = 0; i < numBitLevels; i++){
+        const bit = rangeDecoder.decodeBit(models, startIndex + m);
+        m = m << 1 | bit;
+        symbol |= bit << i;
+    }
+    return symbol;
+}

package/dist/esm/lzma/sync/RangeDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/sync/RangeDecoder.ts"],"sourcesContent":["/**\n * Synchronous Range Decoder for LZMA\n *\n * Decodes arithmetic-coded bits from a buffer.\n * All operations are synchronous - for streaming use the async version.\n */\n\nimport { allocBuffer } from 'extract-base-iterator';\n\n/**\n * Range decoder for synchronous buffer-based LZMA decoding\n */\nexport class RangeDecoder {\n  private input: Buffer;\n  private pos: number;\n  private code: number;\n  private range: number;\n\n  constructor() {\n    this.input = allocBuffer(0); // Replaced by setInput() before use\n    this.pos = 0;\n    this.code = 0;\n    this.range = 0;\n  }\n\n  /**\n   * Set input buffer and initialize decoder state\n   */\n  setInput(input: Buffer, offset = 0): void {\n    this.input = input;\n    this.pos = offset;\n    this.init();\n  }\n\n  /**\n   * Initialize range decoder (reads first 5 bytes)\n   */\n  private init(): void {\n    this.code = 0;\n    this.range = -1; // 0xFFFFFFFF as signed int\n\n    // First byte is ignored (should be 0)\n    this.pos++;\n\n    // Read 4 bytes into code\n    for (let i = 0; i < 4; i++) {\n      this.code = (this.code << 8) | this.input[this.pos++];\n    }\n  }\n\n  /**\n   * Get current position in input buffer\n   */\n  getPosition(): number {\n    return this.pos;\n  }\n\n  /**\n   * Normalize range if needed (read more bytes)\n   */\n  private normalize(): void {\n    if ((this.range & 0xff000000) === 0) {\n      this.code = (this.code << 8) | this.input[this.pos++];\n      this.range <<= 8;\n    }\n  }\n\n  /**\n   * Decode a single bit using probability model\n   * @param probs - Probability array\n   * @param index - Index into probability array\n   * @returns Decoded bit (0 or 1)\n   */\n  decodeBit(probs: Uint16Array, index: number): number {\n    const prob = probs[index];\n    const newBound = (this.range >>> 11) * prob;\n\n    if ((this.code ^ 0x80000000) < (newBound ^ 0x80000000)) {\n      this.range = newBound;\n      probs[index] += (2048 - prob) >>> 5;\n      this.normalize();\n      return 0;\n    }\n    this.range -= newBound;\n    this.code -= newBound;\n    probs[index] -= prob >>> 5;\n    this.normalize();\n    return 1;\n  }\n\n  /**\n   * Decode direct bits (not probability-based)\n   * @param numTotalBits - Number of bits to decode\n   * @returns Decoded value\n   */\n  decodeDirectBits(numTotalBits: number): number {\n    let result = 0;\n    for (let i = numTotalBits; i > 0; i--) {\n      this.range >>>= 1;\n      const t = (this.code - this.range) >>> 31;\n      this.code -= this.range & (t - 1);\n      result = (result << 1) | (1 - t);\n      this.normalize();\n    }\n    return result;\n  }\n}\n\n/**\n * Bit tree decoder for multi-bit symbols\n */\nexport class BitTreeDecoder {\n  private numBitLevels: number;\n  private models: Uint16Array;\n\n  constructor(numBitLevels: number) {\n    this.numBitLevels = numBitLevels;\n    this.models = new Uint16Array(1 << numBitLevels);\n    this.init();\n  }\n\n  /**\n   * Initialize probability models\n   */\n  init(): void {\n    for (let i = 0; i < this.models.length; i++) {\n      this.models[i] = 1024; // kProbInitValue\n    }\n  }\n\n  /**\n   * Decode a symbol (forward bit order)\n   */\n  decode(rangeDecoder: RangeDecoder): number {\n    let m = 1;\n    for (let i = this.numBitLevels; i > 0; i--) {\n      m = (m << 1) | rangeDecoder.decodeBit(this.models, m);\n    }\n    return m - (1 << this.numBitLevels);\n  }\n\n  /**\n   * Decode a symbol (reverse bit order)\n   */\n  reverseDecode(rangeDecoder: RangeDecoder): number {\n    let m = 1;\n    let symbol = 0;\n    for (let i = 0; i < this.numBitLevels; i++) {\n      const bit = rangeDecoder.decodeBit(this.models, m);\n      m = (m << 1) | bit;\n      symbol |= bit << i;\n    }\n    return symbol;\n  }\n}\n\n/**\n * Static reverse decode from external probability array\n */\nexport function reverseDecodeFromArray(models: Uint16Array, startIndex: number, rangeDecoder: RangeDecoder, numBitLevels: number): number {\n  let m = 1;\n  let symbol = 0;\n  for (let i = 0; i < numBitLevels; i++) {\n    const bit = rangeDecoder.decodeBit(models, startIndex + m);\n    m = (m << 1) | bit;\n    symbol |= bit << i;\n  }\n  return symbol;\n}\n"],"names":["allocBuffer","RangeDecoder","setInput","input","offset","pos","init","code","range","i","getPosition","normalize","decodeBit","probs","index","prob","newBound","decodeDirectBits","numTotalBits","result","t","BitTreeDecoder","models","length","decode","rangeDecoder","m","numBitLevels","reverseDecode","symbol","bit","Uint16Array","reverseDecodeFromArray","startIndex"],"mappings":"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"}

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

@@ -0,0 +1,117 @@
+/**
+ * LZMA Types and Constants
+ *
+ * Shared types, constants, and state transition functions for LZMA decoding.
+ * Based on the LZMA SDK specification.
+ */
+export declare const kNumRepDistances = 4;
+export declare const kNumStates = 12;
+export declare const kNumPosSlotBits = 6;
+export declare const kDicLogSizeMin = 0;
+export declare const kNumLenToPosStatesBits = 2;
+export declare const kNumLenToPosStates: number;
+export declare const kMatchMinLen = 2;
+export declare const kNumLowLenBits = 3;
+export declare const kNumMidLenBits = 3;
+export declare const kNumHighLenBits = 8;
+export declare const kNumLowLenSymbols: number;
+export declare const kNumMidLenSymbols: number;
+export declare const kNumLenSymbols: number;
+export declare const kMatchMaxLen: number;
+export declare const kNumAlignBits = 4;
+export declare const kAlignTableSize: number;
+export declare const kAlignMask: number;
+export declare const kStartPosModelIndex = 4;
+export declare const kEndPosModelIndex = 14;
+export declare const kNumPosModels: number;
+export declare const kNumFullDistances: number;
+export declare const kNumLitPosStatesBitsEncodingMax = 4;
+export declare const kNumLitContextBitsMax = 8;
+export declare const kNumPosStatesBitsMax = 4;
+export declare const kNumPosStatesMax: number;
+export declare const kNumPosStatesBitsEncodingMax = 4;
+export declare const kNumPosStatesEncodingMax: number;
+export declare const kNumBitModelTotalBits = 11;
+export declare const kBitModelTotal: number;
+export declare const kNumMoveBits = 5;
+export declare const kProbInitValue: number;
+/**
+ * State transition: after literal byte
+ */
+export declare function stateUpdateChar(state: number): number;
+/**
+ * State transition: after match
+ */
+export declare function stateUpdateMatch(state: number): number;
+/**
+ * State transition: after rep (repeated match)
+ */
+export declare function stateUpdateRep(state: number): number;
+/**
+ * State transition: after short rep
+ */
+export declare function stateUpdateShortRep(state: number): number;
+/**
+ * Check if state indicates previous symbol was a character (literal)
+ */
+export declare function stateIsCharState(state: number): boolean;
+/**
+ * Get length-to-position state index
+ */
+export declare function getLenToPosState(len: number): number;
+/**
+ * Initialize probability array with default values
+ * @param probs - Array to initialize (or null to create new)
+ * @param count - Number of probabilities
+ * @returns Initialized probability array
+ */
+export declare function initBitModels(probs: Uint16Array | null, count?: number): Uint16Array;
+/**
+ * LZMA properties parsed from the 5-byte header
+ */
+export interface LzmaProperties {
+    /** Literal context bits (0-8) */
+    lc: number;
+    /** Literal pos bits (0-4) */
+    lp: number;
+    /** Pos bits (0-4) */
+    pb: number;
+    /** Dictionary size in bytes */
+    dictionarySize: number;
+}
+/**
+ * Parse LZMA properties from a 5-byte buffer
+ */
+export declare function parseProperties(properties: Buffer | Uint8Array): LzmaProperties;
+/**
+ * LZMA2 control byte meanings
+ */
+export declare const LZMA2_CONTROL: {
+    readonly END: 0;
+    readonly UNCOMPRESSED_RESET_DIC: 1;
+    readonly UNCOMPRESSED: 2;
+    readonly LZMA_RESET_STATE_NEW_PROP: 224;
+};
+/**
+ * Check if LZMA2 control byte indicates reset state (new properties)
+ */
+export declare function lzma2NeedsNewProps(control: number): boolean;
+/**
+ * Check if LZMA2 control byte indicates reset probabilities
+ */
+export declare function lzma2NeedsResetProbs(control: number): boolean;
+/**
+ * Check if LZMA2 control byte indicates uncompressed chunk
+ */
+export declare function lzma2IsUncompressed(control: number): boolean;
+/**
+ * Parse LZMA2 dictionary size from property byte
+ */
+export declare function parseLzma2DictionarySize(prop: number): number;
+/**
+ * Output sink interface for fast streaming decode
+ * Can be a Buffer (with write method) or a stream with write() method
+ */
+export interface OutputSink {
+    write(buffer: Buffer): void;
+}

package/dist/esm/lzma/types.js

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/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":"AAAA;;;;;CAKC,GAED,+BAA+B;AAC/B,OAAO,MAAMA,mBAAmB,EAAE;AAClC,OAAO,MAAMC,aAAa,GAAG;AAE7B,0BAA0B;AAC1B,OAAO,MAAMC,kBAAkB,EAAE;AACjC,OAAO,MAAMC,iBAAiB,EAAE;AAChC,OAAO,MAAMC,yBAAyB,EAAE;AACxC,OAAO,MAAMC,qBAAqB,KAAKD,uBAAuB,CAAC,IAAI;AAEnE,yBAAyB;AACzB,OAAO,MAAME,eAAe,EAAE;AAC9B,OAAO,MAAMC,iBAAiB,EAAE;AAChC,OAAO,MAAMC,iBAAiB,EAAE;AAChC,OAAO,MAAMC,kBAAkB,EAAE;AACjC,OAAO,MAAMC,oBAAoB,KAAKH,eAAe,CAAC,IAAI;AAC1D,OAAO,MAAMI,oBAAoB,KAAKH,eAAe,CAAC,IAAI;AAC1D,OAAO,MAAMI,iBAAiBF,oBAAoBC,oBAAqB,CAAA,KAAKF,eAAc,EAAG,CAAC,MAAM;AACpG,OAAO,MAAMI,eAAeP,eAAeM,iBAAiB,EAAE,CAAC,MAAM;AAErE,sBAAsB;AACtB,OAAO,MAAME,gBAAgB,EAAE;AAC/B,OAAO,MAAMC,kBAAkB,KAAKD,cAAc,CAAC,KAAK;AACxD,OAAO,MAAME,aAAaD,kBAAkB,EAAE,CAAC,KAAK;AAEpD,2BAA2B;AAC3B,OAAO,MAAME,sBAAsB,EAAE;AACrC,OAAO,MAAMC,oBAAoB,GAAG;AACpC,OAAO,MAAMC,gBAAgBD,oBAAoBD,oBAAoB,CAAC,KAAK;AAC3E,OAAO,MAAMG,oBAAoB,KAAMF,CAAAA,sBAAsB,CAAA,EAAG,CAAC,MAAM;AAEvE,8BAA8B;AAC9B,OAAO,MAAMG,kCAAkC,EAAE;AACjD,OAAO,MAAMC,wBAAwB,EAAE;AACvC,OAAO,MAAMC,uBAAuB,EAAE;AACtC,OAAO,MAAMC,mBAAmB,KAAKD,qBAAqB,CAAC,KAAK;AAChE,OAAO,MAAME,+BAA+B,EAAE;AAC9C,OAAO,MAAMC,2BAA2B,KAAKD,6BAA6B,CAAC,KAAK;AAEhF,oCAAoC;AACpC,OAAO,MAAME,wBAAwB,GAAG;AACxC,OAAO,MAAMC,iBAAiB,KAAKD,sBAAsB,CAAC,OAAO;AACjE,OAAO,MAAME,eAAe,EAAE;AAC9B,OAAO,MAAMC,iBAAiBF,mBAAmB,EAAE,CAAC,OAAO;AAE3D;;CAEC,GACD,OAAO,SAASG,gBAAgBC,KAAa;IAC3C,IAAIA,QAAQ,GAAG,OAAO;IACtB,IAAIA,QAAQ,IAAI,OAAOA,QAAQ;IAC/B,OAAOA,QAAQ;AACjB;AAEA;;CAEC,GACD,OAAO,SAASC,iBAAiBD,KAAa;IAC5C,OAAOA,QAAQ,IAAI,IAAI;AACzB;AAEA;;CAEC,GACD,OAAO,SAASE,eAAeF,KAAa;IAC1C,OAAOA,QAAQ,IAAI,IAAI;AACzB;AAEA;;CAEC,GACD,OAAO,SAASG,oBAAoBH,KAAa;IAC/C,OAAOA,QAAQ,IAAI,IAAI;AACzB;AAEA;;CAEC,GACD,OAAO,SAASI,iBAAiBJ,KAAa;IAC5C,OAAOA,QAAQ;AACjB;AAEA;;CAEC,GACD,OAAO,SAASK,iBAAiBC,GAAW;IAC1CA,OAAOhC;IACP,OAAOgC,MAAMjC,qBAAqBiC,MAAMjC,qBAAqB;AAC/D;AAEA;;;;;CAKC,GACD,OAAO,SAASkC,cAAcC,KAAyB,EAAEC,KAAc;IACrE,IAAID,UAAU,MAAM;QAClB,IAAIC,UAAUC,WAAW;YACvB,MAAM,IAAIC,MAAM;QAClB;QACAH,QAAQ,IAAII,YAAYH;IAC1B;IACA,IAAK,IAAII,IAAI,GAAGA,IAAIL,MAAMM,MAAM,EAAED,IAAK;QACrCL,KAAK,CAACK,EAAE,GAAGf;IACb;IACA,OAAOU;AACT;AAgBA;;CAEC,GACD,OAAO,SAASO,gBAAgBC,UAA+B;IAC7D,IAAIA,WAAWF,MAAM,GAAG,GAAG;QACzB,MAAM,IAAIH,MAAM;IAClB;IAEA,MAAMM,IAAID,UAAU,CAAC,EAAE,GAAG;IAC1B,MAAME,KAAKD,IAAI;IACf,MAAME,YAAY,CAAC,CAAEF,CAAAA,IAAI,CAAA;IACzB,MAAMG,KAAKD,YAAY;IACvB,MAAME,KAAK,CAAC,CAAEF,CAAAA,YAAY,CAAA;IAE1B,IAAID,KAAK5B,yBAAyB8B,KAAK,KAAKC,KAAK9B,sBAAsB;QACrE,MAAM,IAAIoB,MAAM;IAClB;IAEA,IAAIW,iBAAiB;IACrB,IAAK,IAAIT,IAAI,GAAGA,IAAI,GAAGA,IAAK;QAC1BS,kBAAkB,AAACN,CAAAA,UAAU,CAAC,IAAIH,EAAE,GAAG,IAAG,KAAOA,IAAI;IACvD;IAEA,OAAO;QAAEK;QAAIE;QAAIC;QAAIC;IAAe;AACtC;AAEA;;CAEC,GACD,OAAO,MAAMC,gBAAgB;IAC3BC,KAAK;IACLC,wBAAwB;IACxBC,cAAc;IACdC,2BAA2B;AAC7B,EAAW;AAEX;;CAEC,GACD,OAAO,SAASC,mBAAmBC,OAAe;IAChD,OAAOA,WAAW;AACpB;AAEA;;CAEC,GACD,OAAO,SAASC,qBAAqBD,OAAe;IAClD,OAAOA,WAAW;AACpB;AAEA;;CAEC,GACD,OAAO,SAASE,oBAAoBF,OAAe;IACjD,OAAOA,UAAU;AACnB;AAEA;;CAEC,GACD,OAAO,SAASG,yBAAyBC,IAAY;IACnD,IAAIA,OAAO,IAAI;QACb,MAAM,IAAItB,MAAM;IAClB;IACA,IAAIsB,SAAS,IAAI;QACf,OAAO;IACT;IACA,MAAMC,OAAO,IAAKD,OAAO;IACzB,MAAME,MAAM,AAACF,CAAAA,SAAS,CAAA,IAAK;IAC3B,OAAOC,QAAQC;AACjB"}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/dist/esm/utils/createBufferingDecoder.d.ts

@@ -0,0 +1,10 @@
+import type { Transform as TransformType } from 'stream';
+type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+/**
+ * Helper to create a Transform stream from a synchronous decoder
+ *
+ * This buffers all input and applies the decoder when the stream ends.
+ * This is suitable for codecs that don't support true streaming.
+ */
+export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof TransformType>;
+export {};

package/dist/esm/utils/createBufferingDecoder.js

@@ -0,0 +1,30 @@
+import { bufferFrom, Transform } from 'extract-base-iterator';
+/**
+ * Helper to create a Transform stream from a synchronous decoder
+ *
+ * This buffers all input and applies the decoder when the stream ends.
+ * This is suitable for codecs that don't support true streaming.
+ */ export default function createBufferingDecoder(decodeFn, properties, unpackSize) {
+    const chunks = [];
+    let _totalSize = 0;
+    return new Transform({
+        transform: (chunk, _encoding, callback)=>{
+            chunks.push(chunk);
+            _totalSize += chunk.length;
+            callback();
+        },
+        flush: function(callback) {
+            try {
+                // Concatenate all chunks
+                const input = bufferFrom(Buffer.concat(chunks));
+                // Decode using the synchronous decoder
+                const output = decodeFn(input, properties, unpackSize);
+                // Push the result
+                this.push(output);
+                callback();
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}

package/dist/esm/utils/createBufferingDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/utils/createBufferingDecoder.ts"],"sourcesContent":["import { bufferFrom, Transform } from 'extract-base-iterator';\nimport type { Transform as TransformType } from 'stream';\n\ntype DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Helper to create a Transform stream from a synchronous decoder\n *\n * This buffers all input and applies the decoder when the stream ends.\n * This is suitable for codecs that don't support true streaming.\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof TransformType> {\n  const chunks: Buffer[] = [];\n  let _totalSize = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      chunks.push(chunk);\n      _totalSize += chunk.length;\n      callback();\n    },\n    flush: function (this: InstanceType<typeof TransformType>, callback: (err?: Error | null) => void) {\n      try {\n        // Concatenate all chunks\n        const input = bufferFrom(Buffer.concat(chunks));\n        // Decode using the synchronous decoder\n        const output = decodeFn(input, properties, unpackSize);\n        // Push the result\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["bufferFrom","Transform","createBufferingDecoder","decodeFn","properties","unpackSize","chunks","_totalSize","transform","chunk","_encoding","callback","push","length","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,SAASA,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAK9D;;;;;CAKC,GACD,eAAe,SAASC,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,MAAMC,SAAmB,EAAE;IAC3B,IAAIC,aAAa;IAEjB,OAAO,IAAIN,UAAU;QACnBO,WAAW,CAACC,OAAeC,WAAmBC;YAC5CL,OAAOM,IAAI,CAACH;YACZF,cAAcE,MAAMI,MAAM;YAC1BF;QACF;QACAG,OAAO,SAAoDH,QAAsC;YAC/F,IAAI;gBACF,yBAAyB;gBACzB,MAAMI,QAAQf,WAAWgB,OAAOC,MAAM,CAACX;gBACvC,uCAAuC;gBACvC,MAAMY,SAASf,SAASY,OAAOX,YAAYC;gBAC3C,kBAAkB;gBAClB,IAAI,CAACO,IAAI,CAACM;gBACVP;YACF,EAAE,OAAOQ,KAAK;gBACZR,SAASQ;YACX;QACF;IACF;AACF"}

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

@@ -0,0 +1,21 @@
+/**
+ * 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
+ * Properly handles multi-block XZ files and stream padding
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */
+export declare function decodeXZ(input: Buffer): Buffer;
+/**
+ * Create an XZ decompression Transform stream
+ * @returns Transform stream that decompresses XZ data
+ */
+export declare function createXZDecoder(): TransformType;