@modelhealth/sdk 0.1.6 → 0.1.8

package/wasm/model_health_wasm.js

@@ -1,5 +1,7 @@
 /* @ts-self-types="./model_health_wasm.d.ts" */
 
+//#region exports
+
 export class ModelHealthService {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -15,24 +17,30 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     createSession() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_createSession(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {any} parameters
      * @returns {Promise<any>}
      */
     createSubject(parameters) {
-        const ret = wasm.modelhealthservice_createSubject(this.__wbg_ptr, addHeapObject(parameters));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_createSubject(this.__wbg_ptr, parameters);
+        return ret;
     }
     /**
      * @param {any} activity_json
      * @returns {Promise<void>}
      */
     deleteActivity(activity_json) {
-        const ret = wasm.modelhealthservice_deleteActivity(this.__wbg_ptr, addHeapObject(activity_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_deleteActivity(this.__wbg_ptr, activity_json);
+        return ret;
     }
     /**
      * @param {any} trial_json
@@ -40,10 +48,12 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     downloadAnalysisResult(trial_json, result_tag) {
-        const ptr0 = passStringToWasm0(result_tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(result_tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.modelhealthservice_downloadAnalysisResult(this.__wbg_ptr, addHeapObject(trial_json), ptr0, len0);
-        return takeObject(ret);
+        const ret = wasm.modelhealthservice_downloadAnalysisResult(this.__wbg_ptr, trial_json, ptr0, len0);
+        return ret;
     }
     /**
      * @param {any} trial_json
@@ -51,8 +61,10 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     downloadTrialResultData(trial_json, data_types_json) {
-        const ret = wasm.modelhealthservice_downloadTrialResultData(this.__wbg_ptr, addHeapObject(trial_json), addHeapObject(data_types_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_downloadTrialResultData(this.__wbg_ptr, trial_json, data_types_json);
+        return ret;
     }
     /**
      * @param {any} trial_json
@@ -60,8 +72,10 @@ export class ModelHealthService {
      * @returns {Promise<Array<any>>}
      */
     downloadTrialVideos(trial_json, version_json) {
-        const ret = wasm.modelhealthservice_downloadTrialVideos(this.__wbg_ptr, addHeapObject(trial_json), addHeapObject(version_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_downloadTrialVideos(this.__wbg_ptr, trial_json, version_json);
+        return ret;
     }
     /**
      * @param {string} subject_id
@@ -71,79 +85,90 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     getActivitiesForSubject(subject_id, start_index, count, sort) {
-        const ptr0 = passStringToWasm0(subject_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(subject_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.modelhealthservice_getActivitiesForSubject(this.__wbg_ptr, ptr0, len0, start_index, count, addHeapObject(sort));
-        return takeObject(ret);
+        _assertNum(start_index);
+        _assertNum(count);
+        const ret = wasm.modelhealthservice_getActivitiesForSubject(this.__wbg_ptr, ptr0, len0, start_index, count, sort);
+        return ret;
     }
     /**
      * @param {string} activity_id
      * @returns {Promise<any>}
      */
     getActivity(activity_id) {
-        const ptr0 = passStringToWasm0(activity_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(activity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.modelhealthservice_getActivity(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @returns {Promise<any>}
      */
     getActivityTags() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_getActivityTags(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {any} task_json
      * @returns {Promise<any>}
      */
     getAnalysisStatus(task_json) {
-        const ret = wasm.modelhealthservice_getAnalysisStatus(this.__wbg_ptr, addHeapObject(task_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_getAnalysisStatus(this.__wbg_ptr, task_json);
+        return ret;
     }
     /**
      * @param {string} session_id
      * @returns {Promise<any>}
      */
     getSession(session_id) {
-        const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.modelhealthservice_getSession(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {any} trial_json
      * @returns {Promise<any>}
      */
     getStatus(trial_json) {
-        const ret = wasm.modelhealthservice_getStatus(this.__wbg_ptr, addHeapObject(trial_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_getStatus(this.__wbg_ptr, trial_json);
+        return ret;
     }
     /**
      * @returns {string | undefined}
      */
     getToken() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.modelhealthservice_getToken(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            let v1;
-            if (r0 !== 0) {
-                v1 = getStringFromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            }
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_getToken(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
+        return v1;
     }
     /**
      * @returns {Promise<boolean>}
      */
     isAuthenticated() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_isAuthenticated(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {string} username
@@ -151,41 +176,37 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     login(username, password) {
-        const ptr0 = passStringToWasm0(username, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         const ret = wasm.modelhealthservice_login(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @returns {Promise<void>}
      */
     logout() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_logout(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {string} api_key
      */
     constructor(api_key) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.modelhealthservice_new(retptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            this.__wbg_ptr = r0 >>> 0;
-            ModelHealthServiceFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+        const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.modelhealthservice_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ModelHealthServiceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * @param {string} trial_name
@@ -193,44 +214,56 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     record(trial_name, session_json) {
-        const ptr0 = passStringToWasm0(trial_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(trial_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.modelhealthservice_record(this.__wbg_ptr, ptr0, len0, addHeapObject(session_json));
-        return takeObject(ret);
+        const ret = wasm.modelhealthservice_record(this.__wbg_ptr, ptr0, len0, session_json);
+        return ret;
     }
     /**
      * @param {any} parameters
      * @returns {Promise<void>}
      */
     register(parameters) {
-        const ret = wasm.modelhealthservice_register(this.__wbg_ptr, addHeapObject(parameters));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_register(this.__wbg_ptr, parameters);
+        return ret;
     }
     /**
      * @returns {Promise<boolean>}
      */
     restoreToken() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_restoreToken(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @returns {Promise<any>}
      */
     sessionList() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_sessionList(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {TokenStorage} storage
      */
     setStorage(storage) {
-        wasm.modelhealthservice_setStorage(this.__wbg_ptr, addHeapObject(storage));
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        wasm.modelhealthservice_setStorage(this.__wbg_ptr, storage);
     }
     /**
      * @param {string} token
      */
     setToken(token) {
-        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         wasm.modelhealthservice_setToken(this.__wbg_ptr, ptr0, len0);
     }
@@ -241,41 +274,51 @@ export class ModelHealthService {
      * @returns {Promise<any>}
      */
     startAnalysis(analysis_type_json, trial_json, session_json) {
-        const ret = wasm.modelhealthservice_startAnalysis(this.__wbg_ptr, addHeapObject(analysis_type_json), addHeapObject(trial_json), addHeapObject(session_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_startAnalysis(this.__wbg_ptr, analysis_type_json, trial_json, session_json);
+        return ret;
     }
     /**
      * @param {any} session_json
      * @returns {Promise<void>}
      */
     stopRecording(session_json) {
-        const ret = wasm.modelhealthservice_stopRecording(this.__wbg_ptr, addHeapObject(session_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_stopRecording(this.__wbg_ptr, session_json);
+        return ret;
     }
     /**
      * @returns {Promise<any>}
      */
     subjectList() {
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
         const ret = wasm.modelhealthservice_subjectList(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {string} session_id
      * @returns {Promise<any>}
      */
     trialList(session_id) {
-        const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.modelhealthservice_trialList(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+        return ret;
     }
     /**
      * @param {any} activity_json
      * @returns {Promise<any>}
      */
     updateActivity(activity_json) {
-        const ret = wasm.modelhealthservice_updateActivity(this.__wbg_ptr, addHeapObject(activity_json));
-        return takeObject(ret);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ret = wasm.modelhealthservice_updateActivity(this.__wbg_ptr, activity_json);
+        return ret;
     }
     /**
      * @param {string} code
@@ -283,10 +326,13 @@ export class ModelHealthService {
      * @returns {Promise<void>}
      */
     verify(code, remember_device) {
-        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+        _assertNum(this.__wbg_ptr);
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
+        _assertBoolean(remember_device);
         const ret = wasm.modelhealthservice_verify(this.__wbg_ptr, ptr0, len0, remember_device);
-        return takeObject(ret);
+        return ret;
     }
 }
 if (Symbol.dispose) ModelHealthService.prototype[Symbol.dispose] = ModelHealthService.prototype.free;
@@ -300,12 +346,12 @@ if (Symbol.dispose) ModelHealthService.prototype[Symbol.dispose] = ModelHealthSe
  * @returns {Promise<any>}
  */
 export function calibrateCamera(api_key, token, session_json, checkerboard_json, _status_callback) {
-    const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const ptr1 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.calibrateCamera(ptr0, len0, ptr1, len1, addHeapObject(session_json), addHeapObject(checkerboard_json), addHeapObject(_status_callback));
-    return takeObject(ret);
+    const ret = wasm.calibrateCamera(ptr0, len0, ptr1, len1, session_json, checkerboard_json, _status_callback);
+    return ret;
 }
 
 /**
@@ -317,83 +363,99 @@ export function calibrateCamera(api_key, token, session_json, checkerboard_json,
  * @returns {Promise<any>}
  */
 export function calibrateNeutralPose(api_key, token, subject_json, session_json, _status_callback) {
-    const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const ptr1 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.calibrateNeutralPose(ptr0, len0, ptr1, len1, addHeapObject(subject_json), addHeapObject(session_json), addHeapObject(_status_callback));
-    return takeObject(ret);
+    const ret = wasm.calibrateNeutralPose(ptr0, len0, ptr1, len1, subject_json, session_json, _status_callback);
+    return ret;
 }
 
 export function init() {
     wasm.init();
 }
 
+//#endregion
+
+//#region wasm imports
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+        __wbg_Error_8c4e43fe74559d73: function() { return logError(function (arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_Number_04624de7d0e8332d: function(arg0) {
-            const ret = Number(getObject(arg0));
             return ret;
-        },
-        __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
-            const ret = String(getObject(arg1));
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        }, arguments); },
+        __wbg_Number_04624de7d0e8332d: function() { return logError(function (arg0) {
+            const ret = Number(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_String_8f0eb39a4a4c2f66: function() { return logError(function (arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
+        }, arguments); },
         __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
-            const v = getObject(arg0);
+            const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
+            if (!isLikeNone(ret)) {
+                _assertBoolean(ret);
+            }
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
         __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
-            const ret = debugString(getObject(arg1));
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
         __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
-            const ret = getObject(arg0) in getObject(arg1);
+            const ret = arg0 in arg1;
+            _assertBoolean(ret);
             return ret;
         },
         __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
-            const ret = typeof(getObject(arg0)) === 'function';
+            const ret = typeof(arg0) === 'function';
+            _assertBoolean(ret);
             return ret;
         },
         __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
-            const val = getObject(arg0);
+            const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
+            _assertBoolean(ret);
             return ret;
         },
         __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
-            const ret = typeof(getObject(arg0)) === 'string';
+            const ret = typeof(arg0) === 'string';
+            _assertBoolean(ret);
             return ret;
         },
         __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
-            const ret = getObject(arg0) === undefined;
+            const ret = arg0 === undefined;
+            _assertBoolean(ret);
             return ret;
         },
         __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
-            const ret = getObject(arg0) == getObject(arg1);
+            const ret = arg0 == arg1;
+            _assertBoolean(ret);
             return ret;
         },
         __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
-            const obj = getObject(arg1);
+            const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
+            if (!isLikeNone(ret)) {
+                _assertNum(ret);
+            }
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
         __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
-            const obj = getObject(arg1);
+            const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
-            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             var len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -401,39 +463,44 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg__wbg_cb_unref_d9b87ff7982e3b21: function(arg0) {
-            getObject(arg0)._wbg_cb_unref();
-        },
-        __wbg_abort_2f0584e03e8e3950: function(arg0) {
-            getObject(arg0).abort();
-        },
+        __wbg__wbg_cb_unref_d9b87ff7982e3b21: function() { return logError(function (arg0) {
+            arg0._wbg_cb_unref();
+        }, arguments); },
+        __wbg_abort_2f0584e03e8e3950: function() { return logError(function (arg0) {
+            arg0.abort();
+        }, arguments); },
         __wbg_append_a992ccc37aa62dc4: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-            getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
         __wbg_arrayBuffer_bb54076166006c39: function() { return handleError(function (arg0) {
-            const ret = getObject(arg0).arrayBuffer();
-            return addHeapObject(ret);
+            const ret = arg0.arrayBuffer();
+            return ret;
         }, arguments); },
         __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
-            const ret = getObject(arg0).call(getObject(arg1));
-            return addHeapObject(ret);
+            const ret = arg0.call(arg1);
+            return ret;
         }, arguments); },
         __wbg_call_4708e0c13bdc8e95: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-            return addHeapObject(ret);
+            const ret = arg0.call(arg1, arg2);
+            return ret;
         }, arguments); },
-        __wbg_debug_46a93995fc6f8820: function(arg0, arg1, arg2, arg3) {
-            console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-        },
-        __wbg_done_57b39ecd9addfe81: function(arg0) {
-            const ret = getObject(arg0).done;
+        __wbg_createTask_deeb88a68fc97c9d: function() { return handleError(function (arg0, arg1) {
+            const ret = console.createTask(getStringFromWasm0(arg0, arg1));
             return ret;
-        },
-        __wbg_entries_58c7934c745daac7: function(arg0) {
-            const ret = Object.entries(getObject(arg0));
-            return addHeapObject(ret);
-        },
-        __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+        }, arguments); },
+        __wbg_debug_46a93995fc6f8820: function() { return logError(function (arg0, arg1, arg2, arg3) {
+            console.debug(arg0, arg1, arg2, arg3);
+        }, arguments); },
+        __wbg_done_57b39ecd9addfe81: function() { return logError(function (arg0) {
+            const ret = arg0.done;
+            _assertBoolean(ret);
+            return ret;
+        }, arguments); },
+        __wbg_entries_58c7934c745daac7: function() { return logError(function (arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_error_7534b8e9a36f1ab4: function() { return logError(function (arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
             try {
@@ -441,327 +508,360 @@ function __wbg_get_imports() {
                 deferred0_1 = arg1;
                 console.error(getStringFromWasm0(arg0, arg1));
             } finally {
-                wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
-        },
-        __wbg_error_794d0ffc9d00d5c3: function(arg0, arg1, arg2, arg3) {
-            console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-        },
-        __wbg_error_9a7fe3f932034cde: function(arg0) {
-            console.error(getObject(arg0));
-        },
-        __wbg_fetch_afb6a4b6cacf876d: function(arg0, arg1) {
-            const ret = getObject(arg0).fetch(getObject(arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_fetch_f1856afdb49415d1: function(arg0) {
-            const ret = fetch(getObject(arg0));
-            return addHeapObject(ret);
-        },
-        __wbg_getToken_0219bad7f942aa94: function(arg0) {
-            const ret = getObject(arg0).getToken();
-            return addHeapObject(ret);
-        },
-        __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
-            const ret = getObject(arg0)[arg1 >>> 0];
-            return addHeapObject(ret);
-        },
+        }, arguments); },
+        __wbg_error_794d0ffc9d00d5c3: function() { return logError(function (arg0, arg1, arg2, arg3) {
+            console.error(arg0, arg1, arg2, arg3);
+        }, arguments); },
+        __wbg_error_9a7fe3f932034cde: function() { return logError(function (arg0) {
+            console.error(arg0);
+        }, arguments); },
+        __wbg_fetch_afb6a4b6cacf876d: function() { return logError(function (arg0, arg1) {
+            const ret = arg0.fetch(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_fetch_f1856afdb49415d1: function() { return logError(function (arg0) {
+            const ret = fetch(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_getToken_0219bad7f942aa94: function() { return logError(function (arg0) {
+            const ret = arg0.getToken();
+            return ret;
+        }, arguments); },
+        __wbg_get_9b94d73e6221f75c: function() { return logError(function (arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        }, arguments); },
         __wbg_get_b3ed3ad4be2bc8ac: function() { return handleError(function (arg0, arg1) {
-            const ret = Reflect.get(getObject(arg0), getObject(arg1));
-            return addHeapObject(ret);
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_with_ref_key_1dc361bd10053bfe: function() { return logError(function (arg0, arg1) {
+            const ret = arg0[arg1];
+            return ret;
         }, arguments); },
-        __wbg_get_with_ref_key_1dc361bd10053bfe: function(arg0, arg1) {
-            const ret = getObject(arg0)[getObject(arg1)];
-            return addHeapObject(ret);
-        },
         __wbg_has_d4e53238966c12b6: function() { return handleError(function (arg0, arg1) {
-            const ret = Reflect.has(getObject(arg0), getObject(arg1));
+            const ret = Reflect.has(arg0, arg1);
+            _assertBoolean(ret);
             return ret;
         }, arguments); },
-        __wbg_headers_59a2938db9f80985: function(arg0) {
-            const ret = getObject(arg0).headers;
-            return addHeapObject(ret);
-        },
-        __wbg_info_9e602cf10c5c690b: function(arg0, arg1, arg2, arg3) {
-            console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-        },
-        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+        __wbg_headers_59a2938db9f80985: function() { return logError(function (arg0) {
+            const ret = arg0.headers;
+            return ret;
+        }, arguments); },
+        __wbg_info_9e602cf10c5c690b: function() { return logError(function (arg0, arg1, arg2, arg3) {
+            console.info(arg0, arg1, arg2, arg3);
+        }, arguments); },
+        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function() { return logError(function (arg0) {
             let result;
             try {
-                result = getObject(arg0) instanceof ArrayBuffer;
+                result = arg0 instanceof ArrayBuffer;
             } catch (_) {
                 result = false;
             }
             const ret = result;
+            _assertBoolean(ret);
             return ret;
-        },
-        __wbg_instanceof_Response_ee1d54d79ae41977: function(arg0) {
+        }, arguments); },
+        __wbg_instanceof_Response_ee1d54d79ae41977: function() { return logError(function (arg0) {
             let result;
             try {
-                result = getObject(arg0) instanceof Response;
+                result = arg0 instanceof Response;
             } catch (_) {
                 result = false;
             }
             const ret = result;
+            _assertBoolean(ret);
             return ret;
-        },
-        __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+        }, arguments); },
+        __wbg_instanceof_Uint8Array_9b9075935c74707c: function() { return logError(function (arg0) {
             let result;
             try {
-                result = getObject(arg0) instanceof Uint8Array;
+                result = arg0 instanceof Uint8Array;
             } catch (_) {
                 result = false;
             }
             const ret = result;
+            _assertBoolean(ret);
             return ret;
-        },
-        __wbg_instanceof_Window_ed49b2db8df90359: function(arg0) {
+        }, arguments); },
+        __wbg_instanceof_Window_ed49b2db8df90359: function() { return logError(function (arg0) {
             let result;
             try {
-                result = getObject(arg0) instanceof Window;
+                result = arg0 instanceof Window;
             } catch (_) {
                 result = false;
             }
             const ret = result;
+            _assertBoolean(ret);
             return ret;
-        },
-        __wbg_isArray_d314bb98fcf08331: function(arg0) {
-            const ret = Array.isArray(getObject(arg0));
+        }, arguments); },
+        __wbg_isArray_d314bb98fcf08331: function() { return logError(function (arg0) {
+            const ret = Array.isArray(arg0);
+            _assertBoolean(ret);
             return ret;
-        },
-        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
-            const ret = Number.isSafeInteger(getObject(arg0));
+        }, arguments); },
+        __wbg_isSafeInteger_bfbc7332a9768d2a: function() { return logError(function (arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            _assertBoolean(ret);
             return ret;
-        },
-        __wbg_iterator_6ff6560ca1568e55: function() {
+        }, arguments); },
+        __wbg_iterator_6ff6560ca1568e55: function() { return logError(function () {
             const ret = Symbol.iterator;
-            return addHeapObject(ret);
-        },
-        __wbg_length_32ed9a279acd054c: function(arg0) {
-            const ret = getObject(arg0).length;
             return ret;
-        },
-        __wbg_length_35a7bace40f36eac: function(arg0) {
-            const ret = getObject(arg0).length;
+        }, arguments); },
+        __wbg_length_32ed9a279acd054c: function() { return logError(function (arg0) {
+            const ret = arg0.length;
+            _assertNum(ret);
             return ret;
-        },
-        __wbg_log_24aba2a6d8990b35: function(arg0, arg1, arg2, arg3) {
-            console.log(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-        },
-        __wbg_new_361308b2356cecd0: function() {
+        }, arguments); },
+        __wbg_length_35a7bace40f36eac: function() { return logError(function (arg0) {
+            const ret = arg0.length;
+            _assertNum(ret);
+            return ret;
+        }, arguments); },
+        __wbg_log_24aba2a6d8990b35: function() { return logError(function (arg0, arg1, arg2, arg3) {
+            console.log(arg0, arg1, arg2, arg3);
+        }, arguments); },
+        __wbg_new_361308b2356cecd0: function() { return logError(function () {
             const ret = new Object();
-            return addHeapObject(ret);
-        },
-        __wbg_new_3eb36ae241fe6f44: function() {
+            return ret;
+        }, arguments); },
+        __wbg_new_3eb36ae241fe6f44: function() { return logError(function () {
             const ret = new Array();
-            return addHeapObject(ret);
-        },
+            return ret;
+        }, arguments); },
         __wbg_new_64284bd487f9d239: function() { return handleError(function () {
             const ret = new Headers();
-            return addHeapObject(ret);
+            return ret;
         }, arguments); },
-        __wbg_new_8a6f238a6ece86ea: function() {
+        __wbg_new_8a6f238a6ece86ea: function() { return logError(function () {
             const ret = new Error();
-            return addHeapObject(ret);
-        },
-        __wbg_new_b5d9e2fb389fef91: function(arg0, arg1) {
+            return ret;
+        }, arguments); },
+        __wbg_new_b5d9e2fb389fef91: function() { return logError(function (arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
                 var cb0 = (arg0, arg1) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_1265(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h578f205e426c6879(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
                 };
                 const ret = new Promise(cb0);
-                return addHeapObject(ret);
+                return ret;
             } finally {
                 state0.a = state0.b = 0;
             }
-        },
+        }, arguments); },
         __wbg_new_b949e7f56150a5d1: function() { return handleError(function () {
             const ret = new AbortController();
-            return addHeapObject(ret);
+            return ret;
         }, arguments); },
-        __wbg_new_dca287b076112a51: function() {
+        __wbg_new_dca287b076112a51: function() { return logError(function () {
             const ret = new Map();
-            return addHeapObject(ret);
-        },
-        __wbg_new_dd2b680c8bf6ae29: function(arg0) {
-            const ret = new Uint8Array(getObject(arg0));
-            return addHeapObject(ret);
-        },
-        __wbg_new_from_slice_a3d2629dc1826784: function(arg0, arg1) {
+            return ret;
+        }, arguments); },
+        __wbg_new_dd2b680c8bf6ae29: function() { return logError(function (arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_new_from_slice_a3d2629dc1826784: function() { return logError(function (arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+            return ret;
+        }, arguments); },
+        __wbg_new_no_args_1c7c842f08d00ebb: function() { return logError(function (arg0, arg1) {
             const ret = new Function(getStringFromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
+            return ret;
+        }, arguments); },
         __wbg_new_with_str_and_init_a61cbc6bdef21614: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
-            return addHeapObject(ret);
+            const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
         }, arguments); },
         __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
-            const ret = getObject(arg0).next();
-            return addHeapObject(ret);
+            const ret = arg0.next();
+            return ret;
         }, arguments); },
-        __wbg_next_418f80d8f5303233: function(arg0) {
-            const ret = getObject(arg0).next;
-            return addHeapObject(ret);
-        },
-        __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
-            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
-        },
-        __wbg_push_8ffdcb2063340ba5: function(arg0, arg1) {
-            const ret = getObject(arg0).push(getObject(arg1));
+        __wbg_next_418f80d8f5303233: function() { return logError(function (arg0) {
+            const ret = arg0.next;
             return ret;
-        },
-        __wbg_queueMicrotask_0aa0a927f78f5d98: function(arg0) {
-            const ret = getObject(arg0).queueMicrotask;
-            return addHeapObject(ret);
-        },
-        __wbg_queueMicrotask_5bb536982f78a56f: function(arg0) {
-            queueMicrotask(getObject(arg0));
-        },
-        __wbg_reject_a2176de7f1212be5: function(arg0) {
-            const ret = Promise.reject(getObject(arg0));
-            return addHeapObject(ret);
-        },
-        __wbg_removeToken_6425f06e5d0e85a4: function(arg0) {
-            const ret = getObject(arg0).removeToken();
-            return addHeapObject(ret);
-        },
-        __wbg_resolve_002c4b7d9d8f6b64: function(arg0) {
-            const ret = Promise.resolve(getObject(arg0));
-            return addHeapObject(ret);
-        },
+        }, arguments); },
+        __wbg_prototypesetcall_bdcdcc5842e4d77d: function() { return logError(function (arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        }, arguments); },
+        __wbg_push_8ffdcb2063340ba5: function() { return logError(function (arg0, arg1) {
+            const ret = arg0.push(arg1);
+            _assertNum(ret);
+            return ret;
+        }, arguments); },
+        __wbg_queueMicrotask_0aa0a927f78f5d98: function() { return logError(function (arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        }, arguments); },
+        __wbg_queueMicrotask_5bb536982f78a56f: function() { return logError(function (arg0) {
+            queueMicrotask(arg0);
+        }, arguments); },
+        __wbg_reject_a2176de7f1212be5: function() { return logError(function (arg0) {
+            const ret = Promise.reject(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_removeToken_6425f06e5d0e85a4: function() { return logError(function (arg0) {
+            const ret = arg0.removeToken();
+            return ret;
+        }, arguments); },
+        __wbg_resolve_002c4b7d9d8f6b64: function() { return logError(function (arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_run_bcde7ea43ea6ed7c: function() { return logError(function (arg0, arg1, arg2) {
+            try {
+                var state0 = {a: arg1, b: arg2};
+                var cb0 = () => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures_____invoke__hf5c938e98822d223(a, state0.b, );
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = arg0.run(cb0);
+                _assertBoolean(ret);
+                return ret;
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        }, arguments); },
         __wbg_setTimeout_eff32631ea138533: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
+            const ret = arg0.setTimeout(arg1, arg2);
+            _assertNum(ret);
             return ret;
         }, arguments); },
-        __wbg_setToken_d7bed0c5c0251a65: function(arg0, arg1, arg2) {
+        __wbg_setToken_d7bed0c5c0251a65: function() { return logError(function (arg0, arg1, arg2) {
             let deferred0_0;
             let deferred0_1;
             try {
                 deferred0_0 = arg1;
                 deferred0_1 = arg2;
-                const ret = getObject(arg0).setToken(getStringFromWasm0(arg1, arg2));
-                return addHeapObject(ret);
+                const ret = arg0.setToken(getStringFromWasm0(arg1, arg2));
+                return ret;
             } finally {
-                wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
-        },
-        __wbg_set_1eb0999cf5d27fc8: function(arg0, arg1, arg2) {
-            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-            return addHeapObject(ret);
-        },
-        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
-            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-        },
-        __wbg_set_body_9a7e00afe3cfe244: function(arg0, arg1) {
-            getObject(arg0).body = getObject(arg1);
-        },
-        __wbg_set_credentials_c4a58d2e05ef24fb: function(arg0, arg1) {
-            getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
-        },
-        __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
-            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-        },
-        __wbg_set_headers_cfc5f4b2c1f20549: function(arg0, arg1) {
-            getObject(arg0).headers = getObject(arg1);
-        },
-        __wbg_set_method_c3e20375f5ae7fac: function(arg0, arg1, arg2) {
-            getObject(arg0).method = getStringFromWasm0(arg1, arg2);
-        },
-        __wbg_set_mode_b13642c312648202: function(arg0, arg1) {
-            getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
-        },
-        __wbg_set_signal_f2d3f8599248896d: function(arg0, arg1) {
-            getObject(arg0).signal = getObject(arg1);
-        },
-        __wbg_signal_d1285ecab4ebc5ad: function(arg0) {
-            const ret = getObject(arg0).signal;
-            return addHeapObject(ret);
-        },
-        __wbg_stack_0ed75d68575b0f3c: function(arg0, arg1) {
-            const ret = getObject(arg1).stack;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        }, arguments); },
+        __wbg_set_1eb0999cf5d27fc8: function() { return logError(function (arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_3f1d0b984ed272ed: function() { return logError(function (arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        }, arguments); },
+        __wbg_set_body_9a7e00afe3cfe244: function() { return logError(function (arg0, arg1) {
+            arg0.body = arg1;
+        }, arguments); },
+        __wbg_set_credentials_c4a58d2e05ef24fb: function() { return logError(function (arg0, arg1) {
+            arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+        }, arguments); },
+        __wbg_set_f43e577aea94465b: function() { return logError(function (arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        }, arguments); },
+        __wbg_set_headers_cfc5f4b2c1f20549: function() { return logError(function (arg0, arg1) {
+            arg0.headers = arg1;
+        }, arguments); },
+        __wbg_set_method_c3e20375f5ae7fac: function() { return logError(function (arg0, arg1, arg2) {
+            arg0.method = getStringFromWasm0(arg1, arg2);
+        }, arguments); },
+        __wbg_set_mode_b13642c312648202: function() { return logError(function (arg0, arg1) {
+            arg0.mode = __wbindgen_enum_RequestMode[arg1];
+        }, arguments); },
+        __wbg_set_signal_f2d3f8599248896d: function() { return logError(function (arg0, arg1) {
+            arg0.signal = arg1;
+        }, arguments); },
+        __wbg_signal_d1285ecab4ebc5ad: function() { return logError(function (arg0) {
+            const ret = arg0.signal;
+            return ret;
+        }, arguments); },
+        __wbg_stack_0ed75d68575b0f3c: function() { return logError(function (arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+        }, arguments); },
+        __wbg_static_accessor_GLOBAL_12837167ad935116: function() { return logError(function () {
             const ret = typeof global === 'undefined' ? null : global;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() { return logError(function () {
             const ret = typeof globalThis === 'undefined' ? null : globalThis;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() { return logError(function () {
             const ret = typeof self === 'undefined' ? null : self;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() { return logError(function () {
             const ret = typeof window === 'undefined' ? null : window;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_status_89d7e803db911ee7: function(arg0) {
-            const ret = getObject(arg0).status;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_status_89d7e803db911ee7: function() { return logError(function (arg0) {
+            const ret = arg0.status;
+            _assertNum(ret);
             return ret;
-        },
+        }, arguments); },
         __wbg_stringify_8d1cc6ff383e8bae: function() { return handleError(function (arg0) {
-            const ret = JSON.stringify(getObject(arg0));
-            return addHeapObject(ret);
+            const ret = JSON.stringify(arg0);
+            return ret;
         }, arguments); },
-        __wbg_then_0d9fe2c7b1857d32: function(arg0, arg1, arg2) {
-            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
-            return addHeapObject(ret);
-        },
-        __wbg_then_b9e7b3b5f1a9e1b5: function(arg0, arg1) {
-            const ret = getObject(arg0).then(getObject(arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_url_c484c26b1fbf5126: function(arg0, arg1) {
-            const ret = getObject(arg1).url;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        __wbg_then_0d9fe2c7b1857d32: function() { return logError(function (arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_then_b9e7b3b5f1a9e1b5: function() { return logError(function (arg0, arg1) {
+            const ret = arg0.then(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_url_c484c26b1fbf5126: function() { return logError(function (arg0, arg1) {
+            const ret = arg1.url;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg_value_0546255b415e96c1: function(arg0) {
-            const ret = getObject(arg0).value;
-            return addHeapObject(ret);
-        },
-        __wbg_warn_a40b971467b219c7: function(arg0, arg1, arg2, arg3) {
-            console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-        },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 415, function: Function { arguments: [Externref], shim_idx: 416, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_880, __wasm_bindgen_func_elem_881);
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000002: function(arg0) {
+        }, arguments); },
+        __wbg_value_0546255b415e96c1: function() { return logError(function (arg0) {
+            const ret = arg0.value;
+            return ret;
+        }, arguments); },
+        __wbg_warn_a40b971467b219c7: function() { return logError(function (arg0, arg1, arg2, arg3) {
+            console.warn(arg0, arg1, arg2, arg3);
+        }, arguments); },
+        __wbindgen_cast_0000000000000001: function() { return logError(function (arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 474, function: Function { arguments: [Externref], shim_idx: 475, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h7623950b97f87fe8, wasm_bindgen__convert__closures_____invoke__h047f284fd3985509);
+            return ret;
+        }, arguments); },
+        __wbindgen_cast_0000000000000002: function() { return logError(function (arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            return ret;
+        }, arguments); },
+        __wbindgen_cast_0000000000000003: function() { return logError(function (arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
-            return addHeapObject(ret);
-        },
-        __wbindgen_object_clone_ref: function(arg0) {
-            const ret = getObject(arg0);
-            return addHeapObject(ret);
-        },
-        __wbindgen_object_drop_ref: function(arg0) {
-            takeObject(arg0);
+            return ret;
+        }, arguments); },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
         },
     };
     return {
@@ -770,12 +870,25 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_881(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_881(arg0, arg1, addHeapObject(arg2));
+
+//#endregion
+function wasm_bindgen__convert__closures_____invoke__hf5c938e98822d223(arg0, arg1) {
+    _assertNum(arg0);
+    _assertNum(arg1);
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__hf5c938e98822d223(arg0, arg1);
+    return ret !== 0;
 }
 
-function __wasm_bindgen_func_elem_1265(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1265(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function wasm_bindgen__convert__closures_____invoke__h047f284fd3985509(arg0, arg1, arg2) {
+    _assertNum(arg0);
+    _assertNum(arg1);
+    wasm.wasm_bindgen__convert__closures_____invoke__h047f284fd3985509(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h578f205e426c6879(arg0, arg1, arg2, arg3) {
+    _assertNum(arg0);
+    _assertNum(arg1);
+    wasm.wasm_bindgen__convert__closures_____invoke__h578f205e426c6879(arg0, arg1, arg2, arg3);
 }
 
 
@@ -787,15 +900,24 @@ const ModelHealthServiceFinalization = (typeof FinalizationRegistry === 'undefin
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_modelhealthservice_free(ptr >>> 0, 1));
 
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
 
-    heap[idx] = obj;
+//#region intrinsics
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
     return idx;
 }
 
+function _assertBoolean(n) {
+    if (typeof(n) !== 'boolean') {
+        throw new Error(`expected a boolean argument, found ${typeof(n)}`);
+    }
+}
+
+function _assertNum(n) {
+    if (typeof(n) !== 'number') throw new Error(`expected a number argument, found ${typeof(n)}`);
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => state.dtor(state.a, state.b));
@@ -865,12 +987,6 @@ function debugString(val) {
     return className;
 }
 
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -897,25 +1013,35 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-function getObject(idx) { return heap[idx]; }
-
 function handleError(f, args) {
     try {
         return f.apply(this, args);
     } catch (e) {
-        wasm.__wbindgen_export3(addHeapObject(e));
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
     }
 }
 
-let heap = new Array(128).fill(undefined);
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function logError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        let error = (function () {
+            try {
+                return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
+            } catch(_) {
+                return "<failed to stringify thrown value>";
+            }
+        }());
+        console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
+        throw e;
+    }
+}
+
 function makeMutClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
     const real = (...args) => {
@@ -945,6 +1071,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 }
 
 function passStringToWasm0(arg, malloc, realloc) {
+    if (typeof(arg) !== 'string') throw new Error(`expected a string argument, found ${typeof(arg)}`);
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
         const ptr = malloc(buf.length, 1) >>> 0;
@@ -972,7 +1099,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
         const ret = cachedTextEncoder.encodeInto(arg, view);
-
+        if (ret.read !== arg.length) throw new Error('failed to pass whole string');
         offset += ret.written;
         ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
@@ -981,10 +1108,10 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
+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 });
@@ -1016,6 +1143,10 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
+
+//#endregion
+
+//#region wasm loading
 let wasmModule, wasm;
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
@@ -1108,3 +1239,5 @@ async function __wbg_init(module_or_path) {
 }
 
 export { initSync, __wbg_init as default };
+//#endregion
+export { wasm as __wasm }