jassub
Version:
The Fastest JavaScript SSA/ASS Subtitle Renderer For Browsers
715 lines • 71.6 kB
JavaScript
async function Module(moduleArg = {}) {
var moduleRtn;
var Module = moduleArg;
var ENVIRONMENT_IS_WEB = true;
var out = (...args) => console.log(...args);
var err = (...args) => console.error(...args);
function ready() { readyPromiseResolve?.(Module); if (ENVIRONMENT_IS_PTHREAD) {
startWorker();
} }
var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && self.name?.startsWith("em-pthread");
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 (self.name.startsWith("em-pthread")) {
const url = self.name.split("-").slice(2).join("-");
const _fetch = globalThis.fetch;
globalThis.fetch = _ => _fetch(url);
}
else {
if (moduleArg.__out)
out = moduleArg.__out;
if (moduleArg.__err)
err = moduleArg.__err;
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; }
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 HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var HEAP64, HEAPU64;
var runtimeInitialized = false;
function updateMemoryViews() { var b = wasmMemory.buffer; HEAP8 = new Int8Array(b); HEAP16 = new Int16Array(b); HEAPU8 = new Uint8Array(b); HEAPU16 = new Uint16Array(b); HEAP32 = new Int32Array(b); HEAPU32 = new Uint32Array(b); HEAPF32 = new Float32Array(b); HEAPF64 = new Float64Array(b); HEAP64 = new BigInt64Array(b); HEAPU64 = new BigUint64Array(b); }
function initMemory() { if (ENVIRONMENT_IS_PTHREAD) {
return;
} {
var INITIAL_MEMORY = 62914560;
wasmMemory = new WebAssembly.Memory({ initial: INITIAL_MEMORY / 65536, maximum: 32768, shared: true });
} updateMemoryViews(); }
initMemory();
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, sync, ...callArgs) => { var serializedNumCallArgs = callArgs.length * 2; var sp = stackSave(); var args = stackAlloc(serializedNumCallArgs * 8); var b = args >> 3; for (var i = 0; i < callArgs.length; i++) {
var arg = callArgs[i];
if (typeof arg == "bigint") {
(growMemViews(), HEAP64)[b + 2 * i] = 1n;
(growMemViews(), HEAP64)[b + 2 * i + 1] = arg;
}
else {
(growMemViews(), HEAP64)[b + 2 * i] = 0n;
(growMemViews(), HEAPF64)[b + 2 * i + 1] = arg;
}
} var rtn = __emscripten_run_js_on_main_thread(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync); 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 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 = {}; }, returnWorkerToPool: worker => { var pthread_ptr = worker.pthread_ptr; delete PThread.pthreads[pthread_ptr]; PThread.unusedWorkers.push(worker); PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); worker.pthread_ptr = 0; __emscripten_thread_free_data(pthread_ptr); }, threadInitTLS() { PThread.tlsInitFunctions.forEach(f => f()); }, loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => { worker.onmessage = e => { var d = e["data"]; var cmd = d.cmd; if (d.targetThread && d.targetThread != _pthread_self()) {
var targetWorker = PThread.pthreads[d.targetThread];
if (targetWorker) {
targetWorker.postMessage(d, d.transferList);
}
else {
err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`);
}
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 + 52 >> 2]; var stackSize = (growMemViews(), HEAPU32)[pthread_ptr + 56 >> 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 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("Unsupporting 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; }
function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { var needsDestructorStack = usesDestructorStack(argTypes); var argCount = argTypes.length - 2; var argsList = []; var argsListWired = ["fn"]; if (isClassMethodFunc) {
argsListWired.push("thisWired");
} for (var i = 0; i < argCount; ++i) {
argsList.push(`arg${i}`);
argsListWired.push(`arg${i}Wired`);
} argsList = argsList.join(","); argsListWired = argsListWired.join(","); var invokerFnBody = `return function (${argsList}) {\n`; if (needsDestructorStack) {
invokerFnBody += "var destructors = [];\n";
} var dtorStack = needsDestructorStack ? "destructors" : "null"; var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire"]; if (isClassMethodFunc) {
invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`;
} for (var i = 0; i < argCount; ++i) {
var argName = `toArg${i}Wire`;
invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`;
args1.push(argName);
} invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`; if (needsDestructorStack) {
invokerFnBody += "runDestructors(destructors);\n";
}
else {
for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
if (argTypes[i].destructorFunction !== null) {
invokerFnBody += `${paramName}_dtor(${paramName});\n`;
args1.push(`${paramName}_dtor`);
}
}
} if (returns) {
invokerFnBody += "var ret = fromRetWire(rv);\n" + "return ret;\n";
}
else { } invokerFnBody += "}\n"; return new Function(args1, invokerFnBody); }
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);
}
}
} let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); var invokerFn = invokerFactory(...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]) {
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 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 stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { if (!(maxBytesToWrite > 0))
return 0; var startIdx = outIdx; var endIdx