wasm-bhtsne 1.0.0 → 1.1.0

package/README.md

@@ -10,8 +10,17 @@ This is the wasm version of the [bhtsne](https://github.com/frjnn/bhtsne) crate.
 
 ## Features
 - Harnesses multi-threading capabilities through [wasm-bindgen-rayon](https://github.com/RReverser/wasm-bindgen-rayon).
+- Allows passing t-SNE hyperparameters through a JavaScript object, where you only need to include the parameters you want to change from the defaults. If you don't specify any, default values are used.
+- Supports running the algorithm in iterations, enabling progressive refinement of the embedding
+- Supports both Float32Array and Float64Array for data input 
+
+## Requirements
+To use the multithreading feature, you need to enable `SharedArrayBuffer` on the Web. As stated in the [wasm-bindgen-rayon readme](https://github.com/RReverser/wasm-bindgen-rayon/blob/main/README.md):
+
+In order to use `SharedArrayBuffer` on the Web, you need to enable [cross-origin isolation policies](https://web.dev/coop-coep/). Check out the linked article for details.
 
 ## Installation
+Install the [wasm-bhtsne npm package](https://www.npmjs.com/package/wasm-bhtsne):
 ```shell
 npm i wasm-bhtsne
 ```
@@ -41,16 +50,43 @@ function createRandomMatrix(rows, columns) {
         async onclick() {
 
             // create random points and dimensions
-            const data = createRandomMatrix(500, 7);
+            const data = createRandomMatrix(5000, 512);
+
+            // Example of setting hyperparameters
+            const opt = {
+                learning_rate: 150.0,
+                perplexity: 30.0,
+                theta: 0.6
+            };
+            
+            // let tsne_encoder = new multiThread.bhtSNEf64(data, opt);
+            // or
+            let tsne_encoder = new multiThread.bhtSNEf32(data, opt);
+            let compressed_vectors;
 
-            let tsne_encoder = new multiThread.bhtSNE(data); // create a tSNE instance
-            tsne_encoder.perplexity = 25.0;  // change hyperparameters
+            for (let i = 0; i < 1000; i++) {
+                compressed_vectors = tsne_encoder.step(1)
+                /* …do something with `compressed_vectors`… */
+            }
 
-            // run the algorithm with 1000 iterations 
-            let compressed_vectors = tsne_encoder.step(1000); 
             console.log("Compressed Vectors:", compressed_vectors);
         },
         disabled: false
     });
 })();
 ```
+
+## Hyperparameters
+Here is a list of hyperparameters that can be set in the JavaScript object, along with their default values and descriptions:
+
+- **`learning_rate`** (default: `200.0`): controls the step size during the optimization.
+- **`momentum`** (default: `0.5`): helps accelerate gradients vectors in the right directions, thus leading to faster converging.
+- **`final_momentum`** (default: `0.8`): momentum value used after a certain number of iterations.
+- **`momentum_switch_epoch`** (default: `250`): the epoch after which the algorithm switches to `final_momentum` for the map update.
+- **`stop_lying_epoch`** (default: `250`): the epoch after which the P distribution values become true. For epochs < `stop_lying_epoch`, the values of the P distribution are multiplied by a factor equal to `12.0`.
+- **`theta`** (default: `0.5`): Determines the accuracy of the approximation. Larger values increase the speed but decrease accuracy. Must be strictly greater than 0.0.
+- **`embedding_dim`** (default: `2`): the dimensionality of the embedding space.
+- **`perplexity`** (default: `20.0`): the perplexity value. It determines the balance between local and global aspects of the data. A good value lies between 5.0 and 50.0.
+    
+    
+    

package/package.json

@@ -4,7 +4,7 @@
     "lv291 <baiunco291@proton.me>"
   ],
   "description": "Barnes-Hut implementations of t-SNE in wasm",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/wasm_bhtsne.d.ts

@@ -13,114 +13,43 @@ export function wbg_rayon_start_worker(receiver: number): void;
 * t-distributed stochastic neighbor embedding. Provides a parallel implementation of both the
 * exact version of the algorithm and the tree accelerated one leveraging space partitioning trees.
 */
-export class bhtSNE {
+export class bhtSNEf32 {
   free(): void;
 /**
 * @param {any} data
+* @param {any} opt
 */
-  constructor(data: any);
+  constructor(data: any, opt: any);
 /**
 * Performs a parallel Barnes-Hut approximation of the t-SNE algorithm.
 *
 * # Arguments
 *
-* `epochs` - Sets epochs, the maximum number of fitting iterations.
+* `epochs` - the maximum number of fitting iterations. Must be positive
 * @param {number} epochs
 * @returns {any}
 */
   step(epochs: number): any;
+}
 /**
-* Sets a new learning rate.
-*
-* # Arguments
-*
-* `learning_rate` - new value for the learning rate.
-* @param {number} learning_rate
-*/
-  learning_rate(learning_rate: number): void;
-/**
-* Sets new epochs, i.e the maximum number of fitting iterations.
-*
-* # Arguments
-*
-* `epochs` - new value for the epochs.
-* @param {number} epochs
-*/
-  epochs(epochs: number): void;
-/**
-* Sets a new momentum.
-*
-* # Arguments
-*
-* `momentum` - new value for the momentum.
-* @param {number} momentum
-*/
-  momentum(momentum: number): void;
-/**
-* Sets a new final momentum.
-*
-* # Arguments
-*
-* `final_momentum` - new value for the final momentum.
-* @param {number} final_momentum
-*/
-  final_momentum(final_momentum: number): void;
-/**
-* Sets a new momentum switch epoch, i.e. the epoch after which the algorithm switches to
-* `final_momentum` for the map update.
-*
-* # Arguments
-*
-* `momentum_switch_epoch` - new value for the momentum switch epoch.
-* @param {number} momentum_switch_epoch
-*/
-  momentum_switch_epoch(momentum_switch_epoch: number): void;
-/**
-* Sets a new stop lying epoch, i.e. the epoch after which the P distribution values become
-* true, as defined in the original implementation. For epochs < `stop_lying_epoch` the values
-* of the P distribution are multiplied by a factor equal to `12.0`.
-*
-* # Arguments
-*
-* `stop_lying_epoch` - new value for the stop lying epoch.
-* @param {number} stop_lying_epoch
-*/
-  stop_lying_epoch(stop_lying_epoch: number): void;
-/**
-* Sets a new theta, which determines the accuracy of the approximation. Must be **strictly greater than
-* 0.0**. Large values for θ increase the speed of the algorithm but decrease its accuracy.
-* For small values of θ it is less probable that a cell in the space partitioning tree will
-* be treated as a single point. For θ equal to 0.0 the method degenerates in the exact
-* version.
-*
-* # Arguments
-*
-* * `theta`  - new value for the theta.
-* @param {number} theta
 */
-  theta(theta: number): void;
+export class bhtSNEf64 {
+  free(): void;
 /**
-* Sets a new value for the embedding dimension.
-*
-* # Arguments
-*
-* `embedding_dim` - new value for the embedding space dimensionality.
-* @param {number} embedding_dim
+* @param {any} data
+* @param {any} opt
 */
-  embedding_dim(embedding_dim: number): void;
+  constructor(data: any, opt: any);
 /**
-* Sets a new perplexity value.
+* Performs a parallel Barnes-Hut approximation of the t-SNE algorithm.
 *
 * # Arguments
 *
-* `perplexity` - new value for the perplexity. It's used so that the bandwidth of the Gaussian
-*  kernels, is set in such a way that the perplexity of each the conditional distribution *Pi*
-*  equals a predefined perplexity *u*.
-*
-* A good value for perplexity lies between 5.0 and 50.0.
-* @param {number} perplexity
+* `epochs` - Sets epochs, the maximum number of fitting iterations.
+* @param {number} epochs
+* @returns {any}
 */
-  perplexity(perplexity: number): void;
+  step(epochs: number): any;
 }
 /**
 */
@@ -142,18 +71,12 @@ export class wbg_rayon_PoolBuilder {
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
-  readonly __wbg_bhtsne_free: (a: number) => void;
-  readonly bhtsne_new: (a: number) => number;
-  readonly bhtsne_step: (a: number, b: number, c: number) => void;
-  readonly bhtsne_learning_rate: (a: number, b: number) => void;
-  readonly bhtsne_epochs: (a: number, b: number) => void;
-  readonly bhtsne_momentum: (a: number, b: number) => void;
-  readonly bhtsne_final_momentum: (a: number, b: number) => void;
-  readonly bhtsne_momentum_switch_epoch: (a: number, b: number) => void;
-  readonly bhtsne_stop_lying_epoch: (a: number, b: number) => void;
-  readonly bhtsne_theta: (a: number, b: number) => void;
-  readonly bhtsne_embedding_dim: (a: number, b: number) => void;
-  readonly bhtsne_perplexity: (a: number, b: number) => void;
+  readonly __wbg_bhtsnef32_free: (a: number) => void;
+  readonly bhtsnef32_new: (a: number, b: number) => number;
+  readonly bhtsnef32_step: (a: number, b: number, c: number) => void;
+  readonly __wbg_bhtsnef64_free: (a: number) => void;
+  readonly bhtsnef64_new: (a: number, b: number) => number;
+  readonly bhtsnef64_step: (a: number, b: number, c: number) => void;
   readonly __wbg_wbg_rayon_poolbuilder_free: (a: number) => void;
   readonly wbg_rayon_poolbuilder_numThreads: (a: number) => number;
   readonly wbg_rayon_poolbuilder_receiver: (a: number) => number;

package/wasm_bhtsne.js

@@ -53,7 +53,9 @@ function addHeapObject(obj) {
     return idx;
 }
 
-let WASM_VECTOR_LEN = 0;
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
 
 let cachedUint8Memory0 = null;
 
@@ -64,6 +66,13 @@ function getUint8Memory0() {
     return cachedUint8Memory0;
 }
 
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().slice(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = function (arg, view) {
@@ -114,13 +123,13 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+let cachedBigInt64Memory0 = null;
 
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8Memory0().slice(ptr, ptr + len));
+function getBigInt64Memory0() {
+    if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.buffer !== wasm.memory.buffer) {
+        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
+    }
+    return cachedBigInt64Memory0;
 }
 
 function debugString(val) {
@@ -211,31 +220,32 @@ export function wbg_rayon_start_worker(receiver) {
     wasm.wbg_rayon_start_worker(receiver);
 }
 
-const bhtSNEFinalization = (typeof FinalizationRegistry === 'undefined')
+const bhtSNEf32Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_bhtsne_free(ptr >>> 0));
+    : new FinalizationRegistry(ptr => wasm.__wbg_bhtsnef32_free(ptr >>> 0));
 /**
 * t-distributed stochastic neighbor embedding. Provides a parallel implementation of both the
 * exact version of the algorithm and the tree accelerated one leveraging space partitioning trees.
 */
-export class bhtSNE {
+export class bhtSNEf32 {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        bhtSNEFinalization.unregister(this);
+        bhtSNEf32Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_bhtsne_free(ptr);
+        wasm.__wbg_bhtsnef32_free(ptr);
     }
     /**
     * @param {any} data
+    * @param {any} opt
     */
-    constructor(data) {
-        const ret = wasm.bhtsne_new(addHeapObject(data));
+    constructor(data, opt) {
+        const ret = wasm.bhtsnef32_new(addHeapObject(data), addHeapObject(opt));
         this.__wbg_ptr = ret >>> 0;
         return this;
     }
@@ -244,14 +254,14 @@ export class bhtSNE {
     *
     * # Arguments
     *
-    * `epochs` - Sets epochs, the maximum number of fitting iterations.
+    * `epochs` - the maximum number of fitting iterations. Must be positive
     * @param {number} epochs
     * @returns {any}
     */
     step(epochs) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.bhtsne_step(retptr, this.__wbg_ptr, epochs);
+            wasm.bhtsnef32_step(retptr, this.__wbg_ptr, epochs);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -263,115 +273,58 @@ export class bhtSNE {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-    * Sets a new learning rate.
-    *
-    * # Arguments
-    *
-    * `learning_rate` - new value for the learning rate.
-    * @param {number} learning_rate
-    */
-    learning_rate(learning_rate) {
-        wasm.bhtsne_learning_rate(this.__wbg_ptr, learning_rate);
-    }
-    /**
-    * Sets new epochs, i.e the maximum number of fitting iterations.
-    *
-    * # Arguments
-    *
-    * `epochs` - new value for the epochs.
-    * @param {number} epochs
-    */
-    epochs(epochs) {
-        wasm.bhtsne_epochs(this.__wbg_ptr, epochs);
-    }
-    /**
-    * Sets a new momentum.
-    *
-    * # Arguments
-    *
-    * `momentum` - new value for the momentum.
-    * @param {number} momentum
-    */
-    momentum(momentum) {
-        wasm.bhtsne_momentum(this.__wbg_ptr, momentum);
-    }
-    /**
-    * Sets a new final momentum.
-    *
-    * # Arguments
-    *
-    * `final_momentum` - new value for the final momentum.
-    * @param {number} final_momentum
-    */
-    final_momentum(final_momentum) {
-        wasm.bhtsne_final_momentum(this.__wbg_ptr, final_momentum);
-    }
-    /**
-    * Sets a new momentum switch epoch, i.e. the epoch after which the algorithm switches to
-    * `final_momentum` for the map update.
-    *
-    * # Arguments
-    *
-    * `momentum_switch_epoch` - new value for the momentum switch epoch.
-    * @param {number} momentum_switch_epoch
-    */
-    momentum_switch_epoch(momentum_switch_epoch) {
-        wasm.bhtsne_momentum_switch_epoch(this.__wbg_ptr, momentum_switch_epoch);
-    }
-    /**
-    * Sets a new stop lying epoch, i.e. the epoch after which the P distribution values become
-    * true, as defined in the original implementation. For epochs < `stop_lying_epoch` the values
-    * of the P distribution are multiplied by a factor equal to `12.0`.
-    *
-    * # Arguments
-    *
-    * `stop_lying_epoch` - new value for the stop lying epoch.
-    * @param {number} stop_lying_epoch
-    */
-    stop_lying_epoch(stop_lying_epoch) {
-        wasm.bhtsne_stop_lying_epoch(this.__wbg_ptr, stop_lying_epoch);
+}
+
+const bhtSNEf64Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bhtsnef64_free(ptr >>> 0));
+/**
+*/
+export class bhtSNEf64 {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        bhtSNEf64Finalization.unregister(this);
+        return ptr;
     }
-    /**
-    * Sets a new theta, which determines the accuracy of the approximation. Must be **strictly greater than
-    * 0.0**. Large values for θ increase the speed of the algorithm but decrease its accuracy.
-    * For small values of θ it is less probable that a cell in the space partitioning tree will
-    * be treated as a single point. For θ equal to 0.0 the method degenerates in the exact
-    * version.
-    *
-    * # Arguments
-    *
-    * * `theta`  - new value for the theta.
-    * @param {number} theta
-    */
-    theta(theta) {
-        wasm.bhtsne_theta(this.__wbg_ptr, theta);
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bhtsnef64_free(ptr);
     }
     /**
-    * Sets a new value for the embedding dimension.
-    *
-    * # Arguments
-    *
-    * `embedding_dim` - new value for the embedding space dimensionality.
-    * @param {number} embedding_dim
+    * @param {any} data
+    * @param {any} opt
     */
-    embedding_dim(embedding_dim) {
-        wasm.bhtsne_embedding_dim(this.__wbg_ptr, embedding_dim);
+    constructor(data, opt) {
+        const ret = wasm.bhtsnef64_new(addHeapObject(data), addHeapObject(opt));
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
-    * Sets a new perplexity value.
+    * Performs a parallel Barnes-Hut approximation of the t-SNE algorithm.
     *
     * # Arguments
     *
-    * `perplexity` - new value for the perplexity. It's used so that the bandwidth of the Gaussian
-    *  kernels, is set in such a way that the perplexity of each the conditional distribution *Pi*
-    *  equals a predefined perplexity *u*.
-    *
-    * A good value for perplexity lies between 5.0 and 50.0.
-    * @param {number} perplexity
+    * `epochs` - Sets epochs, the maximum number of fitting iterations.
+    * @param {number} epochs
+    * @returns {any}
     */
-    perplexity(perplexity) {
-        wasm.bhtsne_perplexity(this.__wbg_ptr, perplexity);
+    step(epochs) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bhtsnef64_step(retptr, this.__wbg_ptr, epochs);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 
@@ -459,21 +412,45 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_in = function(arg0, arg1) {
+        const ret = getObject(arg0) in getObject(arg1);
+        return ret;
+    };
     imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'number' ? obj : undefined;
         getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
         getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
     };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
+    imports.wbg.__wbindgen_is_bigint = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'bigint';
+        return ret;
+    };
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
+        const ret = getObject(arg0) === getObject(arg1);
+        return ret;
+    };
     imports.wbg.__wbindgen_is_object = function(arg0) {
         const val = getObject(arg0);
         const ret = typeof(val) === 'object' && val !== null;
         return ret;
     };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
         const ret = getObject(arg0) == getObject(arg1);
         return ret;
@@ -491,9 +468,9 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_as_number = function(arg0) {
+        const ret = +getObject(arg0);
+        return ret;
     };
     imports.wbg.__wbindgen_number_new = function(arg0) {
         const ret = arg0;
@@ -503,6 +480,20 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_getwithrefkey_edc2c8960f0f1191 = function(arg0, arg1) {
+        const ret = getObject(arg0)[getObject(arg1)];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_instanceof_Window_f401953a2cf86220 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Window;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -537,16 +528,6 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).getRandomValues(getObject(arg1));
     }, arguments) };
-    imports.wbg.__wbg_instanceof_Window_f401953a2cf86220 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Window;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
     imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
@@ -611,10 +592,6 @@ function __wbg_get_imports() {
         const ret = global.global;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        const ret = getObject(arg0) === undefined;
-        return ret;
-    };
     imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
@@ -636,6 +613,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_isSafeInteger_f7b04ef02296c4d2 = function(arg0) {
+        const ret = Number.isSafeInteger(getObject(arg0));
+        return ret;
+    };
     imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
@@ -673,6 +654,12 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
+        const v = getObject(arg1);
+        const ret = typeof(v) === 'bigint' ? v : undefined;
+        getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
         const ret = debugString(getObject(arg1));
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -706,6 +693,7 @@ function __wbg_init_memory(imports, maybe_memory) {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedBigInt64Memory0 = null;
     cachedFloat64Memory0 = null;
     cachedInt32Memory0 = null;
     cachedUint8Memory0 = null;