jassub
Version:
The Fastest JavaScript SSA/ASS Subtitle Renderer For Browsers
725 lines • 79.2 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 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_PTHREAD = ENVIRONMENT_IS_WORKER && globalThis.name == "em-pthread";
if (ENVIRONMENT_IS_WORKER) {
_scriptName = self.location.href;
}
var _scriptName;
const supportsGrowth = !!WebAssembly.Memory.prototype.toResizableBuffer;
updateMemoryViews = () => { if (supportsGrowth && self.HEAPU8RAW)
return; var b = supportsGrowth ? wasmMemory.toResizableBuffer() : wasmMemory.buffer; HEAP8 = new Int8Array(b); HEAP16 = new Int16Array(b); HEAPU8 = new Uint8Array(b); HEAPU16 = new Uint16Array(b); HEAP32 = new Int32Array(b); HEAPU32 = new Uint32Array(b); HEAPF32 = new Float32Array(b); HEAPF64 = new Float64Array(b); HEAP64 = new BigInt64Array(b); HEAPU64 = new BigUint64Array(b); self.HEAPU8RAW = new Uint8Array(b); self.WASMMEMORY = wasmMemory; };
if (moduleArg.__out)
out = moduleArg.__out;
if (moduleArg.__err)
err = moduleArg.__err;
if (!self.name.startsWith("em-pthread")) {
const OriginalWorker = globalThis.Worker;
globalThis.Worker = class extends OriginalWorker {
constructor(scriptURL, options = {}) { super(scriptURL, { ...options, name: "em-pthread-" + moduleArg.__url }); }
};
}
if (!ENVIRONMENT_IS_PTHREAD) { }
function abort(what) { throw what; }
class EmscriptenEH {
}
class EmscriptenSjLj extends EmscriptenEH {
}
function growMemViews() { if (wasmMemory.buffer != HEAP8.buffer) {
updateMemoryViews();
} }
var readyPromiseResolve, readyPromiseReject;
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 === "load") {
let messageQueue = [];
self.onmessage = e => messageQueue.push(e);
startWorker = () => { postMessage({ cmd: "loaded" }); 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: "callHandler", 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 === "run") {
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 (msgData.target === "setimmediate") { }
else if (cmd === "checkMailbox") {
if (initializedJS) {
checkMailbox();
}
}
else if (cmd) {
err(`worker: received unknown command ${cmd}`);
err(msgData);
}
}
catch (ex) {
__emscripten_thread_crashed();
throw ex;
} }
self.onmessage = handleMessage;
}
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 = 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) {
callbacks.shift()(Module);
} };
var onPreRuns = [];
var spawnThread = threadParams => { var worker = PThread.getNewWorker(); if (!worker) {
return 6;
} PThread.runningWorkers.push(worker); PThread.pthreads[threadParams.pthread_ptr] = worker; worker.pthread_ptr = threadParams.pthread_ptr; var msg = { cmd: "run", 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 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 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--) {
PThread.allocateUnusedWorker();
} }, terminateAllThreads: () => { for (var worker of PThread.runningWorkers) {
terminateWorker(worker);
} for (var worker of PThread.unusedWorkers) {
terminateWorker(worker);
} 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(`worker sent message (${cmd}) to pthread (${d.targetThread}) that no longer exists`);
}
return;
} if (cmd === "checkMailbox") {
checkMailbox();
}
else if (cmd === "spawnThread") {
spawnThread(d);
}
else if (cmd === "cleanupThread") {
callUserCallback(() => cleanupThread(d.thread));
}
else if (cmd === "loaded") {
worker.loaded = true;
onFinishedLoading(worker);
}
else if (d.target === "setimmediate") {
worker.postMessage(d);
}
else if (cmd === "callHandler") {
Module[d.handler](...d.args);
}
else 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: "load", 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); }, getNewWorker() { if (PThread.unusedWorkers.length == 0) {
PThread.allocateUnusedWorker();
PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
} return PThread.unusedWorkers.pop(); } };
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)
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 === 0 || 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 = "spawnThread";
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 = {};
var BindingError = 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 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]; };
var InternalError = 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; }
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";
}
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) {
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 = e