lzma1 0.0.7 → 0.1.0

package/lib/index.d.ts

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

package/lib/index.js

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

package/lib/lzma.d.ts

@@ -74,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 Int8Array
+ * @returns Compressed data as a byte array
  */
-export declare function compress(data: string | Uint8Array | ArrayBuffer, mode?: keyof LZMA["CompressionModes"]): Int8Array;
+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 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 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/lib/lzma.js

@@ -2485,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;
@@ -2547,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];
@@ -2589,43 +2583,72 @@ export class LZMA {
         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,7 +1,7 @@
 {
 	"name": "lzma1",
 	"type": "module",
-	"version": "0.0.7",
+	"version": "0.1.0",
 	"license": "Apache-2.0",
 	"author": "Filip Seman <filip.seman@pm.me>",
 	"description": "A JavaScript implementation of the Lempel-Ziv-Markov (LZMA) chain compression algorithm",