xz-compat 1.1.1 → 1.1.3

package/dist/cjs/xz/Decoder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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 * IMPORTANT: Buffer Management Pattern\n *\n * When calling decodeLzma2(), use the direct return pattern:\n *\n * ✅ CORRECT - Fast path:\n *   const output = decodeLzma2(data, props, size) as Buffer;\n *\n * ❌ WRONG - Slow path (do NOT buffer):\n *   const chunks: Buffer[] = [];\n *   decodeLzma2(data, props, size, { write: c => chunks.push(c) });\n *   return Buffer.concat(chunks);  // ← Unnecessary copies!\n */\n\nimport { type BufferLike, BufferList, 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';\nimport { tryLoadNative } from '../native.ts';\nimport type { DecodeCallback } from '../sevenz.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// Re-export BufferLike for public API\nexport type { BufferLike } from 'extract-base-iterator';\n\n/**\n * Read a byte from Buffer or BufferList\n */\nfunction readByte(buf: BufferLike, offset: number): number {\n  return Buffer.isBuffer(buf) ? buf[offset] : buf.readByte(offset);\n}\n\n/**\n * Read UInt32LE from Buffer or BufferList (returns null if out of bounds)\n */\nfunction readUInt32LE(buf: BufferLike, offset: number): number | null {\n  if (Buffer.isBuffer(buf)) {\n    if (offset < 0 || offset + 4 > buf.length) return null;\n    return buf.readUInt32LE(offset);\n  }\n  return buf.readUInt32LEAt(offset);\n}\n\n/**\n * Compare buffer contents at offset with expected byte sequence\n * Works with both Buffer and BufferList\n */\nfunction bufferEquals(buf: BufferLike, 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 (readByte(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 * Works with both Buffer and BufferList\n */\nfunction decodeMultibyte(buf: BufferLike, 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 = readByte(buf, offset + i);\n    value |= (byte & 0x7f) << (i * 7);\n    i++;\n    if (i > 4) {\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 * Works with both Buffer and BufferList\n */\nfunction parseIndex(\n  input: BufferLike,\n  indexStart: number,\n  checkSize: number\n): Array<{\n  compressedPos: number;\n  compressedDataSize: number;\n  uncompressedSize: number;\n}> {\n  // One-time binding for buffer access (avoids repeated Buffer.isBuffer checks)\n  const getByte = Buffer.isBuffer(input) ? (offset: number) => input[offset] : (offset: number) => input.readByte(offset);\n\n  // Local multibyte decoder using bound getByte\n  const decodeMultibyteLocal = (offset: number): { value: number; bytesRead: number } => {\n    let value = 0;\n    let i = 0;\n    let byte: number;\n    do {\n      if (offset + i >= input.length) {\n        throw new Error('Truncated multibyte integer');\n      }\n      byte = getByte(offset + i);\n      value |= (byte & 0x7f) << (i * 7);\n      i++;\n      if (i > 4) {\n        throw new Error('Multibyte integer too large');\n      }\n    } while (byte & 0x80);\n    return { value, bytesRead: i };\n  };\n\n  let offset = indexStart;\n\n  // Index indicator (0x00)\n  if (getByte(offset) !== 0x00) {\n    throw new Error('Invalid index indicator');\n  }\n  offset++;\n\n  // Number of records\n  const countResult = decodeMultibyteLocal(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 = decodeMultibyteLocal(offset);\n    offset += unpaddedResult.bytesRead;\n\n    // Uncompressed size\n    const uncompressedResult = decodeMultibyteLocal(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 = getByte(currentPos);\n    const headerSize = (headerSizeRaw + 1) * 4;\n\n    // Calculate compressed data size from unpadded size\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 * Pure JS XZ decompression (handles all XZ spec features)\n * Returns BufferList for memory efficiency with large files.\n */\nfunction decodeXZPure(input: Buffer): Buffer | BufferList {\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 = readByte(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 && readByte(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 backwardSizeLE = readUInt32LE(input, footerEnd - 8);\n  if (backwardSizeLE === null) {\n    throw new Error('Invalid backward size');\n  }\n  const backwardSize = (backwardSizeLE + 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  // Calculate total uncompressed size for multi-block decision\n  let totalUncompressedSize = 0;\n  for (let i = 0; i < blockRecords.length; i++) {\n    totalUncompressedSize += blockRecords[i].uncompressedSize;\n  }\n\n  // Small multi-block files: use Buffer.concat directly (avoids BufferList overhead)\n  // Threshold of 64KB: below this, the overhead of linked list nodes isn't worth it\n  const BUFFERLIST_THRESHOLD = 64 * 1024; // 64KB\n\n  // Single block OR small multi-block: return Buffer directly\n  if (blockRecords.length === 1 || totalUncompressedSize < BUFFERLIST_THRESHOLD) {\n    const record = blockRecords[0];\n    const recordStart = record.compressedPos;\n    const blockInfo = parseBlockHeader(input, recordStart, checkSize);\n    const dataStart = recordStart + blockInfo.headerSize;\n    const dataEnd = dataStart + record.compressedDataSize;\n    const compressedData = input.slice(dataStart, dataEnd);\n\n    let blockOutput = decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize) as Buffer;\n\n    for (let j = blockInfo.filters.length - 1; j >= 0; j--) {\n      blockOutput = applyFilter(blockOutput, blockInfo.filters[j]) as Buffer;\n    }\n\n    return blockOutput;\n  }\n\n  // Multi-block (large): use BufferList to avoid large contiguous allocation\n  const output = new BufferList();\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    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 (fast path, no buffering)\n    let blockOutput = decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize) 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    // Append block to BufferList\n    output.append(blockOutput);\n  }\n\n  return output;\n}\n\n/** Callback invoked when an async decode completes */\nexport type XzDecodeCallback = DecodeCallback<BufferLike>;\n\n/**\n * Decompress XZ data. With a callback the result is provided asynchronously;\n * otherwise a Promise resolves with the decoded data.\n *\n * Returns Buffer for single-block files (most small files).\n * Returns BufferList for multi-block files (avoids large contiguous allocation).\n */\nexport function decodeXZ(input: Buffer, callback: XzDecodeCallback): void;\nexport function decodeXZ(input: Buffer): Promise<BufferLike>;\nexport function decodeXZ(input: Buffer, callback?: XzDecodeCallback): Promise<BufferLike> | void {\n  const worker = (cb: XzDecodeCallback) => {\n    const fallback = () => {\n      try {\n        cb(null, decodeXZPure(input));\n      } catch (err) {\n        cb(err as Error);\n      }\n    };\n\n    const native = tryLoadNative();\n    if (native?.xz?.decompress) {\n      try {\n        const promise = native.xz.decompress(input);\n        if (promise && typeof promise.then === 'function') {\n          promise.then((value) => cb(null, value as BufferLike), fallback);\n          return;\n        }\n      } catch {\n        // fall through to fallback\n      }\n    }\n    fallback();\n  };\n\n  if (typeof callback === 'function') return worker(callback);\n  return new Promise((resolve, reject) => worker((err, value) => (err ? reject(err) : resolve(value as BufferLike))));\n}\n\n/**\n * Create an XZ decompression Transform stream\n * @returns Transform stream that decompresses XZ data\n *\n * Uses BufferList to avoid large contiguous buffer allocations.\n * Decompresses and pushes blocks one at a time for streaming output.\n */\nexport function createXZDecoder(): TransformType {\n  const bufferList = new BufferList();\n\n  return new Transform({\n    transform(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void) {\n      bufferList.append(chunk);\n      callback();\n    },\n\n    flush(callback: (error?: Error | null) => void) {\n      const input: BufferLike = bufferList;\n\n      // One-time binding for buffer access (avoids repeated Buffer.isBuffer checks)\n      const getByte = Buffer.isBuffer(input) ? (offset: number) => input[offset] : (offset: number) => input.readByte(offset);\n\n      const getUInt32LE = Buffer.isBuffer(input) ? (offset: number) => (offset < 0 || offset + 4 > input.length ? null : input.readUInt32LE(offset)) : (offset: number) => input.readUInt32LEAt(offset);\n\n      const equals = (offset: number, expected: number[]): boolean => {\n        if (offset + expected.length > input.length) return false;\n        for (let i = 0; i < expected.length; i++) {\n          if (getByte(offset + i) !== expected[i]) return false;\n        }\n        return true;\n      };\n\n      // Verify XZ magic (need at least 12 bytes)\n      if (input.length < 12 || !equals(0, XZ_MAGIC)) {\n        callback(new Error('Invalid XZ magic bytes'));\n        return;\n      }\n\n      // Stream flags at offset 6-7\n      const checkType = getByte(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      let footerEnd = input.length;\n      while (footerEnd > 12 && getByte(footerEnd - 1) === 0x00) {\n        footerEnd--;\n      }\n      // Align to 4-byte boundary\n      while (footerEnd % 4 !== 0 && footerEnd > 12) {\n        footerEnd++;\n      }\n\n      // Verify footer magic (at footerEnd - 2)\n      if (!equals(footerEnd - 2, XZ_FOOTER_MAGIC)) {\n        callback(new Error('Invalid XZ footer magic'));\n        return;\n      }\n\n      // Get backward size (at footerEnd - 8)\n      const backwardSizeLE = getUInt32LE(footerEnd - 8);\n      if (backwardSizeLE === null) {\n        callback(new Error('Invalid backward size'));\n        return;\n      }\n      const backwardSize = (backwardSizeLE + 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 and push each block (streaming, no large allocations)\n      let blockIndex = 0;\n      const pushBlock = (err: Error | null) => {\n        if (err) {\n          callback(err);\n          return;\n        }\n\n        if (blockIndex >= blockRecords.length) {\n          // All blocks processed - purge input BufferList to free memory\n          if (!Buffer.isBuffer(input)) input.clear();\n          callback(null);\n          return;\n        }\n\n        const record = blockRecords[blockIndex++];\n        const recordStart = record.compressedPos;\n\n        // Parse block header (need to get the header bytes)\n        // Read header size byte first\n        const headerSizeRaw = getByte(recordStart);\n        const headerSize = (headerSizeRaw + 1) * 4;\n\n        // Read the full header to parse filters\n        const headerData = input.slice(recordStart, recordStart + headerSize);\n        const blockInfo = parseBlockHeader(headerData, 0, checkSize);\n\n        // Extract compressed data for this block\n        const dataStart = recordStart + headerSize;\n        const dataEnd = dataStart + record.compressedDataSize;\n        const compressedData = input.slice(dataStart, dataEnd);\n\n        // Decompress this block\n        let blockOutput = decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize) as Buffer;\n\n        // Apply preprocessing filters in reverse order\n        for (let j = blockInfo.filters.length - 1; j >= 0; j--) {\n          blockOutput = applyFilter(blockOutput, blockInfo.filters[j]) as Buffer;\n        }\n\n        // Push the block output immediately (streaming)\n        this.push(blockOutput);\n\n        // Continue with next block\n        pushBlock(null);\n      };\n\n      // Start processing blocks\n      pushBlock(null);\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","readByte","buf","offset","Buffer","isBuffer","readUInt32LE","length","readUInt32LEAt","bufferEquals","expected","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","getByte","decodeMultibyteLocal","countResult","recordCount","records","unpaddedResult","uncompressedResult","compressedPos","unpaddedSize","compressedDataSize","uncompressedSize","currentPos","record","headerSizeRaw","paddedSize","Math","ceil","decodeXZPure","checkSizes","checkType","footerEnd","backwardSizeLE","backwardSize","blockRecords","totalUncompressedSize","BUFFERLIST_THRESHOLD","recordStart","blockInfo","compressedData","blockOutput","decodeLzma2","j","output","BufferList","append","callback","worker","cb","native","fallback","err","tryLoadNative","xz","decompress","promise","then","Promise","resolve","reject","bufferList","Transform","transform","chunk","_encoding","flush","getUInt32LE","equals","blockIndex","pushBlock","clear","headerData"],"mappings":"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"}
+{"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 * IMPORTANT: Buffer Management Pattern\n *\n * When calling decodeLzma2(), use the direct return pattern:\n *\n * ✅ CORRECT - Fast path:\n *   const output = decodeLzma2(data, props, size) as Buffer;\n *\n * ❌ WRONG - Slow path (do NOT buffer):\n *   const chunks: Buffer[] = [];\n *   decodeLzma2(data, props, size, { write: c => chunks.push(c) });\n *   return Buffer.concat(chunks);  // ← Unnecessary copies!\n */\n\nimport { allocBuffer, type BufferLike, BufferList, 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';\nimport { tryLoadNative } from '../native.ts';\nimport type { DecodeCallback } from '../sevenz.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// Re-export BufferLike for public API\nexport type { BufferLike } from 'extract-base-iterator';\n\n/**\n * Read a byte from Buffer or BufferList\n */\nfunction readByte(buf: BufferLike, offset: number): number {\n  return Buffer.isBuffer(buf) ? buf[offset] : buf.readByte(offset);\n}\n\n/**\n * Read UInt32LE from Buffer or BufferList (returns null if out of bounds)\n */\nfunction readUInt32LE(buf: BufferLike, offset: number): number | null {\n  if (Buffer.isBuffer(buf)) {\n    if (offset < 0 || offset + 4 > buf.length) return null;\n    return buf.readUInt32LE(offset);\n  }\n  return buf.readUInt32LEAt(offset);\n}\n\n/**\n * Compare buffer contents at offset with expected byte sequence\n * Works with both Buffer and BufferList\n */\nfunction bufferEquals(buf: BufferLike, 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 (readByte(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 * Works with both Buffer and BufferList\n */\nfunction decodeMultibyte(buf: BufferLike, 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 = readByte(buf, offset + i);\n    value |= (byte & 0x7f) << (i * 7);\n    i++;\n    if (i > 4) {\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 * Works with both Buffer and BufferList\n */\nfunction parseIndex(\n  input: BufferLike,\n  indexStart: number,\n  checkSize: number\n): Array<{\n  compressedPos: number;\n  compressedDataSize: number;\n  uncompressedSize: number;\n}> {\n  // One-time binding for buffer access (avoids repeated Buffer.isBuffer checks)\n  const getByte = Buffer.isBuffer(input) ? (offset: number) => input[offset] : (offset: number) => input.readByte(offset);\n\n  // Local multibyte decoder using bound getByte\n  const decodeMultibyteLocal = (offset: number): { value: number; bytesRead: number } => {\n    let value = 0;\n    let i = 0;\n    let byte: number;\n    do {\n      if (offset + i >= input.length) {\n        throw new Error('Truncated multibyte integer');\n      }\n      byte = getByte(offset + i);\n      value |= (byte & 0x7f) << (i * 7);\n      i++;\n      if (i > 4) {\n        throw new Error('Multibyte integer too large');\n      }\n    } while (byte & 0x80);\n    return { value, bytesRead: i };\n  };\n\n  let offset = indexStart;\n\n  // Index indicator (0x00)\n  if (getByte(offset) !== 0x00) {\n    throw new Error('Invalid index indicator');\n  }\n  offset++;\n\n  // Number of records\n  const countResult = decodeMultibyteLocal(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 = decodeMultibyteLocal(offset);\n    offset += unpaddedResult.bytesRead;\n\n    // Uncompressed size\n    const uncompressedResult = decodeMultibyteLocal(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 = getByte(currentPos);\n    const headerSize = (headerSizeRaw + 1) * 4;\n\n    // Calculate compressed data size from unpadded size\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 * Pure JS XZ decompression (handles all XZ spec features)\n * Returns BufferList for memory efficiency with large files.\n */\nfunction decodeXZPure(input: Buffer): Buffer | BufferList {\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 = readByte(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 && readByte(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 backwardSizeLE = readUInt32LE(input, footerEnd - 8);\n  if (backwardSizeLE === null) {\n    throw new Error('Invalid backward size');\n  }\n  const backwardSize = (backwardSizeLE + 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  // Handle empty files (no blocks) - return empty buffer\n  if (blockRecords.length === 0) return allocBuffer(0);\n\n  // Calculate total uncompressed size for multi-block decision\n  let totalUncompressedSize = 0;\n  for (let i = 0; i < blockRecords.length; i++) {\n    totalUncompressedSize += blockRecords[i].uncompressedSize;\n  }\n\n  // Small multi-block files: use Buffer.concat directly (avoids BufferList overhead)\n  // Threshold of 64KB: below this, the overhead of linked list nodes isn't worth it\n  const BUFFERLIST_THRESHOLD = 64 * 1024; // 64KB\n\n  // Single block OR small multi-block: return Buffer directly\n  if (blockRecords.length === 1 || totalUncompressedSize < BUFFERLIST_THRESHOLD) {\n    const record = blockRecords[0];\n    const recordStart = record.compressedPos;\n    const blockInfo = parseBlockHeader(input, recordStart, checkSize);\n    const dataStart = recordStart + blockInfo.headerSize;\n    const dataEnd = dataStart + record.compressedDataSize;\n    const compressedData = input.slice(dataStart, dataEnd);\n\n    let blockOutput = decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize) as Buffer;\n\n    for (let j = blockInfo.filters.length - 1; j >= 0; j--) {\n      blockOutput = applyFilter(blockOutput, blockInfo.filters[j]) as Buffer;\n    }\n\n    return blockOutput;\n  }\n\n  // Multi-block (large): use BufferList to avoid large contiguous allocation\n  const output = new BufferList();\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    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 (fast path, no buffering)\n    let blockOutput = decodeLzma2(compressedData, blockInfo.lzma2Props, record.uncompressedSize) 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    // Append block to BufferList\n    output.append(blockOutput);\n  }\n\n  return output;\n}\n\n/** Callback invoked when an async decode completes */\nexport type XzDecodeCallback = DecodeCallback<BufferLike>;\n\n/**\n * Decompress XZ data. With a callback the result is provided asynchronously;\n * otherwise a Promise resolves with the decoded data.\n *\n * Returns Buffer for single-block files (most small files).\n * Returns BufferList for multi-block files (avoids large contiguous allocation).\n */\nexport function decodeXZ(input: Buffer, callback: XzDecodeCallback): void;\nexport function decodeXZ(input: Buffer): Promise<BufferLike>;\nexport function decodeXZ(input: Buffer, callback?: XzDecodeCallback): Promise<BufferLike> | void {\n  const worker = (cb: XzDecodeCallback) => {\n    const fallback = () => {\n      try {\n        cb(null, decodeXZPure(input));\n      } catch (err) {\n        cb(err as Error);\n      }\n    };\n\n    const native = tryLoadNative();\n    if (native?.xz?.decompress) {\n      try {\n        const promise = native.xz.decompress(input);\n        if (promise && typeof promise.then === 'function') {\n          promise.then((value) => cb(null, value as BufferLike), fallback);\n          return;\n        }\n      } catch {\n        // fall through to fallback\n      }\n    }\n    fallback();\n  };\n\n  if (typeof callback === 'function') return worker(callback);\n  return new Promise((resolve, reject) => worker((err, value) => (err ? reject(err) : resolve(value as BufferLike))));\n}\n\n// Callback-based LZMA2 decoder type (for Node 0.8+ compatibility - no promises)\ntype Lzma2DecodeCallback = (err: Error | null, result?: Buffer) => void;\ntype Lzma2Decoder = (data: Buffer, props: Buffer, size: number, callback: Lzma2DecodeCallback) => void;\n\n/**\n * Create an XZ decompression Transform stream\n * @returns Transform stream that decompresses XZ data\n *\n * Uses native lzma-native bindings when available for better performance.\n * Falls back to pure JS implementation on older Node versions or when native is unavailable.\n */\nexport function createXZDecoder(): TransformType {\n  const bufferList = new BufferList();\n  // Cache native module lookup (only done once)\n  const native = tryLoadNative();\n\n  // Choose decoder: native (async via callback) or pure JS (sync wrapped in callback)\n  const decodeLzma2Block: Lzma2Decoder = native?.lzma2\n    ? (data, props, size, cb) => {\n        native.lzma2?.(data, props, size).then(\n          (result) => cb(null, result),\n          (err) => cb(err)\n        );\n      }\n    : (data, props, size, cb) => {\n        try {\n          cb(null, decodeLzma2(data, props, size) as Buffer);\n        } catch (err) {\n          cb(err as Error);\n        }\n      };\n\n  return new Transform({\n    transform(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void) {\n      bufferList.append(chunk);\n      callback();\n    },\n\n    flush(callback: (error?: Error | null) => void) {\n      const input: BufferLike = bufferList;\n\n      // One-time binding for buffer access (avoids repeated Buffer.isBuffer checks)\n      const getByte = Buffer.isBuffer(input) ? (offset: number) => input[offset] : (offset: number) => input.readByte(offset);\n\n      const getUInt32LE = Buffer.isBuffer(input) ? (offset: number) => (offset < 0 || offset + 4 > input.length ? null : input.readUInt32LE(offset)) : (offset: number) => input.readUInt32LEAt(offset);\n\n      const equals = (offset: number, expected: number[]): boolean => {\n        if (offset + expected.length > input.length) return false;\n        for (let i = 0; i < expected.length; i++) {\n          if (getByte(offset + i) !== expected[i]) return false;\n        }\n        return true;\n      };\n\n      // Verify XZ magic (need at least 12 bytes)\n      if (input.length < 12 || !equals(0, XZ_MAGIC)) {\n        callback(new Error('Invalid XZ magic bytes'));\n        return;\n      }\n\n      // Stream flags at offset 6-7\n      const checkType = getByte(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      let footerEnd = input.length;\n      while (footerEnd > 12 && getByte(footerEnd - 1) === 0x00) {\n        footerEnd--;\n      }\n      // Align to 4-byte boundary\n      while (footerEnd % 4 !== 0 && footerEnd > 12) {\n        footerEnd++;\n      }\n\n      // Verify footer magic (at footerEnd - 2)\n      if (!equals(footerEnd - 2, XZ_FOOTER_MAGIC)) {\n        callback(new Error('Invalid XZ footer magic'));\n        return;\n      }\n\n      // Get backward size (at footerEnd - 8)\n      const backwardSizeLE = getUInt32LE(footerEnd - 8);\n      if (backwardSizeLE === null) {\n        callback(new Error('Invalid backward size'));\n        return;\n      }\n      const backwardSize = (backwardSizeLE + 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 blocks sequentially (native is async)\n      let blockIndex = 0;\n      const pushBlock = (err: Error | null) => {\n        if (err) {\n          callback(err);\n          return;\n        }\n\n        if (blockIndex >= blockRecords.length) {\n          // All blocks processed - purge input BufferList to free memory\n          if (!Buffer.isBuffer(input)) input.clear();\n          callback(null);\n          return;\n        }\n\n        const record = blockRecords[blockIndex++];\n        const recordStart = record.compressedPos;\n\n        // Parse block header (need to get the header bytes)\n        // Read header size byte first\n        const headerSizeRaw = getByte(recordStart);\n        const headerSize = (headerSizeRaw + 1) * 4;\n\n        // Read the full header to parse filters\n        const headerData = input.slice(recordStart, recordStart + headerSize);\n        const blockInfo = parseBlockHeader(headerData, 0, checkSize);\n\n        // Extract compressed data for this block\n        const dataStart = recordStart + headerSize;\n        const dataEnd = dataStart + record.compressedDataSize;\n        const compressedData = input.slice(dataStart, dataEnd);\n\n        // Decompress this block (native or pure JS, callback-based)\n        decodeLzma2Block(compressedData, blockInfo.lzma2Props, record.uncompressedSize, (decodeErr, blockOutput) => {\n          if (decodeErr || !blockOutput) {\n            pushBlock(decodeErr || new Error('Decode returned no data'));\n            return;\n          }\n\n          // Apply preprocessing filters in reverse order\n          for (let j = blockInfo.filters.length - 1; j >= 0; j--) {\n            blockOutput = applyFilter(blockOutput, blockInfo.filters[j]) as Buffer;\n          }\n\n          // Push the block output immediately (streaming)\n          this.push(blockOutput);\n\n          // Continue with next block\n          pushBlock(null);\n        });\n      };\n\n      // Start processing blocks\n      pushBlock(null);\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","readByte","buf","offset","Buffer","isBuffer","readUInt32LE","length","readUInt32LEAt","bufferEquals","expected","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","getByte","decodeMultibyteLocal","countResult","recordCount","records","unpaddedResult","uncompressedResult","compressedPos","unpaddedSize","compressedDataSize","uncompressedSize","currentPos","record","headerSizeRaw","paddedSize","Math","ceil","decodeXZPure","checkSizes","checkType","footerEnd","backwardSizeLE","backwardSize","blockRecords","allocBuffer","totalUncompressedSize","BUFFERLIST_THRESHOLD","recordStart","blockInfo","compressedData","blockOutput","decodeLzma2","j","output","BufferList","append","callback","worker","cb","native","fallback","err","tryLoadNative","xz","decompress","promise","then","Promise","resolve","reject","bufferList","decodeLzma2Block","lzma2","size","Transform","transform","chunk","_encoding","flush","getUInt32LE","equals","blockIndex","pushBlock","clear","headerData","decodeErr"],"mappings":"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"}

package/dist/esm/compat.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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"}
+{"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.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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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"}
+{"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":"AAAA,oEAAoE;AACpE,2EAA2E;AAC3E,EAAE;AACF,mFAAmF;AACnF,iFAAiF;AACjF,EAAE;AACF,wFAAwF;AACxF,EAAE;AACF,0EAA0E;AAC1E,mEAAmE;AAEnE,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E,mEAAmE;AACnE,SAASC,aAAaC,CAAS;IAC7B,OAAOA,MAAM,KAAKA,MAAM;AAC1B;AAEA,qFAAqF;AACrF,MAAMC,qBAAqB;IAAC;IAAG;IAAG;IAAG;IAAG;CAAE;AAU1C;;;;;;;;;;CAUC,GACD,SAASC,QAAQC,KAAkB,EAAEC,MAAc,EAAEC,SAAkB,EAAEC,MAAc,EAAEC,IAAY;IACnG,IAAIC,WAAWL,MAAMK,QAAQ;IAC7B,IAAIC,UAAUN,MAAMM,OAAO;IAE3B,IAAIF,OAAO,GAAG;QACZ,OAAO;IACT;IAEA,kDAAkD;IAClD,IAAIH,SAASK,UAAU,GAAG;QACxBA,UAAUL,SAAS;IACrB;IAEA,MAAMM,QAAQH,OAAO;IACrB,IAAII,YAAY;IAEhB,MAAOA,aAAaD,MAAO;QACzB,MAAME,SAASN,MAAM,CAACK,UAAU;QAEhC,6CAA6C;QAC7C,IAAIC,WAAW,QAAQA,WAAW,MAAM;YACtCD;YACA;QACF;QAEA,0CAA0C;QAC1C,MAAME,SAAST,SAASO,YAAYF;QACpCA,UAAUL,SAASO;QAEnB,8BAA8B;QAC9B,IAAIE,SAAS,GAAG;YACdL,WAAW;QACb,OAAO;YACL,IAAK,IAAIM,IAAI,GAAGA,IAAID,QAAQC,IAAK;gBAC/BN,YAAY;gBACZA,aAAa;YACf;QACF;QAEA,mCAAmC;QACnC,IAAIR,IAAIM,MAAM,CAACK,YAAY,EAAE;QAE7B,sDAAsD;QACtD,IAAIZ,aAAaC,MAAMQ,YAAY,KAAK,KAAKA,YAAY,MAAM,GAAG;YAChE,iEAAiE;YACjE,IAAIO,MAAM,AAACf,KAAK,KAAOM,MAAM,CAACK,YAAY,EAAE,IAAI,KAAOL,MAAM,CAACK,YAAY,EAAE,IAAI,IAAKL,MAAM,CAACK,YAAY,EAAE;YAE1G,2BAA2B;YAC3BI,MAAMA,QAAQ;YAEd,IAAIC;YAEJ,iDAAiD;YACjD,MAAO,KAAM;gBACX,IAAIX,WAAW;oBACbW,OAAO,AAACD,MAAOX,CAAAA,SAASO,YAAY,CAAA,MAAQ;gBAC9C,OAAO;oBACLK,OAAO,AAACD,MAAOX,CAAAA,SAASO,YAAY,CAAA,MAAQ;gBAC9C;gBAEA,IAAIH,aAAa,GAAG;oBAClB;gBACF;gBAEA,MAAMM,IAAIb,kBAAkB,CAACO,YAAY,EAAE;gBAC3CR,IAAI,AAACgB,SAAU,KAAKF,IAAI,IAAM;gBAE9B,IAAI,CAACf,aAAaC,IAAI;oBACpB;gBACF;gBAEA,+CAA+C;gBAC/Ce,MAAM,AAACC,CAAAA,OAAQ,AAAC,CAAA,KAAM,KAAKF,IAAI,CAAC,IAAK,CAAC,MAAO;YAC/C;YAEA,mCAAmC;YACnC,6DAA6D;YAC7DR,MAAM,CAACK,YAAY,EAAE,GAAG,CAAE,CAAA,AAAC,CAAA,AAACK,SAAS,KAAM,CAAA,IAAK,CAAA,IAAK;YACrDV,MAAM,CAACK,YAAY,EAAE,GAAG,AAACK,SAAS,KAAM;YACxCV,MAAM,CAACK,YAAY,EAAE,GAAG,AAACK,SAAS,IAAK;YACvCV,MAAM,CAACK,YAAY,EAAE,GAAGK,OAAO;YAE/BL,aAAa;YACbH,WAAW;QACb,OAAO;YACLG;YACAH,YAAY;YACZ,IAAIT,aAAaC,IAAI;gBACnBQ,YAAY;YACd;QACF;IACF;IAEA,aAAa;IACbL,MAAMK,QAAQ,GAAGA;IACjBL,MAAMM,OAAO,GAAGA;IAEhB,OAAOE;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASM,UAAUC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACjF,MAAMC,SAASxB,WAAWqB,QAAQ,gCAAgC;IAElE,MAAMf,QAAqB;QACzBK,UAAU;QACVC,SAAS;IACX;IAEAP,QAAQC,OAAO,GAAG,OAAOkB,QAAQA,OAAOC,MAAM;IAE9C,OAAOD;AACT;AAEA;;;CAGC,GACD,OAAO,SAASE,iBAAiBJ,WAAoB,EAAEC,WAAoB;IACzE,oCAAoC;IACpC,MAAMjB,QAAqB;QACzBK,UAAU;QACVC,SAAS;IACX;IACA,IAAIe,YAAY,GAAG,iCAAiC;IACpD,IAAIC,UAAyB,MAAM,oCAAoC;IAEvE,MAAMC,YAAY,IAAI5B,UAAU;QAC9B4B,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIL,WAAWA,QAAQH,MAAM,GAAG,GAAG;gBACjCQ,OAAOC,OAAOC,MAAM,CAAC;oBAACP;oBAASE;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,qDAAqD;YACrD,IAAIG,KAAKR,MAAM,GAAG,GAAG;gBACnBG,UAAUK;gBACVD,SAAS,MAAMjC,YAAY;gBAC3B;YACF;YAEA,qBAAqB;YACrB,MAAMyB,SAASxB,WAAWiC;YAC1B,MAAMG,YAAY/B,QAAQC,OAAOqB,WAAW,OAAOH,QAAQA,OAAOC,MAAM;YAExE,IAAIW,cAAc,GAAG;gBACnB,6BAA6B;gBAC7BR,UAAUK;gBACVD,SAAS,MAAMjC,YAAY;gBAC3B;YACF;YAEA,sDAAsD;YACtD,MAAMsC,SAASb,OAAOc,KAAK,CAAC,GAAGF;YAC/BR,UAAUJ,OAAOc,KAAK,CAACF;YACvBT,aAAaS;YAEbJ,SAAS,MAAMK;QACjB;QACAE,OAAO,SAAgDP,QAAsC;YAC3F,qCAAqC;YACrC,IAAIJ,WAAWA,QAAQH,MAAM,GAAG,GAAG;gBACjC,8DAA8D;gBAC9D,IAAI,CAACe,IAAI,CAACZ;YACZ;YACAI,SAAS;QACX;IACF;IAEA,OAAOH;AACT"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/bcj/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/tukaani-project/xz/blob/master/src/liblzma/simple/arm.c\n//\n// This implementation uses true streaming - processes data chunk by chunk.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Core ARM BCJ conversion function (matches reference arm_code)\n * Works for both encoding and decoding based on isEncoder flag\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n * - ARM pipeline adds +8 to the effective address\n *\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 armCode(nowPos: number, isEncoder: boolean, buffer: Buffer, size: number): number {\n  // Only process complete 4-byte groups\n  size = size & ~3;\n\n  let i = 0;\n  for (; i < size; i += 4) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (buffer[i + 3] === 0xeb) {\n      // Read 24-bit value (little-endian in bytes 0-2)\n      let src = (buffer[i + 2] << 16) | (buffer[i + 1] << 8) | buffer[i + 0];\n\n      // Left shift by 2 (convert from words to bytes)\n      src <<= 2;\n\n      // Sign-extend from 26-bit to 32-bit\n      if (src & 0x02000000) {\n        src |= 0xfc000000;\n      }\n      src = src | 0; // Make signed 32-bit\n\n      let dest: number;\n      if (isEncoder) {\n        // Encoding: relative to absolute\n        // dest = now_pos + i + 8 + src\n        dest = nowPos + i + 8 + src;\n      } else {\n        // Decoding: absolute to relative\n        // dest = src - (now_pos + i + 8)\n        dest = src - (nowPos + i + 8);\n      }\n\n      // Right shift by 2 (convert back from bytes to words)\n      dest >>>= 2;\n\n      // Write back lower 24 bits (little-endian)\n      buffer[i + 2] = (dest >>> 16) & 0xff;\n      buffer[i + 1] = (dest >>> 8) & 0xff;\n      buffer[i + 0] = dest & 0xff;\n    }\n  }\n\n  return i;\n}\n\n/**\n * Decode ARM BCJ filtered data (synchronous, for buffered use)\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  armCode(0, false, output, output.length);\n\n  return output;\n}\n\n/**\n * Create a streaming ARM BCJ decoder Transform.\n * Processes data in 4-byte aligned chunks.\n */\nexport function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  let globalPos = 0; // Position in the overall stream (in bytes)\n  let pending: Buffer | null = null; // Incomplete 4-byte group\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      // Process only complete 4-byte groups\n      const completeBytes = data.length & ~3;\n      if (completeBytes === 0) {\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      const output = bufferFrom(data.slice(0, completeBytes));\n      pending = data.length > completeBytes ? data.slice(completeBytes) : null;\n\n      armCode(globalPos, false, output, output.length);\n      globalPos += completeBytes;\n\n      callback(null, output);\n    },\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      if (pending && pending.length > 0) {\n        this.push(pending);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["allocBuffer","bufferFrom","Transform","armCode","nowPos","isEncoder","buffer","size","i","src","dest","decodeBcjArm","input","_properties","_unpackSize","output","length","createBcjArmDecoder","globalPos","pending","transform","chunk","_encoding","callback","data","Buffer","concat","completeBytes","slice","flush","push"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,wFAAwF;AACxF,EAAE;AACF,2EAA2E;AAE3E,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;;;;;;;;CAeC,GACD,SAASC,QAAQC,MAAc,EAAEC,SAAkB,EAAEC,MAAc,EAAEC,IAAY;IAC/E,sCAAsC;IACtCA,OAAOA,OAAO,CAAC;IAEf,IAAIC,IAAI;IACR,MAAOA,IAAID,MAAMC,KAAK,EAAG;QACvB,2CAA2C;QAC3C,IAAIF,MAAM,CAACE,IAAI,EAAE,KAAK,MAAM;YAC1B,iDAAiD;YACjD,IAAIC,MAAM,AAACH,MAAM,CAACE,IAAI,EAAE,IAAI,KAAOF,MAAM,CAACE,IAAI,EAAE,IAAI,IAAKF,MAAM,CAACE,IAAI,EAAE;YAEtE,gDAAgD;YAChDC,QAAQ;YAER,oCAAoC;YACpC,IAAIA,MAAM,YAAY;gBACpBA,OAAO;YACT;YACAA,MAAMA,MAAM,GAAG,qBAAqB;YAEpC,IAAIC;YACJ,IAAIL,WAAW;gBACb,iCAAiC;gBACjC,+BAA+B;gBAC/BK,OAAON,SAASI,IAAI,IAAIC;YAC1B,OAAO;gBACL,iCAAiC;gBACjC,iCAAiC;gBACjCC,OAAOD,MAAOL,CAAAA,SAASI,IAAI,CAAA;YAC7B;YAEA,sDAAsD;YACtDE,UAAU;YAEV,2CAA2C;YAC3CJ,MAAM,CAACE,IAAI,EAAE,GAAG,AAACE,SAAS,KAAM;YAChCJ,MAAM,CAACE,IAAI,EAAE,GAAG,AAACE,SAAS,IAAK;YAC/BJ,MAAM,CAACE,IAAI,EAAE,GAAGE,OAAO;QACzB;IACF;IAEA,OAAOF;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASG,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASd,WAAWW,QAAQ,gCAAgC;IAElET,QAAQ,GAAG,OAAOY,QAAQA,OAAOC,MAAM;IAEvC,OAAOD;AACT;AAEA;;;CAGC,GACD,OAAO,SAASE,oBAAoBJ,WAAoB,EAAEC,WAAoB;IAC5E,IAAII,YAAY,GAAG,4CAA4C;IAC/D,IAAIC,UAAyB,MAAM,0BAA0B;IAE7D,MAAMC,YAAY,IAAIlB,UAAU;QAC9BkB,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIL,WAAWA,QAAQH,MAAM,GAAG,GAAG;gBACjCQ,OAAOC,OAAOC,MAAM,CAAC;oBAACP;oBAASE;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,sCAAsC;YACtC,MAAMM,gBAAgBH,KAAKR,MAAM,GAAG,CAAC;YACrC,IAAIW,kBAAkB,GAAG;gBACvBR,UAAUK;gBACVD,SAAS,MAAMvB,YAAY;gBAC3B;YACF;YAEA,MAAMe,SAASd,WAAWuB,KAAKI,KAAK,CAAC,GAAGD;YACxCR,UAAUK,KAAKR,MAAM,GAAGW,gBAAgBH,KAAKI,KAAK,CAACD,iBAAiB;YAEpExB,QAAQe,WAAW,OAAOH,QAAQA,OAAOC,MAAM;YAC/CE,aAAaS;YAEbJ,SAAS,MAAMR;QACjB;QACAc,OAAO,SAAgDN,QAAsC;YAC3F,IAAIJ,WAAWA,QAAQH,MAAM,GAAG,GAAG;gBACjC,IAAI,CAACc,IAAI,CAACX;YACZ;YACAI,SAAS;QACX;IACF;IAEA,OAAOH;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/tukaani-project/xz/blob/master/src/liblzma/simple/arm.c\n//\n// This implementation uses true streaming - processes data chunk by chunk.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Core ARM BCJ conversion function (matches reference arm_code)\n * Works for both encoding and decoding based on isEncoder flag\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n * - ARM pipeline adds +8 to the effective address\n *\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 armCode(nowPos: number, isEncoder: boolean, buffer: Buffer, size: number): number {\n  // Only process complete 4-byte groups\n  size = size & ~3;\n\n  let i = 0;\n  for (; i < size; i += 4) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (buffer[i + 3] === 0xeb) {\n      // Read 24-bit value (little-endian in bytes 0-2)\n      let src = (buffer[i + 2] << 16) | (buffer[i + 1] << 8) | buffer[i + 0];\n\n      // Left shift by 2 (convert from words to bytes)\n      src <<= 2;\n\n      // Sign-extend from 26-bit to 32-bit\n      if (src & 0x02000000) {\n        src |= 0xfc000000;\n      }\n      src = src | 0; // Make signed 32-bit\n\n      let dest: number;\n      if (isEncoder) {\n        // Encoding: relative to absolute\n        // dest = now_pos + i + 8 + src\n        dest = nowPos + i + 8 + src;\n      } else {\n        // Decoding: absolute to relative\n        // dest = src - (now_pos + i + 8)\n        dest = src - (nowPos + i + 8);\n      }\n\n      // Right shift by 2 (convert back from bytes to words)\n      dest >>>= 2;\n\n      // Write back lower 24 bits (little-endian)\n      buffer[i + 2] = (dest >>> 16) & 0xff;\n      buffer[i + 1] = (dest >>> 8) & 0xff;\n      buffer[i + 0] = dest & 0xff;\n    }\n  }\n\n  return i;\n}\n\n/**\n * Decode ARM BCJ filtered data (synchronous, for buffered use)\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  armCode(0, false, output, output.length);\n\n  return output;\n}\n\n/**\n * Create a streaming ARM BCJ decoder Transform.\n * Processes data in 4-byte aligned chunks.\n */\nexport function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  let globalPos = 0; // Position in the overall stream (in bytes)\n  let pending: Buffer | null = null; // Incomplete 4-byte group\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      // Process only complete 4-byte groups\n      const completeBytes = data.length & ~3;\n      if (completeBytes === 0) {\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      const output = bufferFrom(data.slice(0, completeBytes));\n      pending = data.length > completeBytes ? data.slice(completeBytes) : null;\n\n      armCode(globalPos, false, output, output.length);\n      globalPos += completeBytes;\n\n      callback(null, output);\n    },\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      if (pending && pending.length > 0) {\n        this.push(pending);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["allocBuffer","bufferFrom","Transform","armCode","nowPos","isEncoder","buffer","size","i","src","dest","decodeBcjArm","input","_properties","_unpackSize","output","length","createBcjArmDecoder","globalPos","pending","transform","chunk","_encoding","callback","data","Buffer","concat","completeBytes","slice","flush","push"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,wFAAwF;AACxF,EAAE;AACF,2EAA2E;AAE3E,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;;;;;;;;CAeC,GACD,SAASC,QAAQC,MAAc,EAAEC,SAAkB,EAAEC,MAAc,EAAEC,IAAY;IAC/E,sCAAsC;IACtCA,OAAOA,OAAO,CAAC;IAEf,IAAIC,IAAI;IACR,MAAOA,IAAID,MAAMC,KAAK,EAAG;QACvB,2CAA2C;QAC3C,IAAIF,MAAM,CAACE,IAAI,EAAE,KAAK,MAAM;YAC1B,iDAAiD;YACjD,IAAIC,MAAM,AAACH,MAAM,CAACE,IAAI,EAAE,IAAI,KAAOF,MAAM,CAACE,IAAI,EAAE,IAAI,IAAKF,MAAM,CAACE,IAAI,EAAE;YAEtE,gDAAgD;YAChDC,QAAQ;YAER,oCAAoC;YACpC,IAAIA,MAAM,YAAY;gBACpBA,OAAO;YACT;YACAA,MAAMA,MAAM,GAAG,qBAAqB;YAEpC,IAAIC;YACJ,IAAIL,WAAW;gBACb,iCAAiC;gBACjC,+BAA+B;gBAC/BK,OAAON,SAASI,IAAI,IAAIC;YAC1B,OAAO;gBACL,iCAAiC;gBACjC,iCAAiC;gBACjCC,OAAOD,MAAOL,CAAAA,SAASI,IAAI,CAAA;YAC7B;YAEA,sDAAsD;YACtDE,UAAU;YAEV,2CAA2C;YAC3CJ,MAAM,CAACE,IAAI,EAAE,GAAG,AAACE,SAAS,KAAM;YAChCJ,MAAM,CAACE,IAAI,EAAE,GAAG,AAACE,SAAS,IAAK;YAC/BJ,MAAM,CAACE,IAAI,EAAE,GAAGE,OAAO;QACzB;IACF;IAEA,OAAOF;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASG,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASd,WAAWW,QAAQ,gCAAgC;IAElET,QAAQ,GAAG,OAAOY,QAAQA,OAAOC,MAAM;IAEvC,OAAOD;AACT;AAEA;;;CAGC,GACD,OAAO,SAASE,oBAAoBJ,WAAoB,EAAEC,WAAoB;IAC5E,IAAII,YAAY,GAAG,4CAA4C;IAC/D,IAAIC,UAAyB,MAAM,0BAA0B;IAE7D,MAAMC,YAAY,IAAIlB,UAAU;QAC9BkB,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIL,WAAWA,QAAQH,MAAM,GAAG,GAAG;gBACjCQ,OAAOC,OAAOC,MAAM,CAAC;oBAACP;oBAASE;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,sCAAsC;YACtC,MAAMM,gBAAgBH,KAAKR,MAAM,GAAG,CAAC;YACrC,IAAIW,kBAAkB,GAAG;gBACvBR,UAAUK;gBACVD,SAAS,MAAMvB,YAAY;gBAC3B;YACF;YAEA,MAAMe,SAASd,WAAWuB,KAAKI,KAAK,CAAC,GAAGD;YACxCR,UAAUK,KAAKR,MAAM,GAAGW,gBAAgBH,KAAKI,KAAK,CAACD,iBAAiB;YAEpExB,QAAQe,WAAW,OAAOH,QAAQA,OAAOC,MAAM;YAC/CE,aAAaS;YAEbJ,SAAS,MAAMR;QACjB;QACAc,OAAO,SAAgDN,QAAsC;YAC3F,IAAIJ,WAAWA,QAAQH,MAAM,GAAG,GAAG;gBACjC,IAAI,CAACc,IAAI,CAACX;YACZ;YACAI,SAAS;QACX;IACF;IAEA,OAAOH;AACT"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/bcj/BcjArm64.ts"],"sourcesContent":["// BCJ (ARM64/AArch64) filter codec - converts ARM64 branch instruction addresses\n// This filter makes ARM64 executables more compressible by LZMA\n//\n// ARM64 uses 32-bit fixed-width instructions. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode ARM64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM64 B/BL instruction format (little-endian):\n * - 4 bytes aligned\n * - B: opcode 0x14 (000101xx)\n * - BL: opcode 0x94 (100101xx)\n * - Bits 0-25 are 26-bit signed offset (in words)\n *\n * @param input - ARM64 BCJ filtered data\n * @param _properties - Unused for ARM64 BCJ\n * @param _unpackSize - Unused for ARM64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (little-endian)\n    let instr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16) | ((output[pos + 3] << 24) >>> 0);\n\n    // Check for B/BL instruction: (instr & 0x7C000000) === 0x14000000\n    // This matches both B (0x14000000) and BL (0x94000000)\n    if ((instr & 0x7c000000) === 0x14000000) {\n      // Extract 26-bit offset\n      let addr = instr & 0x03ffffff;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position (in words)\n      const relAddr = addr - (pos >>> 2);\n\n      // Clear old offset and write new one, preserve opcode\n      instr = (instr & 0xfc000000) | (relAddr & 0x03ffffff);\n\n      // Write back (little-endian)\n      output[pos] = instr & 0xff;\n      output[pos + 1] = (instr >>> 8) & 0xff;\n      output[pos + 2] = (instr >>> 16) & 0xff;\n      output[pos + 3] = (instr >>> 24) & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM64 BCJ decoder Transform stream\n */\nexport function createBcjArm64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm64, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjArm64","input","_properties","_unpackSize","output","pos","length","instr","addr","relAddr","createBcjArm64Decoder","properties","unpackSize"],"mappings":"AAAA,iFAAiF;AACjF,gEAAgE;AAChE,EAAE;AACF,6FAA6F;AAC7F,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,oCAAoC;QACpC,IAAIC,QAAQH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI,KAAO,AAACD,MAAM,CAACC,MAAM,EAAE,IAAI,OAAQ;QAE1G,kEAAkE;QAClE,uDAAuD;QACvD,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,wBAAwB;YACxB,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,qEAAqE;YACrE,MAAMC,UAAUD,OAAQH,CAAAA,QAAQ,CAAA;YAEhC,sDAAsD;YACtDE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,6BAA6B;YAC7BL,MAAM,CAACC,IAAI,GAAGE,QAAQ;YACtBH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;QACrC;QAEAF,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOb,uBAAuBC,gBAAgBW,YAAYC;AAC5D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjArm64.ts"],"sourcesContent":["// BCJ (ARM64/AArch64) filter codec - converts ARM64 branch instruction addresses\n// This filter makes ARM64 executables more compressible by LZMA\n//\n// ARM64 uses 32-bit fixed-width instructions. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode ARM64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM64 B/BL instruction format (little-endian):\n * - 4 bytes aligned\n * - B: opcode 0x14 (000101xx)\n * - BL: opcode 0x94 (100101xx)\n * - Bits 0-25 are 26-bit signed offset (in words)\n *\n * @param input - ARM64 BCJ filtered data\n * @param _properties - Unused for ARM64 BCJ\n * @param _unpackSize - Unused for ARM64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (little-endian)\n    let instr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16) | ((output[pos + 3] << 24) >>> 0);\n\n    // Check for B/BL instruction: (instr & 0x7C000000) === 0x14000000\n    // This matches both B (0x14000000) and BL (0x94000000)\n    if ((instr & 0x7c000000) === 0x14000000) {\n      // Extract 26-bit offset\n      let addr = instr & 0x03ffffff;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position (in words)\n      const relAddr = addr - (pos >>> 2);\n\n      // Clear old offset and write new one, preserve opcode\n      instr = (instr & 0xfc000000) | (relAddr & 0x03ffffff);\n\n      // Write back (little-endian)\n      output[pos] = instr & 0xff;\n      output[pos + 1] = (instr >>> 8) & 0xff;\n      output[pos + 2] = (instr >>> 16) & 0xff;\n      output[pos + 3] = (instr >>> 24) & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM64 BCJ decoder Transform stream\n */\nexport function createBcjArm64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm64, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjArm64","input","_properties","_unpackSize","output","pos","length","instr","addr","relAddr","createBcjArm64Decoder","properties","unpackSize"],"mappings":"AAAA,iFAAiF;AACjF,gEAAgE;AAChE,EAAE;AACF,6FAA6F;AAC7F,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,oCAAoC;QACpC,IAAIC,QAAQH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI,KAAO,AAACD,MAAM,CAACC,MAAM,EAAE,IAAI,OAAQ;QAE1G,kEAAkE;QAClE,uDAAuD;QACvD,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,wBAAwB;YACxB,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,qEAAqE;YACrE,MAAMC,UAAUD,OAAQH,CAAAA,QAAQ,CAAA;YAEhC,sDAAsD;YACtDE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,6BAA6B;YAC7BL,MAAM,CAACC,IAAI,GAAGE,QAAQ;YACtBH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;QACrC;QAEAF,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOb,uBAAuBC,gBAAgBW,YAAYC;AAC5D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/bcj/BcjArmt.ts"],"sourcesContent":["// BCJ (ARM Thumb) filter codec - converts ARM Thumb branch instruction addresses\n// This filter makes ARM Thumb executables more compressible by LZMA\n//\n// ARM Thumb uses 16-bit instructions, but BL (branch with link) spans two 16-bit words.\n// The filter converts relative addresses to absolute during compression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode ARM Thumb BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM Thumb BL instruction format (2 x 16-bit):\n * - First half-word: 1111 0xxx xxxx xxxx (high bits of offset)\n * - Second half-word: 1111 1xxx xxxx xxxx (low bits of offset)\n *\n * @param input - ARM Thumb BCJ filtered data\n * @param _properties - Unused for ARM Thumb BCJ\n * @param _unpackSize - Unused for ARM Thumb BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArmt(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 2-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read two 16-bit values (little-endian)\n    const w0 = output[pos] | (output[pos + 1] << 8);\n    const w1 = output[pos + 2] | (output[pos + 3] << 8);\n\n    // Check for BL instruction pair:\n    // First word: 0xF000-0xF7FF (1111 0xxx xxxx xxxx)\n    // Second word: 0xF800-0xFFFF (1111 1xxx xxxx xxxx)\n    if ((w0 & 0xf800) === 0xf000 && (w1 & 0xf800) === 0xf800) {\n      // Extract and combine the offset parts\n      // High 11 bits from w0, low 11 bits from w1\n      const hi = w0 & 0x7ff;\n      const lo = w1 & 0x7ff;\n\n      // Combine into 22-bit offset (in half-words)\n      let addr = (hi << 11) | lo;\n\n      // Sign-extend 22-bit to 32-bit\n      if (addr & 0x200000) {\n        addr |= 0xffc00000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in half-words, so divide by 2)\n      // Thumb PC is 2 half-words (4 bytes) ahead\n      const relAddr = addr - (pos >>> 1);\n\n      // Write back\n      const newHi = (relAddr >>> 11) & 0x7ff;\n      const newLo = relAddr & 0x7ff;\n\n      output[pos] = newHi & 0xff;\n      output[pos + 1] = 0xf0 | ((newHi >>> 8) & 0x07);\n      output[pos + 2] = newLo & 0xff;\n      output[pos + 3] = 0xf8 | ((newLo >>> 8) & 0x07);\n\n      pos += 4;\n    } else {\n      pos += 2;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM Thumb BCJ decoder Transform stream\n */\nexport function createBcjArmtDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArmt, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjArmt","input","_properties","_unpackSize","output","pos","length","w0","w1","hi","lo","addr","relAddr","newHi","newLo","createBcjArmtDecoder","properties","unpackSize"],"mappings":"AAAA,iFAAiF;AACjF,oEAAoE;AACpE,EAAE;AACF,wFAAwF;AACxF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,yCAAyC;QACzC,MAAMC,KAAKH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI;QAC7C,MAAMG,KAAKJ,MAAM,CAACC,MAAM,EAAE,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI;QAEjD,iCAAiC;QACjC,kDAAkD;QAClD,mDAAmD;QACnD,IAAI,AAACE,CAAAA,KAAK,MAAK,MAAO,UAAU,AAACC,CAAAA,KAAK,MAAK,MAAO,QAAQ;YACxD,uCAAuC;YACvC,4CAA4C;YAC5C,MAAMC,KAAKF,KAAK;YAChB,MAAMG,KAAKF,KAAK;YAEhB,6CAA6C;YAC7C,IAAIG,OAAO,AAACF,MAAM,KAAMC;YAExB,+BAA+B;YAC/B,IAAIC,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,4DAA4D;YAC5D,2CAA2C;YAC3C,MAAMC,UAAUD,OAAQN,CAAAA,QAAQ,CAAA;YAEhC,aAAa;YACb,MAAMQ,QAAQ,AAACD,YAAY,KAAM;YACjC,MAAME,QAAQF,UAAU;YAExBR,MAAM,CAACC,IAAI,GAAGQ,QAAQ;YACtBT,MAAM,CAACC,MAAM,EAAE,GAAG,OAAQ,AAACQ,UAAU,IAAK;YAC1CT,MAAM,CAACC,MAAM,EAAE,GAAGS,QAAQ;YAC1BV,MAAM,CAACC,MAAM,EAAE,GAAG,OAAQ,AAACS,UAAU,IAAK;YAE1CT,OAAO;QACT,OAAO;YACLA,OAAO;QACT;IACF;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASW,qBAAqBC,UAAmB,EAAEC,UAAmB;IAC3E,OAAOlB,uBAAuBC,eAAegB,YAAYC;AAC3D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjArmt.ts"],"sourcesContent":["// BCJ (ARM Thumb) filter codec - converts ARM Thumb branch instruction addresses\n// This filter makes ARM Thumb executables more compressible by LZMA\n//\n// ARM Thumb uses 16-bit instructions, but BL (branch with link) spans two 16-bit words.\n// The filter converts relative addresses to absolute during compression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode ARM Thumb BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM Thumb BL instruction format (2 x 16-bit):\n * - First half-word: 1111 0xxx xxxx xxxx (high bits of offset)\n * - Second half-word: 1111 1xxx xxxx xxxx (low bits of offset)\n *\n * @param input - ARM Thumb BCJ filtered data\n * @param _properties - Unused for ARM Thumb BCJ\n * @param _unpackSize - Unused for ARM Thumb BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArmt(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 2-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read two 16-bit values (little-endian)\n    const w0 = output[pos] | (output[pos + 1] << 8);\n    const w1 = output[pos + 2] | (output[pos + 3] << 8);\n\n    // Check for BL instruction pair:\n    // First word: 0xF000-0xF7FF (1111 0xxx xxxx xxxx)\n    // Second word: 0xF800-0xFFFF (1111 1xxx xxxx xxxx)\n    if ((w0 & 0xf800) === 0xf000 && (w1 & 0xf800) === 0xf800) {\n      // Extract and combine the offset parts\n      // High 11 bits from w0, low 11 bits from w1\n      const hi = w0 & 0x7ff;\n      const lo = w1 & 0x7ff;\n\n      // Combine into 22-bit offset (in half-words)\n      let addr = (hi << 11) | lo;\n\n      // Sign-extend 22-bit to 32-bit\n      if (addr & 0x200000) {\n        addr |= 0xffc00000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in half-words, so divide by 2)\n      // Thumb PC is 2 half-words (4 bytes) ahead\n      const relAddr = addr - (pos >>> 1);\n\n      // Write back\n      const newHi = (relAddr >>> 11) & 0x7ff;\n      const newLo = relAddr & 0x7ff;\n\n      output[pos] = newHi & 0xff;\n      output[pos + 1] = 0xf0 | ((newHi >>> 8) & 0x07);\n      output[pos + 2] = newLo & 0xff;\n      output[pos + 3] = 0xf8 | ((newLo >>> 8) & 0x07);\n\n      pos += 4;\n    } else {\n      pos += 2;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM Thumb BCJ decoder Transform stream\n */\nexport function createBcjArmtDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArmt, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjArmt","input","_properties","_unpackSize","output","pos","length","w0","w1","hi","lo","addr","relAddr","newHi","newLo","createBcjArmtDecoder","properties","unpackSize"],"mappings":"AAAA,iFAAiF;AACjF,oEAAoE;AACpE,EAAE;AACF,wFAAwF;AACxF,yEAAyE;AACzE,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,yCAAyC;QACzC,MAAMC,KAAKH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI;QAC7C,MAAMG,KAAKJ,MAAM,CAACC,MAAM,EAAE,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI;QAEjD,iCAAiC;QACjC,kDAAkD;QAClD,mDAAmD;QACnD,IAAI,AAACE,CAAAA,KAAK,MAAK,MAAO,UAAU,AAACC,CAAAA,KAAK,MAAK,MAAO,QAAQ;YACxD,uCAAuC;YACvC,4CAA4C;YAC5C,MAAMC,KAAKF,KAAK;YAChB,MAAMG,KAAKF,KAAK;YAEhB,6CAA6C;YAC7C,IAAIG,OAAO,AAACF,MAAM,KAAMC;YAExB,+BAA+B;YAC/B,IAAIC,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,4DAA4D;YAC5D,2CAA2C;YAC3C,MAAMC,UAAUD,OAAQN,CAAAA,QAAQ,CAAA;YAEhC,aAAa;YACb,MAAMQ,QAAQ,AAACD,YAAY,KAAM;YACjC,MAAME,QAAQF,UAAU;YAExBR,MAAM,CAACC,IAAI,GAAGQ,QAAQ;YACtBT,MAAM,CAACC,MAAM,EAAE,GAAG,OAAQ,AAACQ,UAAU,IAAK;YAC1CT,MAAM,CAACC,MAAM,EAAE,GAAGS,QAAQ;YAC1BV,MAAM,CAACC,MAAM,EAAE,GAAG,OAAQ,AAACS,UAAU,IAAK;YAE1CT,OAAO;QACT,OAAO;YACLA,OAAO;QACT;IACF;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASW,qBAAqBC,UAAmB,EAAEC,UAAmB;IAC3E,OAAOlB,uBAAuBC,eAAegB,YAAYC;AAC3D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/bcj/BcjIa64.ts"],"sourcesContent":["// BCJ (IA64/Itanium) filter codec - converts IA64 branch instruction addresses\n// This filter makes IA64 executables more compressible by LZMA\n//\n// IA64 uses 128-bit instruction bundles with 3 instructions per bundle.\n// Branch instructions use 21-bit signed offsets (in bundles).\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n// IA64 branch instruction slot mask\n// Each bundle has a 5-bit template and 3 x 41-bit instruction slots\nconst kBranchTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0, 7, 7, 4, 4, 0, 0, 4, 4, 0, 0];\n\n/**\n * Decode IA64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - IA64 BCJ filtered data\n * @param _properties - Unused for IA64 BCJ\n * @param _unpackSize - Unused for IA64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjIa64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 16-byte aligned bundles\n  while (pos + 16 <= output.length) {\n    // Get template (low 5 bits of first byte)\n    const template = output[pos] & 0x1f;\n    const mask = kBranchTable[template];\n\n    // Check each instruction slot (3 slots per bundle)\n    for (let slot = 0; slot < 3; slot++) {\n      if ((mask & (1 << slot)) === 0) {\n        continue;\n      }\n\n      // Calculate bit position for this slot\n      // Slot 0: bits 5-45, Slot 1: bits 46-86, Slot 2: bits 87-127\n      const bitPos = 5 + slot * 41;\n      const bytePos = bitPos >>> 3;\n      const bitOffset = bitPos & 7;\n\n      // Read 8 bytes to get the instruction (may span bytes)\n      // We need at least 6 bytes for a 41-bit instruction\n      if (pos + bytePos + 6 > output.length) {\n        break;\n      }\n\n      // Extract instruction bytes\n      const instr0 = output[pos + bytePos];\n      const instr1 = output[pos + bytePos + 1];\n      const instr2 = output[pos + bytePos + 2];\n      const instr3 = output[pos + bytePos + 3];\n      const instr4 = output[pos + bytePos + 4];\n      const instr5 = output[pos + bytePos + 5];\n\n      // Build instruction value (we only need the immediate field)\n      // The immediate is in bits 13-32 of the instruction (20 bits)\n      // Plus bit 36 as the sign bit\n\n      // For decoding, we extract the address that was encoded and convert back\n      let instrLo = (instr0 >>> bitOffset) | (instr1 << (8 - bitOffset)) | (instr2 << (16 - bitOffset)) | (instr3 << (24 - bitOffset));\n\n      let instrHi = (instr4 >>> bitOffset) | (instr5 << (8 - bitOffset));\n\n      // Check opcode for branch (opcode 4 or 5 in bits 37-40)\n      const opcode = (instrHi >>> (37 - 32 - bitOffset)) & 0xf;\n      if (opcode !== 4 && opcode !== 5) {\n        continue;\n      }\n\n      // Extract 21-bit immediate (bits 13-32 + sign bit 36)\n      const imm20 = (instrLo >>> 13) & 0xfffff;\n      const sign = (instrHi >>> (36 - 32)) & 1;\n\n      // Combine into 21-bit signed value\n      let addr = imm20 | (sign << 20);\n      if (sign) {\n        addr |= 0xffe00000; // Sign-extend\n      }\n\n      // Convert absolute to relative: subtract current position (in bundles)\n      const relAddr = addr - (pos >>> 4);\n\n      // Write back\n      const newImm20 = relAddr & 0xfffff;\n      const newSign = (relAddr >>> 20) & 1;\n\n      // Clear old immediate and write new one\n      instrLo = (instrLo & ~(0xfffff << 13)) | (newImm20 << 13);\n      instrHi = (instrHi & ~(1 << (36 - 32))) | (newSign << (36 - 32));\n\n      // Write back bytes\n      output[pos + bytePos] = (output[pos + bytePos] & ((1 << bitOffset) - 1)) | ((instrLo & 0xff) << bitOffset);\n      output[pos + bytePos + 1] = (instrLo >>> (8 - bitOffset)) & 0xff;\n      output[pos + bytePos + 2] = (instrLo >>> (16 - bitOffset)) & 0xff;\n      output[pos + bytePos + 3] = (instrLo >>> (24 - bitOffset)) & 0xff;\n      output[pos + bytePos + 4] = ((instrLo >>> (32 - bitOffset)) & ((1 << bitOffset) - 1)) | ((instrHi & 0xff) << bitOffset);\n      output[pos + bytePos + 5] = (output[pos + bytePos + 5] & ~((1 << bitOffset) - 1)) | ((instrHi >>> (8 - bitOffset)) & ((1 << bitOffset) - 1));\n    }\n\n    pos += 16;\n  }\n\n  return output;\n}\n\n/**\n * Create an IA64 BCJ decoder Transform stream\n */\nexport function createBcjIa64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjIa64, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","kBranchTable","decodeBcjIa64","input","_properties","_unpackSize","output","pos","length","template","mask","slot","bitPos","bytePos","bitOffset","instr0","instr1","instr2","instr3","instr4","instr5","instrLo","instrHi","opcode","imm20","sign","addr","relAddr","newImm20","newSign","createBcjIa64Decoder","properties","unpackSize"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjIa64.ts"],"sourcesContent":["// BCJ (IA64/Itanium) filter codec - converts IA64 branch instruction addresses\n// This filter makes IA64 executables more compressible by LZMA\n//\n// IA64 uses 128-bit instruction bundles with 3 instructions per bundle.\n// Branch instructions use 21-bit signed offsets (in bundles).\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n// IA64 branch instruction slot mask\n// Each bundle has a 5-bit template and 3 x 41-bit instruction slots\nconst kBranchTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 6, 6, 0, 0, 7, 7, 4, 4, 0, 0, 4, 4, 0, 0];\n\n/**\n * Decode IA64 BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * @param input - IA64 BCJ filtered data\n * @param _properties - Unused for IA64 BCJ\n * @param _unpackSize - Unused for IA64 BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjIa64(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 16-byte aligned bundles\n  while (pos + 16 <= output.length) {\n    // Get template (low 5 bits of first byte)\n    const template = output[pos] & 0x1f;\n    const mask = kBranchTable[template];\n\n    // Check each instruction slot (3 slots per bundle)\n    for (let slot = 0; slot < 3; slot++) {\n      if ((mask & (1 << slot)) === 0) {\n        continue;\n      }\n\n      // Calculate bit position for this slot\n      // Slot 0: bits 5-45, Slot 1: bits 46-86, Slot 2: bits 87-127\n      const bitPos = 5 + slot * 41;\n      const bytePos = bitPos >>> 3;\n      const bitOffset = bitPos & 7;\n\n      // Read 8 bytes to get the instruction (may span bytes)\n      // We need at least 6 bytes for a 41-bit instruction\n      if (pos + bytePos + 6 > output.length) {\n        break;\n      }\n\n      // Extract instruction bytes\n      const instr0 = output[pos + bytePos];\n      const instr1 = output[pos + bytePos + 1];\n      const instr2 = output[pos + bytePos + 2];\n      const instr3 = output[pos + bytePos + 3];\n      const instr4 = output[pos + bytePos + 4];\n      const instr5 = output[pos + bytePos + 5];\n\n      // Build instruction value (we only need the immediate field)\n      // The immediate is in bits 13-32 of the instruction (20 bits)\n      // Plus bit 36 as the sign bit\n\n      // For decoding, we extract the address that was encoded and convert back\n      let instrLo = (instr0 >>> bitOffset) | (instr1 << (8 - bitOffset)) | (instr2 << (16 - bitOffset)) | (instr3 << (24 - bitOffset));\n\n      let instrHi = (instr4 >>> bitOffset) | (instr5 << (8 - bitOffset));\n\n      // Check opcode for branch (opcode 4 or 5 in bits 37-40)\n      const opcode = (instrHi >>> (37 - 32 - bitOffset)) & 0xf;\n      if (opcode !== 4 && opcode !== 5) {\n        continue;\n      }\n\n      // Extract 21-bit immediate (bits 13-32 + sign bit 36)\n      const imm20 = (instrLo >>> 13) & 0xfffff;\n      const sign = (instrHi >>> (36 - 32)) & 1;\n\n      // Combine into 21-bit signed value\n      let addr = imm20 | (sign << 20);\n      if (sign) {\n        addr |= 0xffe00000; // Sign-extend\n      }\n\n      // Convert absolute to relative: subtract current position (in bundles)\n      const relAddr = addr - (pos >>> 4);\n\n      // Write back\n      const newImm20 = relAddr & 0xfffff;\n      const newSign = (relAddr >>> 20) & 1;\n\n      // Clear old immediate and write new one\n      instrLo = (instrLo & ~(0xfffff << 13)) | (newImm20 << 13);\n      instrHi = (instrHi & ~(1 << (36 - 32))) | (newSign << (36 - 32));\n\n      // Write back bytes\n      output[pos + bytePos] = (output[pos + bytePos] & ((1 << bitOffset) - 1)) | ((instrLo & 0xff) << bitOffset);\n      output[pos + bytePos + 1] = (instrLo >>> (8 - bitOffset)) & 0xff;\n      output[pos + bytePos + 2] = (instrLo >>> (16 - bitOffset)) & 0xff;\n      output[pos + bytePos + 3] = (instrLo >>> (24 - bitOffset)) & 0xff;\n      output[pos + bytePos + 4] = ((instrLo >>> (32 - bitOffset)) & ((1 << bitOffset) - 1)) | ((instrHi & 0xff) << bitOffset);\n      output[pos + bytePos + 5] = (output[pos + bytePos + 5] & ~((1 << bitOffset) - 1)) | ((instrHi >>> (8 - bitOffset)) & ((1 << bitOffset) - 1));\n    }\n\n    pos += 16;\n  }\n\n  return output;\n}\n\n/**\n * Create an IA64 BCJ decoder Transform stream\n */\nexport function createBcjIa64Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjIa64, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","kBranchTable","decodeBcjIa64","input","_properties","_unpackSize","output","pos","length","template","mask","slot","bitPos","bytePos","bitOffset","instr0","instr1","instr2","instr3","instr4","instr5","instrLo","instrHi","opcode","imm20","sign","addr","relAddr","newImm20","newSign","createBcjIa64Decoder","properties","unpackSize"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/bcj/BcjPpc.ts"],"sourcesContent":["// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses\n// This filter makes PowerPC executables more compressible by LZMA\n//\n// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode PowerPC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * PowerPC B/BL instruction format (big-endian):\n * - 4 bytes aligned\n * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)\n * - Bits 6-29 are 24-bit signed offset (in words)\n *\n * @param input - PowerPC BCJ filtered data\n * @param _properties - Unused for PowerPC BCJ\n * @param _unpackSize - Unused for PowerPC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjPpc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (big-endian)\n    let instr = (output[pos] << 24) | (output[pos + 1] << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n    // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001\n    if ((instr & 0xfc000003) === 0x48000001) {\n      // Extract 26-bit offset (bits 2-27, the LI field)\n      let addr = instr & 0x03fffffc;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position\n      const relAddr = addr - pos;\n\n      // Clear old offset and write new one\n      instr = (instr & 0xfc000003) | (relAddr & 0x03fffffc);\n\n      // Write back (big-endian)\n      output[pos] = (instr >>> 24) & 0xff;\n      output[pos + 1] = (instr >>> 16) & 0xff;\n      output[pos + 2] = (instr >>> 8) & 0xff;\n      output[pos + 3] = instr & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a PowerPC BCJ decoder Transform stream\n */\nexport function createBcjPpcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjPpc, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjPpc","input","_properties","_unpackSize","output","pos","length","instr","addr","relAddr","createBcjPpcDecoder","properties","unpackSize"],"mappings":"AAAA,6EAA6E;AAC7E,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,iCAAiC;QACjC,IAAIC,QAAQ,AAACH,MAAM,CAACC,IAAI,IAAI,KAAOD,MAAM,CAACC,MAAM,EAAE,IAAI,KAAOD,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,MAAM,EAAE;QAEpG,kEAAkE;QAClE,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,kDAAkD;YAClD,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,0DAA0D;YAC1D,MAAMC,UAAUD,OAAOH;YAEvB,qCAAqC;YACrCE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,0BAA0B;YAC1BL,MAAM,CAACC,IAAI,GAAG,AAACE,UAAU,KAAM;YAC/BH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCH,MAAM,CAACC,MAAM,EAAE,GAAGE,QAAQ;QAC5B;QACAF,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,oBAAoBC,UAAmB,EAAEC,UAAmB;IAC1E,OAAOb,uBAAuBC,cAAcW,YAAYC;AAC1D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjPpc.ts"],"sourcesContent":["// BCJ (PowerPC) filter codec - converts PowerPC branch instruction addresses\n// This filter makes PowerPC executables more compressible by LZMA\n//\n// PowerPC is big-endian. Branch instructions use 26-bit signed offsets.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode PowerPC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * PowerPC B/BL instruction format (big-endian):\n * - 4 bytes aligned\n * - Opcode 0x48 in high byte with AA=0, LK=1 (0x48000001 mask 0xFC000003)\n * - Bits 6-29 are 24-bit signed offset (in words)\n *\n * @param input - PowerPC BCJ filtered data\n * @param _properties - Unused for PowerPC BCJ\n * @param _unpackSize - Unused for PowerPC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjPpc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Read 32-bit value (big-endian)\n    let instr = (output[pos] << 24) | (output[pos + 1] << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n    // Check for B/BL instruction: (instr & 0xFC000003) === 0x48000001\n    if ((instr & 0xfc000003) === 0x48000001) {\n      // Extract 26-bit offset (bits 2-27, the LI field)\n      let addr = instr & 0x03fffffc;\n\n      // Sign-extend 26-bit to 32-bit\n      if (addr & 0x02000000) {\n        addr |= 0xfc000000;\n      }\n\n      // Convert absolute to relative: subtract current position\n      const relAddr = addr - pos;\n\n      // Clear old offset and write new one\n      instr = (instr & 0xfc000003) | (relAddr & 0x03fffffc);\n\n      // Write back (big-endian)\n      output[pos] = (instr >>> 24) & 0xff;\n      output[pos + 1] = (instr >>> 16) & 0xff;\n      output[pos + 2] = (instr >>> 8) & 0xff;\n      output[pos + 3] = instr & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a PowerPC BCJ decoder Transform stream\n */\nexport function createBcjPpcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjPpc, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjPpc","input","_properties","_unpackSize","output","pos","length","instr","addr","relAddr","createBcjPpcDecoder","properties","unpackSize"],"mappings":"AAAA,6EAA6E;AAC7E,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,iCAAiC;QACjC,IAAIC,QAAQ,AAACH,MAAM,CAACC,IAAI,IAAI,KAAOD,MAAM,CAACC,MAAM,EAAE,IAAI,KAAOD,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,MAAM,EAAE;QAEpG,kEAAkE;QAClE,IAAI,AAACE,CAAAA,QAAQ,UAAS,MAAO,YAAY;YACvC,kDAAkD;YAClD,IAAIC,OAAOD,QAAQ;YAEnB,+BAA+B;YAC/B,IAAIC,OAAO,YAAY;gBACrBA,QAAQ;YACV;YAEA,0DAA0D;YAC1D,MAAMC,UAAUD,OAAOH;YAEvB,qCAAqC;YACrCE,QAAQ,AAACA,QAAQ,aAAeE,UAAU;YAE1C,0BAA0B;YAC1BL,MAAM,CAACC,IAAI,GAAG,AAACE,UAAU,KAAM;YAC/BH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,KAAM;YACnCH,MAAM,CAACC,MAAM,EAAE,GAAG,AAACE,UAAU,IAAK;YAClCH,MAAM,CAACC,MAAM,EAAE,GAAGE,QAAQ;QAC5B;QACAF,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,oBAAoBC,UAAmB,EAAEC,UAAmB;IAC1E,OAAOb,uBAAuBC,cAAcW,YAAYC;AAC1D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/bcj/BcjSparc.ts"],"sourcesContent":["// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses\n// This filter makes SPARC executables more compressible by LZMA\n//\n// SPARC is big-endian. CALL instructions use 30-bit signed offsets.\n// The filter only transforms CALL instructions with specific byte patterns.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode SPARC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * SPARC CALL instruction matching (big-endian):\n * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR\n * - First byte 0x7F and (second byte & 0xC0) == 0xC0\n *\n * @param input - SPARC BCJ filtered data\n * @param _properties - Unused for SPARC BCJ\n * @param _unpackSize - Unused for SPARC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    const b0 = output[pos];\n    const b1 = output[pos + 1];\n\n    // Check for CALL instruction with specific byte patterns:\n    // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)\n    if ((b0 === 0x40 && (b1 & 0xc0) === 0x00) || (b0 === 0x7f && (b1 & 0xc0) === 0xc0)) {\n      // Read 32-bit value (big-endian)\n      let src = (b0 << 24) | (b1 << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n      // Shift left by 2 (multiply by 4 for word addressing)\n      src <<= 2;\n\n      // Decoding: subtract position\n      let dest = src - pos;\n\n      // Shift right by 2\n      dest >>>= 2;\n\n      // Reconstruct with sign extension and opcode\n      // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000\n      const signBit = (dest >>> 22) & 1;\n      const signExtend = signBit ? 0x3fc00000 : 0;\n      dest = signExtend | (dest & 0x3fffff) | 0x40000000;\n\n      // Write back (big-endian)\n      output[pos] = (dest >>> 24) & 0xff;\n      output[pos + 1] = (dest >>> 16) & 0xff;\n      output[pos + 2] = (dest >>> 8) & 0xff;\n      output[pos + 3] = dest & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a SPARC BCJ decoder Transform stream\n */\nexport function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","pos","length","b0","b1","src","dest","signBit","signExtend","createBcjSparcDecoder","properties","unpackSize"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,MAAMC,KAAKH,MAAM,CAACC,IAAI;QACtB,MAAMG,KAAKJ,MAAM,CAACC,MAAM,EAAE;QAE1B,0DAA0D;QAC1D,6EAA6E;QAC7E,IAAI,AAACE,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,QAAUD,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,MAAO;YAClF,iCAAiC;YACjC,IAAIC,MAAM,AAACF,MAAM,KAAOC,MAAM,KAAOJ,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,MAAM,EAAE;YAE5E,sDAAsD;YACtDI,QAAQ;YAER,8BAA8B;YAC9B,IAAIC,OAAOD,MAAMJ;YAEjB,mBAAmB;YACnBK,UAAU;YAEV,6CAA6C;YAC7C,mFAAmF;YACnF,MAAMC,UAAU,AAACD,SAAS,KAAM;YAChC,MAAME,aAAaD,UAAU,aAAa;YAC1CD,OAAOE,aAAcF,OAAO,WAAY;YAExC,0BAA0B;YAC1BN,MAAM,CAACC,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCN,MAAM,CAACC,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASS,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOhB,uBAAuBC,gBAAgBc,YAAYC;AAC5D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/bcj/BcjSparc.ts"],"sourcesContent":["// BCJ (SPARC) filter codec - converts SPARC branch instruction addresses\n// This filter makes SPARC executables more compressible by LZMA\n//\n// SPARC is big-endian. CALL instructions use 30-bit signed offsets.\n// The filter only transforms CALL instructions with specific byte patterns.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\nimport createBufferingDecoder from '../../utils/createBufferingDecoder.ts';\n\n/**\n * Decode SPARC BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * SPARC CALL instruction matching (big-endian):\n * - First byte 0x40 and (second byte & 0xC0) == 0x00, OR\n * - First byte 0x7F and (second byte & 0xC0) == 0xC0\n *\n * @param input - SPARC BCJ filtered data\n * @param _properties - Unused for SPARC BCJ\n * @param _unpackSize - Unused for SPARC BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjSparc(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    const b0 = output[pos];\n    const b1 = output[pos + 1];\n\n    // Check for CALL instruction with specific byte patterns:\n    // (b0 == 0x40 && (b1 & 0xC0) == 0x00) || (b0 == 0x7F && (b1 & 0xC0) == 0xC0)\n    if ((b0 === 0x40 && (b1 & 0xc0) === 0x00) || (b0 === 0x7f && (b1 & 0xc0) === 0xc0)) {\n      // Read 32-bit value (big-endian)\n      let src = (b0 << 24) | (b1 << 16) | (output[pos + 2] << 8) | output[pos + 3];\n\n      // Shift left by 2 (multiply by 4 for word addressing)\n      src <<= 2;\n\n      // Decoding: subtract position\n      let dest = src - pos;\n\n      // Shift right by 2\n      dest >>>= 2;\n\n      // Reconstruct with sign extension and opcode\n      // (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000\n      const signBit = (dest >>> 22) & 1;\n      const signExtend = signBit ? 0x3fc00000 : 0;\n      dest = signExtend | (dest & 0x3fffff) | 0x40000000;\n\n      // Write back (big-endian)\n      output[pos] = (dest >>> 24) & 0xff;\n      output[pos + 1] = (dest >>> 16) & 0xff;\n      output[pos + 2] = (dest >>> 8) & 0xff;\n      output[pos + 3] = dest & 0xff;\n    }\n\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a SPARC BCJ decoder Transform stream\n */\nexport function createBcjSparcDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjSparc, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjSparc","input","_properties","_unpackSize","output","pos","length","b0","b1","src","dest","signBit","signExtend","createBcjSparcDecoder","properties","unpackSize"],"mappings":"AAAA,yEAAyE;AACzE,gEAAgE;AAChE,EAAE;AACF,oEAAoE;AACpE,4EAA4E;AAC5E,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,wCAAwC;AAE3E;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,eAAeC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACtF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,MAAMC,KAAKH,MAAM,CAACC,IAAI;QACtB,MAAMG,KAAKJ,MAAM,CAACC,MAAM,EAAE;QAE1B,0DAA0D;QAC1D,6EAA6E;QAC7E,IAAI,AAACE,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,QAAUD,OAAO,QAAQ,AAACC,CAAAA,KAAK,IAAG,MAAO,MAAO;YAClF,iCAAiC;YACjC,IAAIC,MAAM,AAACF,MAAM,KAAOC,MAAM,KAAOJ,MAAM,CAACC,MAAM,EAAE,IAAI,IAAKD,MAAM,CAACC,MAAM,EAAE;YAE5E,sDAAsD;YACtDI,QAAQ;YAER,8BAA8B;YAC9B,IAAIC,OAAOD,MAAMJ;YAEjB,mBAAmB;YACnBK,UAAU;YAEV,6CAA6C;YAC7C,mFAAmF;YACnF,MAAMC,UAAU,AAACD,SAAS,KAAM;YAChC,MAAME,aAAaD,UAAU,aAAa;YAC1CD,OAAOE,aAAcF,OAAO,WAAY;YAExC,0BAA0B;YAC1BN,MAAM,CAACC,IAAI,GAAG,AAACK,SAAS,KAAM;YAC9BN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,KAAM;YAClCN,MAAM,CAACC,MAAM,EAAE,GAAG,AAACK,SAAS,IAAK;YACjCN,MAAM,CAACC,MAAM,EAAE,GAAGK,OAAO;QAC3B;QAEAL,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASS,sBAAsBC,UAAmB,EAAEC,UAAmB;IAC5E,OAAOhB,uBAAuBC,gBAAgBc,YAAYC;AAC5D"}

package/dist/esm/filters/delta/Delta.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/delta/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n//\n// This implementation uses true streaming - processes data chunk by chunk\n// while maintaining state between chunks.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode Delta filtered data (synchronous, for buffered use)\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  for (let j = 0; j < output.length; j++) {\n    const idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming Delta decoder Transform.\n * Processes data chunk by chunk, maintaining state between chunks.\n */\nexport function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    distance = properties[0] + 1;\n  }\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  let byteIndex = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      const output = allocBuffer(chunk.length);\n\n      for (let j = 0; j < chunk.length; j++) {\n        const idx = byteIndex % distance;\n        state[idx] = (state[idx] + chunk[j]) & 0xff;\n        output[j] = state[idx];\n        byteIndex++;\n      }\n\n      callback(null, output);\n    },\n  });\n}\n"],"names":["allocBuffer","bufferFrom","Transform","decodeDelta","input","properties","_unpackSize","distance","length","output","state","i","push","j","idx","createDeltaDecoder","byteIndex","transform","chunk","_encoding","callback"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;AAE1C,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;CAQC,GACD,OAAO,SAASC,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,MAAMI,SAASR,WAAWG,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,MAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOD,MAAM,EAAEK,IAAK;QACtC,MAAMC,MAAMD,IAAIN;QAChBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGL,MAAM,CAACI,EAAE,GAAI;QACxCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAOL;AACT;AAEA;;;CAGC,GACD,OAAO,SAASM,mBAAmBV,UAAmB,EAAEC,WAAoB;IAC1E,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxCD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,uCAAuC;IACvC,MAAMK,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAII,YAAY;IAEhB,OAAO,IAAId,UAAU;QACnBe,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,MAAMX,SAAST,YAAYkB,MAAMV,MAAM;YAEvC,IAAK,IAAIK,IAAI,GAAGA,IAAIK,MAAMV,MAAM,EAAEK,IAAK;gBACrC,MAAMC,MAAME,YAAYT;gBACxBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBE;YACF;YAEAI,SAAS,MAAMX;QACjB;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/delta/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n//\n// This implementation uses true streaming - processes data chunk by chunk\n// while maintaining state between chunks.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode Delta filtered data (synchronous, for buffered use)\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  for (let j = 0; j < output.length; j++) {\n    const idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming Delta decoder Transform.\n * Processes data chunk by chunk, maintaining state between chunks.\n */\nexport function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    distance = properties[0] + 1;\n  }\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  let byteIndex = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      const output = allocBuffer(chunk.length);\n\n      for (let j = 0; j < chunk.length; j++) {\n        const idx = byteIndex % distance;\n        state[idx] = (state[idx] + chunk[j]) & 0xff;\n        output[j] = state[idx];\n        byteIndex++;\n      }\n\n      callback(null, output);\n    },\n  });\n}\n"],"names":["allocBuffer","bufferFrom","Transform","decodeDelta","input","properties","_unpackSize","distance","length","output","state","i","push","j","idx","createDeltaDecoder","byteIndex","transform","chunk","_encoding","callback"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;AAE1C,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;CAQC,GACD,OAAO,SAASC,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,MAAMI,SAASR,WAAWG,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,MAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOD,MAAM,EAAEK,IAAK;QACtC,MAAMC,MAAMD,IAAIN;QAChBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGL,MAAM,CAACI,EAAE,GAAI;QACxCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAOL;AACT;AAEA;;;CAGC,GACD,OAAO,SAASM,mBAAmBV,UAAmB,EAAEC,WAAoB;IAC1E,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxCD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,uCAAuC;IACvC,MAAMK,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAII,YAAY;IAEhB,OAAO,IAAId,UAAU;QACnBe,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,MAAMX,SAAST,YAAYkB,MAAMV,MAAM;YAEvC,IAAK,IAAIK,IAAI,GAAGA,IAAIK,MAAMV,MAAM,EAAEK,IAAK;gBACrC,MAAMC,MAAME,YAAYT;gBACxBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBE;YACF;YAEAI,SAAS,MAAMX;QACjB;IACF;AACF"}

package/dist/esm/filters/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/filters/index.ts"],"sourcesContent":["// Filter implementations for XZ/LZMA\n\nexport * from './bcj/Bcj.ts';\nexport * from './bcj/BcjArm.ts';\nexport * from './bcj/BcjArm64.ts';\nexport * from './bcj/BcjArmt.ts';\nexport * from './bcj/BcjIa64.ts';\nexport * from './bcj/BcjPpc.ts';\nexport * from './bcj/BcjSparc.ts';\nexport * from './delta/Delta.ts';\n"],"names":[],"mappings":"AAAA,qCAAqC;AAErC,cAAc,eAAe;AAC7B,cAAc,kBAAkB;AAChC,cAAc,oBAAoB;AAClC,cAAc,mBAAmB;AACjC,cAAc,mBAAmB;AACjC,cAAc,kBAAkB;AAChC,cAAc,oBAAoB;AAClC,cAAc,mBAAmB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/filters/index.ts"],"sourcesContent":["// Filter implementations for XZ/LZMA\n\nexport * from './bcj/Bcj.ts';\nexport * from './bcj/BcjArm.ts';\nexport * from './bcj/BcjArm64.ts';\nexport * from './bcj/BcjArmt.ts';\nexport * from './bcj/BcjIa64.ts';\nexport * from './bcj/BcjPpc.ts';\nexport * from './bcj/BcjSparc.ts';\nexport * from './delta/Delta.ts';\n"],"names":[],"mappings":"AAAA,qCAAqC;AAErC,cAAc,eAAe;AAC7B,cAAc,kBAAkB;AAChC,cAAc,oBAAoB;AAClC,cAAc,mBAAmB;AACjC,cAAc,mBAAmB;AACjC,cAAc,kBAAkB;AAChC,cAAc,oBAAoB;AAClC,cAAc,mBAAmB"}

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/index.ts"],"sourcesContent":["/**\n * XZ-Compat: XZ/LZMA Decompression Library\n *\n * Pure JavaScript implementation with optional native acceleration\n * via lzma-native on Node.js 10+.\n *\n * Works on Node.js 0.8+ with automatic performance optimization\n * when native bindings are available.\n */\n\n// ============================================================================\n// High-Level APIs (Recommended)\n// ============================================================================\n\n// 7z-specific decoders - accept properties separately, try native automatically\nexport { decode7zLzma, decode7zLzma2, type SevenZDecodeCallback } from './sevenz.ts';\n// XZ container format - self-describing, works great with native acceleration\nexport { type BufferLike, createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.ts';\n\n// ============================================================================\n// Low-Level APIs (Backward Compatibility)\n// ============================================================================\n\n// Raw LZMA decoders (for specialized use cases)\nexport { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.ts';\n\n// ============================================================================\n// Supporting APIs\n// ============================================================================\n\n// Preprocessing filters (BCJ/Delta - used by 7z-iterator)\nexport * from './filters/index.ts';\n\n// Native acceleration utilities\nexport { isNativeAvailable } from './native.ts';\n\n// Callback type used by async decoders\nexport type { DecodeCallback } from './sevenz.ts';\n"],"names":["decode7zLzma","decode7zLzma2","createXZDecoder","decodeXZ","createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","isNativeAvailable"],"mappings":"AAAA;;;;;;;;CAQC,GAED,+EAA+E;AAC/E,gCAAgC;AAChC,+EAA+E;AAE/E,gFAAgF;AAChF,SAASA,YAAY,EAAEC,aAAa,QAAmC,cAAc;AACrF,8EAA8E;AAC9E,SAA0BC,eAAe,EAAEC,QAAQ,QAA+B,kBAAkB;AAEpG,+EAA+E;AAC/E,0CAA0C;AAC1C,+EAA+E;AAE/E,gDAAgD;AAChD,SAASC,kBAAkB,EAAEC,iBAAiB,EAAEC,UAAU,EAAEC,WAAW,QAAQ,kBAAkB;AAEjG,+EAA+E;AAC/E,kBAAkB;AAClB,+EAA+E;AAE/E,0DAA0D;AAC1D,cAAc,qBAAqB;AAEnC,gCAAgC;AAChC,SAASC,iBAAiB,QAAQ,cAAc"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/index.ts"],"sourcesContent":["/**\n * XZ-Compat: XZ/LZMA Decompression Library\n *\n * Pure JavaScript implementation with optional native acceleration\n * via lzma-native on Node.js 10+.\n *\n * Works on Node.js 0.8+ with automatic performance optimization\n * when native bindings are available.\n */\n\n// ============================================================================\n// High-Level APIs (Recommended)\n// ============================================================================\n\n// 7z-specific decoders - accept properties separately, try native automatically\nexport { decode7zLzma, decode7zLzma2, type SevenZDecodeCallback } from './sevenz.ts';\n// XZ container format - self-describing, works great with native acceleration\nexport { type BufferLike, createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.ts';\n\n// ============================================================================\n// Low-Level APIs (Backward Compatibility)\n// ============================================================================\n\n// Raw LZMA decoders (for specialized use cases)\nexport { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.ts';\n\n// ============================================================================\n// Supporting APIs\n// ============================================================================\n\n// Preprocessing filters (BCJ/Delta - used by 7z-iterator)\nexport * from './filters/index.ts';\n\n// Native acceleration utilities\nexport { isNativeAvailable } from './native.ts';\n\n// Callback type used by async decoders\nexport type { DecodeCallback } from './sevenz.ts';\n"],"names":["decode7zLzma","decode7zLzma2","createXZDecoder","decodeXZ","createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","isNativeAvailable"],"mappings":"AAAA;;;;;;;;CAQC,GAED,+EAA+E;AAC/E,gCAAgC;AAChC,+EAA+E;AAE/E,gFAAgF;AAChF,SAASA,YAAY,EAAEC,aAAa,QAAmC,cAAc;AACrF,8EAA8E;AAC9E,SAA0BC,eAAe,EAAEC,QAAQ,QAA+B,kBAAkB;AAEpG,+EAA+E;AAC/E,0CAA0C;AAC1C,+EAA+E;AAE/E,gDAAgD;AAChD,SAASC,kBAAkB,EAAEC,iBAAiB,EAAEC,UAAU,EAAEC,WAAW,QAAQ,kBAAkB;AAEjG,+EAA+E;AAC/E,kBAAkB;AAClB,+EAA+E;AAE/E,0DAA0D;AAC1D,cAAc,qBAAqB;AAEnC,gCAAgC;AAChC,SAASC,iBAAiB,QAAQ,cAAc"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/lzma/index.ts"],"sourcesContent":["/**\n * LZMA Decoder Module\n *\n * Provides both synchronous and streaming LZMA1/LZMA2 decoders.\n *\n * Synchronous API: Use when input is a complete Buffer\n * Streaming API: Use with Transform streams for memory-efficient decompression\n *\n * LZMA1 vs LZMA2:\n * - LZMA2 is chunked and supports true streaming with bounded memory\n * - LZMA1 has no chunk boundaries and requires buffering all input for streaming\n */\n\n// Streaming decoders (Transform streams)\nexport { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.ts';\nexport { decodeLzma2 } from './sync/Lzma2Decoder.ts';\n// Synchronous decoders (for Buffer input)\nexport { decodeLzma } from './sync/LzmaDecoder.ts';\n"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma2","decodeLzma"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;AACzC,SAASA,kBAAkB,EAAEC,iBAAiB,QAAQ,yBAAyB;AAC/E,SAASC,WAAW,QAAQ,yBAAyB;AACrD,0CAA0C;AAC1C,SAASC,UAAU,QAAQ,wBAAwB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/index.ts"],"sourcesContent":["/**\n * LZMA Decoder Module\n *\n * Provides both synchronous and streaming LZMA1/LZMA2 decoders.\n *\n * Synchronous API: Use when input is a complete Buffer\n * Streaming API: Use with Transform streams for memory-efficient decompression\n *\n * LZMA1 vs LZMA2:\n * - LZMA2 is chunked and supports true streaming with bounded memory\n * - LZMA1 has no chunk boundaries and requires buffering all input for streaming\n */\n\n// Streaming decoders (Transform streams)\nexport { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.ts';\nexport { decodeLzma2 } from './sync/Lzma2Decoder.ts';\n// Synchronous decoders (for Buffer input)\nexport { decodeLzma } from './sync/LzmaDecoder.ts';\n"],"names":["createLzma2Decoder","createLzmaDecoder","decodeLzma2","decodeLzma"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;AACzC,SAASA,kBAAkB,EAAEC,iBAAiB,QAAQ,yBAAyB;AAC/E,SAASC,WAAW,QAAQ,yBAAyB;AACrD,0CAA0C;AAC1C,SAASC,UAAU,QAAQ,wBAAwB"}

package/dist/esm/lzma/lib/Lzma2ChunkParser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/lzma/lib/Lzma2ChunkParser.ts"],"sourcesContent":["/**\n * LZMA2 Chunk Parser\n *\n * Shared parsing logic for LZMA2 chunk headers.\n * Used by both synchronous and streaming decoders.\n *\n * LZMA2 control byte ranges:\n * 0x00         = End of stream\n * 0x01         = Uncompressed chunk, dictionary reset\n * 0x02         = Uncompressed chunk, no dictionary reset\n * 0x80-0x9F    = LZMA chunk, no reset (solid mode)\n * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)\n * 0xC0-0xDF    = LZMA chunk, reset state + new properties\n * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties\n */\n\n/**\n * LZMA properties extracted from chunk header\n */\nexport interface LzmaChunkProps {\n  lc: number;\n  lp: number;\n  pb: number;\n}\n\n/**\n * Parsed LZMA2 chunk information\n */\nexport interface Lzma2Chunk {\n  /** Chunk type */\n  type: 'end' | 'uncompressed' | 'lzma';\n  /** Total bytes consumed by header (including control byte) */\n  headerSize: number;\n  /** Whether to reset dictionary */\n  dictReset: boolean;\n  /** Whether to reset state/probabilities */\n  stateReset: boolean;\n  /** New LZMA properties (only for control >= 0xC0) */\n  newProps: LzmaChunkProps | null;\n  /** Uncompressed data size */\n  uncompSize: number;\n  /** Compressed data size (0 for uncompressed chunks) */\n  compSize: number;\n}\n\n/**\n * Result of parsing attempt\n */\nexport type ParseResult = { success: true; chunk: Lzma2Chunk } | { success: false; needBytes: number };\n\n/**\n * Parse an LZMA2 chunk header\n *\n * @param input - Input buffer\n * @param offset - Offset to start parsing\n * @returns Parsed chunk info or number of bytes needed\n */\nexport function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult {\n  if (offset >= input.length) {\n    return { success: false, needBytes: 1 };\n  }\n\n  const control = input[offset];\n\n  // End of stream\n  if (control === 0x00) {\n    return {\n      success: true,\n      chunk: {\n        type: 'end',\n        headerSize: 1,\n        dictReset: false,\n        stateReset: false,\n        newProps: null,\n        uncompSize: 0,\n        compSize: 0,\n      },\n    };\n  }\n\n  // Uncompressed chunk\n  if (control === 0x01 || control === 0x02) {\n    // Need 3 bytes: control + 2 size bytes\n    if (offset + 3 > input.length) {\n      return { success: false, needBytes: 3 - (input.length - offset) };\n    }\n\n    const uncompSize = ((input[offset + 1] << 8) | input[offset + 2]) + 1;\n\n    return {\n      success: true,\n      chunk: {\n        type: 'uncompressed',\n        headerSize: 3,\n        dictReset: control === 0x01,\n        stateReset: false,\n        newProps: null,\n        uncompSize,\n        compSize: 0,\n      },\n    };\n  }\n\n  // LZMA compressed chunk\n  if (control >= 0x80) {\n    const hasNewProps = control >= 0xc0;\n    const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)\n\n    if (offset + minHeaderSize > input.length) {\n      return { success: false, needBytes: minHeaderSize - (input.length - offset) };\n    }\n\n    // Parse sizes\n    const uncompHigh = control & 0x1f;\n    const uncompSize = ((uncompHigh << 16) | (input[offset + 1] << 8) | input[offset + 2]) + 1;\n    const compSize = ((input[offset + 3] << 8) | input[offset + 4]) + 1;\n\n    // Parse properties if present\n    let newProps: LzmaChunkProps | null = null;\n    if (hasNewProps) {\n      const propsByte = input[offset + 5];\n      const lc = propsByte % 9;\n      const remainder = ~~(propsByte / 9);\n      const lp = remainder % 5;\n      const pb = ~~(remainder / 5);\n      newProps = { lc, lp, pb };\n    }\n\n    return {\n      success: true,\n      chunk: {\n        type: 'lzma',\n        headerSize: minHeaderSize,\n        dictReset: control >= 0xe0,\n        stateReset: control >= 0xa0,\n        newProps,\n        uncompSize,\n        compSize,\n      },\n    };\n  }\n\n  // Invalid control byte\n  throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n}\n\n/** Result type for hasCompleteChunk with totalSize included on success */\nexport type CompleteChunkResult = { success: true; chunk: Lzma2Chunk; totalSize: number } | { success: false; needBytes: number };\n\n/**\n * Check if we have enough data for the complete chunk (header + data)\n */\nexport function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult {\n  const result = parseLzma2ChunkHeader(input, offset);\n\n  if (result.success === false) {\n    return { success: false, needBytes: result.needBytes };\n  }\n\n  const { chunk } = result;\n  const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n  const totalSize = chunk.headerSize + dataSize;\n\n  if (offset + totalSize > input.length) {\n    return { success: false, needBytes: totalSize - (input.length - offset) };\n  }\n\n  return { success: true, chunk, totalSize };\n}\n"],"names":["parseLzma2ChunkHeader","input","offset","length","success","needBytes","control","chunk","type","headerSize","dictReset","stateReset","newProps","uncompSize","compSize","hasNewProps","minHeaderSize","uncompHigh","propsByte","lc","remainder","lp","pb","Error","toString","hasCompleteChunk","result","dataSize","totalSize"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/lib/Lzma2ChunkParser.ts"],"sourcesContent":["/**\n * LZMA2 Chunk Parser\n *\n * Shared parsing logic for LZMA2 chunk headers.\n * Used by both synchronous and streaming decoders.\n *\n * LZMA2 control byte ranges:\n * 0x00         = End of stream\n * 0x01         = Uncompressed chunk, dictionary reset\n * 0x02         = Uncompressed chunk, no dictionary reset\n * 0x80-0x9F    = LZMA chunk, no reset (solid mode)\n * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)\n * 0xC0-0xDF    = LZMA chunk, reset state + new properties\n * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties\n */\n\n/**\n * LZMA properties extracted from chunk header\n */\nexport interface LzmaChunkProps {\n  lc: number;\n  lp: number;\n  pb: number;\n}\n\n/**\n * Parsed LZMA2 chunk information\n */\nexport interface Lzma2Chunk {\n  /** Chunk type */\n  type: 'end' | 'uncompressed' | 'lzma';\n  /** Total bytes consumed by header (including control byte) */\n  headerSize: number;\n  /** Whether to reset dictionary */\n  dictReset: boolean;\n  /** Whether to reset state/probabilities */\n  stateReset: boolean;\n  /** New LZMA properties (only for control >= 0xC0) */\n  newProps: LzmaChunkProps | null;\n  /** Uncompressed data size */\n  uncompSize: number;\n  /** Compressed data size (0 for uncompressed chunks) */\n  compSize: number;\n}\n\n/**\n * Result of parsing attempt\n */\nexport type ParseResult = { success: true; chunk: Lzma2Chunk } | { success: false; needBytes: number };\n\n/**\n * Parse an LZMA2 chunk header\n *\n * @param input - Input buffer\n * @param offset - Offset to start parsing\n * @returns Parsed chunk info or number of bytes needed\n */\nexport function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult {\n  if (offset >= input.length) {\n    return { success: false, needBytes: 1 };\n  }\n\n  const control = input[offset];\n\n  // End of stream\n  if (control === 0x00) {\n    return {\n      success: true,\n      chunk: {\n        type: 'end',\n        headerSize: 1,\n        dictReset: false,\n        stateReset: false,\n        newProps: null,\n        uncompSize: 0,\n        compSize: 0,\n      },\n    };\n  }\n\n  // Uncompressed chunk\n  if (control === 0x01 || control === 0x02) {\n    // Need 3 bytes: control + 2 size bytes\n    if (offset + 3 > input.length) {\n      return { success: false, needBytes: 3 - (input.length - offset) };\n    }\n\n    const uncompSize = ((input[offset + 1] << 8) | input[offset + 2]) + 1;\n\n    return {\n      success: true,\n      chunk: {\n        type: 'uncompressed',\n        headerSize: 3,\n        dictReset: control === 0x01,\n        stateReset: false,\n        newProps: null,\n        uncompSize,\n        compSize: 0,\n      },\n    };\n  }\n\n  // LZMA compressed chunk\n  if (control >= 0x80) {\n    const hasNewProps = control >= 0xc0;\n    const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)\n\n    if (offset + minHeaderSize > input.length) {\n      return { success: false, needBytes: minHeaderSize - (input.length - offset) };\n    }\n\n    // Parse sizes\n    const uncompHigh = control & 0x1f;\n    const uncompSize = ((uncompHigh << 16) | (input[offset + 1] << 8) | input[offset + 2]) + 1;\n    const compSize = ((input[offset + 3] << 8) | input[offset + 4]) + 1;\n\n    // Parse properties if present\n    let newProps: LzmaChunkProps | null = null;\n    if (hasNewProps) {\n      const propsByte = input[offset + 5];\n      const lc = propsByte % 9;\n      const remainder = ~~(propsByte / 9);\n      const lp = remainder % 5;\n      const pb = ~~(remainder / 5);\n      newProps = { lc, lp, pb };\n    }\n\n    return {\n      success: true,\n      chunk: {\n        type: 'lzma',\n        headerSize: minHeaderSize,\n        dictReset: control >= 0xe0,\n        stateReset: control >= 0xa0,\n        newProps,\n        uncompSize,\n        compSize,\n      },\n    };\n  }\n\n  // Invalid control byte\n  throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n}\n\n/** Result type for hasCompleteChunk with totalSize included on success */\nexport type CompleteChunkResult = { success: true; chunk: Lzma2Chunk; totalSize: number } | { success: false; needBytes: number };\n\n/**\n * Check if we have enough data for the complete chunk (header + data)\n */\nexport function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult {\n  const result = parseLzma2ChunkHeader(input, offset);\n\n  if (result.success === false) {\n    return { success: false, needBytes: result.needBytes };\n  }\n\n  const { chunk } = result;\n  const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n  const totalSize = chunk.headerSize + dataSize;\n\n  if (offset + totalSize > input.length) {\n    return { success: false, needBytes: totalSize - (input.length - offset) };\n  }\n\n  return { success: true, chunk, totalSize };\n}\n"],"names":["parseLzma2ChunkHeader","input","offset","length","success","needBytes","control","chunk","type","headerSize","dictReset","stateReset","newProps","uncompSize","compSize","hasNewProps","minHeaderSize","uncompHigh","propsByte","lc","remainder","lp","pb","Error","toString","hasCompleteChunk","result","dataSize","totalSize"],"mappings":"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"}