isar_plus 1.0.28 → 1.1.2

package/isar.js

@@ -0,0 +1,972 @@
+window.wasm_bindgen = undefined;
+(function() {
+    const __exports = {};
+    let script_src;
+    if (typeof document !== 'undefined' && document.currentScript !== null) {
+        script_src = new URL(document.currentScript.src, location.href).toString();
+    }
+    let wasm = undefined;
+
+    let heap = new Array(128).fill(undefined);
+
+    heap.push(undefined, null, true, false);
+
+    function getObject(idx) { return heap[idx]; }
+
+    let heap_next = heap.length;
+
+    function addHeapObject(obj) {
+        if (heap_next === heap.length) heap.push(heap.length + 1);
+        const idx = heap_next;
+        heap_next = heap[idx];
+
+        heap[idx] = obj;
+        return idx;
+    }
+
+    function handleError(f, args) {
+        try {
+            return f.apply(this, args);
+        } catch (e) {
+            wasm.__wbindgen_export_0(addHeapObject(e));
+        }
+    }
+
+    let cachedUint8ArrayMemory0 = null;
+
+    function getUint8ArrayMemory0() {
+        if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+            cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachedUint8ArrayMemory0;
+    }
+
+    let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+    cachedTextDecoder.decode();
+
+    function decodeText(ptr, len) {
+        return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+
+    function getStringFromWasm0(ptr, len) {
+        ptr = ptr >>> 0;
+        return decodeText(ptr, len);
+    }
+
+    function isLikeNone(x) {
+        return x === undefined || x === null;
+    }
+
+    let WASM_VECTOR_LEN = 0;
+
+    const cachedTextEncoder = new TextEncoder();
+
+    if (!('encodeInto' in cachedTextEncoder)) {
+        cachedTextEncoder.encodeInto = function (arg, view) {
+            const buf = cachedTextEncoder.encode(arg);
+            view.set(buf);
+            return {
+                read: arg.length,
+                written: buf.length
+            };
+        }
+    }
+
+    function passStringToWasm0(arg, malloc, realloc) {
+
+        if (realloc === undefined) {
+            const buf = cachedTextEncoder.encode(arg);
+            const ptr = malloc(buf.length, 1) >>> 0;
+            getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+            WASM_VECTOR_LEN = buf.length;
+            return ptr;
+        }
+
+        let len = arg.length;
+        let ptr = malloc(len, 1) >>> 0;
+
+        const mem = getUint8ArrayMemory0();
+
+        let offset = 0;
+
+        for (; offset < len; offset++) {
+            const code = arg.charCodeAt(offset);
+            if (code > 0x7F) break;
+            mem[ptr + offset] = code;
+        }
+
+        if (offset !== len) {
+            if (offset !== 0) {
+                arg = arg.slice(offset);
+            }
+            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);
+
+            offset += ret.written;
+            ptr = realloc(ptr, len, offset, 1) >>> 0;
+        }
+
+        WASM_VECTOR_LEN = offset;
+        return ptr;
+    }
+
+    let cachedDataViewMemory0 = null;
+
+    function getDataViewMemory0() {
+        if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+            cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+        }
+        return cachedDataViewMemory0;
+    }
+
+    function getArrayU8FromWasm0(ptr, len) {
+        ptr = ptr >>> 0;
+        return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+    }
+
+    function debugString(val) {
+        // primitive types
+        const type = typeof val;
+        if (type == 'number' || type == 'boolean' || val == null) {
+            return  `${val}`;
+        }
+        if (type == 'string') {
+            return `"${val}"`;
+        }
+        if (type == 'symbol') {
+            const description = val.description;
+            if (description == null) {
+                return 'Symbol';
+            } else {
+                return `Symbol(${description})`;
+            }
+        }
+        if (type == 'function') {
+            const name = val.name;
+            if (typeof name == 'string' && name.length > 0) {
+                return `Function(${name})`;
+            } else {
+                return 'Function';
+            }
+        }
+        // objects
+        if (Array.isArray(val)) {
+            const length = val.length;
+            let debug = '[';
+            if (length > 0) {
+                debug += debugString(val[0]);
+            }
+            for(let i = 1; i < length; i++) {
+                debug += ', ' + debugString(val[i]);
+            }
+            debug += ']';
+            return debug;
+        }
+        // Test for built-in
+        const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+        let className;
+        if (builtInMatches && builtInMatches.length > 1) {
+            className = builtInMatches[1];
+        } else {
+            // Failed to match the standard '[object ClassName]'
+            return toString.call(val);
+        }
+        if (className == 'Object') {
+            // we're a user defined class or Object
+            // JSON.stringify avoids problems with cycles, and is generally much
+            // easier than looping through ownProperties of `val`.
+            try {
+                return 'Object(' + JSON.stringify(val) + ')';
+            } catch (_) {
+                return 'Object';
+            }
+        }
+        // errors
+        if (val instanceof Error) {
+            return `${val.name}: ${val.message}\n${val.stack}`;
+        }
+        // TODO we could test for more things here, like `Set`s and `Map`s.
+        return className;
+    }
+
+    const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry(
+    state => {
+        wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b);
+    }
+    );
+
+    function makeMutClosure(arg0, arg1, dtor, f) {
+        const state = { a: arg0, b: arg1, cnt: 1, dtor };
+        const real = (...args) => {
+
+            // First up with a closure we increment the internal reference
+            // count. This ensures that the Rust closure environment won't
+            // be deallocated while we're invoking it.
+            state.cnt++;
+            const a = state.a;
+            state.a = 0;
+            try {
+                return f(a, state.b, ...args);
+            } finally {
+                if (--state.cnt === 0) {
+                    wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
+                    CLOSURE_DTORS.unregister(state);
+                } else {
+                    state.a = a;
+                }
+            }
+        };
+        real.original = state;
+        CLOSURE_DTORS.register(real, state, state);
+        return real;
+    }
+
+    function dropObject(idx) {
+        if (idx < 132) return;
+        heap[idx] = heap_next;
+        heap_next = idx;
+    }
+
+    function takeObject(idx) {
+        const ret = getObject(idx);
+        dropObject(idx);
+        return ret;
+    }
+    function __wbg_adapter_6(arg0, arg1, arg2) {
+        wasm.__wbindgen_export_4(arg0, arg1, addHeapObject(arg2));
+    }
+
+    function __wbg_adapter_9(arg0, arg1) {
+        wasm.__wbindgen_export_5(arg0, arg1);
+    }
+
+    function __wbg_adapter_16(arg0, arg1, arg2) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbindgen_export_6(retptr, arg0, arg1, addHeapObject(arg2));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+
+    const __wbindgen_enum_IdbRequestReadyState = ["pending", "done"];
+
+    const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
+
+    const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+    async function __wbg_load(module, imports) {
+        if (typeof Response === 'function' && module instanceof Response) {
+            if (typeof WebAssembly.instantiateStreaming === 'function') {
+                try {
+                    return await WebAssembly.instantiateStreaming(module, imports);
+
+                } catch (e) {
+                    const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                    if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                        console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                    } else {
+                        throw e;
+                    }
+                }
+            }
+
+            const bytes = await module.arrayBuffer();
+            return await WebAssembly.instantiate(bytes, imports);
+
+        } else {
+            const instance = await WebAssembly.instantiate(module, imports);
+
+            if (instance instanceof WebAssembly.Instance) {
+                return { instance, module };
+
+            } else {
+                return instance;
+            }
+        }
+    }
+
+    function __wbg_get_imports() {
+        const imports = {};
+        imports.wbg = {};
+        imports.wbg.__wbg_Window_41559019033ede94 = function(arg0) {
+            const ret = getObject(arg0).Window;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_WorkerGlobalScope_d324bffbeaef9f3a = function(arg0) {
+            const ret = getObject(arg0).WorkerGlobalScope;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_abort_48fad284f76f23cd = function() { return handleError(function (arg0) {
+            getObject(arg0).abort();
+        }, arguments) };
+        imports.wbg.__wbg_add_bd7fa428f539a577 = function(arg0, arg1) {
+            const ret = getObject(arg0).add(getObject(arg1));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_bound_99d0883606949696 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_buffer_8d40b1d762fb3c66 = function(arg0) {
+            const ret = getObject(arg0).buffer;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_byteLength_331a6b5545834024 = function(arg0) {
+            const ret = getObject(arg0).byteLength;
+            return ret;
+        };
+        imports.wbg.__wbg_byteOffset_49a5b5608000358b = function(arg0) {
+            const ret = getObject(arg0).byteOffset;
+            return ret;
+        };
+        imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).call(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_clear_cb0b847e7ab689c8 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).clear();
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_commit_a54edce65f3858f2 = function() { return handleError(function (arg0) {
+            getObject(arg0).commit();
+        }, arguments) };
+        imports.wbg.__wbg_createObjectStore_2112aa8eea18ea9d = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_createSyncAccessHandle_d06aab2e41a339b2 = function(arg0) {
+            const ret = getObject(arg0).createSyncAccessHandle();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_delete_33e805b6d49fa644 = function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).delete(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_delete_34b4d9b89634f0c0 = function(arg0, arg1) {
+            const ret = getObject(arg0).delete(getObject(arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_delete_ded22f5899363180 = function(arg0, arg1) {
+            const ret = getObject(arg0).delete(getObject(arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_done_75ed0ee6dd243d9d = function(arg0) {
+            const ret = getObject(arg0).done;
+            return ret;
+        };
+        imports.wbg.__wbg_entries_1a3c3b9544532397 = function(arg0) {
+            const ret = getObject(arg0).entries();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_error_118f1b830b6ccf22 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).error;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_fill_c8751cf67b766c70 = function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).fill(arg1, arg2 >>> 0, arg3 >>> 0);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_flush_d2487a24f3bc3cf4 = function() { return handleError(function (arg0) {
+            getObject(arg0).flush();
+        }, arguments) };
+        imports.wbg.__wbg_from_88bc52ce20ba6318 = function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_getAll_2783028eb1814671 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).getAll();
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_getAll_ff5bd24743b1031a = function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).getAll(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_getDate_9615e288fc892247 = function(arg0) {
+            const ret = getObject(arg0).getDate();
+            return ret;
+        };
+        imports.wbg.__wbg_getDay_c9c4f57fb4ef6fef = function(arg0) {
+            const ret = getObject(arg0).getDay();
+            return ret;
+        };
+        imports.wbg.__wbg_getDirectoryHandle_0fb26677897f1e21 = function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).getDirectoryHandle(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_getDirectory_8564f4b4ae7ee35c = function(arg0) {
+            const ret = getObject(arg0).getDirectory();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_getFileHandle_9f23d09c2497fa5f = function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).getFileHandle(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_getFullYear_e351a9fa7d2fab83 = function(arg0) {
+            const ret = getObject(arg0).getFullYear();
+            return ret;
+        };
+        imports.wbg.__wbg_getHours_4cc14de357c9e723 = function(arg0) {
+            const ret = getObject(arg0).getHours();
+            return ret;
+        };
+        imports.wbg.__wbg_getMinutes_6cde8fdd08b0c2ec = function(arg0) {
+            const ret = getObject(arg0).getMinutes();
+            return ret;
+        };
+        imports.wbg.__wbg_getMonth_8cc234bce5c8bcac = function(arg0) {
+            const ret = getObject(arg0).getMonth();
+            return ret;
+        };
+        imports.wbg.__wbg_getSeconds_c2f02452d804ece0 = function(arg0) {
+            const ret = getObject(arg0).getSeconds();
+            return ret;
+        };
+        imports.wbg.__wbg_getSize_56a06761973a6cd7 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).getSize();
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_getTime_6bb3f64e0f18f817 = function(arg0) {
+            const ret = getObject(arg0).getTime();
+            return ret;
+        };
+        imports.wbg.__wbg_getTimezoneOffset_1e3ddc1382e7c8b0 = function(arg0) {
+            const ret = getObject(arg0).getTimezoneOffset();
+            return ret;
+        };
+        imports.wbg.__wbg_getUint32_2dc0ed17b0324774 = function(arg0, arg1) {
+            const ret = getObject(arg0).getUint32(arg1 >>> 0);
+            return ret;
+        };
+        imports.wbg.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_get_5ee3191755594360 = function(arg0, arg1) {
+            const ret = getObject(arg0).get(getObject(arg1));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_getindex_61bb13d19869849b = function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return ret;
+        };
+        imports.wbg.__wbg_global_f5c2926e57ba457f = function(arg0) {
+            const ret = getObject(arg0).global;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_has_6a9bff5f4208cfca = function(arg0, arg1) {
+            const ret = getObject(arg0).has(getObject(arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_indexedDB_003e3d885edf75fc = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).indexedDB;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_indexedDB_1956995e4297311c = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).indexedDB;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_indexedDB_54f01430b1e194e8 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).indexedDB;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_instanceof_DomException_bd63c2a0e0b53ed5 = function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof DOMException;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_Error_76149ae9b431750e = function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_IdbDatabase_6e6efef94c4a355d = function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IDBDatabase;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_IdbRequest_a4a68ff63181a915 = function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IDBRequest;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_instanceof_WorkerGlobalScope_85d487cc157fd065 = function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof WorkerGlobalScope;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        };
+        imports.wbg.__wbg_isArray_030cce220591fb41 = function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        };
+        imports.wbg.__wbg_keys_200bc2675df61794 = function(arg0) {
+            const ret = getObject(arg0).keys();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_length_186546c51cd61acd = function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        };
+        imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        };
+        imports.wbg.__wbg_length_9d771c54845e987f = function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        };
+        imports.wbg.__wbg_lowerBound_5a50c0a9f6e7db91 = function() { return handleError(function (arg0, arg1) {
+            const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_message_125a1b2998b3552a = function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_message_5481231e71ccaf7b = function(arg0, arg1) {
+            const ret = getObject(arg1).message;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_name_f75f535832c8ea6b = function(arg0, arg1) {
+            const ret = getObject(arg1).name;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_navigator_bfaf1b0b0eb48da2 = function(arg0) {
+            const ret = getObject(arg0).navigator;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new0_b0a0a38c201e6df5 = function() {
+            const ret = new Date();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_0dc86f3faa8a3b53 = function(arg0) {
+            const ret = new Set(getObject(arg0));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_2ff1f68f3676ea53 = function() {
+            const ret = new Map();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_5a2ae4557f92b50e = function(arg0) {
+            const ret = new Date(getObject(arg0));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_da9dc54c5db29dfa = function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_new_f60d6f09990bdb99 = function(arg0, arg1, arg2) {
+            const ret = new DataView(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
+            const ret = new Function(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_newwithyearmonthday_9d5466a369f2521d = function(arg0, arg1, arg2) {
+            const ret = new Date(arg0 >>> 0, arg1, arg2);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_next_1142e1658f75ec63 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_next_692e82279131b03c = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_objectStore_b2a5b80b2e5c5f8b = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_open_7281831ed8ff7bd2 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        };
+        imports.wbg.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        };
+        imports.wbg.__wbg_put_f777be76774b073e = function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).put(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
+            queueMicrotask(getObject(arg0));
+        };
+        imports.wbg.__wbg_queueMicrotask_4488407636f5bf24 = function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_random_7ed63a0b38ee3b75 = function() {
+            const ret = Math.random();
+            return ret;
+        };
+        imports.wbg.__wbg_read_a43bb46027f02ee9 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).read(getArrayU8FromWasm0(arg1, arg2), getObject(arg3));
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_read_e271e94623077591 = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).read(getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_readyState_a2853902a50c6d54 = function(arg0) {
+            const ret = getObject(arg0).readyState;
+            return (__wbindgen_enum_IdbRequestReadyState.indexOf(ret) + 1 || 3) - 1;
+        };
+        imports.wbg.__wbg_resolve_4055c623acdd6a1b = function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_result_825a6aeeb31189d2 = function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).result;
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_setUint32_8a9564ae127df4c5 = function(arg0, arg1, arg2) {
+            getObject(arg0).setUint32(arg1 >>> 0, arg2 >>> 0);
+        };
+        imports.wbg.__wbg_set_1353b2a5e96bc48c = function(arg0, arg1, arg2) {
+            getObject(arg0).set(getArrayU8FromWasm0(arg1, arg2));
+        };
+        imports.wbg.__wbg_set_453345bcda80b89a = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_set_b7f1cf4fae26fe2a = function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_setat_f8fc70f546036b10 = function(arg0, arg1) {
+            getObject(arg0).at = arg1;
+        };
+        imports.wbg.__wbg_setcreate_1eb73f4ea713c1ad = function(arg0, arg1) {
+            getObject(arg0).create = arg1 !== 0;
+        };
+        imports.wbg.__wbg_setcreate_2d32aa4bbcd1d7af = function(arg0, arg1) {
+            getObject(arg0).create = arg1 !== 0;
+        };
+        imports.wbg.__wbg_setkeypath_3a5536ae3a5f612c = function(arg0, arg1) {
+            getObject(arg0).keyPath = getObject(arg1);
+        };
+        imports.wbg.__wbg_setonabort_4edac498cf4576fe = function(arg0, arg1) {
+            getObject(arg0).onabort = getObject(arg1);
+        };
+        imports.wbg.__wbg_setoncomplete_8a32ad2d1ca4f49b = function(arg0, arg1) {
+            getObject(arg0).oncomplete = getObject(arg1);
+        };
+        imports.wbg.__wbg_setonerror_4b0c685c365f600d = function(arg0, arg1) {
+            getObject(arg0).onerror = getObject(arg1);
+        };
+        imports.wbg.__wbg_setonerror_bcdbd7f3921ffb1f = function(arg0, arg1) {
+            getObject(arg0).onerror = getObject(arg1);
+        };
+        imports.wbg.__wbg_setonsuccess_ffb2ddb27ce681d8 = function(arg0, arg1) {
+            getObject(arg0).onsuccess = getObject(arg1);
+        };
+        imports.wbg.__wbg_setonupgradeneeded_4e32d1c6a08c4257 = function(arg0, arg1) {
+            getObject(arg0).onupgradeneeded = getObject(arg1);
+        };
+        imports.wbg.__wbg_size_af8602b0b838d49e = function(arg0) {
+            const ret = getObject(arg0).size;
+            return ret;
+        };
+        imports.wbg.__wbg_slice_974daea329f5c01d = function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).slice(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        };
+        imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        };
+        imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        };
+        imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        };
+        imports.wbg.__wbg_storage_32b4ac688c114c3d = function(arg0) {
+            const ret = getObject(arg0).storage;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_target_f2c963b447be6283 = function(arg0) {
+            const ret = getObject(arg0).target;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        };
+        imports.wbg.__wbg_then_b33a773d723afa3e = function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_then_e22500defe16819f = function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_toString_2ca967683e5874bc = function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).toString(arg1);
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_toString_78df35411a4fd40c = function(arg0) {
+            const ret = getObject(arg0).toString();
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_transaction_553a104dd139f032 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]);
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_transaction_b51dc7b903eb86c1 = function(arg0) {
+            const ret = getObject(arg0).transaction;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_truncate_0fe935591188a14c = function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).truncate(arg1 >>> 0);
+        }, arguments) };
+        imports.wbg.__wbg_truncate_7cddd971e3cf0a8c = function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).truncate(arg1);
+        }, arguments) };
+        imports.wbg.__wbg_upperBound_884e6dbf6030d98b = function() { return handleError(function (arg0, arg1) {
+            const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
+            return addHeapObject(ret);
+        }, arguments) };
+        imports.wbg.__wbg_value_dd9372230531eade = function(arg0) {
+            const ret = getObject(arg0).value;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbg_wbindgencbdrop_eb10308566512b88 = function(arg0) {
+            const obj = getObject(arg0).original;
+            if (obj.cnt-- == 1) {
+                obj.a = 0;
+                return true;
+            }
+            const ret = false;
+            return ret;
+        };
+        imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        };
+        imports.wbg.__wbg_wbindgenisnull_f3037694abe4d97a = function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        };
+        imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        };
+        imports.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb = function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        };
+        imports.wbg.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        };
+        imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        };
+        imports.wbg.__wbg_write_9ac6a5f58a8c835c = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).write(getArrayU8FromWasm0(arg1, arg2), getObject(arg3));
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbg_write_c0e234eeb0039d0d = function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).write(getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments) };
+        imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_cast_2753a612dd9418b8 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 30, function: Function { arguments: [Externref], shim_idx: 31, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, 30, __wbg_adapter_6);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_cast_b2f86a9123567793 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 30, function: Function { arguments: [NamedExternref("Event")], shim_idx: 31, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, 30, __wbg_adapter_6);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_cast_c48efcbaf1edd8f2 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 30, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 64, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, 30, __wbg_adapter_16);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_cast_dd34a6ccfe0dd713 = function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 30, function: Function { arguments: [], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, 30, __wbg_adapter_9);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        };
+        imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+            takeObject(arg0);
+        };
+
+        return imports;
+    }
+
+    function __wbg_init_memory(imports, memory) {
+
+    }
+
+    function __wbg_finalize_init(instance, module) {
+        wasm = instance.exports;
+        __wbg_init.__wbindgen_wasm_module = module;
+        cachedDataViewMemory0 = null;
+        cachedUint8ArrayMemory0 = null;
+
+
+
+        return wasm;
+    }
+
+    function initSync(module) {
+        if (wasm !== undefined) return wasm;
+
+
+        if (typeof module !== 'undefined') {
+            if (Object.getPrototypeOf(module) === Object.prototype) {
+                ({module} = module)
+            } else {
+                console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+            }
+        }
+
+        const imports = __wbg_get_imports();
+
+        __wbg_init_memory(imports);
+
+        if (!(module instanceof WebAssembly.Module)) {
+            module = new WebAssembly.Module(module);
+        }
+
+        const instance = new WebAssembly.Instance(module, imports);
+
+        return __wbg_finalize_init(instance, module);
+    }
+
+    async function __wbg_init(module_or_path) {
+        if (wasm !== undefined) return wasm;
+
+
+        if (typeof module_or_path !== 'undefined') {
+            if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+                ({module_or_path} = module_or_path)
+            } else {
+                console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+            }
+        }
+
+        if (typeof module_or_path === 'undefined' && typeof script_src !== 'undefined') {
+            module_or_path = script_src.replace(/\.js$/, '_bg.wasm');
+        }
+        const imports = __wbg_get_imports();
+
+        if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+            module_or_path = fetch(module_or_path);
+        }
+
+        __wbg_init_memory(imports);
+
+        const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+        return __wbg_finalize_init(instance, module);
+    }
+
+    window.wasm_bindgen = Object.assign(__wbg_init, { initSync }, __exports);
+
+})();

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "isar_plus",
-  "version": "1.0.28",
+  "version": "1.1.2",
   "files": [
-    "isar.wasm"
+    "isar.wasm",
+    "isar.js"
   ]
 }