lzma1 0.0.6 → 0.1.0

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2025 Filip Seman
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright Filip Seman
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { compress, compressString, decompress, decompressString, LZMA } from "./lzma.js";

package/lib/index.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright Filip Seman
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { compress, compressString, decompress, decompressString, LZMA } from "./lzma.js";

package/{dist → lib}/lzma.d.ts

@@ -1,3 +1,19 @@
+/**
+ * Converts a number to a signed 8-bit integer using DataView.
+ *
+ * Previously, this was done with bitwise operations (value << 24 >> 24), but
+ * that approach was obscure and hard to understand. Using DataView improves
+ * readability and ensures correct 8-bit conversion.
+ */
+export declare function toSigned8bit(value: number): number;
+/**
+ * Converts a number to a signed 16-bit integer using DataView.
+ *
+ * Previously, this was done with bitwise operations (value << 16 >> 16), but
+ * that approach was obscure and hard to understand. Using DataView improves
+ * readability and ensures correct 16-bit conversion.
+ */
+export declare function toSigned16bit(value: number): number;
 export declare class LZMA {
     #private;
     readonly CompressionModes: {
@@ -58,22 +74,39 @@ export declare class LZMA {
     ReverseGetPrice(Models: number[], startIndex: number, NumBitLevels: number, symbol: number): number;
     InitBitModels(probs: number[]): void;
     GetPrice(Prob: number, symbol: number): number;
-    encode(inputString: string | Uint8Array): number[] | Uint8Array;
-    compress(data: string | Uint8Array | ArrayBuffer, mode?: keyof typeof this.CompressionModes): Int8Array;
-    decompress(bytearray: Uint8Array | ArrayBuffer): Int8Array | string;
+    encodeString(inputString: string): number[];
+    compress(data: Uint8Array | ArrayBuffer, mode?: keyof typeof this.CompressionModes): number[];
+    compressString(data: string, mode?: keyof typeof this.CompressionModes): number[];
+    decompress(bytearray: Uint8Array | ArrayBuffer): number[];
+    decompressString(bytearray: Uint8Array | ArrayBuffer): string;
 }
 /**
  * Compresses data using LZMA algorithm
  *
- * @param data Data to compress - can be string, Uint8Array or ArrayBuffer
+ * @param data Data to compress - can be Uint8Array or ArrayBuffer
+ * @param mode Compression mode (1-9), defaults to 5
+ * @returns Compressed data as a byte array
+ */
+export declare function compress(data: Uint8Array | ArrayBuffer, mode?: keyof LZMA["CompressionModes"]): Uint8Array;
+/**
+ * Compresses data using LZMA algorithm
+ *
+ * @param data String to compress
  * @param mode Compression mode (1-9), defaults to 5
- * @returns Compressed data as Int8Array
+ * @returns Compressed data as byte array
+ */
+export declare function compressString(data: string, mode?: keyof LZMA["CompressionModes"]): Uint8Array;
+/**
+ * Decompresses LZMA compressed data
+ *
+ * @param data Compressed data as Uint8Array or ArrayBuffer
+ * @returns Decompressed data
  */
-export declare function compress(data: string | Uint8Array | ArrayBuffer, mode?: keyof LZMA["CompressionModes"]): Int8Array;
+export declare function decompress(data: Uint8Array | ArrayBuffer): Uint8Array;
 /**
  * Decompresses LZMA compressed data
  *
  * @param data Compressed data as Uint8Array or ArrayBuffer
- * @returns Decompressed data as string if input was string, or Int8Array if input was binary
+ * @returns Decompressed data as string
  */
-export declare function decompress(data: Uint8Array | ArrayBuffer): string | Int8Array;
+export declare function decompressString(data: Uint8Array | ArrayBuffer): string;

package/{dist → lib}/lzma.js

@@ -45,6 +45,32 @@ const CRC32_TABLE = [
     0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
     0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
 ];
+/**
+ * Converts a number to a signed 8-bit integer using DataView.
+ *
+ * Previously, this was done with bitwise operations (value << 24 >> 24), but
+ * that approach was obscure and hard to understand. Using DataView improves
+ * readability and ensures correct 8-bit conversion.
+ */
+export function toSigned8bit(value) {
+    const buffer = new ArrayBuffer(1);
+    const view = new DataView(buffer);
+    view.setInt8(0, value);
+    return view.getInt8(0);
+}
+/**
+ * Converts a number to a signed 16-bit integer using DataView.
+ *
+ * Previously, this was done with bitwise operations (value << 16 >> 16), but
+ * that approach was obscure and hard to understand. Using DataView improves
+ * readability and ensures correct 16-bit conversion.
+ */
+export function toSigned16bit(value) {
+    const buffer = new ArrayBuffer(2);
+    const view = new DataView(buffer);
+    view.setInt16(0, value);
+    return view.getInt16(0);
+}
 export class LZMA {
     #MAX_UINT32 = 0x100000000; // 2^32
     #_MAX_UINT32 = 0xFFFFFFFF; // 2^32 - 1
@@ -350,7 +376,7 @@ export class LZMA {
         return data;
     }
     #write(buffer, b) {
-        buffer.buf[buffer.count++] = b & 0xFF;
+        buffer.buf[buffer.count++] = toSigned8bit(b);
     }
     #write_0(buffer, buf, off, len) {
         this.#arraycopy(buf, off, buffer.buf, buffer.count, len);
@@ -442,7 +468,7 @@ export class LZMA {
             if (r == -1) {
                 throw new Error("truncated input");
             }
-            properties[i] = r & 0xFF;
+            properties[i] = toSigned8bit(r);
         }
         if (!this.#SetDecoderProperties(properties)) {
             throw new Error("corrupted input");
@@ -1231,7 +1257,7 @@ export class LZMA {
         do {
             symbol = symbol << 1 | this.#decodeBit(decoder.m_Decoders, symbol);
         } while (symbol < 0x100);
-        return symbol & 0xFF;
+        return toSigned8bit(symbol);
     }
     #DecodeWithMatchByte(encoder, matchByte) {
         let bit, matchBit, symbol = 1;
@@ -1247,7 +1273,7 @@ export class LZMA {
                 break;
             }
         } while (symbol < 0x100);
-        return symbol & 0xFF;
+        return toSigned8bit(symbol);
     }
     #createLiteralDecoderEncoder2() {
         const literalDecoder = {
@@ -2341,7 +2367,7 @@ export class LZMA {
         let bit, m = 1, price = 0;
         for (let i = NumBitLevels; i != 0; i -= 1) {
             bit = symbol & 1;
-            symbol >>> 1;
+            symbol >>>= 1;
             price += this.#probPrices[((Models[startIndex + m] - bit ^ -bit) & 0x7FF) >>> 2];
             m = m << 1 | bit;
         }
@@ -2353,7 +2379,7 @@ export class LZMA {
         newBound = (rangeDecoder.Range >>> 11) * prob;
         if ((rangeDecoder.Code ^ this.#MIN_INT32) < (newBound ^ this.#MIN_INT32)) {
             rangeDecoder.Range = newBound;
-            probs[index] = prob + (0x800 - prob >>> 5) << 0x10 >> 0x10;
+            probs[index] = toSigned16bit(prob + (0x800 - prob >>> 5));
             if (!(rangeDecoder.Range & this.#bitMaskForRange)) {
                 rangeDecoder.Code = rangeDecoder.Code << 0x08 | this.#read(rangeDecoder.Stream);
                 rangeDecoder.Range <<= 0x08;
@@ -2363,7 +2389,7 @@ export class LZMA {
         else {
             rangeDecoder.Range -= newBound;
             rangeDecoder.Code -= newBound;
-            probs[index] = prob - (prob >>> 5) << 0x10 >> 0x10;
+            probs[index] = toSigned16bit(prob - (prob >>> 5));
             if (!(rangeDecoder.Range & this.#bitMaskForRange)) {
                 rangeDecoder.Code = rangeDecoder.Code << 0x08 | this.#read(rangeDecoder.Stream);
                 rangeDecoder.Range <<= 0x08;
@@ -2405,12 +2431,12 @@ export class LZMA {
         newBound = (rangeEncoder.Range >>> 11) * prob;
         if (!symbol) {
             rangeEncoder.Range = newBound;
-            probs[index] = prob + (0x800 - prob >>> 5) << 0x10 >> 0x10;
+            probs[index] = toSigned16bit(prob + (0x800 - prob >>> 5));
         }
         else {
             rangeEncoder.Low = this.#add(rangeEncoder.Low, this.#and(this.#fromInt(newBound), [this.#_MAX_UINT32, 0]));
             rangeEncoder.Range -= newBound;
-            probs[index] = prob - (prob >>> 5) << 0x10 >> 0x10;
+            probs[index] = toSigned16bit(prob - (prob >>> 5));
         }
         if (!(rangeEncoder.Range & this.#bitMaskForRange)) {
             rangeEncoder.Range <<= 0x08;
@@ -2444,7 +2470,7 @@ export class LZMA {
     #ShiftLow() {
         const rangeEncoder = this.#compressor.chunker.encoder._rangeEncoder;
         const LowHi = this.#lowBits_0(this.#shru(rangeEncoder.Low, 0x20));
-        if (LowHi != 0 || this.#compare(rangeEncoder.Low, [0xFF000000, 0]) < 0) {
+        if (LowHi !== 0 || this.#compare(rangeEncoder.Low, [0xFF000000, 0]) < 0) {
             rangeEncoder._position = this.#add(rangeEncoder._position, this.#fromInt(rangeEncoder._cacheSize));
             let temp = rangeEncoder._cache;
             do {
@@ -2459,7 +2485,7 @@ export class LZMA {
     GetPrice(Prob, symbol) {
         return this.#probPrices[((Prob - symbol ^ -symbol) & 0x7FF) >>> 2];
     }
-    #decode(utf) {
+    #decodeString(utf) {
         let j = 0, x, y, z, l = utf.length, buf = [], charCodes = [];
         for (let i = 0; i < l; ++i, ++j) {
             x = utf[i] & 0xFF;
@@ -2521,15 +2547,9 @@ export class LZMA {
         }
         return buf.join("");
     }
-    encode(inputString) {
+    encodeString(inputString) {
         let ch, chars = [], elen = 0, l = inputString.length;
-        // Be able to handle binary arrays and buffers.
-        if (typeof inputString === "object") {
-            return inputString;
-        }
-        else {
-            this.#getChars(inputString, 0, l, chars, 0);
-        }
+        this.#getChars(inputString, 0, l, chars, 0);
         // Add extra spaces in the array to break up the unicode symbols.
         for (let i = 0; i < l; ++i) {
             ch = chars[i];
@@ -2548,58 +2568,87 @@ export class LZMA {
         for (let i = 0; i < l; ++i) {
             ch = chars[i];
             if (ch >= 1 && ch <= 0x7F) {
-                data[elen++] = ch & 0xFF;
+                data[elen++] = toSigned8bit(ch);
             }
-            else if (!ch || ch >= 0x80 && ch <= 0x7FF) {
-                data[elen++] = (0xC0 | ch >> 6 & 0x1F) & 0xFF;
-                data[elen++] = (0x80 | ch & 0x3F) & 0xFF;
+            else if (!ch || (ch >= 0x80 && ch <= 0x7FF)) {
+                data[elen++] = toSigned8bit(0xC0 | (ch >> 6 & 0x1F));
+                data[elen++] = toSigned8bit(0x80 | (ch & 0x3F));
             }
             else {
-                data[elen++] = (0xE0 | ch >> 0x0C & 0x0F) & 0xFF;
-                data[elen++] = (0x80 | ch >> 6 & 0x3F) & 0xFF;
-                data[elen++] = (0x80 | ch & 0x3F) & 0xFF;
+                data[elen++] = toSigned8bit(0xE0 | (ch >> 0x0C) & 0x0F);
+                data[elen++] = toSigned8bit(0x80 | ((ch >> 6) & 0x3F));
+                data[elen++] = toSigned8bit(0x80 | (ch & 0x3F));
             }
         }
         return data;
     }
     compress(data, mode = 5) {
-        const encodedData = this.encode(data);
         const compressionMode = this.CompressionModes[mode];
-        this.#byteArrayCompressor(encodedData, compressionMode);
+        this.#byteArrayCompressor(data, compressionMode);
         while (this.#processChunkEncode())
             ;
         const compressedByteArray = this.#toByteArray(this.#compressor.output);
-        return new Int8Array(compressedByteArray);
+        return compressedByteArray;
+    }
+    compressString(data, mode = 5) {
+        const encodedData = this.encodeString(data);
+        return compress(encodedData, mode);
     }
     decompress(bytearray) {
         this.#byteArrayDecompressor(bytearray);
         while (this.#processChunkDecode())
             ;
         const decodedByteArray = this.#toByteArray(this.#decompressor.output);
-        const decoded = this.#decode(decodedByteArray);
-        return decoded instanceof Array
-            ? new Int8Array(decoded)
-            : decoded;
+        return decodedByteArray;
+    }
+    decompressString(bytearray) {
+        this.#byteArrayDecompressor(bytearray);
+        while (this.#processChunkDecode())
+            ;
+        const decodedByteArray = this.#toByteArray(this.#decompressor.output);
+        const decoded = this.#decodeString(decodedByteArray);
+        return decoded;
     }
 }
 /**
  * Compresses data using LZMA algorithm
  *
- * @param data Data to compress - can be string, Uint8Array or ArrayBuffer
+ * @param data Data to compress - can be Uint8Array or ArrayBuffer
  * @param mode Compression mode (1-9), defaults to 5
- * @returns Compressed data as Int8Array
+ * @returns Compressed data as a byte array
  */
 export function compress(data, mode = 5) {
     const lzma = new LZMA();
-    return lzma.compress(data, mode);
+    return new Uint8Array(lzma.compress(data, mode));
+}
+/**
+ * Compresses data using LZMA algorithm
+ *
+ * @param data String to compress
+ * @param mode Compression mode (1-9), defaults to 5
+ * @returns Compressed data as byte array
+ */
+export function compressString(data, mode = 5) {
+    const lzma = new LZMA();
+    return lzma.compressString(data, mode);
 }
 /**
  * Decompresses LZMA compressed data
  *
  * @param data Compressed data as Uint8Array or ArrayBuffer
- * @returns Decompressed data as string if input was string, or Int8Array if input was binary
+ * @returns Decompressed data
  */
 export function decompress(data) {
     const lzma = new LZMA();
-    return lzma.decompress(data);
+    return new Uint8Array(lzma.decompress(data));
+}
+/**
+ * Decompresses LZMA compressed data
+ *
+ * @param data Compressed data as Uint8Array or ArrayBuffer
+ * @returns Decompressed data as string
+ */
+export function decompressString(data) {
+    const lzma = new LZMA();
+    return lzma.decompressString(data);
 }

package/package.json

@@ -1,21 +1,16 @@
 {
 	"name": "lzma1",
 	"type": "module",
-	"version": "0.0.6",
+	"version": "0.1.0",
 	"license": "Apache-2.0",
-	"authors": [
-		"Filip Seman <filip.seman@pm.me>",
-		"Nathan Rugg <nmrugg@gmail.com> - Original library"
-	],
+	"author": "Filip Seman <filip.seman@pm.me>",
 	"description": "A JavaScript implementation of the Lempel-Ziv-Markov (LZMA) chain compression algorithm",
 	"funding": "https://github.com/sponsors/xseman",
 	"homepage": "https://github.com/xseman/lzma1#readme",
 	"keywords": [
 		"lzma",
 		"lzma1",
-		"lzma alone",
-		"compression",
-		"decompression"
+		"lzma alone"
 	],
 	"repository": {
 		"type": "git",
@@ -27,23 +22,23 @@
 		"fmt": "dprint fmt",
 		"fmt:check": "dprint check",
 		"typecheck": "tsc --noEmit",
-		"test": "TS_NODE_TRANSPILE_ONLY=true node --test --experimental-test-coverage --test-coverage-exclude=*.test.ts --loader=ts-node/esm --no-warnings *.test.ts",
-		"test:watch": "TS_NODE_TRANSPILE_ONLY=true node --test --watch --loader=ts-node/esm --no-warnings *.test.ts"
+		"test": "bun test --coverage lzma.test.ts",
+		"test:watch": "bun test --watch lzma.test.ts"
 	},
 	"devDependencies": {
 		"@types/node": "^22.13.0",
 		"dprint": "~0.49.0",
-		"ts-node": "~10.9.0",
 		"typescript": "^5.8.0"
 	},
 	"exports": {
+		"./package.json": "./package.json",
 		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
+			"import": "./lib/index.js",
+			"types": "./lib/index.d.ts"
 		}
 	},
 	"files": [
-		"dist",
-		"!dist/*test*"
+		"lib",
+		"!lib/*test*"
 	]
 }

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * @license
- * Copyright Filip Seman
- * SPDX-License-Identifier: Apache-2.0
- */
-export { compress, decompress } from "./lzma.js";

package/dist/index.js

@@ -1,6 +0,0 @@
-/**
- * @license
- * Copyright Filip Seman
- * SPDX-License-Identifier: Apache-2.0
- */
-export { compress, decompress } from "./lzma.js";