jassub
Version:
The Fastest JavaScript SSA/ASS Subtitle Renderer For Browsers
1,099 lines • 79.3 kB
JavaScript
// 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 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() { if (ENVIRONMENT_IS_PTHREAD) {
startWorker();
} }
var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && globalThis.name == "em-pthread";
if (ENVIRONMENT_IS_WORKER) {
_scriptName = self.location.href;
}
var _scriptName;
ENVIRONMENT_IS_WEB = false;
updateMemoryViews = (o => () => { o(); self.HEAPU8RAW = (growMemViews(), HEAPU8); self.WASMMEMORY = wasmMemory; })(updateMemoryViews);
out = moduleArg.__out || out;
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 }); }
};
}
const _origLoadModule = loadModule;
loadModule = function () { _origLoadModule(); ASM_CONSTS = new Proxy({}, { get() { return $0 => stringToNewUTF8(Emval.toValue($0)); } }); };
if (!ENVIRONMENT_IS_PTHREAD) { }
function abort(what) { throw what; }
class EmscriptenEH {
}
class EmscriptenSjLj extends EmscriptenEH {
}
function growMemViews() { if (wasmMemory.buffer != HEAP8.buffer) {
updateMemoryViews();
} }
var startWorker;
if (ENVIRONMENT_IS_PTHREAD) {
var initializedJS = false;
self.onunhandledrejection = e => { throw e.reason || e; };
function handleMessage(e) { try {
var msgData = e.data;
var cmd = msgData.cmd;
if (cmd == 1) {
let messageQueue = [];
self.onmessage = e => messageQueue.push(e);
startWorker = () => { postMessage({ cmd: 3 }); for (let msg of messageQueue) {
handleMessage(msg);
} self.onmessage = handleMessage; };
for (const handler of msgData.handlers) {
if (!Module[handler] || Module[handler].proxy) {
Module[handler] = (...args) => { postMessage({ cmd: 9, handler, args }); };
if (handler == "print")
out = Module[handler];
if (handler == "printErr")
err = Module[handler];
}
}
wasmMemory = msgData.wasmMemory;
updateMemoryViews();
Module["wasm"] = msgData.wasmModule;
loadModule();
}
else if (cmd == 2) {
establishStackSpace(msgData.pthread_ptr);
__emscripten_thread_init(msgData.pthread_ptr, 0, 0, 1, 0, 0);
PThread.threadInitTLS();
__emscripten_thread_mailbox_await(msgData.pthread_ptr);
if (!initializedJS) {
__embind_initialize_bindings();
initializedJS = true;
}
try {
invokeEntryPoint(msgData.start_routine, msgData.arg);
}
catch (ex) {
if (ex != "unwind") {
throw ex;
}
}
}
else if (cmd == 4) {
if (initializedJS) {
checkMailbox();
}
}
else if (cmd) {
err(`worker: received unknown command ${cmd}`);
err(msgData);
}
}
catch (ex) {
if (runtimeInitialized)
__emscripten_thread_crashed();
throw ex;
} }
self.onmessage = handleMessage;
}
var runtimeInitialized = false;
function getMemoryBuffer() { var firefoxMatch = globalThis.navigator?.userAgent?.match(/Firefox\/(\d+)/); if (!firefoxMatch || Number(firefoxMatch[1]) >= 154) {
try {
var b = wasmMemory.toResizableBuffer();
growMemViews = () => { };
return b;
}
catch { }
} return wasmMemory.buffer; }
function updateMemoryViews() { if (HEAP8?.buffer?.growable)
return; var b = getMemoryBuffer(); 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 = 33554432;
wasmMemory = new WebAssembly.Memory({ initial: INITIAL_MEMORY / 65536, maximum: 32768, shared: true });
} updateMemoryViews(); }
initMemory();
var HEAP8;
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) {
callbacks.shift()(Module);
} };
var onPreRuns = [];
var spawnThread = threadParams => { var worker = PThread.getNewWorker(); if (!worker) {
return 6;
} PThread.pthreads[threadParams.pthread_ptr] = worker; worker.pthread_ptr = threadParams.pthread_ptr; var msg = { cmd: 2, start_routine: threadParams.startRoutine, arg: threadParams.arg, pthread_ptr: threadParams.pthread_ptr }; worker.postMessage(msg, threadParams.transferList); return 0; };
var stackSave = () => _emscripten_stack_get_current();
var stackRestore = val => __emscripten_stack_restore(val);
var stackAlloc = sz => __emscripten_stack_alloc(sz);
var HEAPF64;
var HEAP64;
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++] = 1n;
(growMemViews(), HEAP64)[b++] = arg;
}
else {
(growMemViews(), HEAP64)[b++] = 0n;
(growMemViews(), HEAPF64)[b++] = arg;
}
} 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 HEAP32;
var PThread = { unusedWorkers: [], tlsInitFunctions: [], pthreads: {}, init() { if (!ENVIRONMENT_IS_PTHREAD) {
PThread.initMainThread();
} }, initMainThread() { var pthreadPoolSize = moduleArg.__poolSize | 0; while (pthreadPoolSize--) {
PThread.allocateUnusedWorker();
} }, terminateAllThreads: () => { for (var worker of Object.values(PThread.pthreads)) {
terminateWorker(worker);
} for (var worker of PThread.unusedWorkers) {
terminateWorker(worker);
} PThread.unusedWorkers = []; PThread.pthreads = {}; }, clearMailboxAwait: pthread_ptr => { if (!waitAsyncPolyfilled) {
Atomics.notify((growMemViews(), HEAP32), pthread_ptr >> 2);
} }, terminateRuntime: () => { PThread.terminateAllThreads(); var pthread_ptr = _pthread_self(); ___set_thread_state(0, 0, 0, 1); PThread.clearMailboxAwait(pthread_ptr); }, returnWorkerToPool: worker => { var pthread_ptr = worker.pthread_ptr; delete PThread.pthreads[pthread_ptr]; PThread.unusedWorkers.push(worker); worker.pthread_ptr = 0; PThread.clearMailboxAwait(pthread_ptr); __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];
targetWorker?.postMessage(d);
return;
} if (d === "setimmediate" || d === "_si") {
worker.postMessage(d);
return;
} switch (cmd) {
case 4:
checkMailbox();
break;
case 5:
spawnThread(d);
break;
case 6:
callUserCallback(() => cleanupThread(d.thread));
break;
case 3:
onFinishedLoading(worker);
break;
case 9:
Module[d.handler](...d.args);
break;
default: if (cmd)
err(`worker sent an unknown command ${cmd}`);
} }; worker.onerror = e => { var message = "worker sent an error!"; err(`${message} ${e.filename}:${e.lineno}: ${e.message}`); throw e; }; var handlers = []; var knownHandlers = []; for (var handler of knownHandlers) {
if (Module.propertyIsEnumerable(handler)) {
handlers.push(handler);
}
} worker.postMessage({ cmd: 1, handlers, wasmMemory, wasmModule }); }), async loadWasmModuleToAllWorkers() { if (ENVIRONMENT_IS_PTHREAD) {
return;
} let pthreadPoolReady = Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker)); return pthreadPoolReady; }, allocateUnusedWorker() { var worker; worker = new Worker(new URL("jassub-worker.js", import.meta.url), { type: "module", name: "em-pthread" }); PThread.unusedWorkers.push(worker); return worker; }, getNewWorker() { if (PThread.unusedWorkers.length == 0) {
var newWorker = PThread.allocateUnusedWorker();
PThread.loadWasmModuleToWorker(newWorker);
} return PThread.unusedWorkers.pop(); } };
var HEAPU32;
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 HEAPU8;
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)
return maxIdx; while (heapOrArray[idx] && !(idx >= maxIdx))
++idx; return idx; };
var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => { if (!ptr)
return ""; var end = findStringEnd((growMemViews(), HEAPU8), ptr, maxBytesToRead, ignoreNul); return UTF8Decoder.decode((growMemViews(), HEAPU8).slice(ptr, end)); };
var ___assert_fail = (condition, filename, line, func) => abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(1, 0, 1, pthread_ptr, attr, startRoutine, arg); return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg); }
var _emscripten_has_threading_support = () => !!globalThis.SharedArrayBuffer;
var ___pthread_create_js = (pthread_ptr, attr, startRoutine, arg) => { if (!_emscripten_has_threading_support()) {
return 6;
} var transferList = []; var error = 0; if (ENVIRONMENT_IS_PTHREAD && (!transferList.length || error)) {
return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg);
} if (error)
return error; var threadParams = { startRoutine, pthread_ptr, arg, transferList }; if (ENVIRONMENT_IS_PTHREAD) {
threadParams.cmd = 5;
postMessage(threadParams, transferList);
return 0;
} return spawnThread(threadParams); };
var SYSCALLS = { varargs: undefined, getStr(ptr) { var ret = UTF8ToString(ptr); return ret; } };
function ___syscall_fcntl64(fd, cmd, varargs) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(2, 0, 1, fd, cmd, varargs); SYSCALLS.varargs = varargs; return 0; }
function ___syscall_getdents64(fd, dirp, count) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(3, 0, 1, fd, dirp, count); }
function ___syscall_ioctl(fd, op, varargs) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(4, 0, 1, fd, op, varargs); SYSCALLS.varargs = varargs; return 0; }
function ___syscall_openat(dirfd, path, flags, varargs) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(5, 0, 1, dirfd, path, flags, varargs); SYSCALLS.varargs = varargs; }
var __abort_js = () => abort("");
var AsciiToString = ptr => { var str = ""; while (1) {
var ch = (growMemViews(), HEAPU8)[ptr++];
if (!ch)
return str;
str += String.fromCharCode(ch);
} };
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
class BindingError extends Error {
constructor(message) { super(message); this.name = "BindingError"; }
}
var throwBindingError = message => { throw new BindingError(message); };
function sharedRegisterType(rawType, registeredInstance, options = {}) { var name = registeredInstance.name; if (!rawType) {
throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
} if (registeredTypes.hasOwnProperty(rawType)) {
if (options.ignoreDuplicateRegistrations) {
return;
}
else {
throwBindingError(`Cannot register type '${name}' twice`);
}
} registeredTypes[rawType] = registeredInstance; delete typeDependencies[rawType]; if (awaitingDependencies.hasOwnProperty(rawType)) {
var callbacks = awaitingDependencies[rawType];
delete awaitingDependencies[rawType];
callbacks.forEach(cb => cb());
} }
function registerType(rawType, registeredInstance, options = {}) { return sharedRegisterType(rawType, registeredInstance, options); }
var HEAP16;
var HEAPU16;
var HEAPU64;
var integerReadValueFromPointer = (name, width, signed) => { switch (width) {
case 1: return signed ? pointer => (growMemViews(), HEAP8)[pointer] : pointer => (growMemViews(), HEAPU8)[pointer];
case 2: return signed ? pointer => (growMemViews(), HEAP16)[pointer >> 1] : pointer => (growMemViews(), HEAPU16)[pointer >> 1];
case 4: return signed ? pointer => (growMemViews(), HEAP32)[pointer >> 2] : pointer => (growMemViews(), HEAPU32)[pointer >> 2];
case 8: return signed ? pointer => (growMemViews(), HEAP64)[pointer >> 3] : pointer => (growMemViews(), HEAPU64)[pointer >> 3];
default: throw new TypeError(`invalid integer width (${width}): ${name}`);
} };
var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { name = AsciiToString(name); const isUnsignedType = minRange === 0n; let fromWireType = value => value; if (isUnsignedType) {
const bitSize = size * 8;
fromWireType = value => BigInt.asUintN(bitSize, value);
maxRange = fromWireType(maxRange);
} registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => { if (typeof value == "number") {
value = BigInt(value);
} return value; }, readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), destructorFunction: null }); };
var __embind_register_bool = (rawType, name, trueValue, falseValue) => { name = AsciiToString(name); registerType(rawType, { name, fromWireType: function (wt) { return !!wt; }, toWireType: function (destructors, o) { return o ? trueValue : falseValue; }, readValueFromPointer: function (pointer) { return this.fromWireType((growMemViews(), HEAPU8)[pointer]); }, destructorFunction: null }); };
var shallowCopyInternalPointer = o => ({ count: o.count, deleteScheduled: o.deleteScheduled, preservePointerOnDelete: o.preservePointerOnDelete, ptr: o.ptr, ptrType: o.ptrType, smartPtr: o.smartPtr, smartPtrType: o.smartPtrType });
var throwInstanceAlreadyDeleted = obj => { function getInstanceTypeName(handle) { return handle.$$.ptrType.registeredClass.name; } throwBindingError(getInstanceTypeName(obj) + " instance already deleted"); };
var finalizationRegistry = false;
var detachFinalizer = handle => { };
var runDestructor = $$ => { if ($$.smartPtr) {
$$.smartPtrType.rawDestructor($$.smartPtr);
}
else {
$$.ptrType.registeredClass.rawDestructor($$.ptr);
} };
var releaseClassHandle = $$ => { $$.count.value -= 1; var toDelete = 0 === $$.count.value; if (toDelete) {
runDestructor($$);
} };
var attachFinalizer = handle => { if (!globalThis.FinalizationRegistry) {
attachFinalizer = handle => handle;
return handle;
} finalizationRegistry = new FinalizationRegistry(info => { releaseClassHandle(info.$$); }); attachFinalizer = handle => { var $$ = handle.$$; var hasSmartPtr = !!$$.smartPtr; if (hasSmartPtr) {
var info = { $$ };
finalizationRegistry.register(handle, info, handle);
} return handle; }; detachFinalizer = handle => finalizationRegistry.unregister(handle); return attachFinalizer(handle); };
var deletionQueue = [];
var flushPendingDeletes = () => { while (deletionQueue.length) {
var obj = deletionQueue.pop();
obj.$$.deleteScheduled = false;
obj["delete"]();
} };
var delayFunction;
var init_ClassHandle = () => { let proto = ClassHandle.prototype; Object.assign(proto, { isAliasOf(other) { if (!(this instanceof ClassHandle)) {
return false;
} if (!(other instanceof ClassHandle)) {
return false;
} var leftClass = this.$$.ptrType.registeredClass; var left = this.$$.ptr; other.$$ = other.$$; var rightClass = other.$$.ptrType.registeredClass; var right = other.$$.ptr; while (leftClass.baseClass) {
left = leftClass.upcast(left);
leftClass = leftClass.baseClass;
} while (rightClass.baseClass) {
right = rightClass.upcast(right);
rightClass = rightClass.baseClass;
} return leftClass === rightClass && left === right; }, clone() { if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this);
} if (this.$$.preservePointerOnDelete) {
this.$$.count.value += 1;
return this;
}
else {
var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { $$: { value: shallowCopyInternalPointer(this.$$) } }));
clone.$$.count.value += 1;
clone.$$.deleteScheduled = false;
return clone;
} }, delete() { if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this);
} if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError("Object already scheduled for deletion");
} detachFinalizer(this); releaseClassHandle(this.$$); if (!this.$$.preservePointerOnDelete) {
this.$$.smartPtr = undefined;
this.$$.ptr = undefined;
} }, isDeleted() { return !this.$$.ptr; }, deleteLater() { if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this);
} if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError("Object already scheduled for deletion");
} deletionQueue.push(this); if (deletionQueue.length === 1 && delayFunction) {
delayFunction(flushPendingDeletes);
} this.$$.deleteScheduled = true; return this; } }); const symbolDispose = Symbol.dispose; if (symbolDispose) {
proto[symbolDispose] = proto["delete"];
} };
function ClassHandle() { }
var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
var registeredPointers = {};
var ensureOverloadTable = (proto, methodName, humanName) => { if (undefined === proto[methodName].overloadTable) {
var prevFunc = proto[methodName];
proto[methodName] = function (...args) { if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
} return proto[methodName].overloadTable[args.length].apply(this, args); };
proto[methodName].overloadTable = [];
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
} };
var exposePublicSymbol = (name, value, numArguments) => { if (Module.hasOwnProperty(name)) {
if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
throwBindingError(`Cannot register public name '${name}' twice`);
}
ensureOverloadTable(Module, name, name);
if (Module[name].overloadTable.hasOwnProperty(numArguments)) {
throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
}
Module[name].overloadTable[numArguments] = value;
}
else {
Module[name] = value;
Module[name].argCount = numArguments;
} };
var char_0 = 48;
var char_9 = 57;
var makeLegalFunctionName = name => { name = name.replace(/[^a-zA-Z0-9_]/g, "$"); var f = name.charCodeAt(0); if (f >= char_0 && f <= char_9) {
return `_${name}`;
} return name; };
function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) { this.name = name; this.constructor = constructor; this.instancePrototype = instancePrototype; this.rawDestructor = rawDestructor; this.baseClass = baseClass; this.getActualType = getActualType; this.upcast = upcast; this.downcast = downcast; this.pureVirtualFunctions = []; }
var upcastPointer = (ptr, ptrClass, desiredClass) => { while (ptrClass !== desiredClass) {
if (!ptrClass.upcast) {
throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`);
}
ptr = ptrClass.upcast(ptr);
ptrClass = ptrClass.baseClass;
} return ptr; };
var embindRepr = v => { if (v === null) {
return "null";
} var t = typeof v; if (t === "object" || t === "array" || t === "function") {
return v.toString();
}
else {
return "" + v;
} };
function constNoSmartPtrRawPointerToWireType(destructors, handle) { if (handle === null) {
if (this.isReference) {
throwBindingError(`null is not a valid ${this.name}`);
}
return 0;
} if (!handle.$$) {
throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
} if (!handle.$$.ptr) {
throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
} var handleClass = handle.$$.ptrType.registeredClass; var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); return ptr; }
function genericPointerToWireType(destructors, handle) { var ptr; if (handle === null) {
if (this.isReference) {
throwBindingError(`null is not a valid ${this.name}`);
}
if (this.isSmartPointer) {
ptr = this.rawConstructor();
if (destructors !== null) {
destructors.push(this.rawDestructor, ptr);
}
return ptr;
}
else {
return 0;
}
} if (!handle || !handle.$$) {
throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
} if (!handle.$$.ptr) {
throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
} if (!this.isConst && handle.$$.ptrType.isConst) {
throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
} var handleClass = handle.$$.ptrType.registeredClass; ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); if (this.isSmartPointer) {
if (undefined === handle.$$.smartPtr) {
throwBindingError("Passing raw pointer to smart pointer is illegal");
}
switch (this.sharingPolicy) {
case 0:
if (handle.$$.smartPtrType === this) {
ptr = handle.$$.smartPtr;
}
else {
throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
}
break;
case 1:
ptr = handle.$$.smartPtr;
break;
case 2:
if (handle.$$.smartPtrType === this) {
ptr = handle.$$.smartPtr;
}
else {
var clonedHandle = handle["clone"]();
ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle["delete"]()));
if (destructors !== null) {
destructors.push(this.rawDestructor, ptr);
}
}
break;
default: throwBindingError("Unsupported sharing policy");
}
} return ptr; }
function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { if (handle === null) {
if (this.isReference) {
throwBindingError(`null is not a valid ${this.name}`);
}
return 0;
} if (!handle.$$) {
throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
} if (!handle.$$.ptr) {
throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
} if (handle.$$.ptrType.isConst) {
throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`);
} var handleClass = handle.$$.ptrType.registeredClass; var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); return ptr; }
function readPointer(pointer) { return this.fromWireType((growMemViews(), HEAPU32)[pointer >> 2]); }
var downcastPointer = (ptr, ptrClass, desiredClass) => { if (ptrClass === desiredClass) {
return ptr;
} if (undefined === desiredClass.baseClass) {
return null;
} var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); if (rv === null) {
return null;
} return desiredClass.downcast(rv); };
var registeredInstances = {};
var getBasestPointer = (class_, ptr) => { if (ptr === undefined) {
throwBindingError("ptr should not be undefined");
} while (class_.baseClass) {
ptr = class_.upcast(ptr);
class_ = class_.baseClass;
} return ptr; };
var getInheritedInstance = (class_, ptr) => { ptr = getBasestPointer(class_, ptr); return registeredInstances[ptr]; };
class InternalError extends Error {
constructor(message) { super(message); this.name = "InternalError"; }
}
var throwInternalError = message => { throw new InternalError(message); };
var makeClassHandle = (prototype, record) => { if (!record.ptrType || !record.ptr) {
throwInternalError("makeClassHandle requires ptr and ptrType");
} var hasSmartPtrType = !!record.smartPtrType; var hasSmartPtr = !!record.smartPtr; if (hasSmartPtrType !== hasSmartPtr) {
throwInternalError("Both smartPtrType and smartPtr must be specified");
} record.count = { value: 1 }; return attachFinalizer(Object.create(prototype, { $$: { value: record, writable: true } })); };
function RegisteredPointer_fromWireType(ptr) { var rawPointer = this.getPointee(ptr); if (!rawPointer) {
this.destructor(ptr);
return null;
} var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); if (undefined !== registeredInstance) {
if (0 === registeredInstance.$$.count.value) {
registeredInstance.$$.ptr = rawPointer;
registeredInstance.$$.smartPtr = ptr;
return registeredInstance["clone"]();
}
else {
var rv = registeredInstance["clone"]();
this.destructor(ptr);
return rv;
}
} function makeDefaultHandle() { if (this.isSmartPointer) {
return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this.pointeeType, ptr: rawPointer, smartPtrType: this, smartPtr: ptr });
}
else {
return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this, ptr });
} } var actualType = this.registeredClass.getActualType(rawPointer); var registeredPointerRecord = registeredPointers[actualType]; if (!registeredPointerRecord) {
return makeDefaultHandle.call(this);
} var toType; if (this.isConst) {
toType = registeredPointerRecord.constPointerType;
}
else {
toType = registeredPointerRecord.pointerType;
} var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass); if (dp === null) {
return makeDefaultHandle.call(this);
} if (this.isSmartPointer) {
return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp, smartPtrType: this, smartPtr: ptr });
}
else {
return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp });
} }
var init_RegisteredPointer = () => { Object.assign(RegisteredPointer.prototype, { getPointee(ptr) { if (this.rawGetPointee) {
ptr = this.rawGetPointee(ptr);
} return ptr; }, destructor(ptr) { this.rawDestructor?.(ptr); }, readValueFromPointer: readPointer, fromWireType: RegisteredPointer_fromWireType }); };
function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) { this.name = name; this.registeredClass = registeredClass; this.isReference = isReference; this.isConst = isConst; this.isSmartPointer = isSmartPointer; this.pointeeType = pointeeType; this.sharingPolicy = sharingPolicy; this.rawGetPointee = rawGetPointee; this.rawConstructor = rawConstructor; this.rawShare = rawShare; this.rawDestructor = rawDestructor; if (!isSmartPointer && registeredClass.baseClass === undefined) {
if (isConst) {
this.toWireType = constNoSmartPtrRawPointerToWireType;
this.destructorFunction = null;
}
else {
this.toWireType = nonConstNoSmartPtrRawPointerToWireType;
this.destructorFunction = null;
}
}
else {
this.toWireType = genericPointerToWireType;
} }
var replacePublicSymbol = (name, value, numArguments) => { if (!Module.hasOwnProperty(name)) {
throwInternalError("Replacing nonexistent public symbol");
} if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
Module[name].overloadTable[numArguments] = value;
}
else {
Module[name] = value;
Module[name].argCount = numArguments;
} };
var embind__requireFunction = (signature, rawFunction, isAsync = false) => { signature = AsciiToString(signature); function makeDynCaller() { var rtn = getWasmTableEntry(rawFunction); return rtn; } var fp = makeDynCaller(); if (typeof fp != "function") {
throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
} return fp; };
class UnboundTypeError extends Error {
}
var getTypeName = type => { var ptr = ___getTypeName(type); var rv = AsciiToString(ptr); _free(ptr); return rv; };
var throwUnboundTypeError = (message, types) => { var unboundTypes = []; var seen = {}; function visit(type) { if (seen[type]) {
return;
} if (registeredTypes[type]) {
return;
} if (typeDependencies[type]) {
typeDependencies[type].forEach(visit);
return;
} unboundTypes.push(type); seen[type] = true; } types.forEach(visit); throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "])); };
var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { myTypes.forEach(type => typeDependencies[type] = dependentTypes); function onComplete(typeConverters) { var myTypeConverters = getTypeConverters(typeConverters); if (myTypeConverters.length !== myTypes.length) {
throwInternalError("Mismatched type converter count");
} for (var i = 0; i < myTypes.length; ++i) {
registerType(myTypes[i], myTypeConverters[i]);
} } var typeConverters = new Array(dependentTypes.length); var unregisteredTypes = []; var registered = 0; for (let [i, dt] of dependentTypes.entries()) {
if (registeredTypes.hasOwnProperty(dt)) {
typeConverters[i] = registeredTypes[dt];
}
else {
unregisteredTypes.push(dt);
if (!awaitingDependencies.hasOwnProperty(dt)) {
awaitingDependencies[dt] = [];
}
awaitingDependencies[dt].push(() => { typeConverters[i] = registeredTypes[dt]; ++registered; if (registered === unregisteredTypes.length) {
onComplete(typeConverters);
} });
}
} if (0 === unregisteredTypes.length) {
onComplete(typeConverters);
} };
var __embind_register_class = (rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) => { name = AsciiToString(name); getActualType = embind__requireFunction(getActualTypeSignature, getActualType); upcast &&= embind__requireFunction(upcastSignature, upcast); downcast &&= embind__requireFunction(downcastSignature, downcast); rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); var legalFunctionName = makeLegalFunctionName(name); exposePublicSymbol(legalFunctionName, function () { throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]); }); whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], base => { base = base[0]; var baseClass; var basePrototype; if (baseClassRawType) {
baseClass = base.registeredClass;
basePrototype = baseClass.instancePrototype;
}
else {
basePrototype = ClassHandle.prototype;
} var constructor = createNamedFunction(name, function (...args) { if (Object.getPrototypeOf(this) !== instancePrototype) {
throw new BindingError(`Use 'new' to construct ${name}`);
} if (undefined === registeredClass.constructor_body) {
throw new BindingError(`${name} has no accessible constructor`);
} var body = registeredClass.constructor_body[args.length]; if (undefined === body) {
throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
} return body.apply(this, args); }); var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } }); constructor.prototype = instancePrototype; var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast); if (registeredClass.baseClass) {
registeredClass.baseClass.__derivedClasses ??= [];
registeredClass.baseClass.__derivedClasses.push(registeredClass);
} var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false); var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false); var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false); registeredPointers[rawType] = { pointerType: pointerConverter, constPointerType: constPointerConverter }; replacePublicSymbol(legalFunctionName, constructor); return [referenceConverter, pointerConverter, constPointerConverter]; }); };
var heap32VectorToArray = (count, firstElement) => { var array = []; for (var i = 0; i < count; i++) {
array.push((growMemViews(), HEAPU32)[firstElement + i * 4 >> 2]);
} return array; };
var runDestructors = destructors => { while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr);
} };
function usesDestructorStack(argTypes) { for (var i = 1; i < argTypes.length; ++i) {
if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
return true;
}
} return false; }
function argsUseStackAlloc(argTypes) { for (var i = 1; i < argTypes.length; ++i) {
if (argTypes[i] !== null && argTypes[i].argStackAlloc) {
return true;
}
} return false; }
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); }; }, tffntnn: function anonymous(humanName, throwBindingError, invoker, fn, runDestructors, fromRetWire, toClassParamWire, toArg0Wire, toArg1Wire, toArg2Wire, arg0Wired_dtor) { 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); 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.argStackAlloc) {
destructorSig = "s";
}
else if (arg.destructorFunction === undefined) {
destructorSig = "u";
}
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 receiver (this) types!");
} var isClassMethodFunc = argTypes[1] !== null && classType !== null; var needsDestructorStack = usesDestructorStack(argTypes); var argsNeedStack = argsUseStackAlloc(argTypes); var useStackFrame = argsNeedStack && !isAsync && !needsDestructorStack; if (argsNeedStack && !useStackFrame) {
needsDestructorStack = true;
} 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)]; if (useStackFrame) {
closureArgs.push(stackSave, stackRestore);
} for (var i = 2; i < argCount; ++i) {
var argType = argTypes[i];
closureArgs.push(argType.toWireType.bind(argType));
} if (!needsDestructorStack) {
for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
if (argTypes[i].destructorFunction !== null) {
closureArgs.push(argTypes[i].destructorFunction);
}
}
} 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]) {
throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount - 1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
} classType.registeredClass.constructor_body[argCount - 1] = () => { throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes); }; whenDependentTypesAreResolved([], rawArgTypes, argTypes => { argTypes.splice(1, 0, null); classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); return []; }); return []; }); };
var getFunctionName = signature => { signature = signature.trim(); const argsIndex = signature.indexOf("("); if (argsIndex === -1)
return signature; return signature.slice(0, argsIndex); };
var __embind_register_class_function = (rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual, isAsync, isNonnullReturn) => { var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); methodName = AsciiToString(methodName); methodName = getFunctionName(methodName); rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync); whenDependentTypesAreResolved([], [rawClassType], classType => { classType = classType[0]; var humanName = `${classType.name}.${methodName}`; if (methodName.startsWith("@@")) {
methodName = Symbol[methodName.substring(2)];
} if (isPureVirtual) {
classType.registeredClass.pureVirtualFunctions.push(methodName);
} function unboundTypesHandler() { throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes); } var proto = classType.registeredClass.instancePrototype; var method = proto[methodName]; if (undefined === method || undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {
unboundTypesHandler.argCount = argCount - 2;
unboundTypesHandler.className = classType.name;
proto[methodName] = unboundTypesHandler;
}
else {
ensureOverloadTable(proto, methodName, humanName);
proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
} whenDependentTypesAreResolved([], rawArgTypes, argTypes => { var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync); if (undefined === proto[methodName].overloadTable) {
memberFunction.argCount = argCount - 2;
proto[methodName] = memberFunction;
}
else {
proto[methodName].overloadTable[argCount - 2] = memberFunction;
} return []; }); return []; }); };
var validateThis = (this_, classType, humanName) => { if (!(this_ instanceof Object)) {
throwBindingError(`${humanName} with invalid "this": ${this_}`);
} if (!(this_ instanceof classType.registeredClass.constructor)) {
throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`);
} if (!this_.$$.ptr) {
throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`);
} return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass); };
var __embind_register_class_property = (classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => { fieldName = AsciiToString(fieldName); getter = embind__requireFunction(getterSignature, getter); whenDependentTypesAreResolved([], [classType], classType => { classType = classType[0]; var humanName = `${classType.name}.${fieldName}`; var desc = { get() { throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]); }, enumerable: true, configurable: true }; if (setter) {
desc.set = () => throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]);
}
else {
desc.set = v => throwBindingError(humanName + " is a read-only property");
} Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); whenDependentTypesAreResolved([], setter ? [getterReturnType, setterArgumentType] : [getterReturnType], types => { var getterReturnType = types[0]; var desc = { get() { var ptr = validateThis(this, classType, humanName + " getter"); return getterReturnType.fromWireType(getter(getterContext, ptr)); }, enumerable: true }; if (setter) {
setter = embind__requireFunction(setterSignature, setter);
var setterArgumentType = types[1];
desc.set = function (v) { var ptr = validateThis(this, classType, humanName + " setter"); var destructors = []; setter(setterContext, ptr, setterArgumentType.toWireType(destructors, v)); runDestructors(destructors); };
} Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); return []; }); return []; }); };
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);
} };
var Emval = { toValue: handle => { if (!handle) {
throwBindingError(`Cannot use deleted val. handle = ${handle}`);
} return emval_handles[handle]; }, toHandle: value => { switch (value) {
case undefined: return 2;
case null: return 4;
case true: return 6;
case false: return 8;
default: {
const handle = emval_freelist.pop() || emval_handles.length;
emval_handles[handle] = value;
emval_handles[handle + 1] = 1;
return handle;
}
} } };
var EmValType = { name: "emscripten::val", fromWireType: handle => { var rv = Emval.toValue(handle); __emval_decref(handle); return rv; }, toWireType: (destructors, value) => Emval.toHandle(value), readValueFromPointer: readPointer, destructorFunction: null };
var __embind_register_emval = rawType => registerType(rawType, EmValType);
var HEAPF32;
var floatReadValueFromPointer = (name, width) => { switch (width) {
case 4: return function (pointer) { return this.fromWireType((growMemViews(), HEAPF32)[pointer >> 2]); };
case 8: return function (pointer) { return this.fromWireType((growMemViews(), HEAPF64)[pointer >> 3]); };
default: throw new TypeError(`invalid float width (${width}): ${name}`);
} };
var __embind_register_float = (rawType, name, size) => { name = AsciiToString(name); registerType(rawType, { name, fromWireType: value => value, toWireType: (destructors, value) => value, readValueFromPointer: floatReadValueFromPointer(name, size), destructorFunction: null }); };
var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { name = AsciiToString(name); const isUnsignedType = minRange === 0; let fromWireType = value => value; if (isUnsignedType) {
var bitshift = 32 - 8 * size;
fromWireType = value => value << bitshift >>> bitshift;
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 __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);
}
else {
str = "";
for (var i = 0; i < length; ++i) {
str += String.fromCharCode((growMemViews(), HEAPU8)[payload + i]);
}
} _free(value); return str; }, toWireType(destructors, value) { if (value instanceof ArrayBuffer) {
value = new Uint8Array(value);
} var length; var valueIsOfTypeString = typeof value == "string"; if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) {
throwBindingError("Cannot pass non-string to std::string");
} if (stdStringIsUTF8 && valueIsOfTypeString) {
length = lengthBytesUTF8(value);
}
else {
length = value.length;
} var base = _malloc(4 + length + 1); var ptr = base + 4; (growMemViews(), HEAPU32)[base >> 2] = length; if (valueIsOfTypeString) {
if (stdStringIsUTF8) {
stringToUTF8(value, ptr, length + 1);
}
else {
for (var i = 0; i < length; ++i) {
var charCode = value.charCodeAt(i);
if (charCode > 255) {
_free(base);
throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
}
(growMemViews(), HEAPU8)[ptr + i] = charCode;
}
}
}
else {
(growMemViews(), HEAPU8).set(value, ptr);
} if (destructors !== null) {
destructors.push(_free, base);
} return base; }, readValueFromPointer: readPointer, destructorFunction(ptr) { _free(ptr); } }); };
var UTF16Decoder = new TextDecoder("utf-16le");
var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => { var idx = ptr >> 1; var endIdx = findStringEnd((growMemViews(), HEAPU16), idx, maxBytesToRead / 2, ignoreNul); return UTF16Decoder.decode((growMemViews(), HEAPU16).slice(idx, endIdx)); };
var stringToUTF16 = (str, outPtr, maxBytesToWrite = 2147483647) => { if (maxBytesToWrite < 2)
return 0; maxBytesToWrite -= 2; var startPtr = outPtr; var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; for (var i = 0; i < numCharsToWrite; ++i) {
var codeUnit = str.charCodeAt(i);
(growMemViews(), HEAP16)[outPtr >> 1] = codeUnit;
outPtr += 2;
} (growMemViews(), HEAP16)[outPtr >> 1] = 0; return outPtr - startPtr; };
var lengthBytesUTF16 = str => str.length * 2;
var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => { var str = ""; var startIdx = ptr >> 2; for (var i = 0; !(i >= maxBytesToRead / 4); i++) {
var utf32 = (growMemViews(), HEAPU32)[startIdx + i];
if (!utf32 && !ignoreNul)
break;
str += String.fromCodePoint(utf32);
} return str; };
var stringToUTF32 = (str, outPtr, maxBytesToWrite = 2147483647) => { if (maxBytesToWrite < 4)
return 0; var startPtr = outPtr; var endPtr = startPtr + maxBytesToWrite - 4; for (var i = 0; i < str.length; ++i) {
var codePoint = str.codePointAt(i);
if (codePoint > 65535) {
i++;
}
(growMemViews(), HEAP32)[outPtr >> 2] = codePoint;
outPtr += 4;
if (outPtr + 4 > endPtr)
break;
} (growMemViews(), HEAP32)[outPtr >> 2] = 0; return outPtr - startPtr; };
var lengthBytesUTF32 = str => { var len = 0; for (var i = 0; i < str.length; ++i) {
var codePoint = str.codePointAt(i);
if (codePoint > 65535) {
i++;
}
len += 4;
} return len; };
var __embind_register_std_wstring = (rawType, charSize, name) => { name = AsciiToString(name); var decodeString, encodeString, lengthBytesUTF; if (charSize === 2) {
decodeString = UTF16ToString;
encodeString = stringToUTF16;
lengthBytesUTF = lengthBytesUTF16;
}
else {
decodeString = UTF32ToString;
encodeString = stringToUTF32;
lengthBytesUTF = lengthBytesUTF32;
} registerType(rawType, { name, fromWireType: value => { var length = (growMemViews(), HEAPU32)[value >> 2]; var str = decodeString(value + 4, length * charSize, true); _free(value); return str; }, toWireType: (destructors, value) => { if (!(typeof value == "string")) {
throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
} var length = lengthBytesUTF(value); var ptr = _malloc(4 + length + charSize); (growMemViews(), HEAPU32)[ptr >> 2] = length / charSize; encodeString(value, ptr + 4, length + charSize); if (destructors !== null) {
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 => { var can_block = !ENVIRONMENT_IS_WEB; __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, can_block, 262144, false); PThread.threadInitTLS(); };
var callUserCallback = (func, ...args) => { func(...args); };
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 + 112;
Atomics.store((growMemViews(), HEAP32), waitingAsync >> 2, 1);
} };
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);
}
else if (ENVIRONMENT_IS_PTHREAD) {
postMessage({ targetThread, cmd: 4 });
}
else {
var worker = PThread.pthreads[targetThread];
if (!worker) {
return;
}
worker.postMessage({ cmd: 4 });
} };
var proxiedJSCallArgs = [];
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 {
arg = (growMemViews(), HEAPF64)[b++];
}
proxiedJSCallArgs.push(arg);
} var func = emAsmAddr ? ASM_CONSTS[emAsmAddr] : proxiedFunctionTable[funcIndex]; PThread.currentProxiedOperationCallerThread = callingThread; var rtn = func(...proxiedJSCallArgs); PThread.currentProxiedOperationCallerThread = 0; if (ctx) {
Promise.resolve(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: 6, thread }); };
var __emscripten_thread_set_strongref = thread => { };
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)
return proxyToMainThread(6, 0, 1, which, timeout_ms); if (timers[which]) {
clearTimeout(timers[which].id);
delete timers[which];
} if (!timeout_ms)
return 0; var id = setTimeout(() => { delete timers[which]; callUserCallback(__emscripten_timeout, which, _emscripten_get_now()); }, timeout_ms); timers[which] = { id, timeout_ms }; return 0; }
var _emscripten_date_now = () => Date.now();
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"; };
var getHeapMax = () => 2147483648;
var _emscripten_get_heap_max = () => getHeapMax();
var _emscripten_num_logical_cores = () => navigator["hardwareConcurrency"];
var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
var growMemory = size => { var oldHeapSize = wasmMemory.buffer.byteLength; var pages = (size - oldHeapSize + 65535) / 65536 | 0; try {
wasmMemory.grow(pages);
updateMemoryViews();
return 1;
}
catch (e) { } };
var _emscripten_resize_heap = requestedSize => { var oldSize = (growMemViews(), HEAPU8).length; requestedSize >>>= 0; if (requestedSize <= oldSize) {
return false;
} var maxHeapSize = getHeapMax(); if (requestedSize > maxHeapSize) {
return false;
} for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
var replacement = growMemory(newSize);
if (replacement) {
return true;
}
} return false; };
var ENV = {};
var getExecutableName = () => "./this.program";
var getEnvStrings = () => { if (!getEnvStrings.strings) {
var lang = (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8";
var env = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: lang, _: getExecutableName() };
for (var x in ENV) {
if (ENV[x] === undefined)
delete env[x];
else
env[x] = ENV[x];
}
var strings = [];
for (var x in env) {
strings.push(`${x}=${env[x]}`);
}
getEnvStrings.strings = strings;
} return getEnvStrings.strings; };
function _environ_get(__environ, environ_buf) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(7, 0, 1, __environ, environ_buf); var bufSize = 0; var envp = 0; for (var string of getEnvStrings()) {
var ptr = environ_buf + bufSize;
(growMemViews(), HEAPU32)[__environ + envp >> 2] = ptr;
bufSize += stringToUTF8(string, ptr, Infinity) + 1;
envp += 4;
} return 0; }
function _environ_sizes_get(penviron_count, penviron_buf_size) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(8, 0, 1, penviron_count, penviron_buf_size); var strings = getEnvStrings(); (growMemViews(), HEAPU32)[penviron_count >> 2] = strings.length; var bufSize = 0; for (var string of strings) {
bufSize += lengthBytesUTF8(string) + 1;
} (growMemViews(), HEAPU32)[penviron_buf_size >> 2] = bufSize; return 0; }
function _fd_close(fd) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(9, 0, 1, fd); return 52; }
function _fd_read(fd, iov, iovcnt, pnum) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(10, 0, 1, fd, iov, iovcnt, pnum); return 52; }
function _fd_seek(fd, offset, whence, newOffset) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(11, 0, 1, fd, offset, whence, newOffset); offset = bigintToI53Checked(offset); return 70; }
var printCharBuffers = [null, [], []];
var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul); return UTF8Decoder.decode(heapOrArray.buffer ? heapOrArray.buffer instanceof ArrayBuffer ? heapOrArray.subarray(idx, endPtr) : heapOrArray.slice(idx, endPtr) : new Uint8Array(heapOrArray.slice(idx, endPtr))); };
var printChar = (stream, curr) => { var buffer = printCharBuffers[stream]; if (!curr || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer));
buffer.length = 0;
}
else {
buffer.push(curr);
} };
function _fd_write(fd, iov, iovcnt, pnum) { if (ENVIRONMENT_IS_PTHREAD)
return proxyToMainThread(12, 0, 1, fd, iov, iovcnt, pnum); var num = 0; for (var i = 0; i < iovcnt; i++) {
var ptr = (growMemViews(), HEAPU32)[iov >> 2];
var len = (growMemViews(), HEAPU32)[iov + 4 >> 2];
iov += 8;
for (var j = 0; j < len; j++) {
printChar(fd, (growMemViews(), HEAPU8)[ptr + j]);
}
num += len;
} (growMemViews(), HEAPU32)[pnum >> 2] = num; 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 ASM_CONSTS = { 614605: $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["ha"]; _pthread_self = wasmExports["ia"]; __Znwm = Module["__Znwm"] = wasmExports["ja"]; _free = wasmExports["ka"]; _malloc = Module["_malloc"] = wasmExports["la"]; _calloc = Module["_calloc"] = wasmExports["ma"]; ___getTypeName = wasmExports["na"]; __embind_initialize_bindings = wasmExports["oa"]; _emscripten_builtin_free = Module["_emscripten_builtin_free"] = wasmExports["pa"]; __emscripten_tls_init = wasmExports["qa"]; __emscripten_thread_init = wasmExports["sa"]; ___set_thread_state = wasmExports["ta"]; __emscripten_thread_crashed = wasmExports["ua"]; ___libc_free = Module["___libc_free"] = wasmExports["va"]; _emscripten_builtin_malloc = Module["_emscripten_builtin_malloc"] = wasmExports["wa"]; ___libc_malloc = Module["___libc_malloc"] = wasmExports["xa"]; __emscripten_run_js_on_main_thread_done = wasmExports["ya"]; __emscripten_run_js_on_main_thread = wasmExports["za"]; __emscripten_thread_free_data = wasmExports["Aa"]; __emscripten_thread_exit = wasmExports["Ba"]; __emscripten_timeout = wasmExports["Ca"]; __emscripten_check_mailbox = wasmExports["Da"]; __ZdaPv = Module["__ZdaPv"] = wasmExports["Ea"]; __ZdaPvm = Module["__ZdaPvm"] = wasmExports["Fa"]; __ZdlPv = Module["__ZdlPv"] = wasmExports["Ga"]; __Znam = Module["__Znam"] = wasmExports["Ha"]; __ZnamSt11align_val_t = Module["__ZnamSt11align_val_t"] = wasmExports["Ia"]; __ZnwmSt11align_val_t = Module["__ZnwmSt11align_val_t"] = wasmExports["Ja"]; ___libc_calloc = Module["___libc_calloc"] = wasmExports["Ka"]; ___libc_realloc = Module["___libc_realloc"] = wasmExports["La"]; _emscripten_builtin_calloc = Module["_emscripten_builtin_calloc"] = wasmExports["Ma"]; _emscripten_builtin_realloc = Module["_emscripten_builtin_realloc"] = wasmExports["Na"]; _malloc_size = Module["_malloc_size"] = wasmExports["Oa"]; _malloc_usable_size = Module["_malloc_usable_size"] = wasmExports["Pa"]; _reallocf = Module["_reallocf"] = wasmExports["Qa"]; _setThrew = wasmExports["Ra"]; _emscripten_stack_set_limits = wasmExports["Sa"]; __emscripten_stack_restore = wasmExports["Ta"]; __emscripten_stack_alloc = wasmExports["Ua"]; _emscripten_stack_get_current = wasmExports["Va"]; __indirect_function_table = wasmTable = wasmExports["ra"]; }
var wasmImports;
function assignWasmImports() { wasmImports = { b: ___assert_fail, P: ___pthread_create_js, y: ___syscall_fcntl64, O: ___syscall_getdents64, X: ___syscall_ioctl, z: ___syscall_openat, K: __abort_js, B: __embind_register_bigint, aa: __embind_register_bool, fa: __embind_register_class, ea: __embind_register_class_constructor, d: __embind_register_class_function, ca: __embind_register_class_property, _: __embind_register_emval, A: __embind_register_float, l: __embind_register_integer, e: __embind_register_memory_view, $: __embind_register_std_string, t: __embind_register_std_wstring, ba: __embind_register_void, S: __emscripten_init_main_thread_js, L: __emscripten_notify_mailbox_postmessage, x: __emscripten_receive_on_main_thread_js, G: __emscripten_runtime_keepalive_clear, v: __emscripten_thread_cleanup, R: __emscripten_thread_mailbox_await, Z: __emscripten_thread_set_strongref, E: __emscripten_throw_longjmp, i: __emval_create_invoker, c: __emval_decref, da: __emval_get_property, f: __emval_incref, h: __emval_invoke, p: __emval_new_array, j: __emval_new_cstring, s: __emval_new_object, g: __emval_run_destructors, k: __emval_set_property, H: __setitimer_js, n: _emscripten_asm_const_ptr, w: _emscripten_check_blocking_allowed, m: _emscripten_date_now, u: _emscripten_err, Y: _emscripten_exit_with_live_runtime, M: _emscripten_get_heap_max, o: _emscripten_get_now, N: _emscripten_num_logical_cores, I: _emscripten_resize_heap, T: _environ_get, U: _environ_sizes_get, q: _exit, r: _fd_close, W: _fd_read, Q: _fd_seek, V: _fd_write, D: invoke_iii, C: invoke_iiiii, a: wasmMemory, F: _proc_exit, J: _random_get }; }
function invoke_iii(index, a1, a2) { var sp = stackSave(); try {
return getWasmTableEntry(index)(a1, a2);
}
catch (e) {
stackRestore(sp);
if (!(e instanceof EmscriptenEH))
throw e;
_setThrew(1, 0);
} }
function invoke_iiiii(index, a1, a2, a3, a4) { var sp = stackSave(); try {
return getWasmTableEntry(index)(a1, a2, a3, a4);
}
catch (e) {
stackRestore(sp);
if (!(e instanceof EmscriptenEH))
throw e;
_setThrew(1, 0);
} }
function initRuntime(wasmExports) { runtimeInitialized = true; PThread.tlsInitFunctions.push(wasmExports["qa"]); if (ENVIRONMENT_IS_PTHREAD)
return; wasmExports["ga"](); }
var instantiatePromise;
var wasmModule;
function loadModule() { assignWasmImports(); var imports = { a: wasmImports }; instantiatePromise = 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); return PThread.loadWasmModuleToAllWorkers().then(ready); }); }
if (!ENVIRONMENT_IS_PTHREAD) {
loadModule();
}
await instantiatePromise;
;
return Module;
}
export default Module;
var isPthread = globalThis.name == "em-pthread";
isPthread && Module();
//# sourceMappingURL=jassub-worker.js.map