zeck 2.0.0 → 2.1.0

package/package.json

@@ -5,7 +5,7 @@
     "Peter Ryszkiewicz"
   ],
   "description": "A Rust library for compressing and decompressing data using the Zeckendorf representation algorithm",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,7 +15,8 @@
     "zeck_bg.wasm",
     "zeck.js",
     "zeck_bg.js",
-    "zeck.d.ts"
+    "zeck.d.ts",
+    "LICENSE.txt"
   ],
   "main": "zeck.js",
   "types": "zeck.d.ts",

package/zeck.d.ts

@@ -1,5 +1,41 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Represents a .zeck file with its header information and compressed data.
+ *
+ * This struct holds all the information needed to reconstruct a .zeck file,
+ * including the format version, original file size, endianness flags, and
+ * the compressed data itself.
+ */
+export interface ZeckFile {
+    /**
+     * File format version
+     */
+    version: number;
+    /**
+     * Original uncompressed file size in bytes
+     */
+    original_size: number;
+    /**
+     * Flags byte (bit 0 = big endian, bits 1-7 reserved)
+     */
+    flags: number;
+    /**
+     * Compressed data (without header)
+     */
+    compressed_data: number[];
+}
+
+/**
+ * Result of best compression attempt, containing the best compressed zeck file and the size for the other endianness attempt, or if neither produced compression (both were larger than the original).
+ */
+export type BestCompressionResult = { BigEndianBest: { zeck_file: ZeckFile; le_size: number } } | { LittleEndianBest: { zeck_file: ZeckFile; be_size: number } } | { Neither: { be_size: number; le_size: number } };
+
+/**
+ * Errors that can occur when parsing or processing .zeck files.
+ */
+export type ZeckFormatError = { HeaderTooShort: { actual_length: number; required_length: number } } | { UnsupportedVersion: { found_version: number; supported_version: number } } | { ReservedFlagsSet: { flags: number } } | { CompressionFailed: { original_size: number; be_size: number; le_size: number } } | { DecompressedTooLarge: { expected_size: number; actual_size: number } } | { DataSizeTooLarge: { size: number } };
+
 
 /**
  * Returns the number of bits required to represent the given number. Returns 0 if the number is less than or equal to 0.
@@ -17,6 +53,129 @@
  */
 export function bit_count_for_number(n: number): number;
 
+/**
+ * Compresses data using the Zeckendorf algorithm with big endian interpretation,
+ * and stores the result in a [`ZeckFile`] struct.
+ *
+ * # ⚠️ 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::zeck_file_format::compress::compress_zeck_be;
+ * let data = vec![1, 0];
+ * match compress_zeck_be(&data) {
+ *     Ok(zeck_file) => {
+ *         // Access file information
+ *         println!("Original size: {} bytes", zeck_file.original_size);
+ *         println!("Is big endian: {}", zeck_file.is_big_endian());
+ *         // Serialize to bytes for writing to file
+ *         let bytes = zeck_file.to_bytes();
+ *     }
+ *     Err(e) => {
+ *         // Handle error (e.g., data size too large)
+ *     }
+ * }
+ * ```
+ */
+export function compress_zeck_be(data: Uint8Array): ZeckFile;
+
+/**
+ * Compresses data using the Zeckendorf algorithm with automatic endianness selection,
+ * and stores the result in a [`BestCompressionResult`] struct.
+ *
+ * This function attempts compression with both big endian and little endian interpretations,
+ * and returns the best result, or if neither produced compression (both were larger than the original).
+ *
+ * # ⚠️ 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::zeck_file_format::compress::compress_zeck_best;
+ * # use zeck::zeck_file_format::compress::BestCompressionResult;
+ * # use zeck::zeck_file_format::decompress::decompress_zeck_file;
+ * let data = vec![0, 1]; // Compresses best interpreted as a big endian integer
+ * match compress_zeck_best(&data) {
+ *     Ok(best_compression_result) => {
+ *         match best_compression_result {
+ *             BestCompressionResult::BigEndianBest { zeck_file, le_size } => {
+ *                 let decompressed = decompress_zeck_file(&zeck_file).unwrap();
+ *                 assert_eq!(decompressed, data);
+ *             }
+ *             BestCompressionResult::LittleEndianBest { zeck_file, be_size } => {
+ *                 assert!(false);
+ *             }
+ *             BestCompressionResult::Neither { be_size, le_size } => {
+ *                 assert!(false);
+ *             }
+ *         }
+ *     }
+ *     Err(e) => {
+ *         assert!(false);
+ *     }
+ * }
+ *
+ * let data = vec![1, 0]; // Compresses best interpreted as a little endian integer
+ * match compress_zeck_best(&data) {
+ *     Ok(best_compression_result) => {
+ *         match best_compression_result {
+ *             BestCompressionResult::BigEndianBest { zeck_file, le_size } => {
+ *                 assert!(false);
+ *             }
+ *             BestCompressionResult::LittleEndianBest { zeck_file, be_size } => {
+ *                 let decompressed = decompress_zeck_file(&zeck_file).unwrap();
+ *                 assert_eq!(decompressed, data);
+ *             }
+ *             BestCompressionResult::Neither { be_size, le_size } => {
+ *                 assert!(false);
+ *             }
+ *         }
+ *     }
+ *     Err(e) => {
+ *         assert!(false);
+ *     }
+ * }
+ * ```
+ */
+export function compress_zeck_best(data: Uint8Array): BestCompressionResult;
+
+/**
+ * Compresses data using the Zeckendorf algorithm with little endian interpretation,
+ * and stores the result in a [`ZeckFile`] struct.
+ *
+ * # ⚠️ 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::zeck_file_format::compress::compress_zeck_le;
+ * let data = vec![1, 0];
+ * match compress_zeck_le(&data) {
+ *     Ok(zeck_file) => {
+ *         // Access file information
+ *         println!("Original size: {} bytes", zeck_file.original_size);
+ *         println!("Compressed size: {} bytes", zeck_file.compressed_data.len());
+ *         // Serialize to bytes for writing to file
+ *         let bytes = zeck_file.to_bytes();
+ *     }
+ *     Err(e) => {
+ *         // Handle error (e.g., data size too large)
+ *     }
+ * }
+ * ```
+ */
+export function compress_zeck_le(data: Uint8Array): ZeckFile;
+
 /**
  * Effective Fibonacci Index to Fibonacci Index: FI(efi) === efi + 2, where efi is the Effective Fibonacci Index
  *
@@ -64,9 +223,9 @@ export function ezba_from_ezld(effective_zeckendorf_list_descending: BigUint64Ar
  *
  * ```
  * # 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]);
+ * assert_eq!(ezba_to_ezla(&[0, 0, 0, 0, 0, 0, 0, 0]), vec![] as Vec<u64>);
+ * assert_eq!(ezba_to_ezla(&[1, 0, 0, 0, 0, 0, 0, 0]), vec![0u64]);
+ * assert_eq!(ezba_to_ezla(&[1, 1, 1, 0, 0, 0, 0, 0]), vec![0u64, 2u64, 4u64]);
  * ```
  */
 export function ezba_to_ezla(ezba_bits: Uint8Array): BigUint64Array;
@@ -194,21 +353,21 @@ export function memoized_slow_fibonacci_recursive(fi: bigint): bigint;
  * ```
  * # 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]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(2), vec![3]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(0), vec![] as Vec<u64>);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(1), vec![2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(2), vec![3u64]);
  *
  * // Small Zeckendorf numbers
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(3), vec![4]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(4), vec![4, 2]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(5), vec![5]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(6), vec![5, 2]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(7), vec![5, 3]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(8), vec![6]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(9), vec![6, 2]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(10), vec![6, 3]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(11), vec![6, 4]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(12), vec![6, 4, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(3), vec![4u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(4), vec![4u64, 2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(5), vec![5u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(6), vec![5u64, 2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(7), vec![5u64, 3u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(8), vec![6u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(9), vec![6u64, 2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(10), vec![6u64, 3u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(11), vec![6u64, 4u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(12), vec![6u64, 4u64, 2u64]);
  * ```
  */
 export function memoized_zeckendorf_list_descending_for_integer(n: bigint): BigUint64Array;

package/zeck_bg.js

@@ -3,6 +3,12 @@ export function __wbg_set_wasm(val) {
     wasm = val;
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function getArrayU64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -21,6 +27,11 @@ function getBigUint64ArrayMemory0() {
     return cachedBigUint64ArrayMemory0;
 }
 
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -29,6 +40,15 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 function passArray64ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 8, 8) >>> 0;
     getBigUint64ArrayMemory0().set(arg, ptr / 8);
@@ -43,6 +63,26 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
 let WASM_VECTOR_LEN = 0;
 
 /**
@@ -66,6 +106,159 @@ export function bit_count_for_number(n) {
     return ret >>> 0;
 }
 
+/**
+ * Compresses data using the Zeckendorf algorithm with big endian interpretation,
+ * and stores the result in a [`ZeckFile`] struct.
+ *
+ * # ⚠️ 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::zeck_file_format::compress::compress_zeck_be;
+ * let data = vec![1, 0];
+ * match compress_zeck_be(&data) {
+ *     Ok(zeck_file) => {
+ *         // Access file information
+ *         println!("Original size: {} bytes", zeck_file.original_size);
+ *         println!("Is big endian: {}", zeck_file.is_big_endian());
+ *         // Serialize to bytes for writing to file
+ *         let bytes = zeck_file.to_bytes();
+ *     }
+ *     Err(e) => {
+ *         // Handle error (e.g., data size too large)
+ *     }
+ * }
+ * ```
+ * @param {Uint8Array} data
+ * @returns {ZeckFile}
+ */
+export function compress_zeck_be(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress_zeck_be(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compresses data using the Zeckendorf algorithm with automatic endianness selection,
+ * and stores the result in a [`BestCompressionResult`] struct.
+ *
+ * This function attempts compression with both big endian and little endian interpretations,
+ * and returns the best result, or if neither produced compression (both were larger than the original).
+ *
+ * # ⚠️ 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::zeck_file_format::compress::compress_zeck_best;
+ * # use zeck::zeck_file_format::compress::BestCompressionResult;
+ * # use zeck::zeck_file_format::decompress::decompress_zeck_file;
+ * let data = vec![0, 1]; // Compresses best interpreted as a big endian integer
+ * match compress_zeck_best(&data) {
+ *     Ok(best_compression_result) => {
+ *         match best_compression_result {
+ *             BestCompressionResult::BigEndianBest { zeck_file, le_size } => {
+ *                 let decompressed = decompress_zeck_file(&zeck_file).unwrap();
+ *                 assert_eq!(decompressed, data);
+ *             }
+ *             BestCompressionResult::LittleEndianBest { zeck_file, be_size } => {
+ *                 assert!(false);
+ *             }
+ *             BestCompressionResult::Neither { be_size, le_size } => {
+ *                 assert!(false);
+ *             }
+ *         }
+ *     }
+ *     Err(e) => {
+ *         assert!(false);
+ *     }
+ * }
+ *
+ * let data = vec![1, 0]; // Compresses best interpreted as a little endian integer
+ * match compress_zeck_best(&data) {
+ *     Ok(best_compression_result) => {
+ *         match best_compression_result {
+ *             BestCompressionResult::BigEndianBest { zeck_file, le_size } => {
+ *                 assert!(false);
+ *             }
+ *             BestCompressionResult::LittleEndianBest { zeck_file, be_size } => {
+ *                 let decompressed = decompress_zeck_file(&zeck_file).unwrap();
+ *                 assert_eq!(decompressed, data);
+ *             }
+ *             BestCompressionResult::Neither { be_size, le_size } => {
+ *                 assert!(false);
+ *             }
+ *         }
+ *     }
+ *     Err(e) => {
+ *         assert!(false);
+ *     }
+ * }
+ * ```
+ * @param {Uint8Array} data
+ * @returns {BestCompressionResult}
+ */
+export function compress_zeck_best(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress_zeck_best(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compresses data using the Zeckendorf algorithm with little endian interpretation,
+ * and stores the result in a [`ZeckFile`] struct.
+ *
+ * # ⚠️ 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::zeck_file_format::compress::compress_zeck_le;
+ * let data = vec![1, 0];
+ * match compress_zeck_le(&data) {
+ *     Ok(zeck_file) => {
+ *         // Access file information
+ *         println!("Original size: {} bytes", zeck_file.original_size);
+ *         println!("Compressed size: {} bytes", zeck_file.compressed_data.len());
+ *         // Serialize to bytes for writing to file
+ *         let bytes = zeck_file.to_bytes();
+ *     }
+ *     Err(e) => {
+ *         // Handle error (e.g., data size too large)
+ *     }
+ * }
+ * ```
+ * @param {Uint8Array} data
+ * @returns {ZeckFile}
+ */
+export function compress_zeck_le(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress_zeck_le(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Effective Fibonacci Index to Fibonacci Index: FI(efi) === efi + 2, where efi is the Effective Fibonacci Index
  *
@@ -127,9 +320,9 @@ export function ezba_from_ezld(effective_zeckendorf_list_descending) {
  *
  * ```
  * # 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]);
+ * assert_eq!(ezba_to_ezla(&[0, 0, 0, 0, 0, 0, 0, 0]), vec![] as Vec<u64>);
+ * assert_eq!(ezba_to_ezla(&[1, 0, 0, 0, 0, 0, 0, 0]), vec![0u64]);
+ * assert_eq!(ezba_to_ezla(&[1, 1, 1, 0, 0, 0, 0, 0]), vec![0u64, 2u64, 4u64]);
  * ```
  * @param {Uint8Array} ezba_bits
  * @returns {BigUint64Array}
@@ -295,21 +488,21 @@ export function memoized_slow_fibonacci_recursive(fi) {
  * ```
  * # 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]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(2), vec![3]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(0), vec![] as Vec<u64>);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(1), vec![2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(2), vec![3u64]);
  *
  * // Small Zeckendorf numbers
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(3), vec![4]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(4), vec![4, 2]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(5), vec![5]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(6), vec![5, 2]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(7), vec![5, 3]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(8), vec![6]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(9), vec![6, 2]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(10), vec![6, 3]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(11), vec![6, 4]);
- * assert_eq!(memoized_zeckendorf_list_descending_for_integer(12), vec![6, 4, 2]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(3), vec![4u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(4), vec![4u64, 2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(5), vec![5u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(6), vec![5u64, 2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(7), vec![5u64, 3u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(8), vec![6u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(9), vec![6u64, 2u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(10), vec![6u64, 3u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(11), vec![6u64, 4u64]);
+ * assert_eq!(memoized_zeckendorf_list_descending_for_integer(12), vec![6u64, 4u64, 2u64]);
  * ```
  * @param {bigint} n
  * @returns {BigUint64Array}
@@ -574,6 +767,15 @@ export function zl_to_ezl(zl) {
     return v2;
 }
 
+export function __wbg___wbindgen_throw_dd24417ed36fc46e(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_parse_a09a54cf72639456() { return handleError(function (arg0, arg1) {
+    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+    return ret;
+}, arguments) };
+
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);