jassub 2.5.1 → 2.5.3

package/README.md

@@ -51,6 +51,8 @@ Promise:           33 7.1 29   /  4 3.1 2
 Proxy:             49 10 18
 Fetch:             42 10.1 39  /  41 10.1 34
 getVPQ/rVFC:       80 8 42     /  28 8 42
+-mnontrapping-fptoint 75 15 64
+-msign-ext         69 14 62
 -->
 
 JASSUB supports Chrome/Safari/Firefox 80/17/105, you bring the support down to 67/16.2/68 if you enable some flags/settings in your browser for these features. For other engines polyfills might be needed. Babel is also recommended if you need to support older JS engines as JASSUB ships as ES modules with modern syntax.

package/dist/wasm/jassub-worker.js

@@ -1,14 +1,23 @@
+// emscripten doesnt support conditional loading of wasm modules out of the box
+// so we hack around it by passing the url and simd support via the worker name
+// hopefully not bad?
+if (self.name.startsWith('em-pthread')) {
+    const url = self.name.split('-').slice(2).join('-');
+    const _fetch = globalThis.fetch;
+    globalThis.fetch = _ => _fetch(url);
+    self.name = 'em-pthread';
+}
 async function Module(moduleArg = {}) {
     var moduleRtn;
     var Module = moduleArg;
     var ENVIRONMENT_IS_WEB = true;
+    var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
     var out = (...args) => console.log(...args);
     var err = (...args) => console.error(...args);
     function ready() { readyPromiseResolve?.(Module); if (ENVIRONMENT_IS_PTHREAD) {
         startWorker();
     } }
-    var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
-    var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && self.name?.startsWith("em-pthread");
+    var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && globalThis.name == "em-pthread";
     if (ENVIRONMENT_IS_WORKER) {
         _scriptName = self.location.href;
     }
@@ -16,16 +25,11 @@ async function Module(moduleArg = {}) {
     const supportsGrowth = !!WebAssembly.Memory.prototype.toResizableBuffer;
     updateMemoryViews = () => { if (supportsGrowth && self.HEAPU8RAW)
         return; var b = supportsGrowth ? wasmMemory.toResizableBuffer() : wasmMemory.buffer; HEAP8 = new Int8Array(b); HEAP16 = new Int16Array(b); HEAPU8 = new Uint8Array(b); HEAPU16 = new Uint16Array(b); HEAP32 = new Int32Array(b); HEAPU32 = new Uint32Array(b); HEAPF32 = new Float32Array(b); HEAPF64 = new Float64Array(b); HEAP64 = new BigInt64Array(b); HEAPU64 = new BigUint64Array(b); self.HEAPU8RAW = new Uint8Array(b); self.WASMMEMORY = wasmMemory; };
-    if (self.name.startsWith("em-pthread")) {
-        const url = self.name.split("-").slice(2).join("-");
-        const _fetch = globalThis.fetch;
-        globalThis.fetch = _ => _fetch(url);
-    }
-    else {
-        if (moduleArg.__out)
-            out = moduleArg.__out;
-        if (moduleArg.__err)
-            err = moduleArg.__err;
+    if (moduleArg.__out)
+        out = moduleArg.__out;
+    if (moduleArg.__err)
+        err = moduleArg.__err;
+    if (!self.name.startsWith("em-pthread")) {
         const OriginalWorker = globalThis.Worker;
         globalThis.Worker = class extends OriginalWorker {
             constructor(scriptURL, options = {}) { super(scriptURL, { ...options, name: "em-pthread-" + moduleArg.__url }); }
@@ -33,6 +37,10 @@ async function Module(moduleArg = {}) {
     }
     if (!ENVIRONMENT_IS_PTHREAD) { }
     function abort(what) { throw what; }
+    class EmscriptenEH {
+    }
+    class EmscriptenSjLj extends EmscriptenEH {
+    }
     function growMemViews() { if (wasmMemory.buffer != HEAP8.buffer) {
         updateMemoryViews();
     } }
@@ -99,17 +107,25 @@ async function Module(moduleArg = {}) {
         } }
         self.onmessage = handleMessage;
     }
-    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
-    var HEAP64, HEAPU64;
     var runtimeInitialized = false;
     function updateMemoryViews() { var b = wasmMemory.buffer; HEAP8 = new Int8Array(b); HEAP16 = new Int16Array(b); HEAPU8 = new Uint8Array(b); HEAPU16 = new Uint16Array(b); HEAP32 = new Int32Array(b); HEAPU32 = new Uint32Array(b); HEAPF32 = new Float32Array(b); HEAPF64 = new Float64Array(b); HEAP64 = new BigInt64Array(b); HEAPU64 = new BigUint64Array(b); }
     function initMemory() { if (ENVIRONMENT_IS_PTHREAD) {
         return;
     } {
-        var INITIAL_MEMORY = 62914560;
+        var INITIAL_MEMORY = 33554432;
         wasmMemory = new WebAssembly.Memory({ initial: INITIAL_MEMORY / 65536, maximum: 32768, shared: true });
     } updateMemoryViews(); }
     initMemory();
+    var HEAP16;
+    var HEAP32;
+    var HEAP64;
+    var HEAP8;
+    var HEAPF32;
+    var HEAPF64;
+    var HEAPU16;
+    var HEAPU32;
+    var HEAPU64;
+    var HEAPU8;
     var terminateWorker = worker => { worker.terminate(); worker.onmessage = e => { }; };
     var cleanupThread = pthread_ptr => { var worker = PThread.pthreads[pthread_ptr]; PThread.returnWorkerToPool(worker); };
     var callRuntimeCallbacks = callbacks => { while (callbacks.length > 0) {
@@ -122,20 +138,20 @@ async function Module(moduleArg = {}) {
     var stackSave = () => _emscripten_stack_get_current();
     var stackRestore = val => __emscripten_stack_restore(val);
     var stackAlloc = sz => __emscripten_stack_alloc(sz);
-    var proxyToMainThread = (funcIndex, emAsmAddr, sync, ...callArgs) => { var serializedNumCallArgs = callArgs.length * 2; var sp = stackSave(); var args = stackAlloc(serializedNumCallArgs * 8); var b = args >> 3; for (var i = 0; i < callArgs.length; i++) {
-        var arg = callArgs[i];
+    var proxyToMainThread = (funcIndex, emAsmAddr, proxyMode, ...callArgs) => { var bufSize = 8 * callArgs.length * 2; var sp = stackSave(); var args = stackAlloc(bufSize); var b = args >> 3; for (var arg of callArgs) {
         if (typeof arg == "bigint") {
-            (growMemViews(), HEAP64)[b + 2 * i] = 1n;
-            (growMemViews(), HEAP64)[b + 2 * i + 1] = arg;
+            (growMemViews(), HEAP64)[b++] = 1n;
+            (growMemViews(), HEAP64)[b++] = arg;
         }
         else {
-            (growMemViews(), HEAP64)[b + 2 * i] = 0n;
-            (growMemViews(), HEAPF64)[b + 2 * i + 1] = arg;
+            (growMemViews(), HEAP64)[b++] = 0n;
+            (growMemViews(), HEAPF64)[b++] = arg;
         }
-    } var rtn = __emscripten_run_js_on_main_thread(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync); stackRestore(sp); return rtn; };
+    } var rtn = __emscripten_run_js_on_main_thread(funcIndex, emAsmAddr, bufSize, args, proxyMode); stackRestore(sp); return rtn; };
     function _proc_exit(code) { if (ENVIRONMENT_IS_PTHREAD)
         return proxyToMainThread(0, 0, 1, code); throw `exit(${code})`; }
     var _exit = _proc_exit;
+    var waitAsyncPolyfilled = !Atomics.waitAsync || globalThis.navigator?.userAgent && Number((navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./) || [])[2]) < 91;
     var PThread = { unusedWorkers: [], runningWorkers: [], tlsInitFunctions: [], pthreads: {}, init() { if (!ENVIRONMENT_IS_PTHREAD) {
             PThread.initMainThread();
         } }, initMainThread() { var pthreadPoolSize = !navigator.userAgent.toLowerCase().includes("firefox") && self.crossOriginIsolated ? Math.min(Math.max(0, navigator.hardwareConcurrency - 2), 8) : 0; while (pthreadPoolSize--) {
@@ -144,13 +160,15 @@ async function Module(moduleArg = {}) {
             terminateWorker(worker);
         } for (var worker of PThread.unusedWorkers) {
             terminateWorker(worker);
-        } PThread.unusedWorkers = []; PThread.runningWorkers = []; PThread.pthreads = {}; }, returnWorkerToPool: worker => { var pthread_ptr = worker.pthread_ptr; delete PThread.pthreads[pthread_ptr]; PThread.unusedWorkers.push(worker); PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); worker.pthread_ptr = 0; __emscripten_thread_free_data(pthread_ptr); }, threadInitTLS() { PThread.tlsInitFunctions.forEach(f => f()); }, loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => { worker.onmessage = e => { var d = e["data"]; var cmd = d.cmd; if (d.targetThread && d.targetThread != _pthread_self()) {
+        } PThread.unusedWorkers = []; PThread.runningWorkers = []; PThread.pthreads = {}; }, terminateRuntime: () => { PThread.terminateAllThreads(); var pthread_ptr = _pthread_self(); ___set_thread_state(0, 0, 0, 1); if (!waitAsyncPolyfilled) {
+            Atomics.notify((growMemViews(), HEAP32), pthread_ptr >> 2);
+        } }, returnWorkerToPool: worker => { var pthread_ptr = worker.pthread_ptr; delete PThread.pthreads[pthread_ptr]; PThread.unusedWorkers.push(worker); PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); worker.pthread_ptr = 0; __emscripten_thread_free_data(pthread_ptr); }, threadInitTLS() { PThread.tlsInitFunctions.forEach(f => f()); }, loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => { worker.onmessage = e => { var d = e["data"]; var cmd = d.cmd; if (d.targetThread && d.targetThread != _pthread_self()) {
             var targetWorker = PThread.pthreads[d.targetThread];
             if (targetWorker) {
                 targetWorker.postMessage(d, d.transferList);
             }
             else {
-                err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`);
+                err(`worker sent message (${cmd}) to pthread (${d.targetThread}) that no longer exists`);
             }
             return;
         } if (cmd === "checkMailbox") {
@@ -184,12 +202,62 @@ async function Module(moduleArg = {}) {
             PThread.allocateUnusedWorker();
             PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
         } return PThread.unusedWorkers.pop(); } };
-    function establishStackSpace(pthread_ptr) { var stackHigh = (growMemViews(), HEAPU32)[pthread_ptr + 52 >> 2]; var stackSize = (growMemViews(), HEAPU32)[pthread_ptr + 56 >> 2]; var stackLow = stackHigh - stackSize; _emscripten_stack_set_limits(stackHigh, stackLow); stackRestore(stackHigh); }
+    function establishStackSpace(pthread_ptr) { var stackHigh = (growMemViews(), HEAPU32)[pthread_ptr + 48 >> 2]; var stackSize = (growMemViews(), HEAPU32)[pthread_ptr + 52 >> 2]; var stackLow = stackHigh - stackSize; _emscripten_stack_set_limits(stackHigh, stackLow); stackRestore(stackHigh); }
     var wasmTableMirror = [];
     var getWasmTableEntry = funcPtr => { var func = wasmTableMirror[funcPtr]; if (!func) {
         wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
     } return func; };
     var invokeEntryPoint = (ptr, arg) => { var result = getWasmTableEntry(ptr)(arg); function finish(result) { __emscripten_thread_exit(result); } finish(result); };
+    var lengthBytesUTF8 = str => { var len = 0; for (var i = 0; i < str.length; ++i) {
+        var c = str.charCodeAt(i);
+        if (c <= 127) {
+            len++;
+        }
+        else if (c <= 2047) {
+            len += 2;
+        }
+        else if (c >= 55296 && c <= 57343) {
+            len += 4;
+            ++i;
+        }
+        else {
+            len += 3;
+        }
+    } return len; };
+    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { if (!(maxBytesToWrite > 0))
+        return 0; var startIdx = outIdx; var endIdx = outIdx + maxBytesToWrite - 1; for (var i = 0; i < str.length; ++i) {
+        var u = str.codePointAt(i);
+        if (u <= 127) {
+            if (outIdx >= endIdx)
+                break;
+            heap[outIdx++] = u;
+        }
+        else if (u <= 2047) {
+            if (outIdx + 1 >= endIdx)
+                break;
+            heap[outIdx++] = 192 | u >> 6;
+            heap[outIdx++] = 128 | u & 63;
+        }
+        else if (u <= 65535) {
+            if (outIdx + 2 >= endIdx)
+                break;
+            heap[outIdx++] = 224 | u >> 12;
+            heap[outIdx++] = 128 | u >> 6 & 63;
+            heap[outIdx++] = 128 | u & 63;
+        }
+        else {
+            if (outIdx + 3 >= endIdx)
+                break;
+            heap[outIdx++] = 240 | u >> 18;
+            heap[outIdx++] = 128 | u >> 12 & 63;
+            heap[outIdx++] = 128 | u >> 6 & 63;
+            heap[outIdx++] = 128 | u & 63;
+            i++;
+        }
+    } heap[outIdx] = 0; return outIdx - startIdx; };
+    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, (growMemViews(), HEAPU8), outPtr, maxBytesToWrite);
+    var stringToNewUTF8 = str => { var size = lengthBytesUTF8(str) + 1; var ret = _malloc(size); if (ret)
+        stringToUTF8(str, ret, size); return ret; };
     var wasmMemory;
     var UTF8Decoder = new TextDecoder;
     var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { var maxIdx = idx + maxBytesToRead; if (ignoreNul)
@@ -432,7 +500,7 @@ async function Module(moduleArg = {}) {
                     }
                 }
                 break;
-            default: throwBindingError("Unsupporting sharing policy");
+            default: throwBindingError("Unsupported sharing policy");
         }
     } return ptr; }
     function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { if (handle === null) {
@@ -594,34 +662,21 @@ async function Module(moduleArg = {}) {
             return true;
         }
     } return false; }
-    function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { var needsDestructorStack = usesDestructorStack(argTypes); var argCount = argTypes.length - 2; var argsList = []; var argsListWired = ["fn"]; if (isClassMethodFunc) {
-        argsListWired.push("thisWired");
-    } for (var i = 0; i < argCount; ++i) {
-        argsList.push(`arg${i}`);
-        argsListWired.push(`arg${i}Wired`);
-    } argsList = argsList.join(","); argsListWired = argsListWired.join(","); var invokerFnBody = `return function (${argsList}) {\n`; if (needsDestructorStack) {
-        invokerFnBody += "var destructors = [];\n";
-    } var dtorStack = needsDestructorStack ? "destructors" : "null"; var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire"]; if (isClassMethodFunc) {
-        invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`;
-    } for (var i = 0; i < argCount; ++i) {
-        var argName = `toArg${i}Wire`;
-        invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`;
-        args1.push(argName);
-    } invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`; if (needsDestructorStack) {
-        invokerFnBody += "runDestructors(destructors);\n";
-    }
-    else {
-        for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
-            var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
-            if (argTypes[i].destructorFunction !== null) {
-                invokerFnBody += `${paramName}_dtor(${paramName});\n`;
-                args1.push(`${paramName}_dtor`);
-            }
+    var InvokerFunctions = { ftfnnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, toArg1Wire, toArg2Wire) { return function (arg0, arg1, arg2) { var arg0Wired = toArg0Wire(null, arg0); var arg1Wired = toArg1Wire(null, arg1); var arg2Wired = toArg2Wire(null, arg2); var rv = invoker(fn, arg0Wired, arg1Wired, arg2Wired); var ret = fromRetWire(rv); return ret; }; }, tffn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire) { return function () { var thisWired = toClassParamWire(null, this); invoker(fn, thisWired); }; }, tffnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire) { return function (arg0) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); invoker(fn, thisWired, arg0Wired); }; }, tffnnnnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, toArg1Wire, toArg2Wire, toArg3Wire) { return function (arg0, arg1, arg2, arg3) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); var arg1Wired = toArg1Wire(null, arg1); var arg2Wired = toArg2Wire(null, arg2); var arg3Wired = toArg3Wire(null, arg3); invoker(fn, thisWired, arg0Wired, arg1Wired, arg2Wired, arg3Wired); }; }, tffnnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, toArg1Wire) { return function (arg0, arg1) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); var arg1Wired = toArg1Wire(null, arg1); invoker(fn, thisWired, arg0Wired, arg1Wired); }; }, ttfnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire) { return function (arg0) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); var rv = invoker(fn, thisWired, arg0Wired); var ret = fromRetWire(rv); return ret; }; }, tffnt: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, arg0Wired_dtor) { return function (arg0) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); invoker(fn, thisWired, arg0Wired); arg0Wired_dtor(arg0Wired); }; }, tffnnnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, toArg1Wire, toArg2Wire) { return function (arg0, arg1, arg2) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); var arg1Wired = toArg1Wire(null, arg1); var arg2Wired = toArg2Wire(null, arg2); invoker(fn, thisWired, arg0Wired, arg1Wired, arg2Wired); }; }, ttfn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire) { return function () { var thisWired = toClassParamWire(null, this); var rv = invoker(fn, thisWired); var ret = fromRetWire(rv); return ret; }; }, ttfnnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, toArg1Wire) { return function (arg0, arg1) { var thisWired = toClassParamWire(null, this); var arg0Wired = toArg0Wire(null, arg0); var arg1Wired = toArg1Wire(null, arg1); var rv = invoker(fn, thisWired, arg0Wired, arg1Wired); var ret = fromRetWire(rv); return ret; }; } };
+    function createJsInvokerSignature(argTypes, isClassMethodFunc, returns, isAsync) { const signature = [isClassMethodFunc ? "t" : "f", returns ? "t" : "f", isAsync ? "t" : "f"]; for (let i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+        const arg = argTypes[i];
+        let destructorSig = "";
+        if (arg.destructorFunction === undefined) {
+            destructorSig = "u";
         }
-    } if (returns) {
-        invokerFnBody += "var ret = fromRetWire(rv);\n" + "return ret;\n";
-    }
-    else { } invokerFnBody += "}\n"; return new Function(args1, invokerFnBody); }
+        else if (arg.destructorFunction === null) {
+            destructorSig = "n";
+        }
+        else {
+            destructorSig = "t";
+        }
+        signature.push(destructorSig);
+    } return signature.join(""); }
     function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) { var argCount = argTypes.length; if (argCount < 2) {
         throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
     } var isClassMethodFunc = argTypes[1] !== null && classType !== null; var needsDestructorStack = usesDestructorStack(argTypes); var returns = !argTypes[0].isVoid; var retType = argTypes[0]; var instType = argTypes[1]; var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType?.toWireType.bind(instType)]; for (var i = 2; i < argCount; ++i) {
@@ -633,7 +688,7 @@ async function Module(moduleArg = {}) {
                 closureArgs.push(argTypes[i].destructorFunction);
             }
         }
-    } let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); var invokerFn = invokerFactory(...closureArgs); return createNamedFunction(humanName, invokerFn); }
+    } var signature = createJsInvokerSignature(argTypes, isClassMethodFunc, returns, isAsync); var invokerFn = InvokerFunctions[signature](...closureArgs); return createNamedFunction(humanName, invokerFn); }
     var __embind_register_class_constructor = (rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) => { var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); invoker = embind__requireFunction(invokerSignature, invoker); whenDependentTypesAreResolved([], [rawClassType], classType => { classType = classType[0]; var humanName = `constructor ${classType.name}`; if (undefined === classType.registeredClass.constructor_body) {
         classType.registeredClass.constructor_body = [];
     } if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {
@@ -680,6 +735,7 @@ async function Module(moduleArg = {}) {
     var emval_freelist = [];
     var emval_handles = [0, 1, , 1, null, 1, true, 1, false, 1];
     var __emval_decref = handle => { if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+        var value = emval_handles[handle];
         emval_handles[handle] = undefined;
         emval_freelist.push(handle);
     } };
@@ -711,54 +767,6 @@ async function Module(moduleArg = {}) {
         maxRange = fromWireType(maxRange);
     } registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => value, readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null }); };
     var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array]; var TA = typeMapping[dataTypeIndex]; function decodeMemoryView(handle) { var size = (growMemViews(), HEAPU32)[handle >> 2]; var data = (growMemViews(), HEAPU32)[handle + 4 >> 2]; return new TA((growMemViews(), HEAP8).buffer, data, size); } name = AsciiToString(name); registerType(rawType, { name, fromWireType: decodeMemoryView, readValueFromPointer: decodeMemoryView }, { ignoreDuplicateRegistrations: true }); };
-    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { if (!(maxBytesToWrite > 0))
-        return 0; var startIdx = outIdx; var endIdx = outIdx + maxBytesToWrite - 1; for (var i = 0; i < str.length; ++i) {
-        var u = str.codePointAt(i);
-        if (u <= 127) {
-            if (outIdx >= endIdx)
-                break;
-            heap[outIdx++] = u;
-        }
-        else if (u <= 2047) {
-            if (outIdx + 1 >= endIdx)
-                break;
-            heap[outIdx++] = 192 | u >> 6;
-            heap[outIdx++] = 128 | u & 63;
-        }
-        else if (u <= 65535) {
-            if (outIdx + 2 >= endIdx)
-                break;
-            heap[outIdx++] = 224 | u >> 12;
-            heap[outIdx++] = 128 | u >> 6 & 63;
-            heap[outIdx++] = 128 | u & 63;
-        }
-        else {
-            if (outIdx + 3 >= endIdx)
-                break;
-            heap[outIdx++] = 240 | u >> 18;
-            heap[outIdx++] = 128 | u >> 12 & 63;
-            heap[outIdx++] = 128 | u >> 6 & 63;
-            heap[outIdx++] = 128 | u & 63;
-            i++;
-        }
-    } heap[outIdx] = 0; return outIdx - startIdx; };
-    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, (growMemViews(), HEAPU8), outPtr, maxBytesToWrite);
-    var lengthBytesUTF8 = str => { var len = 0; for (var i = 0; i < str.length; ++i) {
-        var c = str.charCodeAt(i);
-        if (c <= 127) {
-            len++;
-        }
-        else if (c <= 2047) {
-            len += 2;
-        }
-        else if (c >= 55296 && c <= 57343) {
-            len += 4;
-            ++i;
-        }
-        else {
-            len += 3;
-        }
-    } return len; };
     var __embind_register_std_string = (rawType, name) => { name = AsciiToString(name); var stdStringIsUTF8 = true; registerType(rawType, { name, fromWireType(value) { var length = (growMemViews(), HEAPU32)[value >> 2]; var payload = value + 4; var str; if (stdStringIsUTF8) {
             str = UTF8ToString(payload, length, true);
         }
@@ -844,19 +852,16 @@ async function Module(moduleArg = {}) {
             destructors.push(_free, ptr);
         } return ptr; }, readValueFromPointer: readPointer, destructorFunction(ptr) { _free(ptr); } }); };
     var __embind_register_void = (rawType, name) => { name = AsciiToString(name); registerType(rawType, { isVoid: true, name, fromWireType: () => undefined, toWireType: (destructors, o) => undefined }); };
-    var __emscripten_init_main_thread_js = tb => { __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, !ENVIRONMENT_IS_WEB, 65536, false); PThread.threadInitTLS(); };
+    var __emscripten_init_main_thread_js = tb => { __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, !ENVIRONMENT_IS_WEB, 262144, false); PThread.threadInitTLS(); };
     var callUserCallback = func => { func(); };
-    var waitAsyncPolyfilled = !Atomics.waitAsync || globalThis.navigator?.userAgent && Number((navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./) || [])[2]) < 91;
     var __emscripten_thread_mailbox_await = pthread_ptr => { if (!waitAsyncPolyfilled) {
         var wait = Atomics.waitAsync((growMemViews(), HEAP32), pthread_ptr >> 2, pthread_ptr);
         wait.value.then(checkMailbox);
-        var waitingAsync = pthread_ptr + 128;
+        var waitingAsync = pthread_ptr + 120;
         Atomics.store((growMemViews(), HEAP32), waitingAsync >> 2, 1);
     } };
-    var checkMailbox = () => callUserCallback(() => { var pthread_ptr = _pthread_self(); if (pthread_ptr) {
-        __emscripten_thread_mailbox_await(pthread_ptr);
-        __emscripten_check_mailbox();
-    } });
+    var checkMailbox = () => { var pthread_ptr = _pthread_self(); if (!pthread_ptr)
+        return; callUserCallback(() => { __emscripten_thread_mailbox_await(pthread_ptr); __emscripten_check_mailbox(); }); };
     var __emscripten_notify_mailbox_postmessage = (targetThread, currThreadId) => { if (targetThread == currThreadId) {
         setTimeout(checkMailbox);
     }
@@ -871,21 +876,68 @@ async function Module(moduleArg = {}) {
         worker.postMessage({ cmd: "checkMailbox" });
     } };
     var proxiedJSCallArgs = [];
-    var __emscripten_receive_on_main_thread_js = (funcIndex, emAsmAddr, callingThread, numCallArgs, args) => { numCallArgs /= 2; proxiedJSCallArgs.length = numCallArgs; var b = args >> 3; for (var i = 0; i < numCallArgs; i++) {
-        if ((growMemViews(), HEAP64)[b + 2 * i]) {
-            proxiedJSCallArgs[i] = (growMemViews(), HEAP64)[b + 2 * i + 1];
+    var __emscripten_receive_on_main_thread_js = (funcIndex, emAsmAddr, callingThread, bufSize, args, ctx, ctxArgs) => { proxiedJSCallArgs.length = 0; var b = args >> 3; var end = args + bufSize >> 3; while (b < end) {
+        var arg;
+        if ((growMemViews(), HEAP64)[b++]) {
+            arg = (growMemViews(), HEAP64)[b++];
         }
         else {
-            proxiedJSCallArgs[i] = (growMemViews(), HEAPF64)[b + 2 * i + 1];
+            arg = (growMemViews(), HEAPF64)[b++];
         }
-    } var func = proxiedFunctionTable[funcIndex]; PThread.currentProxiedOperationCallerThread = callingThread; var rtn = func(...proxiedJSCallArgs); PThread.currentProxiedOperationCallerThread = 0; return rtn; };
+        proxiedJSCallArgs.push(arg);
+    } var func = emAsmAddr ? ASM_CONSTS[emAsmAddr] : proxiedFunctionTable[funcIndex]; PThread.currentProxiedOperationCallerThread = callingThread; var rtn = func(...proxiedJSCallArgs); PThread.currentProxiedOperationCallerThread = 0; if (ctx) {
+        rtn.then(rtn => __emscripten_run_js_on_main_thread_done(ctx, ctxArgs, rtn));
+        return;
+    } return rtn; };
     var __emscripten_runtime_keepalive_clear = () => { };
     var __emscripten_thread_cleanup = thread => { if (!ENVIRONMENT_IS_PTHREAD)
         cleanupThread(thread);
     else
         postMessage({ cmd: "cleanupThread", thread }); };
     var __emscripten_thread_set_strongref = thread => { };
-    var __emscripten_throw_longjmp = () => { throw Infinity; };
+    var __emscripten_throw_longjmp = () => { throw new EmscriptenSjLj; };
+    var emval_methodCallers = [];
+    var emval_addMethodCaller = caller => { var id = emval_methodCallers.length; emval_methodCallers.push(caller); return id; };
+    var requireRegisteredType = (rawType, humanName) => { var impl = registeredTypes[rawType]; if (undefined === impl) {
+        throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+    } return impl; };
+    var emval_lookupTypes = (argCount, argTypes) => { var a = new Array(argCount); for (var i = 0; i < argCount; ++i) {
+        a[i] = requireRegisteredType((growMemViews(), HEAPU32)[argTypes + i * 4 >> 2], `parameter ${i}`);
+    } return a; };
+    var emval_returnValue = (toReturnWire, destructorsRef, handle) => { var destructors = []; var result = toReturnWire(destructors, handle); if (destructors.length) {
+        (growMemViews(), HEAPU32)[destructorsRef >> 2] = Emval.toHandle(destructors);
+    } return result; };
+    var emval_symbols = {};
+    var getStringOrSymbol = address => { var symbol = emval_symbols[address]; if (symbol === undefined) {
+        return AsciiToString(address);
+    } return symbol; };
+    var __emval_create_invoker = (argCount, argTypesPtr, kind) => { var GenericWireTypeSize = 8; var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr); var toReturnWire = retType.toWireType.bind(retType); var argFromPtr = argTypes.map(type => type.readValueFromPointer.bind(type)); argCount--; var argN = new Array(argCount); var invokerFunction = (handle, methodName, destructorsRef, args) => { var offset = 0; for (var i = 0; i < argCount; ++i) {
+        argN[i] = argFromPtr[i](args + offset);
+        offset += GenericWireTypeSize;
+    } var rv; switch (kind) {
+        case 0:
+            rv = Emval.toValue(handle).apply(null, argN);
+            break;
+        case 2:
+            rv = Reflect.construct(Emval.toValue(handle), argN);
+            break;
+        case 3:
+            rv = argN[0];
+            break;
+        case 1:
+            rv = Emval.toValue(handle)[getStringOrSymbol(methodName)](...argN);
+            break;
+    } return emval_returnValue(toReturnWire, destructorsRef, rv); }; var functionName = `methodCaller<(${argTypes.map(t => t.name)}) => ${retType.name}>`; return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); };
+    var __emval_get_property = (handle, key) => { handle = Emval.toValue(handle); key = Emval.toValue(key); return Emval.toHandle(handle[key]); };
+    var __emval_incref = handle => { if (handle > 9) {
+        emval_handles[handle + 1] += 1;
+    } };
+    var __emval_invoke = (caller, handle, methodName, destructorsRef, args) => emval_methodCallers[caller](handle, methodName, destructorsRef, args);
+    var __emval_new_array = () => Emval.toHandle([]);
+    var __emval_new_cstring = v => Emval.toHandle(getStringOrSymbol(v));
+    var __emval_new_object = () => Emval.toHandle({});
+    var __emval_run_destructors = handle => { var destructors = Emval.toValue(handle); runDestructors(destructors); __emval_decref(handle); };
+    var __emval_set_property = (handle, key, value) => { handle = Emval.toValue(handle); key = Emval.toValue(key); value = Emval.toValue(value); handle[key] = value; };
     var timers = {};
     var _emscripten_get_now = () => performance.timeOrigin + performance.now();
     function __setitimer_js(which, timeout_ms) { if (ENVIRONMENT_IS_PTHREAD)
@@ -898,6 +950,16 @@ async function Module(moduleArg = {}) {
     var INT53_MAX = 9007199254740992;
     var INT53_MIN = -9007199254740992;
     var bigintToI53Checked = num => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+    var readEmAsmArgsArray = [];
+    var readEmAsmArgs = (sigPtr, buf) => { readEmAsmArgsArray.length = 0; var ch; while (ch = (growMemViews(), HEAPU8)[sigPtr++]) {
+        var wide = ch != 105;
+        wide &= ch != 112;
+        buf += wide && buf % 8 ? 4 : 0;
+        readEmAsmArgsArray.push(ch == 112 ? (growMemViews(), HEAPU32)[buf >> 2] : ch == 106 ? (growMemViews(), HEAP64)[buf >> 3] : ch == 105 ? (growMemViews(), HEAP32)[buf >> 2] : (growMemViews(), HEAPF64)[buf >> 3]);
+        buf += wide ? 8 : 4;
+    } return readEmAsmArgsArray; };
+    var runEmAsmFunction = (code, sigPtr, argbuf) => { var args = readEmAsmArgs(sigPtr, argbuf); return ASM_CONSTS[code](...args); };
+    var _emscripten_asm_const_ptr = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf);
     var _emscripten_check_blocking_allowed = () => { };
     var _emscripten_err = str => err(UTF8ToString(str));
     var _emscripten_exit_with_live_runtime = () => { throw "unwind"; };
@@ -977,23 +1039,24 @@ async function Module(moduleArg = {}) {
         }
         num += len;
     } (growMemViews(), HEAPU32)[pnum >> 2] = num; return 0; }
-    var initRandomFill = () => view => view.set(crypto.getRandomValues(new Uint8Array(view.byteLength)));
-    var randomFill = view => { (randomFill = initRandomFill())(view); };
-    var _random_get = (buffer, size) => { randomFill((growMemViews(), HEAPU8).subarray(buffer, buffer + size)); return 0; };
+    var initRandomFill = () => view => (view.set(crypto.getRandomValues(new Uint8Array(view.byteLength))), 0);
+    var randomFill = view => (randomFill = initRandomFill())(view);
+    var _random_get = (buffer, size) => randomFill((growMemViews(), HEAPU8).subarray(buffer, buffer + size));
     PThread.init();
     init_ClassHandle();
     init_RegisteredPointer();
     var proxiedFunctionTable = [_proc_exit, pthreadCreateProxied, ___syscall_fcntl64, ___syscall_getdents64, ___syscall_ioctl, ___syscall_openat, __setitimer_js, _environ_get, _environ_sizes_get, _fd_close, _fd_read, _fd_seek, _fd_write];
-    var __ZdlPvm, _malloc, _free, _calloc, ___getTypeName, __embind_initialize_bindings, _pthread_self, _emscripten_builtin_free, __emscripten_tls_init, __emscripten_thread_init, __emscripten_thread_crashed, ___libc_free, _emscripten_builtin_malloc, ___libc_malloc, __emscripten_run_js_on_main_thread, __emscripten_thread_free_data, __emscripten_thread_exit, __emscripten_timeout, __emscripten_check_mailbox, __ZdaPv, __ZdaPvm, __ZdlPv, __Znaj, __ZnajSt11align_val_t, __Znwj, __ZnwjSt11align_val_t, ___libc_calloc, ___libc_realloc, _emscripten_builtin_calloc, _emscripten_builtin_realloc, _malloc_size, _malloc_usable_size, _reallocf, _setThrew, _emscripten_stack_set_limits, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, __indirect_function_table, wasmTable;
-    function assignWasmExports(wasmExports) { __ZdlPvm = Module["__ZdlPvm"] = wasmExports["Z"]; _malloc = Module["_malloc"] = wasmExports["_"]; _free = wasmExports["$"]; _calloc = Module["_calloc"] = wasmExports["aa"]; ___getTypeName = wasmExports["ba"]; __embind_initialize_bindings = wasmExports["ca"]; _pthread_self = wasmExports["da"]; _emscripten_builtin_free = Module["_emscripten_builtin_free"] = wasmExports["ea"]; __emscripten_tls_init = wasmExports["fa"]; __emscripten_thread_init = wasmExports["ha"]; __emscripten_thread_crashed = wasmExports["ia"]; ___libc_free = Module["___libc_free"] = wasmExports["ja"]; _emscripten_builtin_malloc = Module["_emscripten_builtin_malloc"] = wasmExports["ka"]; ___libc_malloc = Module["___libc_malloc"] = wasmExports["la"]; __emscripten_run_js_on_main_thread = wasmExports["ma"]; __emscripten_thread_free_data = wasmExports["na"]; __emscripten_thread_exit = wasmExports["oa"]; __emscripten_timeout = wasmExports["pa"]; __emscripten_check_mailbox = wasmExports["qa"]; __ZdaPv = Module["__ZdaPv"] = wasmExports["ra"]; __ZdaPvm = Module["__ZdaPvm"] = wasmExports["sa"]; __ZdlPv = Module["__ZdlPv"] = wasmExports["ta"]; __Znaj = Module["__Znaj"] = wasmExports["ua"]; __ZnajSt11align_val_t = Module["__ZnajSt11align_val_t"] = wasmExports["va"]; __Znwj = Module["__Znwj"] = wasmExports["wa"]; __ZnwjSt11align_val_t = Module["__ZnwjSt11align_val_t"] = wasmExports["xa"]; ___libc_calloc = Module["___libc_calloc"] = wasmExports["ya"]; ___libc_realloc = Module["___libc_realloc"] = wasmExports["za"]; _emscripten_builtin_calloc = Module["_emscripten_builtin_calloc"] = wasmExports["Aa"]; _emscripten_builtin_realloc = Module["_emscripten_builtin_realloc"] = wasmExports["Ba"]; _malloc_size = Module["_malloc_size"] = wasmExports["Ca"]; _malloc_usable_size = Module["_malloc_usable_size"] = wasmExports["Da"]; _reallocf = Module["_reallocf"] = wasmExports["Ea"]; _setThrew = wasmExports["Fa"]; _emscripten_stack_set_limits = wasmExports["Ga"]; __emscripten_stack_restore = wasmExports["Ha"]; __emscripten_stack_alloc = wasmExports["Ia"]; _emscripten_stack_get_current = wasmExports["Ja"]; __indirect_function_table = wasmTable = wasmExports["ga"]; }
+    var ASM_CONSTS = { 613693: $0 => stringToNewUTF8(Emval.toValue($0)) };
+    var __ZdlPvm, _pthread_self, __Znwm, _free, _malloc, _calloc, ___getTypeName, __embind_initialize_bindings, _emscripten_builtin_free, __emscripten_tls_init, __emscripten_thread_init, ___set_thread_state, __emscripten_thread_crashed, ___libc_free, _emscripten_builtin_malloc, ___libc_malloc, __emscripten_run_js_on_main_thread_done, __emscripten_run_js_on_main_thread, __emscripten_thread_free_data, __emscripten_thread_exit, __emscripten_timeout, __emscripten_check_mailbox, __ZdaPv, __ZdaPvm, __ZdlPv, __Znam, __ZnamSt11align_val_t, __ZnwmSt11align_val_t, ___libc_calloc, ___libc_realloc, _emscripten_builtin_calloc, _emscripten_builtin_realloc, _malloc_size, _malloc_usable_size, _reallocf, _setThrew, _emscripten_stack_set_limits, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, __indirect_function_table, wasmTable;
+    function assignWasmExports(wasmExports) { __ZdlPvm = Module["__ZdlPvm"] = wasmExports["ia"]; _pthread_self = wasmExports["ja"]; __Znwm = Module["__Znwm"] = wasmExports["ka"]; _free = wasmExports["la"]; _malloc = Module["_malloc"] = wasmExports["ma"]; _calloc = Module["_calloc"] = wasmExports["na"]; ___getTypeName = wasmExports["oa"]; __embind_initialize_bindings = wasmExports["pa"]; _emscripten_builtin_free = Module["_emscripten_builtin_free"] = wasmExports["qa"]; __emscripten_tls_init = wasmExports["ra"]; __emscripten_thread_init = wasmExports["ta"]; ___set_thread_state = wasmExports["ua"]; __emscripten_thread_crashed = wasmExports["va"]; ___libc_free = Module["___libc_free"] = wasmExports["wa"]; _emscripten_builtin_malloc = Module["_emscripten_builtin_malloc"] = wasmExports["xa"]; ___libc_malloc = Module["___libc_malloc"] = wasmExports["ya"]; __emscripten_run_js_on_main_thread_done = wasmExports["za"]; __emscripten_run_js_on_main_thread = wasmExports["Aa"]; __emscripten_thread_free_data = wasmExports["Ba"]; __emscripten_thread_exit = wasmExports["Ca"]; __emscripten_timeout = wasmExports["Da"]; __emscripten_check_mailbox = wasmExports["Ea"]; __ZdaPv = Module["__ZdaPv"] = wasmExports["Fa"]; __ZdaPvm = Module["__ZdaPvm"] = wasmExports["Ga"]; __ZdlPv = Module["__ZdlPv"] = wasmExports["Ha"]; __Znam = Module["__Znam"] = wasmExports["Ia"]; __ZnamSt11align_val_t = Module["__ZnamSt11align_val_t"] = wasmExports["Ja"]; __ZnwmSt11align_val_t = Module["__ZnwmSt11align_val_t"] = wasmExports["Ka"]; ___libc_calloc = Module["___libc_calloc"] = wasmExports["La"]; ___libc_realloc = Module["___libc_realloc"] = wasmExports["Ma"]; _emscripten_builtin_calloc = Module["_emscripten_builtin_calloc"] = wasmExports["Na"]; _emscripten_builtin_realloc = Module["_emscripten_builtin_realloc"] = wasmExports["Oa"]; _malloc_size = Module["_malloc_size"] = wasmExports["Pa"]; _malloc_usable_size = Module["_malloc_usable_size"] = wasmExports["Qa"]; _reallocf = Module["_reallocf"] = wasmExports["Ra"]; _setThrew = wasmExports["Sa"]; _emscripten_stack_set_limits = wasmExports["Ta"]; __emscripten_stack_restore = wasmExports["Ua"]; __emscripten_stack_alloc = wasmExports["Va"]; _emscripten_stack_get_current = wasmExports["Wa"]; __indirect_function_table = wasmTable = wasmExports["sa"]; }
     var wasmImports;
-    function assignWasmImports() { wasmImports = { b: ___assert_fail, K: ___pthread_create_js, p: ___syscall_fcntl64, J: ___syscall_getdents64, T: ___syscall_ioctl, q: ___syscall_openat, F: __abort_js, s: __embind_register_bigint, u: __embind_register_bool, k: __embind_register_class, U: __embind_register_class_constructor, d: __embind_register_class_function, c: __embind_register_class_property, X: __embind_register_emval, r: __embind_register_float, g: __embind_register_integer, e: __embind_register_memory_view, t: __embind_register_std_string, l: __embind_register_std_wstring, v: __embind_register_void, O: __emscripten_init_main_thread_js, G: __emscripten_notify_mailbox_postmessage, L: __emscripten_receive_on_main_thread_js, B: __emscripten_runtime_keepalive_clear, n: __emscripten_thread_cleanup, N: __emscripten_thread_mailbox_await, W: __emscripten_thread_set_strongref, z: __emscripten_throw_longjmp, C: __setitimer_js, o: _emscripten_check_blocking_allowed, f: _emscripten_date_now, m: _emscripten_err, V: _emscripten_exit_with_live_runtime, H: _emscripten_get_heap_max, h: _emscripten_get_now, I: _emscripten_num_logical_cores, D: _emscripten_resize_heap, P: _environ_get, Q: _environ_sizes_get, i: _exit, j: _fd_close, S: _fd_read, M: _fd_seek, R: _fd_write, y: invoke_iii, w: invoke_iiii, x: invoke_iiiii, a: wasmMemory, A: _proc_exit, E: _random_get }; }
+    function assignWasmImports() { wasmImports = { b: ___assert_fail, Q: ___pthread_create_js, y: ___syscall_fcntl64, P: ___syscall_getdents64, Y: ___syscall_ioctl, z: ___syscall_openat, L: __abort_js, B: __embind_register_bigint, ba: __embind_register_bool, ga: __embind_register_class, fa: __embind_register_class_constructor, d: __embind_register_class_function, da: __embind_register_class_property, $: __embind_register_emval, A: __embind_register_float, l: __embind_register_integer, e: __embind_register_memory_view, aa: __embind_register_std_string, t: __embind_register_std_wstring, ca: __embind_register_void, T: __emscripten_init_main_thread_js, M: __emscripten_notify_mailbox_postmessage, x: __emscripten_receive_on_main_thread_js, H: __emscripten_runtime_keepalive_clear, v: __emscripten_thread_cleanup, S: __emscripten_thread_mailbox_await, _: __emscripten_thread_set_strongref, F: __emscripten_throw_longjmp, h: __emval_create_invoker, c: __emval_decref, ea: __emval_get_property, i: __emval_incref, g: __emval_invoke, s: __emval_new_array, j: __emval_new_cstring, r: __emval_new_object, f: __emval_run_destructors, k: __emval_set_property, I: __setitimer_js, n: _emscripten_asm_const_ptr, w: _emscripten_check_blocking_allowed, m: _emscripten_date_now, u: _emscripten_err, Z: _emscripten_exit_with_live_runtime, N: _emscripten_get_heap_max, o: _emscripten_get_now, O: _emscripten_num_logical_cores, J: _emscripten_resize_heap, U: _environ_get, V: _environ_sizes_get, p: _exit, q: _fd_close, X: _fd_read, R: _fd_seek, W: _fd_write, E: invoke_iii, C: invoke_iiii, D: invoke_iiiii, a: wasmMemory, G: _proc_exit, K: _random_get }; }
     function invoke_iii(index, a1, a2) { var sp = stackSave(); try {
         return getWasmTableEntry(index)(a1, a2);
     }
     catch (e) {
         stackRestore(sp);
-        if (e !== e + 0)
+        if (!(e instanceof EmscriptenEH))
             throw e;
         _setThrew(1, 0);
     } }
@@ -1002,7 +1065,7 @@ async function Module(moduleArg = {}) {
     }
     catch (e) {
         stackRestore(sp);
-        if (e !== e + 0)
+        if (!(e instanceof EmscriptenEH))
             throw e;
         _setThrew(1, 0);
     } }
@@ -1011,14 +1074,14 @@ async function Module(moduleArg = {}) {
     }
     catch (e) {
         stackRestore(sp);
-        if (e !== e + 0)
+        if (!(e instanceof EmscriptenEH))
             throw e;
         _setThrew(1, 0);
     } }
-    function initRuntime(wasmExports) { runtimeInitialized = true; PThread.tlsInitFunctions.push(wasmExports["fa"]); if (ENVIRONMENT_IS_PTHREAD)
-        return; wasmExports["Y"](); }
+    function initRuntime(wasmExports) { runtimeInitialized = true; PThread.tlsInitFunctions.push(wasmExports["ra"]); if (ENVIRONMENT_IS_PTHREAD)
+        return; wasmExports["ha"](); }
     var wasmModule;
-    function loadModule() { assignWasmImports(); var imports = { a: wasmImports }; WebAssembly.instantiateStreaming(fetch("jassub-worker.wasm"), imports).then(output => { var wasmExports = (output.instance || output).exports; wasmModule = output.module || Module["wasm"]; assignWasmExports(wasmExports); callRuntimeCallbacks(onPreRuns); initRuntime(wasmExports); PThread.loadWasmModuleToAllWorkers().then(ready); }); }
+    function loadModule() { assignWasmImports(); var imports = { a: wasmImports }; WebAssembly.instantiateStreaming(fetch(new URL("jassub-worker.wasm", import.meta.url)), imports).then(output => { var wasmExports = (output.instance || output).exports; wasmModule = output.module || Module["wasm"]; assignWasmExports(wasmExports); callRuntimeCallbacks(onPreRuns); initRuntime(wasmExports); PThread.loadWasmModuleToAllWorkers().then(ready); }); }
     if (!ENVIRONMENT_IS_PTHREAD) {
         loadModule();
     }
@@ -1032,6 +1095,6 @@ async function Module(moduleArg = {}) {
     return moduleRtn;
 }
 export default Module;
-var isPthread = globalThis.self?.name?.startsWith("em-pthread");
+var isPthread = globalThis.name == "em-pthread";
 isPthread && Module();
 //# sourceMappingURL=jassub-worker.js.map