lzma1 0.0.3 → 0.0.4

package/README.md

@@ -2,35 +2,49 @@
 
 This is a simplified [fork][fork-link] of [Nathan Rugg's][fork-author] package.
 
-The goal of this fork is to simplify and extract the minimal implementation for
-my second project, I'm also trying to add as many typings as possible.
+[fork-link]: https://github.com/LZMA-JS/LZMA-JS
+[fork-author]: https://github.com/nmrugg
+
+## Installation
 
-## Install
+> [!NOTE]
+> This package is native [ESM][mozzila-esm] and no longer provides a
+> CommonJS export. If your project uses CommonJS, you will have to convert to ESM
+> or use the dynamic [`import()`][mozzila-import] function.
 
-**npm registry**
+[mozzila-esm]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules
+[mozzila-import]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import
+
+### npm
 
 ```sh
 npm install lzma1
 ```
 
-**GitHub**
+### deno
 
-```sh
-# same as latest released npm registry version
-npm install xseman/lzma1#master
+Since `v1.28+` import from npm registry using `npm:` prefix.
 
-# latest unreleased changes
-npm install xseman/lzma1#develop
+```ts
+import {
+	compress,
+	decompress,
+} from "npm:lzma1@latest";
+```
+
+### browser
 
-# specific tag version
-npm install xseman/lzma1#0.0.1
+```html
+<script type="module">
+	import { compress, decompress } from "https://esm.sh/lzma1@latest";
+</script>
 ```
 
 ## API
 
 ```ts
 compress(data: string | Uint8Array, mode?: Mode): Int8Array
-decompress(bytearray: Uint8Array): Int8Array
+decompress(data: Uint8Array | ArrayBuffer): string | Int8Array
 ```
 
 ## Usage
@@ -38,14 +52,20 @@ decompress(bytearray: Uint8Array): Int8Array
 Compress and decompress a string with compression level 1.
 
 ```js
-import { compress, decompress } from "lzma1"
+import {
+	compress,
+	decompress,
+} from "lzma1";
 
-const data = "Hello World!"
-const compressed = compress(data, 1)
-const decompressed = decompress(result)
+const data = "Hello World!";
+const compressed = compress(data, 1);
+const decompressed = decompress(result);
 
 // data === decompressed
 ```
 
-[fork-link]: https://github.com/LZMA-JS/LZMA-JS
-[fork-author]: https://github.com/nmrugg
+## Related
+
+- <https://github.com/cscott/lzma-purejs>
+- <https://github.com/glinscott/lzmajs>
+- <https://github.com/mauron85/lzma-purejs/tree/master>

package/dist/lzma.d.ts

@@ -0,0 +1,81 @@
+export declare class LZMA {
+    #private;
+    readonly CompressionModes: {
+        readonly 1: {
+            readonly searchDepth: 16;
+            readonly filterStrength: 64;
+            readonly modeIndex: 0;
+        };
+        readonly 2: {
+            readonly searchDepth: 20;
+            readonly filterStrength: 64;
+            readonly modeIndex: 0;
+        };
+        readonly 3: {
+            readonly searchDepth: 19;
+            readonly filterStrength: 64;
+            readonly modeIndex: 1;
+        };
+        readonly 4: {
+            readonly searchDepth: 20;
+            readonly filterStrength: 64;
+            readonly modeIndex: 1;
+        };
+        readonly 5: {
+            readonly searchDepth: 21;
+            readonly filterStrength: 128;
+            readonly modeIndex: 1;
+        };
+        readonly 6: {
+            readonly searchDepth: 22;
+            readonly filterStrength: 128;
+            readonly modeIndex: 1;
+        };
+        readonly 7: {
+            readonly searchDepth: 23;
+            readonly filterStrength: 128;
+            readonly modeIndex: 1;
+        };
+        readonly 8: {
+            readonly searchDepth: 24;
+            readonly filterStrength: 255;
+            readonly modeIndex: 1;
+        };
+        readonly 9: {
+            readonly searchDepth: 25;
+            readonly filterStrength: 255;
+            readonly modeIndex: 1;
+        };
+    };
+    constructor();
+    GetLenToPosState(len: number): number;
+    StateUpdateChar(index: number): number;
+    writeHeaderProperties(): void;
+    GetPosSlot(pos: number): number;
+    GetPosSlot2(pos: number): number;
+    reverseDecode(Models: number[], startIndex: number, NumBitLevels: number): number;
+    ReverseEncode(startIndex: number, NumBitLevels: number, symbol: number): void;
+    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;
+}
+type CompressionMode = keyof LZMA["CompressionModes"];
+/**
+ * Compresses data using LZMA algorithm
+ *
+ * @param data Data to compress - can be string, Uint8Array or ArrayBuffer
+ * @param mode Compression mode (1-9), defaults to 5
+ * @returns Compressed data as Int8Array
+ */
+export declare function compress(data: string | Uint8Array | ArrayBuffer, mode?: CompressionMode): Int8Array;
+/**
+ * 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
+ */
+export declare function decompress(data: Uint8Array | ArrayBuffer): string | Int8Array;
+export {};