zeck 0.1.0 → 0.2.0

package/README.md

@@ -6,6 +6,8 @@ A Rust library for compressing and decompressing data using the Zeckendorf repre
 
 The Zeckendorf algorithm represents numbers as a sum of non-consecutive Fibonacci numbers. This library interprets input data as a big integer (either big-endian or little-endian), converts it to its Zeckendorf representation, and sometimes achieves compression. However, compression is not guaranteed; the algorithm may result in a larger representation depending on the input data. The library can automatically try both endian interpretations and select the one that produces the best compression.
 
+**Command-line tools** (`zeck-compress` and `zeck-decompress`) are available and can be installed via `cargo install zeck`. See the [Binaries](#binaries) section for usage details.
+
 ## Features
 
 - **Compression & Decompression**: Convert data to/from Zeckendorf representation
@@ -33,42 +35,59 @@ You can see a live demo of the WebAssembly module in action at <https://prizz.gi
 
 Run:
 ```bash
-cargo add zeckendorf
+cargo add zeck
 ```
 
 Or add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-zeckendorf = "0.1.0"
+zeck = "0.1.0"
 ```
 
 For plotting features:
 
 ```toml
 [dependencies]
-zeckendorf = { version = "0.1.0", features = ["plotting"] }
+zeck = { version = "0.1.0", features = ["plotting"] }
 ```
 
 ### Install from GitHub (development version)
 
 Run:
 ```bash
-cargo add zeckendorf --git https://github.com/pRizz/zeckendorf
+cargo add zeck --git https://github.com/pRizz/zeckendorf
 ```
 
 Or add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-zeckendorf = { git = "https://github.com/pRizz/zeckendorf" }
+zeck = { git = "https://github.com/pRizz/zeckendorf" }
 ```
 
 For plotting features:
 
 ```toml
 [dependencies]
-zeckendorf = { git = "https://github.com/pRizz/zeckendorf", features = ["plotting"] }
+zeck = { git = "https://github.com/pRizz/zeckendorf", features = ["plotting"] }
+```
+
+### Install from npm
+
+Run:
+```bash
+npm install zeck
+```
+
+Or add this to your `package.json`:
+
+```json
+{
+  "dependencies": {
+    "zeck": "^0.1.0"
+  }
+}
 ```
 
 ## Usage
@@ -78,7 +97,7 @@ zeckendorf = { git = "https://github.com/pRizz/zeckendorf", features = ["plottin
 #### Big-Endian Interpretation
 
 ```rust
-use zeckendorf_rs::{zeckendorf_compress_be, zeckendorf_decompress_be};
+use zeck::{zeckendorf_compress_be, zeckendorf_decompress_be};
 
 // Compress data (interpreted as big-endian integer)
 let data = vec![12u8];
@@ -92,7 +111,7 @@ assert_eq!(data, decompressed);
 #### Little-Endian Interpretation
 
 ```rust
-use zeckendorf_rs::{zeckendorf_compress_le, zeckendorf_decompress_le};
+use zeck::{zeckendorf_compress_le, zeckendorf_decompress_le};
 
 // Compress data (interpreted as little-endian integer)
 let data = vec![12u8];
@@ -106,7 +125,7 @@ assert_eq!(data, decompressed);
 #### Automatic Best Compression
 
 ```rust
-use zeckendorf_rs::{zeckendorf_compress_best, zeckendorf_decompress_be, zeckendorf_decompress_le, CompressionResult};
+use zeck::{zeckendorf_compress_best, zeckendorf_decompress_be, zeckendorf_decompress_le, CompressionResult};
 
 // Try both endian interpretations and get the best result
 let data = vec![1, 0];
@@ -133,20 +152,20 @@ match result {
 ### Fibonacci Numbers
 
 ```rust
-use zeckendorf_rs::memoized_slow_fibonacci_recursive;
+use zeck::memoized_slow_fibonacci_recursive;
 
 // Calculate Fibonacci numbers (for indices up to 93)
 let fib_10 = memoized_slow_fibonacci_recursive(10); // Returns 55
 
 // For larger numbers, use BigInt versions
-use zeckendorf_rs::fast_doubling_fibonacci_bigint;
+use zeck::fast_doubling_fibonacci_bigint;
 let fib_100 = fast_doubling_fibonacci_bigint(100);
 ```
 
 ### Zeckendorf Representation
 
 ```rust
-use zeckendorf_rs::memoized_zeckendorf_list_descending_for_integer;
+use zeck::memoized_zeckendorf_list_descending_for_integer;
 
 // Get Zeckendorf representation as a list of Fibonacci indices
 let zld = memoized_zeckendorf_list_descending_for_integer(12);
@@ -155,12 +174,126 @@ let zld = memoized_zeckendorf_list_descending_for_integer(12);
 
 ## Binaries
 
-The project includes several utility binaries:
+The project includes several utility binaries. The command-line compression tools (`zeck-compress` and `zeck-decompress`) can be installed globally via:
+
+### Install from crates.io
+
+```bash
+cargo install zeck
+```
+
+### Install from GitHub (development version)
+
+```bash
+cargo install --git https://github.com/pRizz/zeckendorf zeck
+```
+
+After installation, you can use `zeck-compress` and `zeck-decompress` directly from your command line.
+
+### Compression/Decompression Tools
+
+#### zeck-compress
+
+Compresses data using the Zeckendorf representation algorithm. Automatically adds `.zbe` extension for big-endian compression and `.zle` extension for little-endian compression.
+
+```bash
+zeck-compress [INPUT] [-o OUTPUT] [--endian ENDIAN] [-v]
+```
+
+**Options:**
+- `INPUT`: Input file path (optional, reads from stdin if not specified)
+  - Shows a warning if reading from stdin and no data was piped in
+- `-o, --output FILE`: Output file path (optional)
+  - If not specified and input is a file, uses the input filename with the appropriate extension (`.zbe` or `.zle`) appended
+  - If not specified and reading from stdin, writes to stdout
+  - The appropriate extension (`.zbe` for big-endian, `.zle` for little-endian) is automatically added unless the file already ends with `.zbe` or `.zle`
+- `--endian ENDIAN`: Endianness to use (`big`, `little`, or `best`). Default: `best`
+  - `big`: Use big-endian interpretation (output will have `.zbe` extension)
+  - `little`: Use little-endian interpretation (output will have `.zle` extension)
+  - `best`: Try both and use the best result (default, extension added based on which was used)
+  - **Note:** When using `best`, if neither method produces compression (both result in larger or equal output), the tool will exit with an error showing compression statistics
+- `-v, --verbose`: Show compression statistics (default: true, use `--no-verbose` to disable)
+
+**Examples:**
+```bash
+# Compress a file (output filename automatically created from input with extension)
+zeck-compress input.bin
+# Creates input.bin.zbe or input.bin.zle depending on which endianness was used
+
+# Compress with best endianness (statistics shown by default)
+zeck-compress input.bin --endian best
+
+# Compress with specific endianness (creates input.bin.zbe)
+zeck-compress input.bin --endian big
+
+# Compress to a specific output file
+zeck-compress input.bin -o output
+# Creates output.zbe or output.zle depending on which endianness was used
+
+# Compress from stdin to stdout
+cat input.bin | zeck-compress
+```
+
+**Note:** When writing to a file, the output filename is printed to stdout (e.g., "Compressed to: input.bin.zbe"). Verbose statistics are shown by default and include descriptive messages about compression ratios (e.g., "File was compressed by X.XX% (Y bytes -> Z bytes)"). A warning is shown when reading from stdin if no data was piped in.
+
+#### zeck-decompress
+
+Decompresses data that was compressed using the Zeckendorf representation algorithm. Automatically detects endianness from file extension (`.zbe` for big-endian, `.zle` for little-endian).
+
+```bash
+zeck-decompress [INPUT] [-o OUTPUT] [--endian ENDIAN] [-v]
+```
+
+**Options:**
+- `INPUT`: Input file path (optional, reads from stdin if not specified)
+  - When reading from a file, endianness is automatically detected from file extension (`.zbe` for big-endian, `.zle` for little-endian)
+  - **If extension is not recognized, `--endian` is REQUIRED** (exits with error if not specified)
+  - **When reading from stdin, `--endian` is REQUIRED**
+  - Shows a warning if reading from stdin and no data was piped in
+- `-o, --output FILE`: Output file path (optional)
+  - If not specified and input is a file, uses the input filename with `.zbe` or `.zle` extension removed
+  - If not specified and reading from stdin, writes to stdout
+- `--endian ENDIAN`: Endianness used during compression (`big` or `little`)
+  - `big`: Decompress as big-endian
+  - `little`: Decompress as little-endian
+  - **REQUIRED when reading from stdin** (no input file specified)
+  - When reading from a file, this option overrides automatic detection from file extension
+- `-v, --verbose`: Show decompression statistics (default: true, use `--no-verbose` to disable)
+
+**Examples:**
+```bash
+# Decompress a file (endianness detected from .zbe extension, output filename automatically created)
+zeck-decompress input.zbe
+# Automatically uses big-endian decompression, creates output file "input"
+
+# Decompress with little-endian file
+zeck-decompress input.zle
+# Automatically uses little-endian decompression, creates output file "input"
+
+# Decompress to a specific output file
+zeck-decompress input.zbe -o output.bin
+# Automatically uses big-endian decompression
+
+# Override automatic detection
+zeck-decompress input.zbe --endian little -o output.bin
+# Overrides the .zbe extension and uses little-endian
+
+# Decompress from stdin to stdout (--endian is required)
+cat input.zbe | zeck-decompress --endian big
+```
+
+**Note:** The endianness used for decompression must match the endianness used during compression. The file extension (`.zbe` or `.zle`) indicates which endianness was used, so decompression will automatically use the correct endianness when reading from a file. **If the input file doesn't have a recognized extension, `--endian` must be explicitly specified** (the tool will exit with an error if not provided). You can override automatic detection with the `--endian` flag if needed. **When reading from stdin, `--endian` must be explicitly specified** since there's no file extension to detect from.
+
+**Additional features:**
+- When writing to a file, the output filename is printed to stdout (e.g., "Compressed to: input.bin.zbe" or "Decompressed to: output.bin")
+- Verbose statistics are shown by default (use `--no-verbose` to disable) and include descriptive messages about compression/decompression ratios
+- Compression will exit with an error if the data cannot be compressed (when using `--endian best` and neither method produces compression)
+- A warning is shown when reading from stdin if no data was piped in
 
 ### Main Playground
 
 ```bash
-cargo run --release --bin zeckendorf
+cargo run --release --bin zeck
 ```
 
 A playground/scratchpad for testing library functions.

package/package.json

@@ -5,23 +5,23 @@
     "Peter Ryszkiewicz"
   ],
   "description": "A Rust library for compressing and decompressing data using the Zeckendorf representation algorithm",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/pRizz/zeckendorf"
   },
   "files": [
-    "zeckendorf_rs_bg.wasm",
-    "zeckendorf_rs.js",
-    "zeckendorf_rs_bg.js",
-    "zeckendorf_rs.d.ts",
+    "zeck_bg.wasm",
+    "zeck.js",
+    "zeck_bg.js",
+    "zeck.d.ts",
     "LICENSE.txt"
   ],
-  "main": "zeckendorf_rs.js",
-  "types": "zeckendorf_rs.d.ts",
+  "main": "zeck.js",
+  "types": "zeck.d.ts",
   "sideEffects": [
-    "./zeckendorf_rs.js",
+    "./zeck.js",
     "./snippets/*"
   ],
   "keywords": [

package/{zeckendorf_rs.d.ts → zeck.d.ts}

@@ -7,7 +7,7 @@
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::bit_count_for_number;
+ * # use zeck::bit_count_for_number;
  * assert_eq!(bit_count_for_number(0), 0);
  * assert_eq!(bit_count_for_number(1), 1);  // 0b1
  * assert_eq!(bit_count_for_number(2), 2);  // 0b10
@@ -23,7 +23,7 @@ export function bit_count_for_number(n: number): number;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::efi_to_fi;
+ * # use zeck::efi_to_fi;
  * assert_eq!(efi_to_fi(0), 2);
  * assert_eq!(efi_to_fi(1), 3);
  * assert_eq!(efi_to_fi(2), 4);
@@ -45,7 +45,7 @@ export function efi_to_fi(efi: bigint): bigint;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::ezba_from_ezld;
+ * # use zeck::ezba_from_ezld;
  * assert_eq!(ezba_from_ezld(&[]), vec![0]);
  * assert_eq!(ezba_from_ezld(&[0]), vec![1]); // 0th EFI is 2nd FI, which is 1
  * assert_eq!(ezba_from_ezld(&[1]), vec![0, 1]); // 1st EFI is 3rd FI, which is 2
@@ -63,7 +63,7 @@ export function ezba_from_ezld(effective_zeckendorf_list_descending: BigUint64Ar
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::ezba_to_ezla;
+ * # use zeck::ezba_to_ezla;
  * assert_eq!(ezba_to_ezla(&[0, 0, 0, 0, 0, 0, 0, 0]), vec![]);
  * assert_eq!(ezba_to_ezla(&[1, 0, 0, 0, 0, 0, 0, 0]), vec![0]);
  * assert_eq!(ezba_to_ezla(&[1, 1, 1, 0, 0, 0, 0, 0]), vec![0, 2, 4]);
@@ -78,7 +78,7 @@ export function ezba_to_ezla(ezba_bits: Uint8Array): BigUint64Array;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::ezl_to_zl;
+ * # use zeck::ezl_to_zl;
  * assert_eq!(ezl_to_zl(&[0]), vec![2]);
  * assert_eq!(ezl_to_zl(&[1]), vec![3]);
  * assert_eq!(ezl_to_zl(&[2]), vec![4]);
@@ -92,7 +92,7 @@ export function ezl_to_zl(ezl: BigUint64Array): BigUint64Array;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::fi_to_efi;
+ * # use zeck::fi_to_efi;
  * # use num_bigint::BigUint;
  * # use num_traits::{One, Zero};
  * assert_eq!(fi_to_efi(2), 0);
@@ -108,7 +108,7 @@ export function fi_to_efi(fi: bigint): bigint;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::highest_one_bit;
+ * # use zeck::highest_one_bit;
  * assert_eq!(highest_one_bit(0), 0);
  * assert_eq!(highest_one_bit(1), 1);
  * assert_eq!(highest_one_bit(2), 2);
@@ -134,7 +134,7 @@ export function highest_one_bit(n: bigint): bigint;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::memoized_effective_fibonacci;
+ * # use zeck::memoized_effective_fibonacci;
  * # use num_bigint::BigUint;
  * # use num_traits::{One, Zero};
  * assert_eq!(memoized_effective_fibonacci(0), 1);
@@ -164,7 +164,7 @@ export function memoized_effective_fibonacci(efi: bigint): bigint;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::memoized_slow_fibonacci_recursive;
+ * # use zeck::memoized_slow_fibonacci_recursive;
  * // Base cases
  * assert_eq!(memoized_slow_fibonacci_recursive(0), 0);
  * assert_eq!(memoized_slow_fibonacci_recursive(1), 1);
@@ -192,7 +192,7 @@ export function memoized_slow_fibonacci_recursive(fi: bigint): bigint;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::memoized_zeckendorf_list_descending_for_integer;
+ * # use zeck::memoized_zeckendorf_list_descending_for_integer;
  * // Base cases
  * assert_eq!(memoized_zeckendorf_list_descending_for_integer(0), vec![]);
  * assert_eq!(memoized_zeckendorf_list_descending_for_integer(1), vec![2]);
@@ -225,7 +225,7 @@ export function memoized_zeckendorf_list_descending_for_integer(n: bigint): BigU
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::pack_ezba_bits_to_bytes;
+ * # use zeck::pack_ezba_bits_to_bytes;
  * assert_eq!(pack_ezba_bits_to_bytes(&[0]), vec![0]);
  * assert_eq!(pack_ezba_bits_to_bytes(&[1]), vec![1]);
  * assert_eq!(pack_ezba_bits_to_bytes(&[0, 1]), vec![0b10]);
@@ -241,7 +241,7 @@ export function pack_ezba_bits_to_bytes(ezba: Uint8Array): Uint8Array;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::unpack_bytes_to_ezba_bits;
+ * # use zeck::unpack_bytes_to_ezba_bits;
  * assert_eq!(unpack_bytes_to_ezba_bits(&[0]), vec![0, 0, 0, 0, 0, 0, 0, 0]);
  * assert_eq!(unpack_bytes_to_ezba_bits(&[1]), vec![1, 0, 0, 0, 0, 0, 0, 0]);
  * assert_eq!(unpack_bytes_to_ezba_bits(&[0b111]), vec![1, 1, 1, 0, 0, 0, 0, 0]);
@@ -260,7 +260,7 @@ export function unpack_bytes_to_ezba_bits(bytes: Uint8Array): Uint8Array;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_compress_be;
+ * # use zeck::zeckendorf_compress_be;
  * assert_eq!(zeckendorf_compress_be(&[0]), vec![0]);
  * assert_eq!(zeckendorf_compress_be(&[1]), vec![1]);
  * assert_eq!(zeckendorf_compress_be(&[12]), vec![0b111]);
@@ -280,7 +280,7 @@ export function zeckendorf_compress_be(data: Uint8Array): Uint8Array;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_compress_le;
+ * # use zeck::zeckendorf_compress_le;
  * assert_eq!(zeckendorf_compress_le(&[0]), vec![0]);
  * assert_eq!(zeckendorf_compress_le(&[1]), vec![1]);
  * assert_eq!(zeckendorf_compress_le(&[12]), vec![0b111]);
@@ -300,7 +300,7 @@ export function zeckendorf_compress_le(data: Uint8Array): Uint8Array;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_decompress_be;
+ * # use zeck::zeckendorf_decompress_be;
  * assert_eq!(zeckendorf_decompress_be(&[0]), vec![0]);
  * assert_eq!(zeckendorf_decompress_be(&[1]), vec![1]);
  * assert_eq!(zeckendorf_decompress_be(&[0b111]), vec![12]);
@@ -316,7 +316,7 @@ export function zeckendorf_decompress_be(compressed_data: Uint8Array): Uint8Arra
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_decompress_le;
+ * # use zeck::zeckendorf_decompress_le;
  * assert_eq!(zeckendorf_decompress_le(&[0]), vec![0]);
  * assert_eq!(zeckendorf_decompress_le(&[1]), vec![1]);
  * assert_eq!(zeckendorf_decompress_le(&[0b111]), vec![12]);
@@ -337,7 +337,7 @@ export function zeckendorf_decompress_le(compressed_data: Uint8Array): Uint8Arra
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zl_to_ezl;
+ * # use zeck::zl_to_ezl;
  * assert_eq!(zl_to_ezl(&[2]), vec![0]);
  * assert_eq!(zl_to_ezl(&[3]), vec![1]);
  * assert_eq!(zl_to_ezl(&[4]), vec![2]);

package/zeck.js

@@ -0,0 +1,5 @@
+import * as wasm from "./zeck_bg.wasm";
+export * from "./zeck_bg.js";
+import { __wbg_set_wasm } from "./zeck_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/{zeckendorf_rs_bg.js → zeck_bg.js}

@@ -51,7 +51,7 @@ let WASM_VECTOR_LEN = 0;
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::bit_count_for_number;
+ * # use zeck::bit_count_for_number;
  * assert_eq!(bit_count_for_number(0), 0);
  * assert_eq!(bit_count_for_number(1), 1);  // 0b1
  * assert_eq!(bit_count_for_number(2), 2);  // 0b10
@@ -72,7 +72,7 @@ export function bit_count_for_number(n) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::efi_to_fi;
+ * # use zeck::efi_to_fi;
  * assert_eq!(efi_to_fi(0), 2);
  * assert_eq!(efi_to_fi(1), 3);
  * assert_eq!(efi_to_fi(2), 4);
@@ -99,7 +99,7 @@ export function efi_to_fi(efi) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::ezba_from_ezld;
+ * # use zeck::ezba_from_ezld;
  * assert_eq!(ezba_from_ezld(&[]), vec![0]);
  * assert_eq!(ezba_from_ezld(&[0]), vec![1]); // 0th EFI is 2nd FI, which is 1
  * assert_eq!(ezba_from_ezld(&[1]), vec![0, 1]); // 1st EFI is 3rd FI, which is 2
@@ -126,7 +126,7 @@ export function ezba_from_ezld(effective_zeckendorf_list_descending) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::ezba_to_ezla;
+ * # use zeck::ezba_to_ezla;
  * assert_eq!(ezba_to_ezla(&[0, 0, 0, 0, 0, 0, 0, 0]), vec![]);
  * assert_eq!(ezba_to_ezla(&[1, 0, 0, 0, 0, 0, 0, 0]), vec![0]);
  * assert_eq!(ezba_to_ezla(&[1, 1, 1, 0, 0, 0, 0, 0]), vec![0, 2, 4]);
@@ -150,7 +150,7 @@ export function ezba_to_ezla(ezba_bits) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::ezl_to_zl;
+ * # use zeck::ezl_to_zl;
  * assert_eq!(ezl_to_zl(&[0]), vec![2]);
  * assert_eq!(ezl_to_zl(&[1]), vec![3]);
  * assert_eq!(ezl_to_zl(&[2]), vec![4]);
@@ -173,7 +173,7 @@ export function ezl_to_zl(ezl) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::fi_to_efi;
+ * # use zeck::fi_to_efi;
  * # use num_bigint::BigUint;
  * # use num_traits::{One, Zero};
  * assert_eq!(fi_to_efi(2), 0);
@@ -194,7 +194,7 @@ export function fi_to_efi(fi) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::highest_one_bit;
+ * # use zeck::highest_one_bit;
  * assert_eq!(highest_one_bit(0), 0);
  * assert_eq!(highest_one_bit(1), 1);
  * assert_eq!(highest_one_bit(2), 2);
@@ -225,7 +225,7 @@ export function highest_one_bit(n) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::memoized_effective_fibonacci;
+ * # use zeck::memoized_effective_fibonacci;
  * # use num_bigint::BigUint;
  * # use num_traits::{One, Zero};
  * assert_eq!(memoized_effective_fibonacci(0), 1);
@@ -260,7 +260,7 @@ export function memoized_effective_fibonacci(efi) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::memoized_slow_fibonacci_recursive;
+ * # use zeck::memoized_slow_fibonacci_recursive;
  * // Base cases
  * assert_eq!(memoized_slow_fibonacci_recursive(0), 0);
  * assert_eq!(memoized_slow_fibonacci_recursive(1), 1);
@@ -293,7 +293,7 @@ export function memoized_slow_fibonacci_recursive(fi) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::memoized_zeckendorf_list_descending_for_integer;
+ * # use zeck::memoized_zeckendorf_list_descending_for_integer;
  * // Base cases
  * assert_eq!(memoized_zeckendorf_list_descending_for_integer(0), vec![]);
  * assert_eq!(memoized_zeckendorf_list_descending_for_integer(1), vec![2]);
@@ -333,7 +333,7 @@ export function memoized_zeckendorf_list_descending_for_integer(n) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::pack_ezba_bits_to_bytes;
+ * # use zeck::pack_ezba_bits_to_bytes;
  * assert_eq!(pack_ezba_bits_to_bytes(&[0]), vec![0]);
  * assert_eq!(pack_ezba_bits_to_bytes(&[1]), vec![1]);
  * assert_eq!(pack_ezba_bits_to_bytes(&[0, 1]), vec![0b10]);
@@ -358,7 +358,7 @@ export function pack_ezba_bits_to_bytes(ezba) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::unpack_bytes_to_ezba_bits;
+ * # use zeck::unpack_bytes_to_ezba_bits;
  * assert_eq!(unpack_bytes_to_ezba_bits(&[0]), vec![0, 0, 0, 0, 0, 0, 0, 0]);
  * assert_eq!(unpack_bytes_to_ezba_bits(&[1]), vec![1, 0, 0, 0, 0, 0, 0, 0]);
  * assert_eq!(unpack_bytes_to_ezba_bits(&[0b111]), vec![1, 1, 1, 0, 0, 0, 0, 0]);
@@ -386,7 +386,7 @@ export function unpack_bytes_to_ezba_bits(bytes) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_compress_be;
+ * # use zeck::zeckendorf_compress_be;
  * assert_eq!(zeckendorf_compress_be(&[0]), vec![0]);
  * assert_eq!(zeckendorf_compress_be(&[1]), vec![1]);
  * assert_eq!(zeckendorf_compress_be(&[12]), vec![0b111]);
@@ -415,7 +415,7 @@ export function zeckendorf_compress_be(data) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_compress_le;
+ * # use zeck::zeckendorf_compress_le;
  * assert_eq!(zeckendorf_compress_le(&[0]), vec![0]);
  * assert_eq!(zeckendorf_compress_le(&[1]), vec![1]);
  * assert_eq!(zeckendorf_compress_le(&[12]), vec![0b111]);
@@ -444,7 +444,7 @@ export function zeckendorf_compress_le(data) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_decompress_be;
+ * # use zeck::zeckendorf_decompress_be;
  * assert_eq!(zeckendorf_decompress_be(&[0]), vec![0]);
  * assert_eq!(zeckendorf_decompress_be(&[1]), vec![1]);
  * assert_eq!(zeckendorf_decompress_be(&[0b111]), vec![12]);
@@ -469,7 +469,7 @@ export function zeckendorf_decompress_be(compressed_data) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zeckendorf_decompress_le;
+ * # use zeck::zeckendorf_decompress_le;
  * assert_eq!(zeckendorf_decompress_le(&[0]), vec![0]);
  * assert_eq!(zeckendorf_decompress_le(&[1]), vec![1]);
  * assert_eq!(zeckendorf_decompress_le(&[0b111]), vec![12]);
@@ -499,7 +499,7 @@ export function zeckendorf_decompress_le(compressed_data) {
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::zl_to_ezl;
+ * # use zeck::zl_to_ezl;
  * assert_eq!(zl_to_ezl(&[2]), vec![0]);
  * assert_eq!(zl_to_ezl(&[3]), vec![1]);
  * assert_eq!(zl_to_ezl(&[4]), vec![2]);

package/zeckendorf_rs.js

@@ -1,5 +0,0 @@
-import * as wasm from "./zeckendorf_rs_bg.wasm";
-export * from "./zeckendorf_rs_bg.js";
-import { __wbg_set_wasm } from "./zeckendorf_rs_bg.js";
-__wbg_set_wasm(wasm);
-wasm.__wbindgen_start();