xz-compat 0.1.0

package/dist/cjs/lzma/sync/RangeDecoder.d.cts

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

@@ -0,0 +1,162 @@
+/**
+ * Synchronous Range Decoder for LZMA
+ *
+ * Decodes arithmetic-coded bits from a buffer.
+ * All operations are synchronous - for streaming use the async version.
+ */ "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 BitTreeDecoder;
+    },
+    get RangeDecoder () {
+        return RangeDecoder;
+    },
+    get reverseDecodeFromArray () {
+        return reverseDecodeFromArray;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+var RangeDecoder = /*#__PURE__*/ function() {
+    "use strict";
+    function RangeDecoder() {
+        _class_call_check(this, RangeDecoder);
+        this.input = (0, _extractbaseiterator.allocBuffer)(0); // Replaced by setInput() before use
+        this.pos = 0;
+        this.code = 0;
+        this.range = 0;
+    }
+    var _proto = RangeDecoder.prototype;
+    /**
+   * Set input buffer and initialize decoder state
+   */ _proto.setInput = function setInput(input) {
+        var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+        this.input = input;
+        this.pos = offset;
+        this.init();
+    };
+    /**
+   * Initialize range decoder (reads first 5 bytes)
+   */ _proto.init = function 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(var i = 0; i < 4; i++){
+            this.code = this.code << 8 | this.input[this.pos++];
+        }
+    };
+    /**
+   * Get current position in input buffer
+   */ _proto.getPosition = function getPosition() {
+        return this.pos;
+    };
+    /**
+   * Normalize range if needed (read more bytes)
+   */ _proto.normalize = function 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)
+   */ _proto.decodeBit = function decodeBit(probs, index) {
+        var prob = probs[index];
+        var 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
+   */ _proto.decodeDirectBits = function decodeDirectBits(numTotalBits) {
+        var result = 0;
+        for(var i = numTotalBits; i > 0; i--){
+            this.range >>>= 1;
+            var t = this.code - this.range >>> 31;
+            this.code -= this.range & t - 1;
+            result = result << 1 | 1 - t;
+            this.normalize();
+        }
+        return result;
+    };
+    return RangeDecoder;
+}();
+var BitTreeDecoder = /*#__PURE__*/ function() {
+    "use strict";
+    function BitTreeDecoder(numBitLevels) {
+        _class_call_check(this, BitTreeDecoder);
+        this.numBitLevels = numBitLevels;
+        this.models = new Uint16Array(1 << numBitLevels);
+        this.init();
+    }
+    var _proto = BitTreeDecoder.prototype;
+    /**
+   * Initialize probability models
+   */ _proto.init = function init() {
+        for(var i = 0; i < this.models.length; i++){
+            this.models[i] = 1024; // kProbInitValue
+        }
+    };
+    /**
+   * Decode a symbol (forward bit order)
+   */ _proto.decode = function decode(rangeDecoder) {
+        var m = 1;
+        for(var 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)
+   */ _proto.reverseDecode = function reverseDecode(rangeDecoder) {
+        var m = 1;
+        var symbol = 0;
+        for(var i = 0; i < this.numBitLevels; i++){
+            var bit = rangeDecoder.decodeBit(this.models, m);
+            m = m << 1 | bit;
+            symbol |= bit << i;
+        }
+        return symbol;
+    };
+    return BitTreeDecoder;
+}();
+function reverseDecodeFromArray(models, startIndex, rangeDecoder, numBitLevels) {
+    var m = 1;
+    var symbol = 0;
+    for(var i = 0; i < numBitLevels; i++){
+        var bit = rangeDecoder.decodeBit(models, startIndex + m);
+        m = m << 1 | bit;
+        symbol |= bit << i;
+    }
+    return symbol;
+}
+/* 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/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":["BitTreeDecoder","RangeDecoder","reverseDecodeFromArray","input","allocBuffer","pos","code","range","setInput","offset","init","i","getPosition","normalize","decodeBit","probs","index","prob","newBound","decodeDirectBits","numTotalBits","result","t","numBitLevels","models","Uint16Array","length","decode","rangeDecoder","m","reverseDecode","symbol","bit","startIndex"],"mappings":"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"}

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

@@ -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/cjs/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;
+}