xz-compat 0.1.0

package/dist/esm/xz/Decoder.js

@@ -0,0 +1,313 @@
+/**
+ * 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 { Transform } from 'extract-base-iterator';
+import { decodeBcj } from '../filters/bcj/Bcj.js';
+import { decodeBcjArm } from '../filters/bcj/BcjArm.js';
+import { decodeBcjArm64 } from '../filters/bcj/BcjArm64.js';
+import { decodeBcjArmt } from '../filters/bcj/BcjArmt.js';
+import { decodeBcjIa64 } from '../filters/bcj/BcjIa64.js';
+import { decodeBcjPpc } from '../filters/bcj/BcjPpc.js';
+import { decodeBcjSparc } from '../filters/bcj/BcjSparc.js';
+import { decodeDelta } from '../filters/delta/Delta.js';
+import { decodeLzma2 } from '../lzma/index.js';
+// XZ magic bytes
+const XZ_MAGIC = [
+    0xfd,
+    0x37,
+    0x7a,
+    0x58,
+    0x5a,
+    0x00
+];
+const XZ_FOOTER_MAGIC = [
+    0x59,
+    0x5a
+]; // "YZ"
+// Filter IDs (from XZ specification)
+const FILTER_DELTA = 0x03;
+const FILTER_BCJ_X86 = 0x04;
+const FILTER_BCJ_PPC = 0x05;
+const FILTER_BCJ_IA64 = 0x06;
+const FILTER_BCJ_ARM = 0x07;
+const FILTER_BCJ_ARMT = 0x08;
+const FILTER_BCJ_SPARC = 0x09;
+const FILTER_BCJ_ARM64 = 0x0a;
+const FILTER_LZMA2 = 0x21;
+/**
+ * Simple buffer comparison
+ */ function bufferEquals(buf, offset, expected) {
+    if (offset + expected.length > buf.length) {
+        return false;
+    }
+    for(let 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) {
+    let value = 0;
+    let i = 0;
+    let 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,
+        bytesRead: i
+    };
+}
+/**
+ * Apply a preprocessing filter (BCJ/Delta) to decompressed data
+ */ function applyFilter(data, filter) {
+    switch(filter.id){
+        case FILTER_BCJ_X86:
+            return decodeBcj(data, filter.props);
+        case FILTER_BCJ_ARM:
+            return decodeBcjArm(data, filter.props);
+        case FILTER_BCJ_ARM64:
+            return decodeBcjArm64(data, filter.props);
+        case FILTER_BCJ_ARMT:
+            return decodeBcjArmt(data, filter.props);
+        case FILTER_BCJ_PPC:
+            return decodeBcjPpc(data, filter.props);
+        case FILTER_BCJ_SPARC:
+            return decodeBcjSparc(data, filter.props);
+        case FILTER_BCJ_IA64:
+            return decodeBcjIa64(data, filter.props);
+        case FILTER_DELTA:
+            return decodeDelta(data, filter.props);
+        default:
+            throw new Error(`Unsupported filter: 0x${filter.id.toString(16)}`);
+    }
+}
+/**
+ * Parse XZ Block Header to extract filters and LZMA2 properties
+ */ function parseBlockHeader(input, offset, _checkSize) {
+    // Block header size
+    const blockHeaderSizeRaw = input[offset];
+    if (blockHeaderSizeRaw === 0) {
+        throw new Error('Invalid block header size (index indicator found instead of block)');
+    }
+    const blockHeaderSize = (blockHeaderSizeRaw + 1) * 4;
+    // Parse block header
+    const blockHeaderStart = offset;
+    offset++; // skip size byte
+    const blockFlags = input[offset++];
+    const numFilters = (blockFlags & 0x03) + 1;
+    const hasCompressedSize = (blockFlags & 0x40) !== 0;
+    const hasUncompressedSize = (blockFlags & 0x80) !== 0;
+    // Skip optional sizes
+    if (hasCompressedSize) {
+        const result = decodeMultibyte(input, offset);
+        offset += result.bytesRead;
+    }
+    if (hasUncompressedSize) {
+        const result = decodeMultibyte(input, offset);
+        offset += result.bytesRead;
+    }
+    // Parse all filters
+    const filters = [];
+    let lzma2Props = null;
+    for(let i = 0; i < numFilters; i++){
+        const filterIdResult = decodeMultibyte(input, offset);
+        const filterId = filterIdResult.value;
+        offset += filterIdResult.bytesRead;
+        const propsSizeResult = decodeMultibyte(input, offset);
+        offset += propsSizeResult.bytesRead;
+        const 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${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)
+    const blockDataStart = blockHeaderStart + blockHeaderSize;
+    return {
+        filters,
+        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) {
+    let offset = indexStart;
+    // Index indicator (0x00)
+    if (input[offset] !== 0x00) {
+        throw new Error('Invalid index indicator');
+    }
+    offset++;
+    // Number of records
+    const countResult = decodeMultibyte(input, offset);
+    const recordCount = countResult.value;
+    offset += countResult.bytesRead;
+    const records = [];
+    // Parse each record
+    for(let i = 0; i < recordCount; i++){
+        // Unpadded Size (header + compressed data + check)
+        const unpaddedResult = decodeMultibyte(input, offset);
+        offset += unpaddedResult.bytesRead;
+        // Uncompressed size
+        const 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
+    let currentPos = 12; // After stream header
+    for(let i = 0; i < records.length; i++){
+        const record = records[i];
+        // Record where this block's header starts
+        record.compressedPos = currentPos;
+        // Get block header size from the actual data
+        const headerSizeRaw = input[currentPos];
+        const 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
+        const paddedSize = Math.ceil(record.unpaddedSize / 4) * 4;
+        currentPos += paddedSize;
+    }
+    return records;
+}
+/**
+ * Decompress XZ data synchronously
+ * Properly handles multi-block XZ files and stream padding
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */ export function decodeXZ(input) {
+    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
+    const checkType = input[7] & 0x0f;
+    // Check sizes based on check type
+    const checkSizes = {
+        0: 0,
+        1: 4,
+        4: 8,
+        10: 32
+    };
+    const 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
+    let 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
+    const backwardSize = (input.readUInt32LE(footerEnd - 8) + 1) * 4;
+    const indexStart = footerEnd - 12 - backwardSize;
+    // Parse Index to get block information
+    const blockRecords = parseIndex(input, indexStart, checkSize);
+    // Decompress each block
+    const outputChunks = [];
+    let _totalOutputSize = 0;
+    for(let i = 0; i < blockRecords.length; i++){
+        const record = blockRecords[i];
+        const recordStart = record.compressedPos;
+        // Parse block header
+        const blockInfo = parseBlockHeader(input, recordStart, checkSize);
+        // Extract compressed data for this block
+        const dataStart = recordStart + blockInfo.headerSize;
+        // compressedDataSize is calculated from the Index's Unpadded Size minus header and check
+        const 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.
+        const compressedData = input.slice(dataStart, dataEnd);
+        // Decompress this block with LZMA2
+        const blockChunks = [];
+        decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize, {
+            write: (chunk)=>{
+                blockChunks.push(chunk);
+            }
+        });
+        // Concatenate LZMA2 output
+        let 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(let j = blockInfo.filters.length - 1; j >= 0; j--){
+            blockOutput = applyFilter(blockOutput, blockInfo.filters[j]);
+        }
+        outputChunks.push(blockOutput);
+        _totalOutputSize += blockOutput.length;
+    }
+    return Buffer.concat(outputChunks);
+}
+/**
+ * Create an XZ decompression Transform stream
+ * @returns Transform stream that decompresses XZ data
+ */ export function createXZDecoder() {
+    const chunks = [];
+    return new Transform({
+        transform (chunk, _encoding, callback) {
+            chunks.push(chunk);
+            callback();
+        },
+        flush (callback) {
+            try {
+                const input = Buffer.concat(chunks);
+                const output = decodeXZ(input);
+                this.push(output);
+                callback();
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}

package/dist/esm/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":["Transform","decodeBcj","decodeBcjArm","decodeBcjArm64","decodeBcjArmt","decodeBcjIa64","decodeBcjPpc","decodeBcjSparc","decodeDelta","decodeLzma2","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","props","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","decodeXZ","checkSizes","checkType","footerEnd","backwardSize","readUInt32LE","blockRecords","outputChunks","_totalOutputSize","recordStart","blockInfo","compressedData","blockChunks","write","chunk","blockOutput","Buffer","concat","j","createXZDecoder","chunks","transform","_encoding","callback","flush","output","err"],"mappings":"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"}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "xz-compat",
+  "version": "0.1.0",
+  "description": "XZ Decompression Library",
+  "keywords": [
+    "extract",
+    "iterator",
+    "asyncIterator",
+    "Symbol.asyncIterator",
+    "7z",
+    "7zip",
+    "seven-zip",
+    "decompress",
+    "lzma",
+    "lzma2",
+    "archive",
+    "stream"
+  ],
+  "homepage": "https://github.com/kmalakoff/xz-compat",
+  "bugs": {
+    "url": "https://github.com/kmalakoff/xz-compat/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/kmalakoff/xz-compat.git"
+  },
+  "license": "MIT",
+  "author": "Kevin Malakoff <kmalakoff@gmail.com> (https://github.com/kmalakoff)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/cjs/index.js",
+  "source": "src/index.ts",
+  "types": "dist/cjs/index.d.ts",
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsds build",
+    "format": "tsds format",
+    "prepublishOnly": "tsds validate",
+    "test": "tsds test:node --no-timeouts",
+    "test:engines": "nvu engines tsds test:node --no-timeouts",
+    "version": "tsds version"
+  },
+  "dependencies": {
+    "extract-base-iterator": "^3.0.0",
+    "os-shim": "^0.1.3"
+  },
+  "devDependencies": {
+    "@types/mocha": "*",
+    "@types/node": "*",
+    "fs-iterator": "^7.0.0",
+    "fs-remove-compat": "^1.0.1",
+    "fs-stats-spys": "^1.0.0",
+    "get-file-compat": "^2.0.0",
+    "mkdirp-classic": "^0.5.3",
+    "node-version-use": "*",
+    "tar-iterator": "^3.3.1",
+    "ts-dev-stack": "*",
+    "tsds-config": "*"
+  },
+  "engines": {
+    "node": ">=0.8"
+  }
+}