zeck 0.1.0 → 1.0.7

package/README.md

@@ -6,6 +6,10 @@ 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.
 
+**⚠️ Warning:** Compressing or decompressing files larger than 10KB (10,000 bytes) is unstable due to time and memory pressure. The library may experience performance issues, excessive memory usage, or failures when processing files exceeding this size.
+
+**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 +37,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 +99,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 +113,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 +127,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 +154,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 +176,128 @@ 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
+
+**⚠️ Warning:** Compressing or decompressing files larger than 10KB (10,000 bytes) is unstable due to time and memory pressure. The library may experience performance issues, excessive memory usage, or failures when processing files exceeding this size.
+
+#### 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.
@@ -168,20 +305,20 @@ A playground/scratchpad for testing library functions.
 ### Generate Test Data
 
 ```bash
-cargo run --release --bin generate_data <size_in_bytes> [filename]
+cargo run --release --bin zeck-generate-data --features development_tools -- <size_in_bytes> [filename]
 ```
 
 Generates random test data files in the `generated_data/` directory.
 
 Example:
 ```bash
-cargo run --release --bin generate_data 1024 my_file.bin
+cargo run --release --bin zeck-generate-data --features development_tools -- 1024 my_file.bin
 ```
 
 ### Generate Statistics
 
 ```bash
-cargo run --release --bin generate_statistics --features plotting
+cargo run --release --bin zeck-generate-statistics --features plotting,development_tools
 ```
 
 Generates comprehensive compression statistics and plots:
@@ -194,7 +331,7 @@ Generates comprehensive compression statistics and plots:
 ### Plot Compression Ratios
 
 ```bash
-cargo run --release --bin plot --features plotting
+cargo run --release --bin zeck-plot --features plotting,development_tools
 ```
 
 Generates visualization plots of:
@@ -269,7 +406,7 @@ This avoids redundant Fibonacci numbers (F(0)=0 and F(1)=F(2)=1).
 - Compression is not guaranteed—some inputs may result in larger output
 - Compression effectiveness decreases as input size increases
 - The library supports both big-endian and little-endian interpretations, but other byte orderings or word boundaries are not currently explored
-- Compression of large amounts of data causes memory issues. It is currently not recommended to compress files larger than 100,000 bytes.
+- **⚠️ Warning:** Compressing or decompressing files larger than 10KB (10,000 bytes) is unstable due to time and memory pressure. The library may experience performance issues, excessive memory usage, or failures when processing files exceeding this size.
 
 ## License
 

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": "1.0.7",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pRizz/zeckendorf"
+    "url": "https://github.com/pRizz/zeckendorf.git"
   },
   "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]);
@@ -255,76 +255,96 @@ export function unpack_bytes_to_ezba_bits(bytes: Uint8Array): Uint8Array;
  *
  * Assumes the input data is interpreted as a big endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * TODO: Technically, the way the input data is interpreted is arbitrary; we could interpret it as little endian which could result in a more compact representation. We could go even further and interpret the data at different byte or word boundaries to see if it results in a more compact representation, and signify to the caller which interpretation was used. We probably need a better understanding of random distributions of data to determine what is the optimal interpretation. More investigation is needed here.
  *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_compress_be(&[54]), vec![30]);
- * assert_eq!(zeckendorf_compress_be(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
- * assert_eq!(zeckendorf_compress_be(&[255]), vec![33, 2]);
- * assert_eq!(zeckendorf_compress_be(&[1, 0]), vec![34, 2]);
+ * # use zeck::zeckendorf_compress_be_broken_do_not_use;
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[1, 0]), vec![34, 2]);
  * ```
  */
-export function zeckendorf_compress_be(data: Uint8Array): Uint8Array;
+export function zeckendorf_compress_be_broken_do_not_use(data: Uint8Array): Uint8Array;
 
 /**
  * Compresses a slice of bytes using the Zeckendorf algorithm.
  *
  * Assumes the input data is interpreted as a little endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_compress_le(&[54]), vec![30]);
- * assert_eq!(zeckendorf_compress_le(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
- * assert_eq!(zeckendorf_compress_le(&[255]), vec![33, 2]);
- * assert_eq!(zeckendorf_compress_le(&[0, 1]), vec![34, 2]);
+ * # use zeck::zeckendorf_compress_le_broken_do_not_use;
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[0, 1]), vec![34, 2]);
  * ```
  */
-export function zeckendorf_compress_le(data: Uint8Array): Uint8Array;
+export function zeckendorf_compress_le_broken_do_not_use(data: Uint8Array): Uint8Array;
 
 /**
  * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the big endian bytes interpretation.
  *
  * Assume the original input data was interpreted as a big endian integer, for now. See the TODO in the [`zeckendorf_compress_be`] function for more information.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_decompress_be(&[33, 2]), vec![255]);
- * assert_eq!(zeckendorf_decompress_be(&[34, 2]), vec![1, 0]);
+ * # use zeck::zeckendorf_decompress_be_broken_do_not_use;
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[34, 2]), vec![1, 0]);
  * ```
  */
-export function zeckendorf_decompress_be(compressed_data: Uint8Array): Uint8Array;
+export function zeckendorf_decompress_be_broken_do_not_use(compressed_data: Uint8Array): Uint8Array;
 
 /**
  * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the little endian bytes interpretation.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_decompress_le(&[33, 2]), vec![255]);
- * assert_eq!(zeckendorf_decompress_le(&[34, 2]), vec![0, 1]);
+ * # use zeck::zeckendorf_decompress_le_broken_do_not_use;
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[34, 2]), vec![0, 1]);
  * ```
  */
-export function zeckendorf_decompress_le(compressed_data: Uint8Array): Uint8Array;
+export function zeckendorf_decompress_le_broken_do_not_use(compressed_data: Uint8Array): Uint8Array;
 
 /**
  * An Effective Zeckendorf List (EZL) has a lowest EFI of 0, which is an FI of 2.
@@ -337,7 +357,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]);
@@ -381,27 +381,32 @@ export function unpack_bytes_to_ezba_bits(bytes) {
  *
  * Assumes the input data is interpreted as a big endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * TODO: Technically, the way the input data is interpreted is arbitrary; we could interpret it as little endian which could result in a more compact representation. We could go even further and interpret the data at different byte or word boundaries to see if it results in a more compact representation, and signify to the caller which interpretation was used. We probably need a better understanding of random distributions of data to determine what is the optimal interpretation. More investigation is needed here.
  *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_compress_be(&[54]), vec![30]);
- * assert_eq!(zeckendorf_compress_be(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
- * assert_eq!(zeckendorf_compress_be(&[255]), vec![33, 2]);
- * assert_eq!(zeckendorf_compress_be(&[1, 0]), vec![34, 2]);
+ * # use zeck::zeckendorf_compress_be_broken_do_not_use;
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_be_broken_do_not_use(&[1, 0]), vec![34, 2]);
  * ```
  * @param {Uint8Array} data
  * @returns {Uint8Array}
  */
-export function zeckendorf_compress_be(data) {
+export function zeckendorf_compress_be_broken_do_not_use(data) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.zeckendorf_compress_be(ptr0, len0);
+    const ret = wasm.zeckendorf_compress_be_broken_do_not_use(ptr0, len0);
     var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v2;
@@ -412,25 +417,30 @@ export function zeckendorf_compress_be(data) {
  *
  * Assumes the input data is interpreted as a little endian integer. The output data is in little endian order, so the first bit and byte is the least significant bit and byte and the last bit and byte is the most significant bit and byte.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_compress_le(&[54]), vec![30]);
- * assert_eq!(zeckendorf_compress_le(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
- * assert_eq!(zeckendorf_compress_le(&[255]), vec![33, 2]);
- * assert_eq!(zeckendorf_compress_le(&[0, 1]), vec![34, 2]);
+ * # use zeck::zeckendorf_compress_le_broken_do_not_use;
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[12]), vec![0b111]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[54]), vec![30]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[55]), vec![0, 1]); // 55 is the 10 indexed Fibonacci number, which is the 8 indexed effective Fibonacci number, and therefore is the first number needing two bytes to contain these 8 bits, because there is 1 "use bit" and 7 "skip bits" in the effective zeckendorf bits ascending.
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[255]), vec![33, 2]);
+ * assert_eq!(zeckendorf_compress_le_broken_do_not_use(&[0, 1]), vec![34, 2]);
  * ```
  * @param {Uint8Array} data
  * @returns {Uint8Array}
  */
-export function zeckendorf_compress_le(data) {
+export function zeckendorf_compress_le_broken_do_not_use(data) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.zeckendorf_compress_le(ptr0, len0);
+    const ret = wasm.zeckendorf_compress_le_broken_do_not_use(ptr0, len0);
     var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v2;
@@ -441,23 +451,28 @@ export function zeckendorf_compress_le(data) {
  *
  * Assume the original input data was interpreted as a big endian integer, for now. See the TODO in the [`zeckendorf_compress_be`] function for more information.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_decompress_be(&[33, 2]), vec![255]);
- * assert_eq!(zeckendorf_decompress_be(&[34, 2]), vec![1, 0]);
+ * # use zeck::zeckendorf_decompress_be_broken_do_not_use;
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_be_broken_do_not_use(&[34, 2]), vec![1, 0]);
  * ```
  * @param {Uint8Array} compressed_data
  * @returns {Uint8Array}
  */
-export function zeckendorf_decompress_be(compressed_data) {
+export function zeckendorf_decompress_be_broken_do_not_use(compressed_data) {
     const ptr0 = passArray8ToWasm0(compressed_data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.zeckendorf_decompress_be(ptr0, len0);
+    const ret = wasm.zeckendorf_decompress_be_broken_do_not_use(ptr0, len0);
     var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v2;
@@ -466,23 +481,28 @@ export function zeckendorf_decompress_be(compressed_data) {
 /**
  * Decompresses a slice of bytes compressed using the Zeckendorf algorithm, assuming the original data was compressed using the little endian bytes interpretation.
  *
+ * # ⚠️ Warning
+ *
+ * **Compressing or decompressing data larger than 10KB (10,000 bytes) is unstable due to time and memory pressure.**
+ * The library may experience performance issues, excessive memory usage, or failures when processing data exceeding this size.
+ *
  * # Examples
  *
  * ```
- * # use zeckendorf_rs::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]);
- * assert_eq!(zeckendorf_decompress_le(&[33, 2]), vec![255]);
- * assert_eq!(zeckendorf_decompress_le(&[34, 2]), vec![0, 1]);
+ * # use zeck::zeckendorf_decompress_le_broken_do_not_use;
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[0]), vec![0]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[1]), vec![1]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[0b111]), vec![12]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[33, 2]), vec![255]);
+ * assert_eq!(zeckendorf_decompress_le_broken_do_not_use(&[34, 2]), vec![0, 1]);
  * ```
  * @param {Uint8Array} compressed_data
  * @returns {Uint8Array}
  */
-export function zeckendorf_decompress_le(compressed_data) {
+export function zeckendorf_decompress_le_broken_do_not_use(compressed_data) {
     const ptr0 = passArray8ToWasm0(compressed_data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.zeckendorf_decompress_le(ptr0, len0);
+    const ret = wasm.zeckendorf_decompress_le_broken_do_not_use(ptr0, len0);
     var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v2;
@@ -499,7 +519,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();