zeck 0.2.0 → 1.0.7

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.
 
+**⚠️ 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
@@ -192,6 +194,8 @@ After installation, you can use `zeck-compress` and `zeck-decompress` directly f
 
 ### 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.
@@ -301,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:
@@ -327,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:
@@ -402,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,11 +5,11 @@
     "Peter Ryszkiewicz"
   ],
   "description": "A Rust library for compressing and decompressing data using the Zeckendorf representation algorithm",
-  "version": "0.2.0",
+  "version": "1.0.7",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pRizz/zeckendorf"
+    "url": "https://github.com/pRizz/zeckendorf.git"
   },
   "files": [
     "zeck_bg.wasm",

package/zeck.d.ts

@@ -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 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]);
- * 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 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]);
- * 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 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]);
- * 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 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]);
- * 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.

package/zeck_bg.js

@@ -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 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]);
- * 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 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]);
- * 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 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]);
- * 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 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]);
- * 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;