web-ifc
Version:
ifc loading on the web
1,169 lines (1,168 loc) • 6.08 MB
JavaScript
"use strict";
var WebIFC = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// dist/web-ifc-mt.js
var require_web_ifc_mt = __commonJS({
"dist/web-ifc-mt.js"(exports, module) {
"use strict";
var WebIFCWasm2 = (() => {
var _scriptName = globalThis.document?.currentScript?.src;
return async function(moduleArg = {}) {
var moduleRtn;
var Module = moduleArg;
var ENVIRONMENT_IS_WEB = !!globalThis.window;
var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && self.name?.startsWith("em-pthread");
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
if (ENVIRONMENT_IS_WORKER) {
_scriptName = self.location.href;
}
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var readAsync, readBinary;
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
try {
scriptDirectory = new URL(".", _scriptName).href;
} catch {
}
{
if (ENVIRONMENT_IS_WORKER) {
readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
readAsync = async (url) => {
var response = await fetch(url, { credentials: "same-origin" });
if (response.ok) {
return response.arrayBuffer();
}
throw new Error(response.status + " : " + response.url);
};
}
} else {
}
var out = console.log.bind(console);
var err = console.error.bind(console);
var wasmBinary;
var wasmModule;
var ABORT = false;
var EXITSTATUS;
function growMemViews() {
if (wasmMemory.buffer != HEAP8.buffer) {
updateMemoryViews();
}
}
var readyPromiseResolve, readyPromiseReject;
var startWorker;
if (ENVIRONMENT_IS_PTHREAD) {
let handleMessage2 = function(e) {
try {
var msgData = e["data"];
var cmd = msgData.cmd;
if (cmd === "load") {
let messageQueue = [];
self.onmessage = (e2) => messageQueue.push(e2);
startWorker = () => {
postMessage({ cmd: "loaded" });
for (let msg of messageQueue) {
handleMessage2(msg);
}
self.onmessage = handleMessage2;
};
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();
wasmModule = msgData.wasmModule;
createWasm();
run();
} 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;
}
};
var handleMessage = handleMessage2;
var initializedJS = false;
self.onunhandledrejection = (e) => {
throw e.reason || e;
};
self.onmessage = handleMessage2;
}
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;
}
if (Module["wasmMemory"]) {
wasmMemory = Module["wasmMemory"];
} else {
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
wasmMemory = new WebAssembly.Memory({ initial: INITIAL_MEMORY / 65536, maximum: 65536, shared: true });
}
updateMemoryViews();
}
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(onPreRuns);
}
function initRuntime() {
runtimeInitialized = true;
if (ENVIRONMENT_IS_PTHREAD) return startWorker();
if (!Module["noFSInit"] && !FS.initialized) FS.init();
TTY.init();
wasmExports["ja"]();
FS.ignorePermissions = false;
}
function postRun() {
if (ENVIRONMENT_IS_PTHREAD) {
return;
}
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(onPostRuns);
}
function abort(what) {
Module["onAbort"]?.(what);
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
what += ". Build with -sASSERTIONS for more info.";
var e = new WebAssembly.RuntimeError(what);
readyPromiseReject?.(e);
throw e;
}
var wasmBinaryFile;
function findWasmBinary() {
return locateFile("web-ifc-mt.wasm");
}
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
}
throw "both async and sync fetching of the wasm failed";
}
async function getWasmBinary(binaryFile) {
if (!wasmBinary) {
try {
var response = await readAsync(binaryFile);
return new Uint8Array(response);
} catch {
}
}
return getBinarySync(binaryFile);
}
async function instantiateArrayBuffer(binaryFile, imports) {
try {
var binary = await getWasmBinary(binaryFile);
var instance = await WebAssembly.instantiate(binary, imports);
return instance;
} catch (reason) {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
}
}
async function instantiateAsync(binary, binaryFile, imports) {
if (!binary) {
try {
var response = fetch(binaryFile, { credentials: "same-origin" });
var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
return instantiationResult;
} catch (reason) {
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
}
}
return instantiateArrayBuffer(binaryFile, imports);
}
function getWasmImports() {
assignWasmImports();
var imports = { a: wasmImports };
return imports;
}
async function createWasm() {
function receiveInstance(instance2, module2) {
wasmExports = instance2.exports;
wasmExports = applySignatureConversions(wasmExports);
registerTLSInit(wasmExports["qa"]);
assignWasmExports(wasmExports);
wasmModule = module2;
return wasmExports;
}
function receiveInstantiationResult(result2) {
return receiveInstance(result2["instance"], result2["module"]);
}
var info = getWasmImports();
if (Module["instantiateWasm"]) {
return new Promise((resolve, reject) => {
Module["instantiateWasm"](info, (inst, mod) => {
resolve(receiveInstance(inst, mod));
});
});
}
if (ENVIRONMENT_IS_PTHREAD) {
var instance = new WebAssembly.Instance(wasmModule, getWasmImports());
return receiveInstance(instance, wasmModule);
}
wasmBinaryFile ??= findWasmBinary();
var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
var exports2 = receiveInstantiationResult(result);
return exports2;
}
class ExitStatus {
name = "ExitStatus";
constructor(status) {
this.message = `Program terminated with exit(${status})`;
this.status = status;
}
}
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 addOnPreRun = (cb) => onPreRuns.push(cb);
var runDependencies = 0;
var dependenciesFulfilled = null;
var removeRunDependency = (id) => {
runDependencies--;
Module["monitorRunDependencies"]?.(runDependencies);
if (runDependencies == 0) {
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
};
var addRunDependency = (id) => {
runDependencies++;
Module["monitorRunDependencies"]?.(runDependencies);
};
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 runtimeKeepaliveCounter = 0;
var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 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 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++ >>> 0] = 1n;
(growMemViews(), HEAP64)[b++ >>> 0] = arg;
} else {
(growMemViews(), HEAP64)[b++ >>> 0] = 0n;
(growMemViews(), HEAPF64)[b++ >>> 0] = arg;
}
}
var rtn = __emscripten_run_js_on_main_thread(funcIndex, emAsmAddr, bufSize, args, sync);
stackRestore(sp);
return rtn;
};
function _proc_exit(code) {
if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(0, 0, 1, code);
EXITSTATUS = code;
if (!keepRuntimeAlive()) {
PThread.terminateAllThreads();
Module["onExit"]?.(code);
ABORT = true;
}
quit_(code, new ExitStatus(code));
}
function exitOnMainThread(returnCode) {
if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(1, 0, 0, returnCode);
_exit(returnCode);
}
var exitJS = (status, implicit) => {
EXITSTATUS = status;
if (ENVIRONMENT_IS_PTHREAD) {
exitOnMainThread(status);
throw "unwind";
}
_proc_exit(status);
};
var _exit = exitJS;
var PThread = { unusedWorkers: [], runningWorkers: [], tlsInitFunctions: [], pthreads: {}, init() {
if (!ENVIRONMENT_IS_PTHREAD) {
PThread.initMainThread();
}
}, initMainThread() {
var pthreadPoolSize = navigator.hardwareConcurrency;
while (pthreadPoolSize--) {
PThread.allocateUnusedWorker();
}
addOnPreRun(async () => {
var pthreadPoolReady = PThread.loadWasmModuleToAllWorkers();
addRunDependency("loading-workers");
await pthreadPoolReady;
removeRunDependency("loading-workers");
});
}, 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 = ["onExit", "onAbort", "print", "printErr"];
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;
var pthreadMainJs = _scriptName;
if (Module["mainScriptUrlOrBlob"]) {
pthreadMainJs = Module["mainScriptUrlOrBlob"];
if (typeof pthreadMainJs != "string") {
pthreadMainJs = URL.createObjectURL(pthreadMainJs);
}
}
worker = new Worker(pthreadMainJs, { name: "em-pthread" });
PThread.unusedWorkers.push(worker);
}, getNewWorker() {
if (PThread.unusedWorkers.length == 0) {
PThread.allocateUnusedWorker();
PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
}
return PThread.unusedWorkers.pop();
} };
var onPostRuns = [];
var addOnPostRun = (cb) => onPostRuns.push(cb);
function establishStackSpace(pthread_ptr) {
var stackHigh = (growMemViews(), HEAPU32)[pthread_ptr + 52 >>> 2 >>> 0];
var stackSize = (growMemViews(), HEAPU32)[pthread_ptr + 56 >>> 2 >>> 0];
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) => {
runtimeKeepaliveCounter = 0;
noExitRuntime = 0;
var result = getWasmTableEntry(ptr)(arg);
function finish(result2) {
if (keepRuntimeAlive()) {
EXITSTATUS = result2;
return;
}
__emscripten_thread_exit(result2);
}
finish(result);
};
var noExitRuntime = true;
var registerTLSInit = (tlsInitFunc) => PThread.tlsInitFunctions.push(tlsInitFunc);
var wasmMemory;
class ExceptionInfo {
constructor(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
}
set_type(type) {
(growMemViews(), HEAPU32)[this.ptr + 4 >>> 2 >>> 0] = type;
}
get_type() {
return (growMemViews(), HEAPU32)[this.ptr + 4 >>> 2 >>> 0];
}
set_destructor(destructor) {
(growMemViews(), HEAPU32)[this.ptr + 8 >>> 2 >>> 0] = destructor;
}
get_destructor() {
return (growMemViews(), HEAPU32)[this.ptr + 8 >>> 2 >>> 0];
}
set_caught(caught) {
caught = caught ? 1 : 0;
(growMemViews(), HEAP8)[this.ptr + 12 >>> 0] = caught;
}
get_caught() {
return (growMemViews(), HEAP8)[this.ptr + 12 >>> 0] != 0;
}
set_rethrown(rethrown) {
rethrown = rethrown ? 1 : 0;
(growMemViews(), HEAP8)[this.ptr + 13 >>> 0] = rethrown;
}
get_rethrown() {
return (growMemViews(), HEAP8)[this.ptr + 13 >>> 0] != 0;
}
init(type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor);
}
set_adjusted_ptr(adjustedPtr) {
(growMemViews(), HEAPU32)[this.ptr + 16 >>> 2 >>> 0] = adjustedPtr;
}
get_adjusted_ptr() {
return (growMemViews(), HEAPU32)[this.ptr + 16 >>> 2 >>> 0];
}
}
var exceptionLast = 0;
var uncaughtExceptionCount = 0;
var INT53_MAX = 9007199254740992;
var INT53_MIN = -9007199254740992;
var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
function ___cxa_throw(ptr, type, destructor) {
ptr >>>= 0;
type >>>= 0;
destructor >>>= 0;
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw exceptionLast;
}
var __abort_js = () => abort("");
var tupleRegistrations = {};
var runDestructors = (destructors) => {
while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr);
}
};
function readPointer(pointer) {
return this.fromWireType((growMemViews(), HEAPU32)[pointer >>> 2 >>> 0]);
}
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
var InternalError = class InternalError extends Error {
constructor(message) {
super(message);
this.name = "InternalError";
}
};
var throwInternalError = (message) => {
throw new InternalError(message);
};
var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
myTypes.forEach((type) => typeDependencies[type] = dependentTypes);
function onComplete(typeConverters2) {
var myTypeConverters = getTypeConverters(typeConverters2);
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_finalize_value_array = function(rawTupleType) {
rawTupleType >>>= 0;
var reg = tupleRegistrations[rawTupleType];
delete tupleRegistrations[rawTupleType];
var elements = reg.elements;
var elementsLength = elements.length;
var elementTypes = elements.map((elt) => elt.getterReturnType).concat(elements.map((elt) => elt.setterArgumentType));
var rawConstructor = reg.rawConstructor;
var rawDestructor = reg.rawDestructor;
whenDependentTypesAreResolved([rawTupleType], elementTypes, (elementTypes2) => {
for (const [i, elt] of elements.entries()) {
const getterReturnType = elementTypes2[i];
const getter = elt.getter;
const getterContext = elt.getterContext;
const setterArgumentType = elementTypes2[i + elementsLength];
const setter = elt.setter;
const setterContext = elt.setterContext;
elt.read = (ptr) => getterReturnType.fromWireType(getter(getterContext, ptr));
elt.write = (ptr, o) => {
var destructors = [];
setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o));
runDestructors(destructors);
};
}
return [{ name: reg.name, fromWireType: (ptr) => {
var rv = new Array(elementsLength);
for (var i = 0; i < elementsLength; ++i) {
rv[i] = elements[i].read(ptr);
}
rawDestructor(ptr);
return rv;
}, toWireType: (destructors, o) => {
if (elementsLength !== o.length) {
throw new TypeError(`Incorrect number of tuple elements for ${reg.name}: expected=${elementsLength}, actual=${o.length}`);
}
var ptr = rawConstructor();
for (var i = 0; i < elementsLength; ++i) {
elements[i].write(ptr, o[i]);
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr);
}
return ptr;
}, readValueFromPointer: readPointer, destructorFunction: rawDestructor }];
});
};
var structRegistrations = {};
var __embind_finalize_value_object = function(structType) {
structType >>>= 0;
var reg = structRegistrations[structType];
delete structRegistrations[structType];
var rawConstructor = reg.rawConstructor;
var rawDestructor = reg.rawDestructor;
var fieldRecords = reg.fields;
var fieldTypes = fieldRecords.map((field) => field.getterReturnType).concat(fieldRecords.map((field) => field.setterArgumentType));
whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes2) => {
var fields = {};
for (var [i, field] of fieldRecords.entries()) {
const getterReturnType = fieldTypes2[i];
const getter = field.getter;
const getterContext = field.getterContext;
const setterArgumentType = fieldTypes2[i + fieldRecords.length];
const setter = field.setter;
const setterContext = field.setterContext;
fields[field.fieldName] = { read: (ptr) => getterReturnType.fromWireType(getter(getterContext, ptr)), write: (ptr, o) => {
var destructors = [];
setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o));
runDestructors(destructors);
}, optional: getterReturnType.optional };
}
return [{ name: reg.name, fromWireType: (ptr) => {
var rv = {};
for (var i2 in fields) {
rv[i2] = fields[i2].read(ptr);
}
rawDestructor(ptr);
return rv;
}, toWireType: (destructors, o) => {
for (var fieldName in fields) {
if (!(fieldName in o) && !fields[fieldName].optional) {
throw new TypeError(`Missing field: "${fieldName}"`);
}
}
var ptr = rawConstructor();
for (fieldName in fields) {
fields[fieldName].write(ptr, o[fieldName]);
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr);
}
return ptr;
}, readValueFromPointer: readPointer, destructorFunction: rawDestructor }];
});
};
var AsciiToString = (ptr) => {
ptr >>>= 0;
var str = "";
while (1) {
var ch = (growMemViews(), HEAPU8)[ptr++ >>> 0];
if (!ch) return str;
str += String.fromCharCode(ch);
}
};
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 >>> 0] : (pointer) => (growMemViews(), HEAPU8)[pointer >>> 0];
case 2:
return signed ? (pointer) => (growMemViews(), HEAP16)[pointer >>> 1 >>> 0] : (pointer) => (growMemViews(), HEAPU16)[pointer >>> 1 >>> 0];
case 4:
return signed ? (pointer) => (growMemViews(), HEAP32)[pointer >>> 2 >>> 0] : (pointer) => (growMemViews(), HEAPU32)[pointer >>> 2 >>> 0];
case 8:
return signed ? (pointer) => (growMemViews(), HEAP64)[pointer >>> 3 >>> 0] : (pointer) => (growMemViews(), HEAPU64)[pointer >>> 3 >>> 0];
default:
throw new TypeError(`invalid integer width (${width}): ${name}`);
}
};
var __embind_register_bigint = function(primitiveType, name, size, minRange, maxRange) {
primitiveType >>>= 0;
name >>>= 0;
size >>>= 0;
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 });
};
function __embind_register_bool(rawType, name, trueValue, falseValue) {
rawType >>>= 0;
name >>>= 0;
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 >>> 0]);
}, 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 = (handle2) => handle2;
return handle;
}
finalizationRegistry = new FinalizationRegistry((info) => {
releaseClassHandle(info.$$);
});
attachFinalizer = (handle2) => {
var $$ = handle2.$$;
var hasSmartPtr = !!$$.smartPtr;
if (hasSmartPtr) {
var info = { $$ };
finalizationRegistry.register(handle2, info, handle2);
}
return handle2;
};
detachFinalizer = (handle2) => finalizationRegistry.unregister(handle2);
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 = void 0;
this.$$.ptr = void 0;
}
}, 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 (void 0 === 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 (void 0 === numArguments || void 0 !== Module[name].overloadTable && void 0 !== 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 (void 0 === 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;
}
var downcastPointer = (ptr, ptrClass, desiredClass) => {
if (ptrClass === desiredClass) {
return ptr;
}
if (void 0 === 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 === void 0) {
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 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(