7z-iterator 0.1.0

package/dist/esm/sevenz/codecs/Aes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Aes.ts"],"sourcesContent":["// 7z AES-256-CBC codec with SHA-256 key derivation\n// Implements password-based decryption for encrypted 7z archives\n//\n// Properties format:\n//   Byte 0: bits 0-5 = NumCyclesPower (iterations = 2^NumCyclesPower)\n//           bit 6 = IV present flag\n//           bit 7 = Salt present flag\n//   Byte 1: upper nibble = salt size extension\n//           lower nibble = IV size extension\n//   Following bytes: salt data, then IV data\n//\n// Key derivation:\n//   For each round (2^NumCyclesPower times):\n//     hash = SHA256(salt + password_utf16le + round_counter_8bytes)\n//   Final key = first 32 bytes of accumulated hash\n\nimport crypto from 'crypto';\nimport { allocBuffer, bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n// Global password storage - set before decryption\nvar _password: string | null = null;\n\n/**\n * Set the password for AES decryption\n */\nexport function setPassword(password: string | null): void {\n  _password = password;\n}\n\n/**\n * Get the current password\n */\nexport function getPassword(): string | null {\n  return _password;\n}\n\n/**\n * Parse AES properties to extract key derivation parameters\n */\nfunction parseProperties(properties: Buffer): { numCyclesPower: number; salt: Buffer; iv: Buffer } {\n  if (!properties || properties.length < 1) {\n    throw new Error('AES: missing properties');\n  }\n\n  var b0 = properties[0];\n  var numCyclesPower = b0 & 0x3f;\n\n  // Check for special case: no salt/IV flags\n  if ((b0 & 0xc0) === 0) {\n    // No salt, no IV - use zeros\n    return {\n      numCyclesPower: numCyclesPower,\n      salt: allocBuffer(0),\n      iv: allocBuffer(16),\n    };\n  }\n\n  if (properties.length < 2) {\n    throw new Error('AES: properties too short');\n  }\n\n  var b1 = properties[1];\n\n  // Calculate sizes\n  // saltSize = ((b0 >> 7) & 1) + (b1 >> 4)\n  // ivSize = ((b0 >> 6) & 1) + (b1 & 0x0F)\n  var saltSize = ((b0 >>> 7) & 1) + (b1 >>> 4);\n  var ivSize = ((b0 >>> 6) & 1) + (b1 & 0x0f);\n\n  var expectedSize = 2 + saltSize + ivSize;\n  if (properties.length < expectedSize) {\n    throw new Error('AES: properties too short for salt/IV');\n  }\n\n  var salt = properties.slice(2, 2 + saltSize);\n  var iv = allocBuffer(16);\n\n  // Copy IV data (may be less than 16 bytes, rest is zeros)\n  var ivData = properties.slice(2 + saltSize, 2 + saltSize + ivSize);\n  for (var i = 0; i < ivData.length && i < 16; i++) {\n    iv[i] = ivData[i];\n  }\n\n  return {\n    numCyclesPower: numCyclesPower,\n    salt: salt,\n    iv: iv,\n  };\n}\n\n/**\n * Convert password string to UTF-16LE buffer\n */\nfunction passwordToUtf16LE(password: string): Buffer {\n  var buf = allocBuffer(password.length * 2);\n  for (var i = 0; i < password.length; i++) {\n    var code = password.charCodeAt(i);\n    buf[i * 2] = code & 0xff;\n    buf[i * 2 + 1] = (code >>> 8) & 0xff;\n  }\n  return buf;\n}\n\n/**\n * Derive AES-256 key from password using 7z's SHA-256 iteration scheme\n *\n * Algorithm:\n *   For round = 0 to 2^numCyclesPower - 1:\n *     hash.update(salt)\n *     hash.update(password_utf16le)\n *     hash.update(round as 8-byte little-endian)\n *   key = hash.digest()\n */\nfunction deriveKey(password: string, salt: Buffer, numCyclesPower: number): Buffer {\n  var passwordBuf = passwordToUtf16LE(password);\n  var numRounds = 2 ** numCyclesPower;\n\n  // For special case 0x3F, don't iterate\n  if (numCyclesPower === 0x3f) {\n    // Direct concatenation mode\n    var key = allocBuffer(32);\n    var offset = 0;\n    for (var j = 0; j < salt.length && offset < 32; j++) {\n      key[offset++] = salt[j];\n    }\n    for (var k = 0; k < passwordBuf.length && offset < 32; k++) {\n      key[offset++] = passwordBuf[k];\n    }\n    return key;\n  }\n\n  // Counter buffer (8 bytes, little-endian)\n  var counter = allocBuffer(8);\n\n  // Create hash and iterate\n  var hash = crypto.createHash('sha256');\n\n  for (var round = 0; round < numRounds; round++) {\n    // Write round counter as little-endian 64-bit\n    counter[0] = round & 0xff;\n    counter[1] = (round >>> 8) & 0xff;\n    counter[2] = (round >>> 16) & 0xff;\n    counter[3] = (round >>> 24) & 0xff;\n    // Upper 32 bits - for large round counts\n    var high = Math.floor(round / 0x100000000);\n    counter[4] = high & 0xff;\n    counter[5] = (high >>> 8) & 0xff;\n    counter[6] = (high >>> 16) & 0xff;\n    counter[7] = (high >>> 24) & 0xff;\n\n    hash.update(salt);\n    hash.update(passwordBuf);\n    hash.update(counter);\n  }\n\n  return hash.digest() as Buffer;\n}\n\n/**\n * Decode AES-256-CBC encrypted data\n *\n * @param input - Encrypted data\n * @param properties - AES properties (numCyclesPower, salt, IV)\n * @param _unpackSize - Unused\n * @returns Decrypted data\n */\nexport function decodeAes(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  if (!_password) {\n    throw new Error('AES: password required but not set');\n  }\n\n  if (!properties) {\n    throw new Error('AES: properties required');\n  }\n\n  var params = parseProperties(properties);\n  var key = deriveKey(_password, params.salt, params.numCyclesPower);\n\n  // Create AES-256-CBC decipher\n  var decipher = crypto.createDecipheriv('aes-256-cbc', key, params.iv);\n  decipher.setAutoPadding(false); // 7z doesn't use PKCS7 padding\n\n  // Node 0.8 returns binary strings, newer Node returns Buffers\n  // Use 'binary' encoding for compatibility\n  // @ts-expect-error - 'binary' encoding is deprecated but required for Node 0.8 compatibility\n  var decStr = decipher.update(input, 'binary', 'binary') + decipher.final('binary');\n  var decrypted = bufferFrom(decStr, 'binary' as BufferEncoding);\n\n  return decrypted;\n}\n\n/**\n * Create an AES decoder Transform stream\n */\nexport function createAesDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeAes, properties, unpackSize);\n}\n"],"names":["crypto","allocBuffer","bufferFrom","createBufferingDecoder","_password","setPassword","password","getPassword","parseProperties","properties","length","Error","b0","numCyclesPower","salt","iv","b1","saltSize","ivSize","expectedSize","slice","ivData","i","passwordToUtf16LE","buf","code","charCodeAt","deriveKey","passwordBuf","numRounds","key","offset","j","k","counter","hash","createHash","round","high","Math","floor","update","digest","decodeAes","input","_unpackSize","params","decipher","createDecipheriv","setAutoPadding","decStr","final","decrypted","createAesDecoder","unpackSize"],"mappings":"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"}

package/dist/esm/sevenz/codecs/BZip2.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode BZip2 compressed data
+ *
+ * @param input - BZip2 compressed data (with BZh header)
+ * @param _properties - Unused for BZip2
+ * @param _unpackSize - Unused for seek-bzip
+ * @returns Decompressed data
+ */
+export declare function decodeBzip2(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a BZip2 decoder Transform stream
+ */
+export declare function createBzip2Decoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/BZip2.js

@@ -0,0 +1,22 @@
+// BZip2 codec - bzip2 compression
+// 7z stores bzip2 data with the standard BZh header
+//
+// Uses seek-bzip for decompression (pure JavaScript)
+import Bunzip from 'seek-bzip';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode BZip2 compressed data
+ *
+ * @param input - BZip2 compressed data (with BZh header)
+ * @param _properties - Unused for BZip2
+ * @param _unpackSize - Unused for seek-bzip
+ * @returns Decompressed data
+ */ export function decodeBzip2(input, _properties, _unpackSize) {
+    // seek-bzip.decode(input, output) - returns output buffer
+    return Bunzip.decode(input);
+}
+/**
+ * Create a BZip2 decoder Transform stream
+ */ export function createBzip2Decoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeBzip2, properties, unpackSize);
+}

package/dist/esm/sevenz/codecs/BZip2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BZip2.ts"],"sourcesContent":["// BZip2 codec - bzip2 compression\n// 7z stores bzip2 data with the standard BZh header\n//\n// Uses seek-bzip for decompression (pure JavaScript)\n\nimport type { Transform } from 'readable-stream';\nimport Bunzip from 'seek-bzip';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode BZip2 compressed data\n *\n * @param input - BZip2 compressed data (with BZh header)\n * @param _properties - Unused for BZip2\n * @param _unpackSize - Unused for seek-bzip\n * @returns Decompressed data\n */\nexport function decodeBzip2(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  // seek-bzip.decode(input, output) - returns output buffer\n  return Bunzip.decode(input);\n}\n\n/**\n * Create a BZip2 decoder Transform stream\n */\nexport function createBzip2Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBzip2, properties, unpackSize);\n}\n"],"names":["Bunzip","createBufferingDecoder","decodeBzip2","input","_properties","_unpackSize","decode","createBzip2Decoder","properties","unpackSize"],"mappings":"AAAA,kCAAkC;AAClC,oDAAoD;AACpD,EAAE;AACF,qDAAqD;AAGrD,OAAOA,YAAY,YAAY;AAC/B,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;CAOC,GACD,OAAO,SAASC,YAAYC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACnF,0DAA0D;IAC1D,OAAOL,OAAOM,MAAM,CAACH;AACvB;AAEA;;CAEC,GACD,OAAO,SAASI,mBAAmBC,UAAmB,EAAEC,UAAmB;IACzE,OAAOR,uBAAuBC,aAAaM,YAAYC;AACzD"}

package/dist/esm/sevenz/codecs/Bcj.d.ts

@@ -0,0 +1,15 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode BCJ (x86) filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * @param input - BCJ filtered data
+ * @param _properties - Unused for BCJ
+ * @param _unpackSize - Unused for BCJ
+ * @returns Unfiltered data
+ */
+export declare function decodeBcj(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a BCJ decoder Transform stream
+ */
+export declare function createBcjDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Bcj.js

@@ -0,0 +1,75 @@
+// BCJ (x86) filter codec - converts x86 CALL/JMP relative addresses
+// This is a simple filter that makes executables more compressible by LZMA
+//
+// BCJ transforms relative addresses in x86 CALL (0xE8) and JMP (0xE9) instructions
+// to absolute addresses, which creates more repetitive patterns for compression.
+//
+// Reference: https://github.com/jljusten/LZMA-SDK/blob/master/C/Bra86.c
+import { bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode BCJ (x86) filtered data
+ * Reverses the BCJ transformation by converting absolute addresses back to relative
+ *
+ * @param input - BCJ filtered data
+ * @param _properties - Unused for BCJ
+ * @param _unpackSize - Unused for BCJ
+ * @returns Unfiltered data
+ */ export function decodeBcj(input, _properties, _unpackSize) {
+    // BCJ filter state
+    var pos = 0;
+    var prevMask = 0;
+    var output = bufferFrom(input); // Copy since we modify in place
+    while(pos < output.length - 4){
+        var b = output[pos];
+        // Check for CALL (0xE8) or JMP (0xE9) opcode
+        if (b !== 0xe8 && b !== 0xe9) {
+            pos++;
+            prevMask = 0;
+            continue;
+        }
+        // Check mask to avoid false positives in data
+        var offset = pos + 5;
+        if (offset > output.length) {
+            break;
+        }
+        // Skip if in masked region (previous conversion affected this area)
+        if ((prevMask & 1) !== 0) {
+            prevMask = prevMask >> 1 | 4;
+            pos++;
+            continue;
+        }
+        // Read the 32-bit address (little-endian)
+        var addr = output[pos + 1] | output[pos + 2] << 8 | output[pos + 3] << 16 | output[pos + 4] << 24 >>> 0;
+        // Check if this looks like a converted address
+        // High byte should be 0x00 or 0xFF for typical code
+        var highByte = output[pos + 4];
+        if (highByte === 0x00 || highByte === 0xff) {
+            // Convert absolute to relative
+            var newAddr;
+            if (highByte === 0x00) {
+                // Positive offset - subtract position
+                newAddr = addr - pos;
+            } else {
+                // Negative offset (0xFF high byte)
+                newAddr = addr + pos;
+            }
+            // Write back as little-endian
+            output[pos + 1] = newAddr & 0xff;
+            output[pos + 2] = newAddr >>> 8 & 0xff;
+            output[pos + 3] = newAddr >>> 16 & 0xff;
+            output[pos + 4] = newAddr >>> 24 & 0xff;
+            pos += 5;
+            prevMask = 0;
+        } else {
+            pos++;
+            prevMask = 0;
+        }
+    }
+    return output;
+}
+/**
+ * Create a BCJ decoder Transform stream
+ */ export function createBcjDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeBcj, properties, unpackSize);
+}

package/dist/esm/sevenz/codecs/Bcj.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/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/jljusten/LZMA-SDK/blob/master/C/Bra86.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode BCJ (x86) filtered data\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  // BCJ filter state\n  var pos = 0;\n  var prevMask = 0;\n  var output = bufferFrom(input); // Copy since we modify in place\n\n  while (pos < output.length - 4) {\n    var b = output[pos];\n\n    // Check for CALL (0xE8) or JMP (0xE9) opcode\n    if (b !== 0xe8 && b !== 0xe9) {\n      pos++;\n      prevMask = 0;\n      continue;\n    }\n\n    // Check mask to avoid false positives in data\n    var offset = pos + 5;\n    if (offset > output.length) {\n      break;\n    }\n\n    // Skip if in masked region (previous conversion affected this area)\n    if ((prevMask & 1) !== 0) {\n      prevMask = (prevMask >> 1) | 4;\n      pos++;\n      continue;\n    }\n\n    // Read the 32-bit address (little-endian)\n    var addr = output[pos + 1] | (output[pos + 2] << 8) | (output[pos + 3] << 16) | ((output[pos + 4] << 24) >>> 0);\n\n    // Check if this looks like a converted address\n    // High byte should be 0x00 or 0xFF for typical code\n    var highByte = output[pos + 4];\n\n    if (highByte === 0x00 || highByte === 0xff) {\n      // Convert absolute to relative\n      var newAddr: number;\n      if (highByte === 0x00) {\n        // Positive offset - subtract position\n        newAddr = addr - pos;\n      } else {\n        // Negative offset (0xFF high byte)\n        newAddr = addr + pos;\n      }\n\n      // Write back as little-endian\n      output[pos + 1] = newAddr & 0xff;\n      output[pos + 2] = (newAddr >>> 8) & 0xff;\n      output[pos + 3] = (newAddr >>> 16) & 0xff;\n      output[pos + 4] = (newAddr >>> 24) & 0xff;\n\n      pos += 5;\n      prevMask = 0;\n    } else {\n      pos++;\n      prevMask = 0;\n    }\n  }\n\n  return output;\n}\n\n/**\n * Create a BCJ decoder Transform stream\n */\nexport function createBcjDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcj, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcj","input","_properties","_unpackSize","pos","prevMask","output","length","b","offset","addr","highByte","newAddr","createBcjDecoder","properties","unpackSize"],"mappings":"AAAA,oEAAoE;AACpE,2EAA2E;AAC3E,EAAE;AACF,mFAAmF;AACnF,iFAAiF;AACjF,EAAE;AACF,wEAAwE;AAExE,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;CAQC,GACD,OAAO,SAASC,UAAUC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACjF,mBAAmB;IACnB,IAAIC,MAAM;IACV,IAAIC,WAAW;IACf,IAAIC,SAASR,WAAWG,QAAQ,gCAAgC;IAEhE,MAAOG,MAAME,OAAOC,MAAM,GAAG,EAAG;QAC9B,IAAIC,IAAIF,MAAM,CAACF,IAAI;QAEnB,6CAA6C;QAC7C,IAAII,MAAM,QAAQA,MAAM,MAAM;YAC5BJ;YACAC,WAAW;YACX;QACF;QAEA,8CAA8C;QAC9C,IAAII,SAASL,MAAM;QACnB,IAAIK,SAASH,OAAOC,MAAM,EAAE;YAC1B;QACF;QAEA,oEAAoE;QACpE,IAAI,AAACF,CAAAA,WAAW,CAAA,MAAO,GAAG;YACxBA,WAAW,AAACA,YAAY,IAAK;YAC7BD;YACA;QACF;QAEA,0CAA0C;QAC1C,IAAIM,OAAOJ,MAAM,CAACF,MAAM,EAAE,GAAIE,MAAM,CAACF,MAAM,EAAE,IAAI,IAAME,MAAM,CAACF,MAAM,EAAE,IAAI,KAAO,AAACE,MAAM,CAACF,MAAM,EAAE,IAAI,OAAQ;QAE7G,+CAA+C;QAC/C,oDAAoD;QACpD,IAAIO,WAAWL,MAAM,CAACF,MAAM,EAAE;QAE9B,IAAIO,aAAa,QAAQA,aAAa,MAAM;YAC1C,+BAA+B;YAC/B,IAAIC;YACJ,IAAID,aAAa,MAAM;gBACrB,sCAAsC;gBACtCC,UAAUF,OAAON;YACnB,OAAO;gBACL,mCAAmC;gBACnCQ,UAAUF,OAAON;YACnB;YAEA,8BAA8B;YAC9BE,MAAM,CAACF,MAAM,EAAE,GAAGQ,UAAU;YAC5BN,MAAM,CAACF,MAAM,EAAE,GAAG,AAACQ,YAAY,IAAK;YACpCN,MAAM,CAACF,MAAM,EAAE,GAAG,AAACQ,YAAY,KAAM;YACrCN,MAAM,CAACF,MAAM,EAAE,GAAG,AAACQ,YAAY,KAAM;YAErCR,OAAO;YACPC,WAAW;QACb,OAAO;YACLD;YACAC,WAAW;QACb;IACF;IAEA,OAAOC;AACT;AAEA;;CAEC,GACD,OAAO,SAASO,iBAAiBC,UAAmB,EAAEC,UAAmB;IACvE,OAAOhB,uBAAuBC,WAAWc,YAAYC;AACvD"}

package/dist/esm/sevenz/codecs/Copy.d.ts

@@ -0,0 +1,14 @@
+import { type Transform } from 'readable-stream';
+/**
+ * Create a Copy decoder stream
+ * Simply passes through data unchanged
+ */
+export declare function createCopyDecoder(): Transform;
+/**
+ * Decode a buffer using Copy codec (no-op)
+ * @param input - Input buffer
+ * @param _properties - Unused
+ * @param _unpackSize - Unused
+ * @returns Same buffer (no transformation)
+ */
+export declare function decodeCopy(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;

package/dist/esm/sevenz/codecs/Copy.js

@@ -0,0 +1,18 @@
+// Copy codec - passthrough (no compression)
+// This is the simplest codec, just passes data through unchanged
+import { PassThrough } from 'readable-stream';
+/**
+ * Create a Copy decoder stream
+ * Simply passes through data unchanged
+ */ export function createCopyDecoder() {
+    return new PassThrough();
+}
+/**
+ * Decode a buffer using Copy codec (no-op)
+ * @param input - Input buffer
+ * @param _properties - Unused
+ * @param _unpackSize - Unused
+ * @returns Same buffer (no transformation)
+ */ export function decodeCopy(input, _properties, _unpackSize) {
+    return input;
+}

package/dist/esm/sevenz/codecs/Copy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Copy.ts"],"sourcesContent":["// Copy codec - passthrough (no compression)\n// This is the simplest codec, just passes data through unchanged\n\nimport { PassThrough, type Transform } from 'readable-stream';\n\n/**\n * Create a Copy decoder stream\n * Simply passes through data unchanged\n */\nexport function createCopyDecoder(): Transform {\n  return new PassThrough();\n}\n\n/**\n * Decode a buffer using Copy codec (no-op)\n * @param input - Input buffer\n * @param _properties - Unused\n * @param _unpackSize - Unused\n * @returns Same buffer (no transformation)\n */\nexport function decodeCopy(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  return input;\n}\n"],"names":["PassThrough","createCopyDecoder","decodeCopy","input","_properties","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,iEAAiE;AAEjE,SAASA,WAAW,QAAwB,kBAAkB;AAE9D;;;CAGC,GACD,OAAO,SAASC;IACd,OAAO,IAAID;AACb;AAEA;;;;;;CAMC,GACD,OAAO,SAASE,WAAWC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IAClF,OAAOF;AACT"}

package/dist/esm/sevenz/codecs/Deflate.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode Deflate compressed data
+ *
+ * @param input - Deflate compressed data
+ * @param _properties - Unused for Deflate
+ * @param _unpackSize - Unused for Deflate
+ * @returns Decompressed data
+ */
+export declare function decodeDeflate(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a Deflate decoder Transform stream
+ */
+export declare function createDeflateDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Deflate.js

@@ -0,0 +1,24 @@
+// Deflate codec - standard zlib/zip compression
+// 7z uses raw deflate without zlib or gzip headers
+//
+// Uses pako for pure JavaScript decompression (works on all Node versions)
+import { bufferFrom } from 'extract-base-iterator';
+import pako from 'pako';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode Deflate compressed data
+ *
+ * @param input - Deflate compressed data
+ * @param _properties - Unused for Deflate
+ * @param _unpackSize - Unused for Deflate
+ * @returns Decompressed data
+ */ export function decodeDeflate(input, _properties, _unpackSize) {
+    // pako.inflateRaw returns Uint8Array, convert to Buffer
+    var result = pako.inflateRaw(input);
+    return bufferFrom(result);
+}
+/**
+ * Create a Deflate decoder Transform stream
+ */ export function createDeflateDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeDeflate, properties, unpackSize);
+}

package/dist/esm/sevenz/codecs/Deflate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Deflate.ts"],"sourcesContent":["// Deflate codec - standard zlib/zip compression\n// 7z uses raw deflate without zlib or gzip headers\n//\n// Uses pako for pure JavaScript decompression (works on all Node versions)\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport pako from 'pako';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode Deflate compressed data\n *\n * @param input - Deflate compressed data\n * @param _properties - Unused for Deflate\n * @param _unpackSize - Unused for Deflate\n * @returns Decompressed data\n */\nexport function decodeDeflate(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  // pako.inflateRaw returns Uint8Array, convert to Buffer\n  var result = pako.inflateRaw(input);\n  return bufferFrom(result);\n}\n\n/**\n * Create a Deflate decoder Transform stream\n */\nexport function createDeflateDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeDeflate, properties, unpackSize);\n}\n"],"names":["bufferFrom","pako","createBufferingDecoder","decodeDeflate","input","_properties","_unpackSize","result","inflateRaw","createDeflateDecoder","properties","unpackSize"],"mappings":"AAAA,gDAAgD;AAChD,mDAAmD;AACnD,EAAE;AACF,2EAA2E;AAE3E,SAASA,UAAU,QAAQ,wBAAwB;AACnD,OAAOC,UAAU,OAAO;AAExB,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;CAOC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,wDAAwD;IACxD,IAAIC,SAASN,KAAKO,UAAU,CAACJ;IAC7B,OAAOJ,WAAWO;AACpB;AAEA;;CAEC,GACD,OAAO,SAASE,qBAAqBC,UAAmB,EAAEC,UAAmB;IAC3E,OAAOT,uBAAuBC,eAAeO,YAAYC;AAC3D"}

package/dist/esm/sevenz/codecs/Delta.d.ts

@@ -0,0 +1,15 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode Delta filtered data
+ * Reverses the delta transformation by adding previous values
+ *
+ * @param input - Delta filtered data
+ * @param properties - Optional 1-byte properties (distance - 1)
+ * @param _unpackSize - Unused for Delta
+ * @returns Unfiltered data
+ */
+export declare function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a Delta decoder Transform stream
+ */
+export declare function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Delta.js

@@ -0,0 +1,41 @@
+// Delta filter codec - stores differences between consecutive bytes
+// Useful for data with gradual changes (images, audio, sensor data)
+//
+// The Delta filter stores the difference between each byte and the byte
+// N positions before it, where N is the "distance" parameter (default 1).
+// This makes data with regular patterns more compressible.
+import { bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from './createBufferingDecoder.js';
+/**
+ * Decode Delta filtered data
+ * Reverses the delta transformation by adding previous values
+ *
+ * @param input - Delta filtered data
+ * @param properties - Optional 1-byte properties (distance - 1)
+ * @param _unpackSize - Unused for Delta
+ * @returns Unfiltered data
+ */ export function decodeDelta(input, properties, _unpackSize) {
+    // Distance parameter: default is 1
+    var distance = 1;
+    if (properties && properties.length >= 1) {
+        // Properties byte contains (distance - 1)
+        distance = properties[0] + 1;
+    }
+    var output = bufferFrom(input); // Copy since we modify in place
+    // State buffer for multi-byte distance
+    var state = new Array(distance);
+    for(var i = 0; i < distance; i++){
+        state[i] = 0;
+    }
+    for(var j = 0; j < output.length; j++){
+        var idx = j % distance;
+        state[idx] = state[idx] + output[j] & 0xff;
+        output[j] = state[idx];
+    }
+    return output;
+}
+/**
+ * Create a Delta decoder Transform stream
+ */ export function createDeltaDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeDelta, properties, unpackSize);
+}

package/dist/esm/sevenz/codecs/Delta.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/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\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode Delta filtered data\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  var distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  var output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  var state = new Array(distance);\n  for (var i = 0; i < distance; i++) {\n    state[i] = 0;\n  }\n\n  for (var j = 0; j < output.length; j++) {\n    var 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 Delta decoder Transform stream\n */\nexport function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeDelta, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","state","Array","i","j","idx","createDeltaDecoder","unpackSize"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAE3D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;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,IAAII,SAASR,WAAWG,QAAQ,gCAAgC;IAEhE,uCAAuC;IACvC,IAAIM,QAAQ,IAAIC,MAAMJ;IACtB,IAAK,IAAIK,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCF,KAAK,CAACE,EAAE,GAAG;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOD,MAAM,EAAEK,IAAK;QACtC,IAAIC,MAAMD,IAAIN;QACdG,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;;CAEC,GACD,OAAO,SAASM,mBAAmBV,UAAmB,EAAEW,UAAmB;IACzE,OAAOd,uBAAuBC,aAAaE,YAAYW;AACzD"}

package/dist/esm/sevenz/codecs/Lzma.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode LZMA compressed data to buffer
+ *
+ * @param input - LZMA compressed data
+ * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)
+ * @param unpackSize - Expected output size (optional, -1 for unknown)
+ * @returns Decompressed data
+ */
+export declare function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
+/**
+ * Create an LZMA decoder Transform stream
+ */
+export declare function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Lzma.js

@@ -0,0 +1,38 @@
+// LZMA codec - uses lzma-purejs for raw LZMA decompression
+// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)
+// Import lzma-purejs - provides raw LZMA decoder
+import lzmajs from 'lzma-purejs';
+import createBufferingDecoder from './createBufferingDecoder.js';
+import { createInputStream, createOutputStream } from './streams.js';
+var LzmaDecoder = lzmajs.LZMA.Decoder;
+/**
+ * Decode LZMA compressed data to buffer
+ *
+ * @param input - LZMA compressed data
+ * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)
+ * @param unpackSize - Expected output size (optional, -1 for unknown)
+ * @returns Decompressed data
+ */ export function decodeLzma(input, properties, unpackSize) {
+    if (!properties || properties.length < 5) {
+        throw new Error('LZMA requires 5-byte properties');
+    }
+    var decoder = new LzmaDecoder();
+    // setDecoderProperties expects array-like with 5 bytes
+    if (!decoder.setDecoderProperties(properties)) {
+        throw new Error('Invalid LZMA properties');
+    }
+    var inStream = createInputStream(input, 0, input.length);
+    var outStream = createOutputStream();
+    // Use -1 for unknown size (decoder will use end marker)
+    var size = typeof unpackSize === 'number' ? unpackSize : -1;
+    var success = decoder.code(inStream, outStream, size);
+    if (!success) {
+        throw new Error('LZMA decompression failed');
+    }
+    return outStream.toBuffer();
+}
+/**
+ * Create an LZMA decoder Transform stream
+ */ export function createLzmaDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeLzma, properties, unpackSize);
+}

package/dist/esm/sevenz/codecs/Lzma.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["// LZMA codec - uses lzma-purejs for raw LZMA decompression\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n\n// Import lzma-purejs - provides raw LZMA decoder\nimport lzmajs from 'lzma-purejs';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createInputStream, createOutputStream } from './streams.ts';\n\nvar LzmaDecoder = lzmajs.LZMA.Decoder;\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size (optional, -1 for unknown)\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  var decoder = new LzmaDecoder();\n\n  // setDecoderProperties expects array-like with 5 bytes\n  if (!decoder.setDecoderProperties(properties)) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  var inStream = createInputStream(input, 0, input.length);\n  var outStream = createOutputStream();\n\n  // Use -1 for unknown size (decoder will use end marker)\n  var size = typeof unpackSize === 'number' ? unpackSize : -1;\n\n  var success = decoder.code(inStream, outStream, size);\n  if (!success) {\n    throw new Error('LZMA decompression failed');\n  }\n\n  return outStream.toBuffer();\n}\n\n/**\n * Create an LZMA decoder Transform stream\n */\nexport function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeLzma, properties, unpackSize);\n}\n"],"names":["lzmajs","createBufferingDecoder","createInputStream","createOutputStream","LzmaDecoder","LZMA","Decoder","decodeLzma","input","properties","unpackSize","length","Error","decoder","setDecoderProperties","inStream","outStream","size","success","code","toBuffer","createLzmaDecoder"],"mappings":"AAAA,2DAA2D;AAC3D,+FAA+F;AAE/F,iDAAiD;AACjD,OAAOA,YAAY,cAAc;AAEjC,OAAOC,4BAA4B,8BAA8B;AACjE,SAASC,iBAAiB,EAAEC,kBAAkB,QAAQ,eAAe;AAErE,IAAIC,cAAcJ,OAAOK,IAAI,CAACC,OAAO;AAErC;;;;;;;CAOC,GACD,OAAO,SAASC,WAAWC,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAIC,UAAU,IAAIT;IAElB,uDAAuD;IACvD,IAAI,CAACS,QAAQC,oBAAoB,CAACL,aAAa;QAC7C,MAAM,IAAIG,MAAM;IAClB;IAEA,IAAIG,WAAWb,kBAAkBM,OAAO,GAAGA,MAAMG,MAAM;IACvD,IAAIK,YAAYb;IAEhB,wDAAwD;IACxD,IAAIc,OAAO,OAAOP,eAAe,WAAWA,aAAa,CAAC;IAE1D,IAAIQ,UAAUL,QAAQM,IAAI,CAACJ,UAAUC,WAAWC;IAChD,IAAI,CAACC,SAAS;QACZ,MAAM,IAAIN,MAAM;IAClB;IAEA,OAAOI,UAAUI,QAAQ;AAC3B;AAEA;;CAEC,GACD,OAAO,SAASC,kBAAkBZ,UAAmB,EAAEC,UAAmB;IACxE,OAAOT,uBAAuBM,YAAYE,YAAYC;AACxD"}

package/dist/esm/sevenz/codecs/Lzma2.d.ts

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode LZMA2 compressed data to buffer
+ *
+ * @param input - LZMA2 compressed data
+ * @param properties - Properties buffer (1 byte: dictionary size)
+ * @param _unpackSize - Unused (LZMA2 has internal size markers)
+ * @returns Decompressed data
+ */
+export declare function decodeLzma2(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create an LZMA2 decoder Transform stream
+ */
+export declare function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Lzma2.js

@@ -0,0 +1,145 @@
+// LZMA2 codec - wrapper around lzma-purejs for LZMA2 decompression
+// LZMA2 is a container format that wraps LZMA chunks with framing
+//
+// LZMA2 format specification:
+// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md
+//
+// Control byte values:
+// 0x00         = End of stream
+// 0x01         = Uncompressed chunk, dictionary reset
+// 0x02         = Uncompressed chunk, no dictionary reset
+// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)
+// Import lzma-purejs - provides raw LZMA decoder
+import lzmajs from 'lzma-purejs';
+import createBufferingDecoder from './createBufferingDecoder.js';
+import { createInputStream, createOutputStream } from './streams.js';
+var LzmaDecoder = lzmajs.LZMA.Decoder;
+/**
+ * Decode LZMA2 dictionary size from properties byte
+ * Properties byte encodes dictionary size as: 2^(dictByte/2 + 12) or similar
+ *
+ * Per XZ spec, dictionary sizes are:
+ * 0x00 = 4 KiB (2^12)
+ * 0x01 = 6 KiB
+ * 0x02 = 8 KiB (2^13)
+ * ...
+ * 0x28 = 1.5 GiB
+ */ function decodeDictionarySize(propByte) {
+    if (propByte > 40) {
+        throw new Error(`Invalid LZMA2 dictionary size property: ${propByte}`);
+    }
+    if (propByte === 40) {
+        // Max dictionary size: 4 GiB - 1
+        return 0xffffffff;
+    }
+    // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)
+    var base = 2 | propByte & 1;
+    var shift = Math.floor(propByte / 2) + 11;
+    return base << shift;
+}
+/**
+ * Decode LZMA2 compressed data to buffer
+ *
+ * @param input - LZMA2 compressed data
+ * @param properties - Properties buffer (1 byte: dictionary size)
+ * @param _unpackSize - Unused (LZMA2 has internal size markers)
+ * @returns Decompressed data
+ */ export function decodeLzma2(input, properties, _unpackSize) {
+    if (!properties || properties.length < 1) {
+        throw new Error('LZMA2 requires properties byte');
+    }
+    var dictSize = decodeDictionarySize(properties[0]);
+    var output = [];
+    var offset = 0;
+    // LZMA decoder instance - reused across chunks
+    var decoder = new LzmaDecoder();
+    decoder.setDictionarySize(dictSize);
+    // Track current LZMA properties (lc, lp, pb)
+    var propsSet = false;
+    while(offset < input.length){
+        var control = input[offset++];
+        if (control === 0x00) {
+            break;
+        }
+        if (control === 0x01 || control === 0x02) {
+            // Uncompressed chunk
+            // 0x01 = dictionary reset + uncompressed
+            // 0x02 = uncompressed (no reset)
+            // Note: Dictionary reset (0x01) is handled implicitly since we don't
+            // maintain dictionary state across uncompressed chunks in this implementation
+            if (offset + 2 > input.length) {
+                throw new Error('Truncated LZMA2 uncompressed chunk header');
+            }
+            // Size is big-endian, 16-bit, value + 1
+            var uncompSize = (input[offset] << 8 | input[offset + 1]) + 1;
+            offset += 2;
+            if (offset + uncompSize > input.length) {
+                throw new Error('Truncated LZMA2 uncompressed data');
+            }
+            // Copy uncompressed data
+            output.push(input.slice(offset, offset + uncompSize));
+            offset += uncompSize;
+        } else if (control >= 0x80) {
+            // LZMA compressed chunk
+            // Control byte format (bits 7-0):
+            // Bit 7: always 1 for LZMA chunk
+            // Bit 6: reset state
+            // Bit 5: new properties (implies state reset)
+            // Bits 4-0: high 5 bits of uncompressed size - 1
+            var newProps = (control & 0x20) !== 0;
+            if (offset + 4 > input.length) {
+                throw new Error('Truncated LZMA2 LZMA chunk header');
+            }
+            // Uncompressed size: 5 bits from control + 16 bits from next 2 bytes + 1
+            var uncompHigh = control & 0x1f;
+            var uncompSize2 = (uncompHigh << 16 | input[offset] << 8 | input[offset + 1]) + 1;
+            offset += 2;
+            // Compressed size: 16 bits + 1
+            var compSize = (input[offset] << 8 | input[offset + 1]) + 1;
+            offset += 2;
+            // If new properties, read 1-byte LZMA properties
+            if (newProps) {
+                if (offset >= input.length) {
+                    throw new Error('Truncated LZMA2 properties byte');
+                }
+                var propsByte = input[offset++];
+                // Properties byte: pb * 45 + lp * 9 + lc
+                // where pb, lp, lc are LZMA parameters
+                var lc = propsByte % 9;
+                var remainder = Math.floor(propsByte / 9);
+                var lp = remainder % 5;
+                var pb = Math.floor(remainder / 5);
+                if (!decoder.setLcLpPb(lc, lp, pb)) {
+                    throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);
+                }
+                propsSet = true;
+            }
+            if (!propsSet) {
+                throw new Error('LZMA chunk without properties');
+            }
+            if (offset + compSize > input.length) {
+                throw new Error('Truncated LZMA2 compressed data');
+            }
+            // Decode LZMA chunk
+            var inStream = createInputStream(input, offset, compSize);
+            var outStream = createOutputStream();
+            // Note: decoder.code() internally calls init() after setting streams
+            // For LZMA2, the decoder state is managed per-chunk through props resets
+            // Decode the chunk
+            var success = decoder.code(inStream, outStream, uncompSize2);
+            if (!success) {
+                throw new Error('LZMA decompression failed');
+            }
+            output.push(outStream.toBuffer());
+            offset += compSize;
+        } else {
+            throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);
+        }
+    }
+    return Buffer.concat(output);
+}
+/**
+ * Create an LZMA2 decoder Transform stream
+ */ export function createLzma2Decoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeLzma2, properties, unpackSize);
+}

package/dist/esm/sevenz/codecs/Lzma2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma2.ts"],"sourcesContent":["// LZMA2 codec - wrapper around lzma-purejs for LZMA2 decompression\n// LZMA2 is a container format that wraps LZMA chunks with framing\n//\n// LZMA2 format specification:\n// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md\n//\n// Control byte values:\n// 0x00         = End of stream\n// 0x01         = Uncompressed chunk, dictionary reset\n// 0x02         = Uncompressed chunk, no dictionary reset\n// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)\n\n// Import lzma-purejs - provides raw LZMA decoder\nimport lzmajs from 'lzma-purejs';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createInputStream, createOutputStream } from './streams.ts';\n\nvar LzmaDecoder = lzmajs.LZMA.Decoder;\n\n/**\n * Decode LZMA2 dictionary size from properties byte\n * Properties byte encodes dictionary size as: 2^(dictByte/2 + 12) or similar\n *\n * Per XZ spec, dictionary sizes are:\n * 0x00 = 4 KiB (2^12)\n * 0x01 = 6 KiB\n * 0x02 = 8 KiB (2^13)\n * ...\n * 0x28 = 1.5 GiB\n */\nfunction decodeDictionarySize(propByte: number): number {\n  if (propByte > 40) {\n    throw new Error(`Invalid LZMA2 dictionary size property: ${propByte}`);\n  }\n  if (propByte === 40) {\n    // Max dictionary size: 4 GiB - 1\n    return 0xffffffff;\n  }\n  // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)\n  var base = 2 | (propByte & 1);\n  var shift = Math.floor(propByte / 2) + 11;\n  return base << shift;\n}\n\n/**\n * Decode LZMA2 compressed data to buffer\n *\n * @param input - LZMA2 compressed data\n * @param properties - Properties buffer (1 byte: dictionary size)\n * @param _unpackSize - Unused (LZMA2 has internal size markers)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  var dictSize = decodeDictionarySize(properties[0]);\n  var output: Buffer[] = [];\n  var offset = 0;\n\n  // LZMA decoder instance - reused across chunks\n  var decoder = new LzmaDecoder();\n  decoder.setDictionarySize(dictSize);\n\n  // Track current LZMA properties (lc, lp, pb)\n  var propsSet = false;\n\n  while (offset < input.length) {\n    var control = input[offset++];\n\n    if (control === 0x00) {\n      // End of LZMA2 stream\n      break;\n    }\n\n    if (control === 0x01 || control === 0x02) {\n      // Uncompressed chunk\n      // 0x01 = dictionary reset + uncompressed\n      // 0x02 = uncompressed (no reset)\n      // Note: Dictionary reset (0x01) is handled implicitly since we don't\n      // maintain dictionary state across uncompressed chunks in this implementation\n\n      if (offset + 2 > input.length) {\n        throw new Error('Truncated LZMA2 uncompressed chunk header');\n      }\n\n      // Size is big-endian, 16-bit, value + 1\n      var uncompSize = ((input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      if (offset + uncompSize > input.length) {\n        throw new Error('Truncated LZMA2 uncompressed data');\n      }\n\n      // Copy uncompressed data\n      output.push(input.slice(offset, offset + uncompSize));\n      offset += uncompSize;\n    } else if (control >= 0x80) {\n      // LZMA compressed chunk\n      // Control byte format (bits 7-0):\n      // Bit 7: always 1 for LZMA chunk\n      // Bit 6: reset state\n      // Bit 5: new properties (implies state reset)\n      // Bits 4-0: high 5 bits of uncompressed size - 1\n\n      var newProps = (control & 0x20) !== 0;\n\n      if (offset + 4 > input.length) {\n        throw new Error('Truncated LZMA2 LZMA chunk header');\n      }\n\n      // Uncompressed size: 5 bits from control + 16 bits from next 2 bytes + 1\n      var uncompHigh = control & 0x1f;\n      var uncompSize2 = ((uncompHigh << 16) | (input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // Compressed size: 16 bits + 1\n      var compSize = ((input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // If new properties, read 1-byte LZMA properties\n      if (newProps) {\n        if (offset >= input.length) {\n          throw new Error('Truncated LZMA2 properties byte');\n        }\n        var propsByte = input[offset++];\n\n        // Properties byte: pb * 45 + lp * 9 + lc\n        // where pb, lp, lc are LZMA parameters\n        var lc = propsByte % 9;\n        var remainder = Math.floor(propsByte / 9);\n        var lp = remainder % 5;\n        var pb = Math.floor(remainder / 5);\n\n        if (!decoder.setLcLpPb(lc, lp, pb)) {\n          throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n        }\n        propsSet = true;\n      }\n\n      if (!propsSet) {\n        throw new Error('LZMA chunk without properties');\n      }\n\n      if (offset + compSize > input.length) {\n        throw new Error('Truncated LZMA2 compressed data');\n      }\n\n      // Decode LZMA chunk\n      var inStream = createInputStream(input, offset, compSize);\n      var outStream = createOutputStream();\n\n      // Note: decoder.code() internally calls init() after setting streams\n      // For LZMA2, the decoder state is managed per-chunk through props resets\n\n      // Decode the chunk\n      var success = decoder.code(inStream, outStream, uncompSize2);\n      if (!success) {\n        throw new Error('LZMA decompression failed');\n      }\n\n      output.push(outStream.toBuffer());\n      offset += compSize;\n    } else {\n      throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n    }\n  }\n\n  return Buffer.concat(output);\n}\n\n/**\n * Create an LZMA2 decoder Transform stream\n */\nexport function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeLzma2, properties, unpackSize);\n}\n"],"names":["lzmajs","createBufferingDecoder","createInputStream","createOutputStream","LzmaDecoder","LZMA","Decoder","decodeDictionarySize","propByte","Error","base","shift","Math","floor","decodeLzma2","input","properties","_unpackSize","length","dictSize","output","offset","decoder","setDictionarySize","propsSet","control","uncompSize","push","slice","newProps","uncompHigh","uncompSize2","compSize","propsByte","lc","remainder","lp","pb","setLcLpPb","inStream","outStream","success","code","toBuffer","toString","Buffer","concat","createLzma2Decoder","unpackSize"],"mappings":"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"}

package/dist/esm/sevenz/codecs/createBufferingDecoder.d.ts

@@ -0,0 +1,7 @@
+import { Transform } from 'readable-stream';
+export type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+/**
+ * Create a Transform stream that buffers all input, then decodes in flush
+ * This is the common pattern for codecs that can't stream (need full input)
+ */
+export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/createBufferingDecoder.js

@@ -0,0 +1,25 @@
+// Helper to create a Transform stream that buffers all input before decoding
+// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)
+import { Transform } from 'readable-stream';
+/**
+ * Create a Transform stream that buffers all input, then decodes in flush
+ * This is the common pattern for codecs that can't stream (need full input)
+ */ export default function createBufferingDecoder(decodeFn, properties, unpackSize) {
+    var chunks = [];
+    return new Transform({
+        transform: (chunk, _encoding, callback)=>{
+            chunks.push(chunk);
+            callback();
+        },
+        flush: function(callback) {
+            try {
+                var input = Buffer.concat(chunks);
+                var output = decodeFn(input, properties, unpackSize);
+                this.push(output);
+                callback();
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}

package/dist/esm/sevenz/codecs/createBufferingDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/createBufferingDecoder.ts"],"sourcesContent":["// Helper to create a Transform stream that buffers all input before decoding\n// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)\n\nimport { Transform, type TransformCallback } from 'readable-stream';\n\nexport type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Create a Transform stream that buffers all input, then decodes in flush\n * This is the common pattern for codecs that can't stream (need full input)\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Transform {\n  var chunks: Buffer[] = [];\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: TransformCallback) => {\n      chunks.push(chunk);\n      callback();\n    },\n    flush: function (callback: TransformCallback) {\n      try {\n        var input = Buffer.concat(chunks);\n        var output = decodeFn(input, properties, unpackSize);\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["Transform","createBufferingDecoder","decodeFn","properties","unpackSize","chunks","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;AAE1F,SAASA,SAAS,QAAgC,kBAAkB;AAIpE;;;CAGC,GACD,eAAe,SAASC,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,IAAIC,SAAmB,EAAE;IAEzB,OAAO,IAAIL,UAAU;QACnBM,WAAW,CAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAUF,QAA2B;YAC1C,IAAI;gBACF,IAAIG,QAAQC,OAAOC,MAAM,CAACT;gBAC1B,IAAIU,SAASb,SAASU,OAAOT,YAAYC;gBACzC,IAAI,CAACM,IAAI,CAACK;gBACVN;YACF,EAAE,OAAOO,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}