xz-compat 0.1.0

package/dist/cjs/lzma/types.js

@@ -0,0 +1,264 @@
+/**
+ * LZMA Types and Constants
+ *
+ * Shared types, constants, and state transition functions for LZMA decoding.
+ * Based on the LZMA SDK specification.
+ */ // LZMA State Machine Constants
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get LZMA2_CONTROL () {
+        return LZMA2_CONTROL;
+    },
+    get getLenToPosState () {
+        return getLenToPosState;
+    },
+    get initBitModels () {
+        return initBitModels;
+    },
+    get kAlignMask () {
+        return kAlignMask;
+    },
+    get kAlignTableSize () {
+        return kAlignTableSize;
+    },
+    get kBitModelTotal () {
+        return kBitModelTotal;
+    },
+    get kDicLogSizeMin () {
+        return kDicLogSizeMin;
+    },
+    get kEndPosModelIndex () {
+        return kEndPosModelIndex;
+    },
+    get kMatchMaxLen () {
+        return kMatchMaxLen;
+    },
+    get kMatchMinLen () {
+        return kMatchMinLen;
+    },
+    get kNumAlignBits () {
+        return kNumAlignBits;
+    },
+    get kNumBitModelTotalBits () {
+        return kNumBitModelTotalBits;
+    },
+    get kNumFullDistances () {
+        return kNumFullDistances;
+    },
+    get kNumHighLenBits () {
+        return kNumHighLenBits;
+    },
+    get kNumLenSymbols () {
+        return kNumLenSymbols;
+    },
+    get kNumLenToPosStates () {
+        return kNumLenToPosStates;
+    },
+    get kNumLenToPosStatesBits () {
+        return kNumLenToPosStatesBits;
+    },
+    get kNumLitContextBitsMax () {
+        return kNumLitContextBitsMax;
+    },
+    get kNumLitPosStatesBitsEncodingMax () {
+        return kNumLitPosStatesBitsEncodingMax;
+    },
+    get kNumLowLenBits () {
+        return kNumLowLenBits;
+    },
+    get kNumLowLenSymbols () {
+        return kNumLowLenSymbols;
+    },
+    get kNumMidLenBits () {
+        return kNumMidLenBits;
+    },
+    get kNumMidLenSymbols () {
+        return kNumMidLenSymbols;
+    },
+    get kNumMoveBits () {
+        return kNumMoveBits;
+    },
+    get kNumPosModels () {
+        return kNumPosModels;
+    },
+    get kNumPosSlotBits () {
+        return kNumPosSlotBits;
+    },
+    get kNumPosStatesBitsEncodingMax () {
+        return kNumPosStatesBitsEncodingMax;
+    },
+    get kNumPosStatesBitsMax () {
+        return kNumPosStatesBitsMax;
+    },
+    get kNumPosStatesEncodingMax () {
+        return kNumPosStatesEncodingMax;
+    },
+    get kNumPosStatesMax () {
+        return kNumPosStatesMax;
+    },
+    get kNumRepDistances () {
+        return kNumRepDistances;
+    },
+    get kNumStates () {
+        return kNumStates;
+    },
+    get kProbInitValue () {
+        return kProbInitValue;
+    },
+    get kStartPosModelIndex () {
+        return kStartPosModelIndex;
+    },
+    get lzma2IsUncompressed () {
+        return lzma2IsUncompressed;
+    },
+    get lzma2NeedsNewProps () {
+        return lzma2NeedsNewProps;
+    },
+    get lzma2NeedsResetProbs () {
+        return lzma2NeedsResetProbs;
+    },
+    get parseLzma2DictionarySize () {
+        return parseLzma2DictionarySize;
+    },
+    get parseProperties () {
+        return parseProperties;
+    },
+    get stateIsCharState () {
+        return stateIsCharState;
+    },
+    get stateUpdateChar () {
+        return stateUpdateChar;
+    },
+    get stateUpdateMatch () {
+        return stateUpdateMatch;
+    },
+    get stateUpdateRep () {
+        return stateUpdateRep;
+    },
+    get stateUpdateShortRep () {
+        return stateUpdateShortRep;
+    }
+});
+var kNumRepDistances = 4;
+var kNumStates = 12;
+var kNumPosSlotBits = 6;
+var kDicLogSizeMin = 0;
+var kNumLenToPosStatesBits = 2;
+var kNumLenToPosStates = 1 << kNumLenToPosStatesBits; // 4
+var kMatchMinLen = 2;
+var kNumLowLenBits = 3;
+var kNumMidLenBits = 3;
+var kNumHighLenBits = 8;
+var kNumLowLenSymbols = 1 << kNumLowLenBits; // 8
+var kNumMidLenSymbols = 1 << kNumMidLenBits; // 8
+var kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols + (1 << kNumHighLenBits); // 272
+var kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1; // 273
+var kNumAlignBits = 4;
+var kAlignTableSize = 1 << kNumAlignBits; // 16
+var kAlignMask = kAlignTableSize - 1; // 15
+var kStartPosModelIndex = 4;
+var kEndPosModelIndex = 14;
+var kNumPosModels = kEndPosModelIndex - kStartPosModelIndex; // 10
+var kNumFullDistances = 1 << (kEndPosModelIndex >>> 1); // 128
+var kNumLitPosStatesBitsEncodingMax = 4;
+var kNumLitContextBitsMax = 8;
+var kNumPosStatesBitsMax = 4;
+var kNumPosStatesMax = 1 << kNumPosStatesBitsMax; // 16
+var kNumPosStatesBitsEncodingMax = 4;
+var kNumPosStatesEncodingMax = 1 << kNumPosStatesBitsEncodingMax; // 16
+var kNumBitModelTotalBits = 11;
+var kBitModelTotal = 1 << kNumBitModelTotalBits; // 2048
+var kNumMoveBits = 5;
+var kProbInitValue = kBitModelTotal >>> 1; // 1024
+function stateUpdateChar(state) {
+    if (state < 4) return 0;
+    if (state < 10) return state - 3;
+    return state - 6;
+}
+function stateUpdateMatch(state) {
+    return state < 7 ? 7 : 10;
+}
+function stateUpdateRep(state) {
+    return state < 7 ? 8 : 11;
+}
+function stateUpdateShortRep(state) {
+    return state < 7 ? 9 : 11;
+}
+function stateIsCharState(state) {
+    return state < 7;
+}
+function getLenToPosState(len) {
+    len -= kMatchMinLen;
+    return len < kNumLenToPosStates ? len : kNumLenToPosStates - 1;
+}
+function initBitModels(probs, count) {
+    if (probs === null) {
+        if (count === undefined) {
+            throw new Error('count required when probs is null');
+        }
+        probs = new Uint16Array(count);
+    }
+    for(var i = 0; i < probs.length; i++){
+        probs[i] = kProbInitValue;
+    }
+    return probs;
+}
+function parseProperties(properties) {
+    if (properties.length < 5) {
+        throw new Error('LZMA properties must be at least 5 bytes');
+    }
+    var d = properties[0] & 0xff;
+    var lc = d % 9;
+    var remainder = ~~(d / 9);
+    var lp = remainder % 5;
+    var pb = ~~(remainder / 5);
+    if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {
+        throw new Error('Invalid LZMA properties');
+    }
+    var dictionarySize = 0;
+    for(var i = 0; i < 4; i++){
+        dictionarySize |= (properties[1 + i] & 0xff) << i * 8;
+    }
+    return {
+        lc: lc,
+        lp: lp,
+        pb: pb,
+        dictionarySize: dictionarySize
+    };
+}
+var LZMA2_CONTROL = {
+    END: 0x00,
+    UNCOMPRESSED_RESET_DIC: 0x01,
+    UNCOMPRESSED: 0x02,
+    LZMA_RESET_STATE_NEW_PROP: 0xe0
+};
+function lzma2NeedsNewProps(control) {
+    return control >= 0xe0;
+}
+function lzma2NeedsResetProbs(control) {
+    return control >= 0xa0;
+}
+function lzma2IsUncompressed(control) {
+    return control < 0x80;
+}
+function parseLzma2DictionarySize(prop) {
+    if (prop > 40) {
+        throw new Error('Invalid LZMA2 dictionary size property');
+    }
+    if (prop === 40) {
+        return 0xffffffff;
+    }
+    var base = 2 | prop & 1;
+    var exp = (prop >>> 1) + 11;
+    return base << exp;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

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

package/dist/cjs/package.json

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

package/dist/cjs/utils/createBufferingDecoder.d.cts

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

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

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

package/dist/cjs/utils/createBufferingDecoder.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Helper to create a Transform stream from a synchronous decoder
+ *
+ * This buffers all input and applies the decoder when the stream ends.
+ * This is suitable for codecs that don't support true streaming.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return createBufferingDecoder;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+function createBufferingDecoder(decodeFn, properties, unpackSize) {
+    var chunks = [];
+    var _totalSize = 0;
+    return new _extractbaseiterator.Transform({
+        transform: function(chunk, _encoding, callback) {
+            chunks.push(chunk);
+            _totalSize += chunk.length;
+            callback();
+        },
+        flush: function flush(callback) {
+            try {
+                // Concatenate all chunks
+                var input = (0, _extractbaseiterator.bufferFrom)(Buffer.concat(chunks));
+                // Decode using the synchronous decoder
+                var output = decodeFn(input, properties, unpackSize);
+                // Push the result
+                this.push(output);
+                callback();
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/utils/createBufferingDecoder.ts"],"sourcesContent":["import { bufferFrom, Transform } from 'extract-base-iterator';\nimport type { Transform as TransformType } from 'stream';\n\ntype DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Helper to create a Transform stream from a synchronous decoder\n *\n * This buffers all input and applies the decoder when the stream ends.\n * This is suitable for codecs that don't support true streaming.\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof TransformType> {\n  const chunks: Buffer[] = [];\n  let _totalSize = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      chunks.push(chunk);\n      _totalSize += chunk.length;\n      callback();\n    },\n    flush: function (this: InstanceType<typeof TransformType>, callback: (err?: Error | null) => void) {\n      try {\n        // Concatenate all chunks\n        const input = bufferFrom(Buffer.concat(chunks));\n        // Decode using the synchronous decoder\n        const output = decodeFn(input, properties, unpackSize);\n        // Push the result\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createBufferingDecoder","decodeFn","properties","unpackSize","chunks","_totalSize","Transform","transform","chunk","_encoding","callback","push","length","flush","input","bufferFrom","Buffer","concat","output","err"],"mappings":";;;;+BAKA;;;;;CAKC,GACD;;;eAAwBA;;;mCAXc;AAWvB,SAASA,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,IAAMC,SAAmB,EAAE;IAC3B,IAAIC,aAAa;IAEjB,OAAO,IAAIC,8BAAS,CAAC;QACnBC,WAAW,SAACC,OAAeC,WAAmBC;YAC5CN,OAAOO,IAAI,CAACH;YACZH,cAAcG,MAAMI,MAAM;YAC1BF;QACF;QACAG,OAAO,SAAPA,MAA2DH,QAAsC;YAC/F,IAAI;gBACF,yBAAyB;gBACzB,IAAMI,QAAQC,IAAAA,+BAAU,EAACC,OAAOC,MAAM,CAACb;gBACvC,uCAAuC;gBACvC,IAAMc,SAASjB,SAASa,OAAOZ,YAAYC;gBAC3C,kBAAkB;gBAClB,IAAI,CAACQ,IAAI,CAACO;gBACVR;YACF,EAAE,OAAOS,KAAK;gBACZT,SAASS;YACX;QACF;IACF;AACF"}

package/dist/cjs/xz/Decoder.d.cts

@@ -0,0 +1,21 @@
+/**
+ * XZ Decompression Module
+ *
+ * XZ is a container format that wraps LZMA2 compressed data.
+ * This module provides both synchronous and streaming XZ decoders.
+ *
+ * Pure JavaScript implementation, works on Node.js 0.8+
+ */
+import type { Transform as TransformType } from 'stream';
+/**
+ * Decompress XZ data synchronously
+ * Properly handles multi-block XZ files and stream padding
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */
+export declare function decodeXZ(input: Buffer): Buffer;
+/**
+ * Create an XZ decompression Transform stream
+ * @returns Transform stream that decompresses XZ data
+ */
+export declare function createXZDecoder(): TransformType;

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

@@ -0,0 +1,21 @@
+/**
+ * XZ Decompression Module
+ *
+ * XZ is a container format that wraps LZMA2 compressed data.
+ * This module provides both synchronous and streaming XZ decoders.
+ *
+ * Pure JavaScript implementation, works on Node.js 0.8+
+ */
+import type { Transform as TransformType } from 'stream';
+/**
+ * Decompress XZ data synchronously
+ * Properly handles multi-block XZ files and stream padding
+ * @param input - XZ compressed data
+ * @returns Decompressed data
+ */
+export declare function decodeXZ(input: Buffer): Buffer;
+/**
+ * Create an XZ decompression Transform stream
+ * @returns Transform stream that decompresses XZ data
+ */
+export declare function createXZDecoder(): TransformType;