xz-compat 0.1.0

package/dist/cjs/xz/Decoder.js

@@ -0,0 +1,325 @@
+/**
+ * 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+
+ */ "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 createXZDecoder () {
+        return createXZDecoder;
+    },
+    get decodeXZ () {
+        return decodeXZ;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _Bcjts = require("../filters/bcj/Bcj.js");
+var _BcjArmts = require("../filters/bcj/BcjArm.js");
+var _BcjArm64ts = require("../filters/bcj/BcjArm64.js");
+var _BcjArmtts = require("../filters/bcj/BcjArmt.js");
+var _BcjIa64ts = require("../filters/bcj/BcjIa64.js");
+var _BcjPpcts = require("../filters/bcj/BcjPpc.js");
+var _BcjSparcts = require("../filters/bcj/BcjSparc.js");
+var _Deltats = require("../filters/delta/Delta.js");
+var _indexts = require("../lzma/index.js");
+// XZ magic bytes
+var XZ_MAGIC = [
+    0xfd,
+    0x37,
+    0x7a,
+    0x58,
+    0x5a,
+    0x00
+];
+var XZ_FOOTER_MAGIC = [
+    0x59,
+    0x5a
+]; // "YZ"
+// Filter IDs (from XZ specification)
+var FILTER_DELTA = 0x03;
+var FILTER_BCJ_X86 = 0x04;
+var FILTER_BCJ_PPC = 0x05;
+var FILTER_BCJ_IA64 = 0x06;
+var FILTER_BCJ_ARM = 0x07;
+var FILTER_BCJ_ARMT = 0x08;
+var FILTER_BCJ_SPARC = 0x09;
+var FILTER_BCJ_ARM64 = 0x0a;
+var FILTER_LZMA2 = 0x21;
+/**
+ * Simple buffer comparison
+ */ function bufferEquals(buf, offset, expected) {
+    if (offset + expected.length > buf.length) {
+        return false;
+    }
+    for(var i = 0; i < expected.length; i++){
+        if (buf[offset + i] !== expected[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Decode variable-length integer (XZ multibyte encoding)
+ * Returns number, but limits to 32-bit to work on Node 0.8+
+ */ function decodeMultibyte(buf, offset) {
+    var value = 0;
+    var i = 0;
+    var byte;
+    do {
+        if (offset + i >= buf.length) {
+            throw new Error('Truncated multibyte integer');
+        }
+        byte = buf[offset + i];
+        value |= (byte & 0x7f) << i * 7;
+        i++;
+        if (i > 4) {
+            // Reduced to prevent overflow on Node 0.8
+            throw new Error('Multibyte integer too large');
+        }
+    }while (byte & 0x80);
+    return {
+        value: value,
+        bytesRead: i
+    };
+}
+/**
+ * Apply a preprocessing filter (BCJ/Delta) to decompressed data
+ */ function applyFilter(data, filter) {
+    switch(filter.id){
+        case FILTER_BCJ_X86:
+            return (0, _Bcjts.decodeBcj)(data, filter.props);
+        case FILTER_BCJ_ARM:
+            return (0, _BcjArmts.decodeBcjArm)(data, filter.props);
+        case FILTER_BCJ_ARM64:
+            return (0, _BcjArm64ts.decodeBcjArm64)(data, filter.props);
+        case FILTER_BCJ_ARMT:
+            return (0, _BcjArmtts.decodeBcjArmt)(data, filter.props);
+        case FILTER_BCJ_PPC:
+            return (0, _BcjPpcts.decodeBcjPpc)(data, filter.props);
+        case FILTER_BCJ_SPARC:
+            return (0, _BcjSparcts.decodeBcjSparc)(data, filter.props);
+        case FILTER_BCJ_IA64:
+            return (0, _BcjIa64ts.decodeBcjIa64)(data, filter.props);
+        case FILTER_DELTA:
+            return (0, _Deltats.decodeDelta)(data, filter.props);
+        default:
+            throw new Error("Unsupported filter: 0x".concat(filter.id.toString(16)));
+    }
+}
+/**
+ * Parse XZ Block Header to extract filters and LZMA2 properties
+ */ function parseBlockHeader(input, offset, _checkSize) {
+    // Block header size
+    var blockHeaderSizeRaw = input[offset];
+    if (blockHeaderSizeRaw === 0) {
+        throw new Error('Invalid block header size (index indicator found instead of block)');
+    }
+    var blockHeaderSize = (blockHeaderSizeRaw + 1) * 4;
+    // Parse block header
+    var blockHeaderStart = offset;
+    offset++; // skip size byte
+    var blockFlags = input[offset++];
+    var numFilters = (blockFlags & 0x03) + 1;
+    var hasCompressedSize = (blockFlags & 0x40) !== 0;
+    var hasUncompressedSize = (blockFlags & 0x80) !== 0;
+    // Skip optional sizes
+    if (hasCompressedSize) {
+        var result = decodeMultibyte(input, offset);
+        offset += result.bytesRead;
+    }
+    if (hasUncompressedSize) {
+        var result1 = decodeMultibyte(input, offset);
+        offset += result1.bytesRead;
+    }
+    // Parse all filters
+    var filters = [];
+    var lzma2Props = null;
+    for(var i = 0; i < numFilters; i++){
+        var filterIdResult = decodeMultibyte(input, offset);
+        var filterId = filterIdResult.value;
+        offset += filterIdResult.bytesRead;
+        var propsSizeResult = decodeMultibyte(input, offset);
+        offset += propsSizeResult.bytesRead;
+        var filterProps = input.slice(offset, offset + propsSizeResult.value);
+        offset += propsSizeResult.value;
+        if (filterId === FILTER_LZMA2) {
+            // LZMA2 must be the last filter
+            lzma2Props = filterProps;
+        } else if (filterId === FILTER_DELTA || filterId >= FILTER_BCJ_X86 && filterId <= FILTER_BCJ_ARM64) {
+            // Preprocessing filter - store for later application
+            filters.push({
+                id: filterId,
+                props: filterProps
+            });
+        } else {
+            throw new Error("Unsupported filter: 0x".concat(filterId.toString(16)));
+        }
+    }
+    if (!lzma2Props) {
+        throw new Error('No LZMA2 filter found in XZ block');
+    }
+    // Skip to end of block header (must be aligned to 4 bytes)
+    var blockDataStart = blockHeaderStart + blockHeaderSize;
+    return {
+        filters: filters,
+        lzma2Props: lzma2Props,
+        headerSize: blockHeaderSize,
+        dataStart: blockDataStart,
+        dataEnd: input.length,
+        nextOffset: blockDataStart
+    };
+}
+/**
+ * Parse XZ Index to get block positions
+ *
+ * XZ Index stores "Unpadded Size" for each block which equals:
+ * Block Header Size + Compressed Data Size + Check Size
+ * (does NOT include padding to 4-byte boundary)
+ */ function parseIndex(input, indexStart, checkSize) {
+    var offset = indexStart;
+    // Index indicator (0x00)
+    if (input[offset] !== 0x00) {
+        throw new Error('Invalid index indicator');
+    }
+    offset++;
+    // Number of records
+    var countResult = decodeMultibyte(input, offset);
+    var recordCount = countResult.value;
+    offset += countResult.bytesRead;
+    var records = [];
+    // Parse each record
+    for(var i = 0; i < recordCount; i++){
+        // Unpadded Size (header + compressed data + check)
+        var unpaddedResult = decodeMultibyte(input, offset);
+        offset += unpaddedResult.bytesRead;
+        // Uncompressed size
+        var uncompressedResult = decodeMultibyte(input, offset);
+        offset += uncompressedResult.bytesRead;
+        records.push({
+            compressedPos: 0,
+            unpaddedSize: unpaddedResult.value,
+            compressedDataSize: 0,
+            uncompressedSize: uncompressedResult.value
+        });
+    }
+    // Calculate actual positions by walking through blocks
+    var currentPos = 12; // After stream header
+    for(var i1 = 0; i1 < records.length; i1++){
+        var record = records[i1];
+        // Record where this block's header starts
+        record.compressedPos = currentPos;
+        // Get block header size from the actual data
+        var headerSizeRaw = input[currentPos];
+        var headerSize = (headerSizeRaw + 1) * 4;
+        // Calculate compressed data size from unpadded size
+        // unpaddedSize = headerSize + compressedDataSize + checkSize
+        record.compressedDataSize = record.unpaddedSize - headerSize - checkSize;
+        // Move to next block: unpaddedSize + padding to 4-byte boundary
+        var paddedSize = Math.ceil(record.unpaddedSize / 4) * 4;
+        currentPos += paddedSize;
+    }
+    return records;
+}
+function decodeXZ(input) {
+    var _loop = function(i) {
+        var record = blockRecords[i];
+        var recordStart = record.compressedPos;
+        // Parse block header
+        var blockInfo = parseBlockHeader(input, recordStart, checkSize);
+        // Extract compressed data for this block
+        var dataStart = recordStart + blockInfo.headerSize;
+        // compressedDataSize is calculated from the Index's Unpadded Size minus header and check
+        var dataEnd = dataStart + record.compressedDataSize;
+        // Note: XZ blocks have padding AFTER the check field to align to 4 bytes,
+        // but the compressedSize from index is exact - no need to strip padding.
+        // LZMA2 data includes a 0x00 end marker which must NOT be stripped.
+        var compressedData = input.slice(dataStart, dataEnd);
+        // Decompress this block with LZMA2
+        var blockChunks = [];
+        (0, _indexts.decodeLzma2)(compressedData, blockInfo.lzma2Props, record.uncompressedSize, {
+            write: function(chunk) {
+                blockChunks.push(chunk);
+            }
+        });
+        // Concatenate LZMA2 output
+        var blockOutput = Buffer.concat(blockChunks);
+        // Apply preprocessing filters in reverse order (BCJ/Delta applied after LZMA2)
+        // Filters are stored in order they were applied during compression,
+        // so we need to reverse for decompression
+        for(var j = blockInfo.filters.length - 1; j >= 0; j--){
+            blockOutput = applyFilter(blockOutput, blockInfo.filters[j]);
+        }
+        outputChunks.push(blockOutput);
+        _totalOutputSize += blockOutput.length;
+    };
+    var _checkSizes_checkType;
+    // Verify XZ magic
+    if (input.length < 12 || !bufferEquals(input, 0, XZ_MAGIC)) {
+        throw new Error('Invalid XZ magic bytes');
+    }
+    // Stream flags at offset 6-7
+    var checkType = input[7] & 0x0f;
+    // Check sizes based on check type
+    var checkSizes = {
+        0: 0,
+        1: 4,
+        4: 8,
+        10: 32
+    };
+    var checkSize = (_checkSizes_checkType = checkSizes[checkType]) !== null && _checkSizes_checkType !== void 0 ? _checkSizes_checkType : 0;
+    // Find footer by skipping stream padding (null bytes at end before footer)
+    // Stream padding must be multiple of 4 bytes
+    var footerEnd = input.length;
+    while(footerEnd > 12 && input[footerEnd - 1] === 0x00){
+        footerEnd--;
+    }
+    // Align to 4-byte boundary (stream padding rules)
+    while(footerEnd % 4 !== 0 && footerEnd > 12){
+        footerEnd++;
+    }
+    // Verify footer magic (at footerEnd - 2)
+    if (!bufferEquals(input, footerEnd - 2, XZ_FOOTER_MAGIC)) {
+        throw new Error('Invalid XZ footer magic');
+    }
+    // Get backward size (tells us where index starts) - at footerEnd - 8
+    var backwardSize = (input.readUInt32LE(footerEnd - 8) + 1) * 4;
+    var indexStart = footerEnd - 12 - backwardSize;
+    // Parse Index to get block information
+    var blockRecords = parseIndex(input, indexStart, checkSize);
+    // Decompress each block
+    var outputChunks = [];
+    var _totalOutputSize = 0;
+    for(var i = 0; i < blockRecords.length; i++)_loop(i);
+    return Buffer.concat(outputChunks);
+}
+function createXZDecoder() {
+    var chunks = [];
+    return new _extractbaseiterator.Transform({
+        transform: function transform(chunk, _encoding, callback) {
+            chunks.push(chunk);
+            callback();
+        },
+        flush: function flush(callback) {
+            try {
+                var input = Buffer.concat(chunks);
+                var output = decodeXZ(input);
+                this.push(output);
+                callback();
+            } 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/xz/Decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/xz/Decoder.ts"],"sourcesContent":["/**\n * XZ Decompression Module\n *\n * XZ is a container format that wraps LZMA2 compressed data.\n * This module provides both synchronous and streaming XZ decoders.\n *\n * Pure JavaScript implementation, works on Node.js 0.8+\n */\n\nimport { Transform } from 'extract-base-iterator';\nimport type { Transform as TransformType } from 'stream';\nimport { decodeBcj } from '../filters/bcj/Bcj.ts';\nimport { decodeBcjArm } from '../filters/bcj/BcjArm.ts';\nimport { decodeBcjArm64 } from '../filters/bcj/BcjArm64.ts';\nimport { decodeBcjArmt } from '../filters/bcj/BcjArmt.ts';\nimport { decodeBcjIa64 } from '../filters/bcj/BcjIa64.ts';\nimport { decodeBcjPpc } from '../filters/bcj/BcjPpc.ts';\nimport { decodeBcjSparc } from '../filters/bcj/BcjSparc.ts';\nimport { decodeDelta } from '../filters/delta/Delta.ts';\nimport { decodeLzma2 } from '../lzma/index.ts';\n\n// XZ magic bytes\nconst XZ_MAGIC = [0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00];\nconst XZ_FOOTER_MAGIC = [0x59, 0x5a]; // \"YZ\"\n\n// Filter IDs (from XZ specification)\nconst FILTER_DELTA = 0x03;\nconst FILTER_BCJ_X86 = 0x04;\nconst FILTER_BCJ_PPC = 0x05;\nconst FILTER_BCJ_IA64 = 0x06;\nconst FILTER_BCJ_ARM = 0x07;\nconst FILTER_BCJ_ARMT = 0x08;\nconst FILTER_BCJ_SPARC = 0x09;\nconst FILTER_BCJ_ARM64 = 0x0a;\nconst FILTER_LZMA2 = 0x21;\n\n// Filter info for parsing\ninterface FilterInfo {\n  id: number;\n  props: Buffer;\n}\n\n/**\n * Simple buffer comparison\n */\nfunction bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean {\n  if (offset + expected.length > buf.length) {\n    return false;\n  }\n  for (let i = 0; i < expected.length; i++) {\n    if (buf[offset + i] !== expected[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Decode variable-length integer (XZ multibyte encoding)\n * Returns number, but limits to 32-bit to work on Node 0.8+\n */\nfunction decodeMultibyte(buf: Buffer, offset: number): { value: number; bytesRead: number } {\n  let value = 0;\n  let i = 0;\n  let byte: number;\n  do {\n    if (offset + i >= buf.length) {\n      throw new Error('Truncated multibyte integer');\n    }\n    byte = buf[offset + i];\n    value |= (byte & 0x7f) << (i * 7);\n    i++;\n    if (i > 4) {\n      // Reduced to prevent overflow on Node 0.8\n      throw new Error('Multibyte integer too large');\n    }\n  } while (byte & 0x80);\n  return { value, bytesRead: i };\n}\n\n/**\n * Apply a preprocessing filter (BCJ/Delta) to decompressed data\n */\nfunction applyFilter(data: Buffer, filter: FilterInfo): Buffer {\n  switch (filter.id) {\n    case FILTER_BCJ_X86:\n      return decodeBcj(data, filter.props);\n    case FILTER_BCJ_ARM:\n      return decodeBcjArm(data, filter.props);\n    case FILTER_BCJ_ARM64:\n      return decodeBcjArm64(data, filter.props);\n    case FILTER_BCJ_ARMT:\n      return decodeBcjArmt(data, filter.props);\n    case FILTER_BCJ_PPC:\n      return decodeBcjPpc(data, filter.props);\n    case FILTER_BCJ_SPARC:\n      return decodeBcjSparc(data, filter.props);\n    case FILTER_BCJ_IA64:\n      return decodeBcjIa64(data, filter.props);\n    case FILTER_DELTA:\n      return decodeDelta(data, filter.props);\n    default:\n      throw new Error(`Unsupported filter: 0x${filter.id.toString(16)}`);\n  }\n}\n\n/**\n * Parse XZ Block Header to extract filters and LZMA2 properties\n */\nfunction parseBlockHeader(\n  input: Buffer,\n  offset: number,\n  _checkSize: number\n): {\n  filters: FilterInfo[];\n  lzma2Props: Buffer;\n  headerSize: number;\n  dataStart: number;\n  dataEnd: number;\n  nextOffset: number;\n} {\n  // Block header size\n  const blockHeaderSizeRaw = input[offset];\n  if (blockHeaderSizeRaw === 0) {\n    throw new Error('Invalid block header size (index indicator found instead of block)');\n  }\n  const blockHeaderSize = (blockHeaderSizeRaw + 1) * 4;\n\n  // Parse block header\n  const blockHeaderStart = offset;\n  offset++; // skip size byte\n\n  const blockFlags = input[offset++];\n  const numFilters = (blockFlags & 0x03) + 1;\n  const hasCompressedSize = (blockFlags & 0x40) !== 0;\n  const hasUncompressedSize = (blockFlags & 0x80) !== 0;\n\n  // Skip optional sizes\n  if (hasCompressedSize) {\n    const result = decodeMultibyte(input, offset);\n    offset += result.bytesRead;\n  }\n\n  if (hasUncompressedSize) {\n    const result = decodeMultibyte(input, offset);\n    offset += result.bytesRead;\n  }\n\n  // Parse all filters\n  const filters: FilterInfo[] = [];\n  let lzma2Props: Buffer | null = null;\n\n  for (let i = 0; i < numFilters; i++) {\n    const filterIdResult = decodeMultibyte(input, offset);\n    const filterId = filterIdResult.value;\n    offset += filterIdResult.bytesRead;\n\n    const propsSizeResult = decodeMultibyte(input, offset);\n    offset += propsSizeResult.bytesRead;\n\n    const filterProps = input.slice(offset, offset + propsSizeResult.value);\n    offset += propsSizeResult.value;\n\n    if (filterId === FILTER_LZMA2) {\n      // LZMA2 must be the last filter\n      lzma2Props = filterProps;\n    } else if (filterId === FILTER_DELTA || (filterId >= FILTER_BCJ_X86 && filterId <= FILTER_BCJ_ARM64)) {\n      // Preprocessing filter - store for later application\n      filters.push({ id: filterId, props: filterProps });\n    } else {\n      throw new Error(`Unsupported filter: 0x${filterId.toString(16)}`);\n    }\n  }\n\n  if (!lzma2Props) {\n    throw new Error('No LZMA2 filter found in XZ block');\n  }\n\n  // Skip to end of block header (must be aligned to 4 bytes)\n  const blockDataStart = blockHeaderStart + blockHeaderSize;\n\n  return {\n    filters,\n    lzma2Props,\n    headerSize: blockHeaderSize,\n    dataStart: blockDataStart,\n    dataEnd: input.length,\n    nextOffset: blockDataStart,\n  };\n}\n\n/**\n * Parse XZ Index to get block positions\n *\n * XZ Index stores \"Unpadded Size\" for each block which equals:\n * Block Header Size + Compressed Data Size + Check Size\n * (does NOT include padding to 4-byte boundary)\n */\nfunction parseIndex(\n  input: Buffer,\n  indexStart: number,\n  checkSize: number\n): Array<{\n  compressedPos: number;\n  compressedDataSize: number;\n  uncompressedSize: number;\n}> {\n  let offset = indexStart;\n\n  // Index indicator (0x00)\n  if (input[offset] !== 0x00) {\n    throw new Error('Invalid index indicator');\n  }\n  offset++;\n\n  // Number of records\n  const countResult = decodeMultibyte(input, offset);\n  const recordCount = countResult.value;\n  offset += countResult.bytesRead;\n\n  const records: Array<{\n    compressedPos: number;\n    unpaddedSize: number;\n    compressedDataSize: number;\n    uncompressedSize: number;\n  }> = [];\n\n  // Parse each record\n  for (let i = 0; i < recordCount; i++) {\n    // Unpadded Size (header + compressed data + check)\n    const unpaddedResult = decodeMultibyte(input, offset);\n    offset += unpaddedResult.bytesRead;\n\n    // Uncompressed size\n    const uncompressedResult = decodeMultibyte(input, offset);\n    offset += uncompressedResult.bytesRead;\n\n    records.push({\n      compressedPos: 0, // will be calculated\n      unpaddedSize: unpaddedResult.value,\n      compressedDataSize: 0, // will be calculated\n      uncompressedSize: uncompressedResult.value,\n    });\n  }\n\n  // Calculate actual positions by walking through blocks\n  let currentPos = 12; // After stream header\n  for (let i = 0; i < records.length; i++) {\n    const record = records[i];\n    // Record where this block's header starts\n    record.compressedPos = currentPos;\n\n    // Get block header size from the actual data\n    const headerSizeRaw = input[currentPos];\n    const headerSize = (headerSizeRaw + 1) * 4;\n\n    // Calculate compressed data size from unpadded size\n    // unpaddedSize = headerSize + compressedDataSize + checkSize\n    record.compressedDataSize = record.unpaddedSize - headerSize - checkSize;\n\n    // Move to next block: unpaddedSize + padding to 4-byte boundary\n    const paddedSize = Math.ceil(record.unpaddedSize / 4) * 4;\n    currentPos += paddedSize;\n  }\n\n  return records;\n}\n\n/**\n * Decompress XZ data synchronously\n * Properly handles multi-block XZ files and stream padding\n * @param input - XZ compressed data\n * @returns Decompressed data\n */\nexport function decodeXZ(input: Buffer): Buffer {\n  // Verify XZ magic\n  if (input.length < 12 || !bufferEquals(input, 0, XZ_MAGIC)) {\n    throw new Error('Invalid XZ magic bytes');\n  }\n\n  // Stream flags at offset 6-7\n  const checkType = input[7] & 0x0f;\n\n  // Check sizes based on check type\n  const checkSizes: { [key: number]: number } = {\n    0: 0, // None\n    1: 4, // CRC32\n    4: 8, // CRC64\n    10: 32, // SHA-256\n  };\n  const checkSize = checkSizes[checkType] ?? 0;\n\n  // Find footer by skipping stream padding (null bytes at end before footer)\n  // Stream padding must be multiple of 4 bytes\n  let footerEnd = input.length;\n  while (footerEnd > 12 && input[footerEnd - 1] === 0x00) {\n    footerEnd--;\n  }\n  // Align to 4-byte boundary (stream padding rules)\n  while (footerEnd % 4 !== 0 && footerEnd > 12) {\n    footerEnd++;\n  }\n\n  // Verify footer magic (at footerEnd - 2)\n  if (!bufferEquals(input, footerEnd - 2, XZ_FOOTER_MAGIC)) {\n    throw new Error('Invalid XZ footer magic');\n  }\n\n  // Get backward size (tells us where index starts) - at footerEnd - 8\n  const backwardSize = (input.readUInt32LE(footerEnd - 8) + 1) * 4;\n  const indexStart = footerEnd - 12 - backwardSize;\n\n  // Parse Index to get block information\n  const blockRecords = parseIndex(input, indexStart, checkSize);\n\n  // Decompress each block\n  const outputChunks: Buffer[] = [];\n  let _totalOutputSize = 0;\n\n  for (let i = 0; i < blockRecords.length; i++) {\n    const record = blockRecords[i];\n    const recordStart = record.compressedPos;\n\n    // Parse block header\n    const blockInfo = parseBlockHeader(input, recordStart, checkSize);\n\n    // Extract compressed data for this block\n    const dataStart = recordStart + blockInfo.headerSize;\n    // compressedDataSize is calculated from the Index's Unpadded Size minus header and check\n    const dataEnd = dataStart + record.compressedDataSize;\n\n    // Note: XZ blocks have padding AFTER the check field to align to 4 bytes,\n    // but the compressedSize from index is exact - no need to strip padding.\n    // LZMA2 data includes a 0x00 end marker which must NOT be stripped.\n    const compressedData = input.slice(dataStart, dataEnd);\n\n    // Decompress this block with LZMA2\n    const blockChunks: Buffer[] = [];\n    decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize, {\n      write: (chunk: Buffer) => {\n        blockChunks.push(chunk);\n      },\n    });\n\n    // Concatenate LZMA2 output\n    let blockOutput = Buffer.concat(blockChunks) as Buffer;\n\n    // Apply preprocessing filters in reverse order (BCJ/Delta applied after LZMA2)\n    // Filters are stored in order they were applied during compression,\n    // so we need to reverse for decompression\n    for (let j = blockInfo.filters.length - 1; j >= 0; j--) {\n      blockOutput = applyFilter(blockOutput, blockInfo.filters[j]) as Buffer;\n    }\n\n    outputChunks.push(blockOutput);\n    _totalOutputSize += blockOutput.length;\n  }\n\n  return Buffer.concat(outputChunks);\n}\n\n/**\n * Create an XZ decompression Transform stream\n * @returns Transform stream that decompresses XZ data\n */\nexport function createXZDecoder(): TransformType {\n  const chunks: Buffer[] = [];\n\n  return new Transform({\n    transform(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void) {\n      chunks.push(chunk);\n      callback();\n    },\n\n    flush(callback: (error?: Error | null) => void) {\n      try {\n        const input = Buffer.concat(chunks);\n        const output = decodeXZ(input);\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createXZDecoder","decodeXZ","XZ_MAGIC","XZ_FOOTER_MAGIC","FILTER_DELTA","FILTER_BCJ_X86","FILTER_BCJ_PPC","FILTER_BCJ_IA64","FILTER_BCJ_ARM","FILTER_BCJ_ARMT","FILTER_BCJ_SPARC","FILTER_BCJ_ARM64","FILTER_LZMA2","bufferEquals","buf","offset","expected","length","i","decodeMultibyte","value","byte","Error","bytesRead","applyFilter","data","filter","id","decodeBcj","props","decodeBcjArm","decodeBcjArm64","decodeBcjArmt","decodeBcjPpc","decodeBcjSparc","decodeBcjIa64","decodeDelta","toString","parseBlockHeader","input","_checkSize","blockHeaderSizeRaw","blockHeaderSize","blockHeaderStart","blockFlags","numFilters","hasCompressedSize","hasUncompressedSize","result","filters","lzma2Props","filterIdResult","filterId","propsSizeResult","filterProps","slice","push","blockDataStart","headerSize","dataStart","dataEnd","nextOffset","parseIndex","indexStart","checkSize","countResult","recordCount","records","unpaddedResult","uncompressedResult","compressedPos","unpaddedSize","compressedDataSize","uncompressedSize","currentPos","record","headerSizeRaw","paddedSize","Math","ceil","blockRecords","recordStart","blockInfo","compressedData","blockChunks","decodeLzma2","write","chunk","blockOutput","Buffer","concat","j","outputChunks","_totalOutputSize","checkSizes","checkType","footerEnd","backwardSize","readUInt32LE","chunks","Transform","transform","_encoding","callback","flush","output","err"],"mappings":"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"}

package/dist/esm/compat.d.ts

@@ -0,0 +1 @@
+export declare function tmpdir(): string;

package/dist/esm/compat.js

@@ -0,0 +1,7 @@
+/**
+ * Compatibility Layer for Node.js 0.8+
+ * Local to this package - contains only needed functions.
+ */ import os from 'os';
+export function tmpdir() {
+    return typeof os.tmpdir === 'function' ? os.tmpdir() : require('os-shim').tmpdir();
+}

package/dist/esm/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/compat.ts"],"sourcesContent":["/**\n * Compatibility Layer for Node.js 0.8+\n * Local to this package - contains only needed functions.\n */\nimport os from 'os';\n\nexport function tmpdir(): string {\n  return typeof os.tmpdir === 'function' ? os.tmpdir() : require('os-shim').tmpdir();\n}\n"],"names":["os","tmpdir","require"],"mappings":"AAAA;;;CAGC,GACD,OAAOA,QAAQ,KAAK;AAEpB,OAAO,SAASC;IACd,OAAO,OAAOD,GAAGC,MAAM,KAAK,aAAaD,GAAGC,MAAM,KAAKC,QAAQ,WAAWD,MAAM;AAClF"}

package/dist/esm/filters/bcj/Bcj.d.ts

@@ -0,0 +1,16 @@
+import { Transform } from 'extract-base-iterator';
+/**
+ * Decode BCJ (x86) filtered data (synchronous, for buffered use)
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * @param input - BCJ filtered data
+ * @param _properties - Unused for BCJ
+ * @param _unpackSize - Unused for BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a streaming BCJ decoder Transform.
+ * Processes data chunk by chunk, buffering incomplete instructions.
+ */
+export declare function createBcjDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

package/dist/esm/filters/bcj/Bcj.js

@@ -0,0 +1,184 @@
+// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses
+// This is a simple filter that makes executables more compressible by LZMA
+//
+// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions
+// to absolute addresses, which creates more repetitive patterns for compression.
+//
+// Reference: https://github.com/tukaani-project/xz/blob/master/src/liblzma/simple/x86.c
+//
+// This implementation uses true streaming - processes data chunk by chunk
+// while buffering incomplete instructions across chunk boundaries.
+import { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';
+// Test if byte is 0x00 or 0xFF (valid MSB for converted addresses)
+function Test86MSByte(b) {
+    return b === 0 || b === 0xff;
+}
+// Lookup table for mask to bit number conversion (used in false positive prevention)
+const MASK_TO_BIT_NUMBER = [
+    0,
+    1,
+    2,
+    2,
+    3
+];
+/**
+ * Core x86 BCJ conversion function (matches reference x86_code)
+ * Works for both encoding and decoding based on isEncoder flag
+ *
+ * @param state - Filter state (prevMask and prevPos)
+ * @param nowPos - Current position in the overall stream
+ * @param isEncoder - true for encoding, false for decoding
+ * @param buffer - Buffer to process (modified in place)
+ * @param size - Size of buffer
+ * @returns Number of bytes processed
+ */ function x86Code(state, nowPos, isEncoder, buffer, size) {
+    let prevMask = state.prevMask;
+    let prevPos = state.prevPos;
+    if (size < 5) {
+        return 0;
+    }
+    // Decay prev_pos if too far from current position
+    if (nowPos - prevPos > 5) {
+        prevPos = nowPos - 5;
+    }
+    const limit = size - 5;
+    let bufferPos = 0;
+    while(bufferPos <= limit){
+        const opcode = buffer[bufferPos];
+        // Check for CALL (0xE8) or JMP (0xE9) opcode
+        if (opcode !== 0xe8 && opcode !== 0xe9) {
+            bufferPos++;
+            continue;
+        }
+        // Calculate offset from previous position
+        const offset = nowPos + bufferPos - prevPos;
+        prevPos = nowPos + bufferPos;
+        // Update mask based on offset
+        if (offset > 5) {
+            prevMask = 0;
+        } else {
+            for(let i = 0; i < offset; i++){
+                prevMask &= 0x77;
+                prevMask <<= 1;
+            }
+        }
+        // Get the high byte of the address
+        let b = buffer[bufferPos + 4];
+        // Check if this looks like a valid address to convert
+        if (Test86MSByte(b) && prevMask >> 1 <= 4 && prevMask >> 1 !== 3) {
+            // Read 32-bit address (big-endian style: high byte first in src)
+            let src = b << 24 | buffer[bufferPos + 3] << 16 | buffer[bufferPos + 2] << 8 | buffer[bufferPos + 1];
+            // Make src unsigned 32-bit
+            src = src >>> 0;
+            let dest;
+            // Conversion loop with false positive correction
+            while(true){
+                if (isEncoder) {
+                    dest = src + (nowPos + bufferPos + 5) >>> 0;
+                } else {
+                    dest = src - (nowPos + bufferPos + 5) >>> 0;
+                }
+                if (prevMask === 0) {
+                    break;
+                }
+                const i = MASK_TO_BIT_NUMBER[prevMask >> 1];
+                b = dest >>> 24 - i * 8 & 0xff;
+                if (!Test86MSByte(b)) {
+                    break;
+                }
+                // XOR correction for false positive prevention
+                src = (dest ^ (1 << 32 - i * 8) - 1) >>> 0;
+            }
+            // Write back the converted address
+            // High byte: ~(((dest >> 24) & 1) - 1) produces 0x00 or 0xFF
+            buffer[bufferPos + 4] = ~((dest >>> 24 & 1) - 1) & 0xff;
+            buffer[bufferPos + 3] = dest >>> 16 & 0xff;
+            buffer[bufferPos + 2] = dest >>> 8 & 0xff;
+            buffer[bufferPos + 1] = dest & 0xff;
+            bufferPos += 5;
+            prevMask = 0;
+        } else {
+            bufferPos++;
+            prevMask |= 1;
+            if (Test86MSByte(b)) {
+                prevMask |= 0x10;
+            }
+        }
+    }
+    // Save state
+    state.prevMask = prevMask;
+    state.prevPos = prevPos;
+    return bufferPos;
+}
+/**
+ * Decode BCJ (x86) filtered data (synchronous, for buffered use)
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * @param input - BCJ filtered data
+ * @param _properties - Unused for BCJ
+ * @param _unpackSize - Unused for BCJ
+ * @returns Unfiltered data
+ */ export function decodeBcj(input, _properties, _unpackSize) {
+    const output = bufferFrom(input); // Copy since we modify in place
+    const state = {
+        prevMask: 0,
+        prevPos: 0xfffffffb
+    };
+    x86Code(state, 0, false, output, output.length);
+    return output;
+}
+/**
+ * Create a streaming BCJ decoder Transform.
+ * Processes data chunk by chunk, buffering incomplete instructions.
+ */ export function createBcjDecoder(_properties, _unpackSize) {
+    // State that persists across chunks
+    const state = {
+        prevMask: 0,
+        prevPos: 0xfffffffb
+    };
+    let globalPos = 0; // Position in the overall stream
+    let pending = null; // Bytes pending from previous chunk
+    const transform = new Transform({
+        transform: (chunk, _encoding, callback)=>{
+            // Combine pending bytes with new chunk
+            let data;
+            if (pending && pending.length > 0) {
+                data = Buffer.concat([
+                    pending,
+                    chunk
+                ]);
+            } else {
+                data = chunk;
+            }
+            // We need at least 5 bytes to process an instruction
+            if (data.length < 5) {
+                pending = data;
+                callback(null, allocBuffer(0));
+                return;
+            }
+            // Process the buffer
+            const output = bufferFrom(data);
+            const processed = x86Code(state, globalPos, false, output, output.length);
+            if (processed === 0) {
+                // Not enough data to process
+                pending = data;
+                callback(null, allocBuffer(0));
+                return;
+            }
+            // Output processed bytes, keep unprocessed as pending
+            const result = output.slice(0, processed);
+            pending = output.slice(processed);
+            globalPos += processed;
+            callback(null, result);
+        },
+        flush: function(callback) {
+            // Output any remaining pending bytes
+            if (pending && pending.length > 0) {
+                // Process final bytes - can't convert incomplete instructions
+                this.push(pending);
+            }
+            callback(null);
+        }
+    });
+    return transform;
+}

package/dist/esm/filters/bcj/Bcj.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/Bcj.ts"],"sourcesContent":["// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses\n// This is a simple filter that makes executables more compressible by LZMA\n//\n// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions\n// to absolute addresses, which creates more repetitive patterns for compression.\n//\n// Reference: https://github.com/tukaani-project/xz/blob/master/src/liblzma/simple/x86.c\n//\n// This implementation uses true streaming - processes data chunk by chunk\n// while buffering incomplete instructions across chunk boundaries.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n// Test if byte is 0x00 or 0xFF (valid MSB for converted addresses)\nfunction Test86MSByte(b: number): boolean {\n  return b === 0 || b === 0xff;\n}\n\n// Lookup table for mask to bit number conversion (used in false positive prevention)\nconst MASK_TO_BIT_NUMBER = [0, 1, 2, 2, 3];\n\n/**\n * BCJ x86 filter state\n */\ninterface BcjX86State {\n  prevMask: number;\n  prevPos: number;\n}\n\n/**\n * Core x86 BCJ conversion function (matches reference x86_code)\n * Works for both encoding and decoding based on isEncoder flag\n *\n * @param state - Filter state (prevMask and prevPos)\n * @param nowPos - Current position in the overall stream\n * @param isEncoder - true for encoding, false for decoding\n * @param buffer - Buffer to process (modified in place)\n * @param size - Size of buffer\n * @returns Number of bytes processed\n */\nfunction x86Code(state: BcjX86State, nowPos: number, isEncoder: boolean, buffer: Buffer, size: number): number {\n  let prevMask = state.prevMask;\n  let prevPos = state.prevPos;\n\n  if (size < 5) {\n    return 0;\n  }\n\n  // Decay prev_pos if too far from current position\n  if (nowPos - prevPos > 5) {\n    prevPos = nowPos - 5;\n  }\n\n  const limit = size - 5;\n  let bufferPos = 0;\n\n  while (bufferPos <= limit) {\n    const opcode = buffer[bufferPos];\n\n    // Check for CALL (0xE8) or JMP (0xE9) opcode\n    if (opcode !== 0xe8 && opcode !== 0xe9) {\n      bufferPos++;\n      continue;\n    }\n\n    // Calculate offset from previous position\n    const offset = nowPos + bufferPos - prevPos;\n    prevPos = nowPos + bufferPos;\n\n    // Update mask based on offset\n    if (offset > 5) {\n      prevMask = 0;\n    } else {\n      for (let i = 0; i < offset; i++) {\n        prevMask &= 0x77;\n        prevMask <<= 1;\n      }\n    }\n\n    // Get the high byte of the address\n    let b = buffer[bufferPos + 4];\n\n    // Check if this looks like a valid address to convert\n    if (Test86MSByte(b) && prevMask >> 1 <= 4 && prevMask >> 1 !== 3) {\n      // Read 32-bit address (big-endian style: high byte first in src)\n      let src = (b << 24) | (buffer[bufferPos + 3] << 16) | (buffer[bufferPos + 2] << 8) | buffer[bufferPos + 1];\n\n      // Make src unsigned 32-bit\n      src = src >>> 0;\n\n      let dest: number;\n\n      // Conversion loop with false positive correction\n      while (true) {\n        if (isEncoder) {\n          dest = (src + (nowPos + bufferPos + 5)) >>> 0;\n        } else {\n          dest = (src - (nowPos + bufferPos + 5)) >>> 0;\n        }\n\n        if (prevMask === 0) {\n          break;\n        }\n\n        const i = MASK_TO_BIT_NUMBER[prevMask >> 1];\n        b = (dest >>> (24 - i * 8)) & 0xff;\n\n        if (!Test86MSByte(b)) {\n          break;\n        }\n\n        // XOR correction for false positive prevention\n        src = (dest ^ ((1 << (32 - i * 8)) - 1)) >>> 0;\n      }\n\n      // Write back the converted address\n      // High byte: ~(((dest >> 24) & 1) - 1) produces 0x00 or 0xFF\n      buffer[bufferPos + 4] = ~(((dest >>> 24) & 1) - 1) & 0xff;\n      buffer[bufferPos + 3] = (dest >>> 16) & 0xff;\n      buffer[bufferPos + 2] = (dest >>> 8) & 0xff;\n      buffer[bufferPos + 1] = dest & 0xff;\n\n      bufferPos += 5;\n      prevMask = 0;\n    } else {\n      bufferPos++;\n      prevMask |= 1;\n      if (Test86MSByte(b)) {\n        prevMask |= 0x10;\n      }\n    }\n  }\n\n  // Save state\n  state.prevMask = prevMask;\n  state.prevPos = prevPos;\n\n  return bufferPos;\n}\n\n/**\n * Decode BCJ (x86) filtered data (synchronous, for buffered use)\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - BCJ filtered data\n * @param _properties - Unused for BCJ\n * @param _unpackSize - Unused for BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  const state: BcjX86State = {\n    prevMask: 0,\n    prevPos: 0xfffffffb, // (uint32_t)(-5) in C\n  };\n\n  x86Code(state, 0, false, output, output.length);\n\n  return output;\n}\n\n/**\n * Create a streaming BCJ decoder Transform.\n * Processes data chunk by chunk, buffering incomplete instructions.\n */\nexport function createBcjDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // State that persists across chunks\n  const state: BcjX86State = {\n    prevMask: 0,\n    prevPos: 0xfffffffb, // (uint32_t)(-5) in C\n  };\n  let globalPos = 0; // Position in the overall stream\n  let pending: Buffer | null = null; // Bytes pending from previous chunk\n\n  const transform = new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      // Combine pending bytes with new chunk\n      let data: Buffer;\n      if (pending && pending.length > 0) {\n        data = Buffer.concat([pending, chunk]);\n      } else {\n        data = chunk;\n      }\n\n      // We need at least 5 bytes to process an instruction\n      if (data.length < 5) {\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      // Process the buffer\n      const output = bufferFrom(data);\n      const processed = x86Code(state, globalPos, false, output, output.length);\n\n      if (processed === 0) {\n        // Not enough data to process\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      // Output processed bytes, keep unprocessed as pending\n      const result = output.slice(0, processed);\n      pending = output.slice(processed);\n      globalPos += processed;\n\n      callback(null, result);\n    },\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      // Output any remaining pending bytes\n      if (pending && pending.length > 0) {\n        // Process final bytes - can't convert incomplete instructions\n        this.push(pending);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["allocBuffer","bufferFrom","Transform","Test86MSByte","b","MASK_TO_BIT_NUMBER","x86Code","state","nowPos","isEncoder","buffer","size","prevMask","prevPos","limit","bufferPos","opcode","offset","i","src","dest","decodeBcj","input","_properties","_unpackSize","output","length","createBcjDecoder","globalPos","pending","transform","chunk","_encoding","callback","data","Buffer","concat","processed","result","slice","flush","push"],"mappings":"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"}

package/dist/esm/filters/bcj/BcjArm.d.ts

@@ -0,0 +1,16 @@
+import { Transform } from 'extract-base-iterator';
+/**
+ * Decode ARM BCJ filtered data (synchronous, for buffered use)
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * @param input - ARM BCJ filtered data
+ * @param _properties - Unused for ARM BCJ
+ * @param _unpackSize - Unused for ARM BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a streaming ARM BCJ decoder Transform.
+ * Processes data in 4-byte aligned chunks.
+ */
+export declare function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;