jassub 2.5.0 → 2.5.2

package/dist/wasm/jassub-worker.js

@@ -2,13 +2,13 @@ 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;
     }
@@ -33,6 +33,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 +103,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 +134,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 +156,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 +198,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 +496,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 +658,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 +684,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 +731,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 +763,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 +848,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 +872,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 +946,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 +1035,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 +1061,7 @@ async function Module(moduleArg = {}) {
     }
     catch (e) {
         stackRestore(sp);
-        if (e !== e + 0)
+        if (!(e instanceof EmscriptenEH))
             throw e;
         _setThrew(1, 0);
     } }
@@ -1011,14 +1070,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 +1091,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