xz-compat 0.1.0 → 0.2.1

package/README.md

@@ -8,6 +8,7 @@ xz-compat is a complete pure JavaScript implementation of XZ decompression with
 
 - ✅ **XZ Format Support**: Full XZ container format decoding
 - ✅ **LZMA2 Decoder**: Complete LZMA2 decompression implementation
+- ✅ **High-Level 7z API**: Streamlined decoding for 7z files with automatic native acceleration
 - ✅ **BCJ Filters**: Branch conversion for improved compression on executables
   - x86 (32-bit)
   - ARM (32-bit)
@@ -19,7 +20,7 @@ xz-compat is a complete pure JavaScript implementation of XZ decompression with
 - ✅ **Delta Filter**: Byte-level delta encoding
 - ✅ **Streaming & Sync**: Both streaming transforms and synchronous decoding
 - ✅ **Node 0.8+**: Works on legacy Node.js versions
-- ✅ **No Native Dependencies**: Pure JavaScript, no compilation required
+- ✅ **Native Acceleration**: Optional @napi-rs/lzma on Node.js 14+ for 3-5x performance boost
 
 ## Installation
 
@@ -27,9 +28,19 @@ xz-compat is a complete pure JavaScript implementation of XZ decompression with
 npm install xz-compat
 ```
 
+### Optional Native Acceleration
+
+For Node.js 14+, install `@napi-rs/lzma` for automatic performance boost:
+
+```bash
+npm install @napi-rs/lzma
+```
+
+This provides 3-5x faster decompression. The library automatically detects and uses native bindings when available, falling back to pure JavaScript on older Node versions or when not installed.
+
 ## Quick Start
 
-### Synchronous XZ Decompression
+### XZ Decompression (Self-describing format)
 
 ```javascript
 import { readFileSync } from 'fs';
@@ -55,7 +66,18 @@ decoder.on('data', (chunk) => {
 });
 ```
 
-### LZMA2 Decompression
+### 7z LZMA/LZMA2 Decompression (High-level API)
+
+```javascript
+import { decode7zLzma2, decode7zLzma } from 'xz-compat';
+
+// Decompress LZMA2 from a 7z file (properties extracted separately)
+const lzma2Data = readFileSync('data.7z');
+const lzma2Properties = /* from 7z folder structure */;
+const decompressed = decode7zLzma2(lzma2Data, lzma2Properties);
+```
+
+### LZMA/LZMA2 (Low-level API)
 
 ```javascript
 import { decodeLzma2 } from 'xz-compat';
@@ -90,20 +112,46 @@ const unfilteredArm = decodeBcjArm(armData);
 
 ## API Reference
 
-### XZ Decompression
+### High-Level APIs (Recommended)
 
+#### XZ Decompression
 #### `decodeXZ(buffer: Buffer): Buffer`
 Synchronously decompresses XZ format data.
+- **Automatic native acceleration**: Uses @napi-rs/lzma when available on Node 14+
+- **Self-describing**: Properties embedded in XZ format
 
 #### `createXZDecoder(): Transform`
 Creates a streaming Transform for XZ decompression.
+- Automatically uses native acceleration when available
+
+#### 7z LZMA/LZMA2 Decompression
+#### `decode7zLzma2(data: Buffer, properties: Buffer, unpackSize?: number): Buffer`
+Decompresses LZMA2 data from a 7z file.
+- Accepts properties separately (matching 7z format)
+- Tries native acceleration via @napi-rs/lzma automatically
+- Falls back to pure JavaScript if native unavailable
+
+#### `decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number): Buffer`
+Decompresses LZMA1 data from a 7z file.
+- Accepts 5-byte properties separately
+- Tries native acceleration automatically
+
+### Low-Level APIs (Specialized Use)
+
+#### LZMA Decompression
+#### `decodeLzma(buffer: Buffer, properties: Buffer, outSize: number, sink?: OutputSink): Buffer`
+Synchronously decodes LZMA1 compressed data.
+- Low-level API for raw LZMA data
+- Requires separate properties and output size
 
-### LZMA2 Decompression
+#### `createLzmaDecoder(properties: Buffer, outSize: number): Transform`
+Creates a streaming Transform for LZMA1 decompression.
 
-#### `decodeLzma2(buffer: Buffer, properties: Buffer, unpackSize: number, sink: OutputSink): void`
+#### LZMA2 Decompression
+#### `decodeLzma2(buffer: Buffer, properties: Buffer, unpackSize: number, sink?: OutputSink): Buffer`
 Synchronously decodes LZMA2 compressed data.
 
-#### `createLzma2Decoder(properties: Buffer, unpackSize: number): Transform`
+#### `createLzma2Decoder(properties: Buffer, unpackSize?: number): Transform`
 Creates a streaming Transform for LZMA2 decompression.
 
 ### BCJ Filters

package/dist/cjs/index.d.cts

@@ -1,4 +1,14 @@
-export * from './filters/index.js';
-export type { OutputSink } from './lzma/index.js';
-export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectLzmaFormat, Lzma2Decoder, LzmaDecoder, } from './lzma/index.js';
+/**
+ * XZ-Compat: XZ/LZMA Decompression Library
+ *
+ * Pure JavaScript implementation with optional native acceleration
+ * via @napi-rs/lzma on Node.js 14+.
+ *
+ * Works on Node.js 0.8+ with automatic performance optimization
+ * when native bindings are available.
+ */
+export { decode7zLzma, decode7zLzma2 } from './sevenz.js';
 export { createXZDecoder, decodeXZ } from './xz/Decoder.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.js';
+export * from './filters/index.js';
+export { isNativeAvailable } from './native.js';

package/dist/cjs/index.d.ts

@@ -1,4 +1,14 @@
-export * from './filters/index.js';
-export type { OutputSink } from './lzma/index.js';
-export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2, detectLzmaFormat, Lzma2Decoder, LzmaDecoder, } from './lzma/index.js';
+/**
+ * XZ-Compat: XZ/LZMA Decompression Library
+ *
+ * Pure JavaScript implementation with optional native acceleration
+ * via @napi-rs/lzma on Node.js 14+.
+ *
+ * Works on Node.js 0.8+ with automatic performance optimization
+ * when native bindings are available.
+ */
+export { decode7zLzma, decode7zLzma2 } from './sevenz.js';
 export { createXZDecoder, decodeXZ } from './xz/Decoder.js';
+export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.js';
+export * from './filters/index.js';
+export { isNativeAvailable } from './native.js';

package/dist/cjs/index.js

@@ -1,5 +1,15 @@
-// XZ and LZMA decoders for external use
-// Re-export filters for convenience
+/**
+ * XZ-Compat: XZ/LZMA Decompression Library
+ *
+ * Pure JavaScript implementation with optional native acceleration
+ * via @napi-rs/lzma on Node.js 14+.
+ *
+ * Works on Node.js 0.8+ with automatic performance optimization
+ * when native bindings are available.
+ */ // ============================================================================
+// High-Level APIs (Recommended)
+// ============================================================================
+// 7z-specific decoders - accept properties separately, try native automatically
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -11,12 +21,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get Lzma2Decoder () {
-        return _indexts.Lzma2Decoder;
-    },
-    get LzmaDecoder () {
-        return _indexts.LzmaDecoder;
-    },
     get createLzma2Decoder () {
         return _indexts.createLzma2Decoder;
     },
@@ -26,6 +30,12 @@ _export(exports, {
     get createXZDecoder () {
         return _Decoderts.createXZDecoder;
     },
+    get decode7zLzma () {
+        return _sevenzts.decode7zLzma;
+    },
+    get decode7zLzma2 () {
+        return _sevenzts.decode7zLzma2;
+    },
     get decodeLzma () {
         return _indexts.decodeLzma;
     },
@@ -35,13 +45,15 @@ _export(exports, {
     get decodeXZ () {
         return _Decoderts.decodeXZ;
     },
-    get detectLzmaFormat () {
-        return _indexts.detectLzmaFormat;
+    get isNativeAvailable () {
+        return _nativets.isNativeAvailable;
     }
 });
-_export_star(require("./filters/index.js"), exports);
-var _indexts = require("./lzma/index.js");
+var _sevenzts = require("./sevenz.js");
 var _Decoderts = require("./xz/Decoder.js");
+var _indexts = require("./lzma/index.js");
+_export_star(require("./filters/index.js"), exports);
+var _nativets = require("./native.js");
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/index.ts"],"sourcesContent":["// XZ and LZMA decoders for external use\n\n// Re-export filters for convenience\nexport * from './filters/index.ts';\nexport type { OutputSink } from './lzma/index.ts';\nexport {\n  createLzma2Decoder,\n  createLzmaDecoder,\n  decodeLzma,\n  decodeLzma2,\n  detectLzmaFormat,\n  Lzma2Decoder,\n  LzmaDecoder,\n} from './lzma/index.ts';\nexport { createXZDecoder, decodeXZ } from './xz/Decoder.ts';\n"],"names":["Lzma2Decoder","LzmaDecoder","createLzma2Decoder","createLzmaDecoder","createXZDecoder","decodeLzma","decodeLzma2","decodeXZ","detectLzmaFormat"],"mappings":"AAAA,wCAAwC;AAExC,oCAAoC;;;;;;;;;;;;QASlCA;eAAAA,qBAAY;;QACZC;eAAAA,oBAAW;;QANXC;eAAAA,2BAAkB;;QAClBC;eAAAA,0BAAiB;;QAOVC;eAAAA,0BAAe;;QANtBC;eAAAA,mBAAU;;QACVC;eAAAA,oBAAW;;QAKaC;eAAAA,mBAAQ;;QAJhCC;eAAAA,yBAAgB;;;qBAPJ;uBAUP;yBACmC"}
+{"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 @napi-rs/lzma on Node.js 14+.\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 } from './sevenz.ts';\n// XZ container format - self-describing, works great with native acceleration\nexport { createXZDecoder, decodeXZ } 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"],"names":["createLzma2Decoder","createLzmaDecoder","createXZDecoder","decode7zLzma","decode7zLzma2","decodeLzma","decodeLzma2","decodeXZ","isNativeAvailable"],"mappings":"AAAA;;;;;;;;CAQC,GAED,+EAA+E;AAC/E,gCAAgC;AAChC,+EAA+E;AAE/E,gFAAgF;;;;;;;;;;;;QAUvEA;eAAAA,2BAAkB;;QAAEC;eAAAA,0BAAiB;;QAPrCC;eAAAA,0BAAe;;QAFfC;eAAAA,sBAAY;;QAAEC;eAAAA,uBAAa;;QASYC;eAAAA,mBAAU;;QAAEC;eAAAA,oBAAW;;QAP7CC;eAAAA,mBAAQ;;QAiBzBC;eAAAA,2BAAiB;;;wBAnBkB;yBAEF;uBAOqC;qBAOjE;wBAGoB"}

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

@@ -11,21 +11,5 @@
  * - LZMA1 has no chunk boundaries and requires buffering all input for streaming
  */
 export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
-export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
-export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
-export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
-export * from './types.js';
-/**
- * Detect LZMA format from compressed data
- *
- * LZMA2 uses chunk-based framing with control bytes:
- * - 0x00: End of stream
- * - 0x01-0x02: Uncompressed chunks
- * - 0x80-0xFF: LZMA compressed chunks
- *
- * LZMA1 is raw LZMA-compressed data (no framing)
- *
- * @param data - Compressed data to analyze
- * @returns 'lzma1' for LZMA1, 'lzma2' for LZMA2
- */
-export declare function detectLzmaFormat(data: Buffer): 'lzma1' | 'lzma2';
+export { decodeLzma2 } from './sync/Lzma2Decoder.js';
+export { decodeLzma } from './sync/LzmaDecoder.js';

package/dist/cjs/lzma/index.d.ts

@@ -11,21 +11,5 @@
  * - LZMA1 has no chunk boundaries and requires buffering all input for streaming
  */
 export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
-export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
-export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
-export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
-export * from './types.js';
-/**
- * Detect LZMA format from compressed data
- *
- * LZMA2 uses chunk-based framing with control bytes:
- * - 0x00: End of stream
- * - 0x01-0x02: Uncompressed chunks
- * - 0x80-0xFF: LZMA compressed chunks
- *
- * LZMA1 is raw LZMA-compressed data (no framing)
- *
- * @param data - Compressed data to analyze
- * @returns 'lzma1' for LZMA1, 'lzma2' for LZMA2
- */
-export declare function detectLzmaFormat(data: Buffer): 'lzma1' | 'lzma2';
+export { decodeLzma2 } from './sync/Lzma2Decoder.js';
+export { decodeLzma } from './sync/LzmaDecoder.js';

package/dist/cjs/lzma/index.js

@@ -21,18 +21,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get BitTreeDecoder () {
-        return _RangeDecoderts.BitTreeDecoder;
-    },
-    get Lzma2Decoder () {
-        return _Lzma2Decoderts.Lzma2Decoder;
-    },
-    get LzmaDecoder () {
-        return _LzmaDecoderts.LzmaDecoder;
-    },
-    get RangeDecoder () {
-        return _RangeDecoderts.RangeDecoder;
-    },
     get createLzma2Decoder () {
         return _transformsts.createLzma2Decoder;
     },
@@ -44,40 +32,9 @@ _export(exports, {
     },
     get decodeLzma2 () {
         return _Lzma2Decoderts.decodeLzma2;
-    },
-    get detectLzmaFormat () {
-        return detectLzmaFormat;
     }
 });
 var _transformsts = require("./stream/transforms.js");
 var _Lzma2Decoderts = require("./sync/Lzma2Decoder.js");
 var _LzmaDecoderts = require("./sync/LzmaDecoder.js");
-var _RangeDecoderts = require("./sync/RangeDecoder.js");
-_export_star(require("./types.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-function detectLzmaFormat(data) {
-    if (data.length === 0) {
-        // Default to LZMA2 for empty data (matches LZMA2 decoder behavior)
-        return 'lzma2';
-    }
-    var firstByte = data[0];
-    // LZMA2 control bytes: 0x00, 0x01, 0x02, or 0x80-0xFF
-    if (firstByte === 0x00 || firstByte === 0x01 || firstByte === 0x02 || firstByte >= 0x80 && firstByte <= 0xff) {
-        return 'lzma2';
-    }
-    // All other values indicate LZMA1 (raw LZMA data)
-    return 'lzma1';
-}
 /* 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/index.js.map

@@ -1 +1 @@
-{"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, Lzma2Decoder } from './sync/Lzma2Decoder.ts';\n// Synchronous decoders (for Buffer input)\nexport { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.ts';\nexport { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.ts';\n// Type exports\nexport * from './types.ts';\n\n/**\n * Detect LZMA format from compressed data\n *\n * LZMA2 uses chunk-based framing with control bytes:\n * - 0x00: End of stream\n * - 0x01-0x02: Uncompressed chunks\n * - 0x80-0xFF: LZMA compressed chunks\n *\n * LZMA1 is raw LZMA-compressed data (no framing)\n *\n * @param data - Compressed data to analyze\n * @returns 'lzma1' for LZMA1, 'lzma2' for LZMA2\n */\nexport function detectLzmaFormat(data: Buffer): 'lzma1' | 'lzma2' {\n  if (data.length === 0) {\n    // Default to LZMA2 for empty data (matches LZMA2 decoder behavior)\n    return 'lzma2';\n  }\n\n  const firstByte = data[0];\n\n  // LZMA2 control bytes: 0x00, 0x01, 0x02, or 0x80-0xFF\n  if (firstByte === 0x00 || firstByte === 0x01 || firstByte === 0x02 || (firstByte >= 0x80 && firstByte <= 0xff)) {\n    return 'lzma2';\n  }\n\n  // All other values indicate LZMA1 (raw LZMA data)\n  return 'lzma1';\n}\n"],"names":["BitTreeDecoder","Lzma2Decoder","LzmaDecoder","RangeDecoder","createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2","detectLzmaFormat","data","length","firstByte"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;;;;;;;;;;;;QAKhCA;eAAAA,8BAAc;;QAHDC;eAAAA,4BAAY;;QAEbC;eAAAA,0BAAW;;QACPC;eAAAA,4BAAY;;QAJ5BC;eAAAA,gCAAkB;;QAAEC;eAAAA,+BAAiB;;QAGrCC;eAAAA,yBAAU;;QAFVC;eAAAA,2BAAW;;QAoBJC;eAAAA;;;4BArBsC;8BACZ;6BAEF;8BACK;qBAE/B;;;;;;;;;;;;;;AAeP,SAASA,iBAAiBC,IAAY;IAC3C,IAAIA,KAAKC,MAAM,KAAK,GAAG;QACrB,mEAAmE;QACnE,OAAO;IACT;IAEA,IAAMC,YAAYF,IAAI,CAAC,EAAE;IAEzB,sDAAsD;IACtD,IAAIE,cAAc,QAAQA,cAAc,QAAQA,cAAc,QAASA,aAAa,QAAQA,aAAa,MAAO;QAC9G,OAAO;IACT;IAEA,kDAAkD;IAClD,OAAO;AACT"}
+{"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","decodeLzma","decodeLzma2"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,yCAAyC;;;;;;;;;;;;QAChCA;eAAAA,gCAAkB;;QAAEC;eAAAA,+BAAiB;;QAGrCC;eAAAA,yBAAU;;QAFVC;eAAAA,2BAAW;;;4BADkC;8BAC1B;6BAED"}

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

@@ -57,7 +57,9 @@ export declare class Lzma2Decoder {
  * @param input - LZMA2 compressed data
  * @param properties - 1-byte properties (dictionary size)
  * @param unpackSize - Expected output size (optional, autodetects if not provided)
- * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */
-export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number;
+export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: {
+    write(buffer: Buffer): void;
+}): Buffer | number;

package/dist/cjs/lzma/sync/Lzma2Decoder.d.ts

@@ -57,7 +57,9 @@ export declare class Lzma2Decoder {
  * @param input - LZMA2 compressed data
  * @param properties - 1-byte properties (dictionary size)
  * @param unpackSize - Expected output size (optional, autodetects if not provided)
- * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */
-export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number;
+export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: {
+    write(buffer: Buffer): void;
+}): Buffer | number;

package/dist/cjs/lzma/sync/Lzma2Decoder.js

@@ -198,14 +198,15 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
                 }
                 // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
                 var useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
-                // Decode LZMA chunk
-                var chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);
-                var decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);
-                // Copy to output
+                // Decode LZMA chunk - use zero-copy when we have pre-allocated buffer
                 if (outputBuffer) {
-                    decoded.copy(outputBuffer, outputPos);
-                    outputPos += decoded.length;
+                    // Zero-copy: decode directly into caller's buffer
+                    var bytesWritten = this.lzmaDecoder.decodeToBuffer(input, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);
+                    outputPos += bytesWritten;
                 } else {
+                    // No pre-allocation: decode to new buffer and collect chunks
+                    var chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);
+                    var decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);
                     outputChunks.push(decoded);
                 }
                 offset = dataOffset + chunk.compSize;

package/dist/cjs/lzma/sync/Lzma2Decoder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/sync/Lzma2Decoder.ts"],"sourcesContent":["/**\n * Synchronous LZMA2 Decoder\n *\n * LZMA2 is a container format that wraps LZMA chunks with framing.\n * Decodes LZMA2 data from a buffer.\n */\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport { parseLzma2ChunkHeader } from '../Lzma2ChunkParser.ts';\nimport { type OutputSink, parseLzma2DictionarySize } from '../types.ts';\nimport { LzmaDecoder } from './LzmaDecoder.ts';\n\n/**\n * Synchronous LZMA2 decoder\n */\nexport class Lzma2Decoder {\n  private lzmaDecoder: LzmaDecoder;\n  private dictionarySize: number;\n  private propsSet: boolean;\n\n  constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink) {\n    if (!properties || properties.length < 1) {\n      throw new Error('LZMA2 requires properties byte');\n    }\n\n    this.dictionarySize = parseLzma2DictionarySize(properties[0]);\n    this.lzmaDecoder = new LzmaDecoder(outputSink);\n    this.lzmaDecoder.setDictionarySize(this.dictionarySize);\n    this.propsSet = false;\n  }\n\n  /**\n   * Reset the dictionary (for stream boundaries)\n   */\n  resetDictionary(): void {\n    this.lzmaDecoder.resetDictionary();\n  }\n\n  /**\n   * Reset all probability models (for stream boundaries)\n   */\n  resetProbabilities(): void {\n    this.lzmaDecoder.resetProbabilities();\n  }\n\n  /**\n   * Set LZMA properties\n   */\n  setLcLpPb(lc: number, lp: number, pb: number): boolean {\n    return this.lzmaDecoder.setLcLpPb(lc, lp, pb);\n  }\n\n  /**\n   * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)\n   */\n  feedUncompressed(data: Buffer): void {\n    this.lzmaDecoder.feedUncompressed(data);\n  }\n\n  /**\n   * Decode raw LZMA data (used internally for LZMA2 chunks)\n   * @param input - LZMA compressed data\n   * @param offset - Input offset\n   * @param outSize - Expected output size\n   * @param solid - Use solid mode\n   * @returns Decompressed data\n   */\n  decodeLzmaData(input: Buffer, offset: number, outSize: number, solid = false): Buffer {\n    return this.lzmaDecoder.decode(input, offset, outSize, solid);\n  }\n\n  /**\n   * Decode LZMA2 data with streaming output\n   * @param input - LZMA2 compressed data\n   * @returns Total number of bytes written to sink\n   */\n  decodeWithSink(input: Buffer): number {\n    let totalBytes = 0;\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        totalBytes += uncompData.length;\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk directly to sink\n        totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Flush any remaining data in the OutWindow\n    this.lzmaDecoder.flushOutWindow();\n\n    return totalBytes;\n  }\n\n  /**\n   * Decode LZMA2 data\n   * @param input - LZMA2 compressed data\n   * @param unpackSize - Expected output size (optional, for pre-allocation)\n   * @returns Decompressed data\n   */\n  decode(input: Buffer, unpackSize?: number): Buffer {\n    // Pre-allocate output buffer if size is known\n    let outputBuffer: Buffer | null = null;\n    let outputPos = 0;\n    const outputChunks: Buffer[] = [];\n\n    if (unpackSize && unpackSize > 0) {\n      outputBuffer = allocBufferUnsafe(unpackSize);\n    }\n\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Copy to output\n        if (outputBuffer) {\n          uncompData.copy(outputBuffer, outputPos);\n          outputPos += uncompData.length;\n        } else {\n          outputChunks.push(uncompData);\n        }\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk\n        const chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);\n        const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);\n\n        // Copy to output\n        if (outputBuffer) {\n          decoded.copy(outputBuffer, outputPos);\n          outputPos += decoded.length;\n        } else {\n          outputChunks.push(decoded);\n        }\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Return pre-allocated buffer or concatenated chunks\n    if (outputBuffer) {\n      return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;\n    }\n    return Buffer.concat(outputChunks);\n  }\n}\n\n/**\n * Decode LZMA2 data synchronously\n * @param input - LZMA2 compressed data\n * @param properties - 1-byte properties (dictionary size)\n * @param unpackSize - Expected output size (optional, autodetects if not provided)\n * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)\n * @returns Decompressed data (or bytes written if outputSink provided)\n */\nexport function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number {\n  const decoder = new Lzma2Decoder(properties, outputSink);\n  if (outputSink) {\n    // Zero-copy mode: write to sink during decode\n    return decoder.decodeWithSink(input);\n  }\n  // Buffering mode: returns Buffer (zero-copy)\n  return decoder.decode(input, unpackSize);\n}\n"],"names":["Lzma2Decoder","decodeLzma2","properties","outputSink","length","Error","dictionarySize","parseLzma2DictionarySize","lzmaDecoder","LzmaDecoder","setDictionarySize","propsSet","resetDictionary","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","totalBytes","result","parseLzma2ChunkHeader","success","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","dataOffset","uncompData","slice","newProps","stateReset","useSolid","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","allocBufferUnsafe","copy","push","chunkData","decoded","Buffer","concat","decoder"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/sync/Lzma2Decoder.ts"],"sourcesContent":["/**\n * Synchronous LZMA2 Decoder\n *\n * LZMA2 is a container format that wraps LZMA chunks with framing.\n * Decodes LZMA2 data from a buffer.\n */\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport { parseLzma2ChunkHeader } from '../Lzma2ChunkParser.ts';\nimport { type OutputSink, parseLzma2DictionarySize } from '../types.ts';\nimport { LzmaDecoder } from './LzmaDecoder.ts';\n\n/**\n * Synchronous LZMA2 decoder\n */\nexport class Lzma2Decoder {\n  private lzmaDecoder: LzmaDecoder;\n  private dictionarySize: number;\n  private propsSet: boolean;\n\n  constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink) {\n    if (!properties || properties.length < 1) {\n      throw new Error('LZMA2 requires properties byte');\n    }\n\n    this.dictionarySize = parseLzma2DictionarySize(properties[0]);\n    this.lzmaDecoder = new LzmaDecoder(outputSink);\n    this.lzmaDecoder.setDictionarySize(this.dictionarySize);\n    this.propsSet = false;\n  }\n\n  /**\n   * Reset the dictionary (for stream boundaries)\n   */\n  resetDictionary(): void {\n    this.lzmaDecoder.resetDictionary();\n  }\n\n  /**\n   * Reset all probability models (for stream boundaries)\n   */\n  resetProbabilities(): void {\n    this.lzmaDecoder.resetProbabilities();\n  }\n\n  /**\n   * Set LZMA properties\n   */\n  setLcLpPb(lc: number, lp: number, pb: number): boolean {\n    return this.lzmaDecoder.setLcLpPb(lc, lp, pb);\n  }\n\n  /**\n   * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)\n   */\n  feedUncompressed(data: Buffer): void {\n    this.lzmaDecoder.feedUncompressed(data);\n  }\n\n  /**\n   * Decode raw LZMA data (used internally for LZMA2 chunks)\n   * @param input - LZMA compressed data\n   * @param offset - Input offset\n   * @param outSize - Expected output size\n   * @param solid - Use solid mode\n   * @returns Decompressed data\n   */\n  decodeLzmaData(input: Buffer, offset: number, outSize: number, solid = false): Buffer {\n    return this.lzmaDecoder.decode(input, offset, outSize, solid);\n  }\n\n  /**\n   * Decode LZMA2 data with streaming output\n   * @param input - LZMA2 compressed data\n   * @returns Total number of bytes written to sink\n   */\n  decodeWithSink(input: Buffer): number {\n    let totalBytes = 0;\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        totalBytes += uncompData.length;\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk directly to sink\n        totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Flush any remaining data in the OutWindow\n    this.lzmaDecoder.flushOutWindow();\n\n    return totalBytes;\n  }\n\n  /**\n   * Decode LZMA2 data\n   * @param input - LZMA2 compressed data\n   * @param unpackSize - Expected output size (optional, for pre-allocation)\n   * @returns Decompressed data\n   */\n  decode(input: Buffer, unpackSize?: number): Buffer {\n    // Pre-allocate output buffer if size is known\n    let outputBuffer: Buffer | null = null;\n    let outputPos = 0;\n    const outputChunks: Buffer[] = [];\n\n    if (unpackSize && unpackSize > 0) {\n      outputBuffer = allocBufferUnsafe(unpackSize);\n    }\n\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Copy to output\n        if (outputBuffer) {\n          uncompData.copy(outputBuffer, outputPos);\n          outputPos += uncompData.length;\n        } else {\n          outputChunks.push(uncompData);\n        }\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk - use zero-copy when we have pre-allocated buffer\n        if (outputBuffer) {\n          // Zero-copy: decode directly into caller's buffer\n          const bytesWritten = this.lzmaDecoder.decodeToBuffer(input, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);\n          outputPos += bytesWritten;\n        } else {\n          // No pre-allocation: decode to new buffer and collect chunks\n          const chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);\n          const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);\n          outputChunks.push(decoded);\n        }\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Return pre-allocated buffer or concatenated chunks\n    if (outputBuffer) {\n      return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;\n    }\n    return Buffer.concat(outputChunks);\n  }\n}\n\n/**\n * Decode LZMA2 data synchronously\n * @param input - LZMA2 compressed data\n * @param properties - 1-byte properties (dictionary size)\n * @param unpackSize - Expected output size (optional, autodetects if not provided)\n * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)\n * @returns Decompressed data (or bytes written if outputSink provided)\n */\nexport function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: { write(buffer: Buffer): void }): Buffer | number {\n  const decoder = new Lzma2Decoder(properties, outputSink as OutputSink);\n  if (outputSink) {\n    // Zero-copy mode: write to sink during decode\n    return decoder.decodeWithSink(input);\n  }\n  // Buffering mode: returns Buffer (zero-copy)\n  return decoder.decode(input, unpackSize);\n}\n"],"names":["Lzma2Decoder","decodeLzma2","properties","outputSink","length","Error","dictionarySize","parseLzma2DictionarySize","lzmaDecoder","LzmaDecoder","setDictionarySize","propsSet","resetDictionary","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","totalBytes","result","parseLzma2ChunkHeader","success","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","dataOffset","uncompData","slice","newProps","stateReset","useSolid","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","allocBufferUnsafe","copy","push","bytesWritten","decodeToBuffer","chunkData","decoded","Buffer","concat","decoder"],"mappings":"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"}

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

@@ -76,6 +76,17 @@ export declare class LzmaDecoder {
      * @returns Number of bytes written to sink
      */
     decodeWithSink(input: Buffer, inputOffset: number, outSize: number, solid?: boolean): number;
+    /**
+     * Decode LZMA data directly into caller's buffer (zero-copy)
+     * @param input - Compressed input buffer
+     * @param inputOffset - Offset into input buffer
+     * @param outSize - Expected output size
+     * @param output - Pre-allocated output buffer to write to
+     * @param outputOffset - Offset in output buffer to start writing
+     * @param solid - If true, preserve state from previous decode
+     * @returns Number of bytes written
+     */
+    decodeToBuffer(input: Buffer, inputOffset: number, outSize: number, output: Buffer, outputOffset: number, solid?: boolean): number;
     /**
      * Decode LZMA data
      * @param input - Compressed input buffer
@@ -88,10 +99,17 @@ export declare class LzmaDecoder {
 }
 /**
  * Decode LZMA1 data synchronously
+ *
+ * Note: LZMA1 is a low-level format. @napi-rs/lzma expects self-describing
+ * data (like XZ), but here we accept raw LZMA with properties specified separately.
+ * Pure JS implementation is used for LZMA1.
+ *
  * @param input - Compressed data (without 5-byte properties header)
  * @param properties - 5-byte LZMA properties
  * @param outSize - Expected output size
- * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */
-export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: OutputSink): Buffer | number;
+export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: {
+    write(buffer: Buffer): void;
+}): Buffer | number;

package/dist/cjs/lzma/sync/LzmaDecoder.d.ts

@@ -76,6 +76,17 @@ export declare class LzmaDecoder {
      * @returns Number of bytes written to sink
      */
     decodeWithSink(input: Buffer, inputOffset: number, outSize: number, solid?: boolean): number;
+    /**
+     * Decode LZMA data directly into caller's buffer (zero-copy)
+     * @param input - Compressed input buffer
+     * @param inputOffset - Offset into input buffer
+     * @param outSize - Expected output size
+     * @param output - Pre-allocated output buffer to write to
+     * @param outputOffset - Offset in output buffer to start writing
+     * @param solid - If true, preserve state from previous decode
+     * @returns Number of bytes written
+     */
+    decodeToBuffer(input: Buffer, inputOffset: number, outSize: number, output: Buffer, outputOffset: number, solid?: boolean): number;
     /**
      * Decode LZMA data
      * @param input - Compressed input buffer
@@ -88,10 +99,17 @@ export declare class LzmaDecoder {
 }
 /**
  * Decode LZMA1 data synchronously
+ *
+ * Note: LZMA1 is a low-level format. @napi-rs/lzma expects self-describing
+ * data (like XZ), but here we accept raw LZMA with properties specified separately.
+ * Pure JS implementation is used for LZMA1.
+ *
  * @param input - Compressed data (without 5-byte properties header)
  * @param properties - 5-byte LZMA properties
  * @param outSize - Expected output size
- * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */
-export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: OutputSink): Buffer | number;
+export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: {
+    write(buffer: Buffer): void;
+}): Buffer | number;

package/dist/cjs/lzma/sync/LzmaDecoder.js

@@ -453,14 +453,16 @@ var LzmaDecoder = /*#__PURE__*/ function() {
         return outPos;
     };
     /**
-   * Decode LZMA data
+   * Decode LZMA data directly into caller's buffer (zero-copy)
    * @param input - Compressed input buffer
    * @param inputOffset - Offset into input buffer
    * @param outSize - Expected output size
+   * @param output - Pre-allocated output buffer to write to
+   * @param outputOffset - Offset in output buffer to start writing
    * @param solid - If true, preserve state from previous decode
-   * @returns Decompressed data
-   */ _proto.decode = function decode(input, inputOffset, outSize) {
-        var solid = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+   * @returns Number of bytes written
+   */ _proto.decodeToBuffer = function decodeToBuffer(input, inputOffset, outSize, output, outputOffset) {
+        var solid = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : false;
         this.rangeDecoder.setInput(input, inputOffset);
         if (!solid) {
             this.outWindow.init(false);
@@ -476,10 +478,10 @@ var LzmaDecoder = /*#__PURE__*/ function() {
             // Solid mode: preserve dictionary state but reinitialize range decoder
             this.outWindow.init(true);
         }
-        var output = (0, _extractbaseiterator.allocBufferUnsafe)(outSize);
-        var outPos = 0;
+        var outPos = outputOffset;
+        var outEnd = outputOffset + outSize;
         var cumPos = this.totalPos;
-        while(outPos < outSize){
+        while(outPos < outEnd){
             var posState = cumPos & this.posStateMask;
             if (this.rangeDecoder.decodeBit(this.isMatchDecoders, (this.state << _typests.kNumPosStatesBitsMax) + posState) === 0) {
                 // Literal
@@ -563,6 +565,19 @@ var LzmaDecoder = /*#__PURE__*/ function() {
             }
         }
         this.totalPos = cumPos;
+        return outPos - outputOffset;
+    };
+    /**
+   * Decode LZMA data
+   * @param input - Compressed input buffer
+   * @param inputOffset - Offset into input buffer
+   * @param outSize - Expected output size
+   * @param solid - If true, preserve state from previous decode
+   * @returns Decompressed data
+   */ _proto.decode = function decode(input, inputOffset, outSize) {
+        var solid = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+        var output = (0, _extractbaseiterator.allocBufferUnsafe)(outSize);
+        this.decodeToBuffer(input, inputOffset, outSize, output, 0, solid);
         return output;
     };
     return LzmaDecoder;