@keymanapp/kmc-kmn 17.0.155-alpha → 17.0.157-alpha

package/build/src/import/kmcmplib/wasm-host.js

@@ -1,1145 +1,3264 @@
-var Module = (() => {
-    var _scriptDir = import.meta.url;
-    return (async function (Module = {}) {
-        var Module = typeof Module != "undefined" ? Module : {};
-        var readyPromiseResolve, readyPromiseReject;
-        Module["ready"] = new Promise(function (resolve, reject) { readyPromiseResolve = resolve; readyPromiseReject = reject; });
-        var moduleOverrides = Object.assign({}, Module);
-        var arguments_ = [];
-        var thisProgram = "./this.program";
-        var quit_ = (status, toThrow) => { throw toThrow; };
-        var ENVIRONMENT_IS_WEB = typeof window == "object";
-        var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
-        var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
-        var scriptDirectory = "";
-        function locateFile(path) { if (Module["locateFile"]) {
-            return Module["locateFile"](path, scriptDirectory);
-        } return scriptDirectory + path; }
-        var read_, readAsync, readBinary, setWindowTitle;
-        if (ENVIRONMENT_IS_NODE) {
-            const { createRequire: createRequire } = await import("module");
-            var require = createRequire(import.meta.url);
-            var fs = require("fs");
-            var nodePath = require("path");
-            if (ENVIRONMENT_IS_WORKER) {
-                scriptDirectory = nodePath.dirname(scriptDirectory) + "/";
-            }
-            else {
-                scriptDirectory = require("url").fileURLToPath(new URL("./", import.meta.url));
-            }
-            read_ = (filename, binary) => { filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); return fs.readFileSync(filename, binary ? undefined : "utf8"); };
-            readBinary = filename => { var ret = read_(filename, true); if (!ret.buffer) {
-                ret = new Uint8Array(ret);
-            } return ret; };
-            readAsync = (filename, onload, onerror) => { filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); fs.readFile(filename, function (err, data) { if (err)
-                onerror(err);
-            else
-                onload(data.buffer); }); };
-            if (process.argv.length > 1) {
-                thisProgram = process.argv[1].replace(/\\/g, "/");
-            }
-            arguments_ = process.argv.slice(2);
-            process.on("uncaughtException", function (ex) { if (ex !== "unwind" && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
-                throw ex;
-            } });
-            var nodeMajor = process.versions.node.split(".")[0];
-            if (nodeMajor < 15) {
-                process.on("unhandledRejection", function (reason) { throw reason; });
-            }
-            quit_ = (status, toThrow) => { process.exitCode = status; throw toThrow; };
-            Module["inspect"] = function () { return "[Emscripten Module object]"; };
-        }
-        else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-            if (ENVIRONMENT_IS_WORKER) {
-                scriptDirectory = self.location.href;
-            }
-            else if (typeof document != "undefined" && document.currentScript) {
-                scriptDirectory = document.currentScript.src;
-            }
-            if (_scriptDir) {
-                scriptDirectory = _scriptDir;
-            }
-            if (scriptDirectory.indexOf("blob:") !== 0) {
-                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
-            }
-            else {
-                scriptDirectory = "";
-            }
-            {
-                read_ = url => { var xhr = new XMLHttpRequest; xhr.open("GET", url, false); xhr.send(null); return xhr.responseText; };
-                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 = (url, onload, onerror) => { var xhr = new XMLHttpRequest; xhr.open("GET", url, true); xhr.responseType = "arraybuffer"; xhr.onload = () => { if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    onload(xhr.response);
-                    return;
-                } onerror(); }; xhr.onerror = onerror; xhr.send(null); };
-            }
-            setWindowTitle = title => document.title = title;
-        }
-        else { }
-        var out = Module["print"] || console.log.bind(console);
-        var err = Module["printErr"] || console.warn.bind(console);
-        Object.assign(Module, moduleOverrides);
-        moduleOverrides = null;
-        if (Module["arguments"])
-            arguments_ = Module["arguments"];
-        if (Module["thisProgram"])
-            thisProgram = Module["thisProgram"];
-        if (Module["quit"])
-            quit_ = Module["quit"];
-        var wasmBinary;
-        if (Module["wasmBinary"])
-            wasmBinary = Module["wasmBinary"];
-        var noExitRuntime = Module["noExitRuntime"] || true;
-        if (typeof WebAssembly != "object") {
-            abort("no native wasm support detected");
-        }
-        var wasmMemory;
-        var ABORT = false;
-        var EXITSTATUS;
-        function assert(condition, text) { if (!condition) {
-            abort(text);
-        } }
-        var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
-        function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { var endIdx = idx + maxBytesToRead; var endPtr = idx; while (heapOrArray[endPtr] && !(endPtr >= endIdx))
-            ++endPtr; if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-            return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-        } var str = ""; while (idx < endPtr) {
-            var u0 = heapOrArray[idx++];
-            if (!(u0 & 128)) {
-                str += String.fromCharCode(u0);
-                continue;
-            }
-            var u1 = heapOrArray[idx++] & 63;
-            if ((u0 & 224) == 192) {
-                str += String.fromCharCode((u0 & 31) << 6 | u1);
-                continue;
-            }
-            var u2 = heapOrArray[idx++] & 63;
-            if ((u0 & 240) == 224) {
-                u0 = (u0 & 15) << 12 | u1 << 6 | u2;
-            }
-            else {
-                u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
-            }
-            if (u0 < 65536) {
-                str += String.fromCharCode(u0);
-            }
-            else {
-                var ch = u0 - 65536;
-                str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
-            }
-        } return str; }
-        function UTF8ToString(ptr, maxBytesToRead) { return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; }
-        function 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.charCodeAt(i);
-            if (u >= 55296 && u <= 57343) {
-                var u1 = str.charCodeAt(++i);
-                u = 65536 + ((u & 1023) << 10) | u1 & 1023;
-            }
-            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;
-            }
-        } heap[outIdx] = 0; return outIdx - startIdx; }
-        function stringToUTF8(str, outPtr, maxBytesToWrite) { return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); }
-        function 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 HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
-        function updateMemoryViews() { var b = wasmMemory.buffer; Module["HEAP8"] = HEAP8 = new Int8Array(b); Module["HEAP16"] = HEAP16 = new Int16Array(b); Module["HEAP32"] = HEAP32 = new Int32Array(b); Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); Module["HEAPU16"] = HEAPU16 = new Uint16Array(b); Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); Module["HEAPF32"] = HEAPF32 = new Float32Array(b); Module["HEAPF64"] = HEAPF64 = new Float64Array(b); }
-        var wasmTable;
-        var __ATPRERUN__ = [];
-        var __ATINIT__ = [];
-        var __ATPOSTRUN__ = [];
-        var runtimeInitialized = false;
-        var runtimeKeepaliveCounter = 0;
-        function preRun() { if (Module["preRun"]) {
-            if (typeof Module["preRun"] == "function")
-                Module["preRun"] = [Module["preRun"]];
-            while (Module["preRun"].length) {
-                addOnPreRun(Module["preRun"].shift());
-            }
-        } callRuntimeCallbacks(__ATPRERUN__); }
-        function initRuntime() { runtimeInitialized = true; callRuntimeCallbacks(__ATINIT__); }
-        function postRun() { if (Module["postRun"]) {
-            if (typeof Module["postRun"] == "function")
-                Module["postRun"] = [Module["postRun"]];
-            while (Module["postRun"].length) {
-                addOnPostRun(Module["postRun"].shift());
-            }
-        } callRuntimeCallbacks(__ATPOSTRUN__); }
-        function addOnPreRun(cb) { __ATPRERUN__.unshift(cb); }
-        function addOnInit(cb) { __ATINIT__.unshift(cb); }
-        function addOnPostRun(cb) { __ATPOSTRUN__.unshift(cb); }
-        var runDependencies = 0;
-        var runDependencyWatcher = null;
-        var dependenciesFulfilled = null;
-        function addRunDependency(id) { runDependencies++; if (Module["monitorRunDependencies"]) {
-            Module["monitorRunDependencies"](runDependencies);
-        } }
-        function removeRunDependency(id) { runDependencies--; if (Module["monitorRunDependencies"]) {
-            Module["monitorRunDependencies"](runDependencies);
-        } if (runDependencies == 0) {
-            if (runDependencyWatcher !== null) {
-                clearInterval(runDependencyWatcher);
-                runDependencyWatcher = null;
-            }
-            if (dependenciesFulfilled) {
-                var callback = dependenciesFulfilled;
-                dependenciesFulfilled = null;
-                callback();
-            }
-        } }
-        function abort(what) { if (Module["onAbort"]) {
-            Module["onAbort"](what);
-        } what = "Aborted(" + what + ")"; err(what); ABORT = true; EXITSTATUS = 1; what += ". Build with -sASSERTIONS for more info."; if (runtimeInitialized) {
-            ___trap();
-        } var e = new WebAssembly.RuntimeError(what); readyPromiseReject(e); throw e; }
-        var dataURIPrefix = "data:application/octet-stream;base64,";
-        function isDataURI(filename) { return filename.startsWith(dataURIPrefix); }
-        function isFileURI(filename) { return filename.startsWith("file://"); }
-        var wasmBinaryFile;
-        if (Module["locateFile"]) {
-            wasmBinaryFile = "wasm-host.wasm";
-            if (!isDataURI(wasmBinaryFile)) {
-                wasmBinaryFile = locateFile(wasmBinaryFile);
-            }
-        }
-        else {
-            wasmBinaryFile = new URL("wasm-host.wasm", import.meta.url).href;
-        }
-        function getBinary(file) { try {
-            if (file == wasmBinaryFile && wasmBinary) {
-                return new Uint8Array(wasmBinary);
-            }
-            if (readBinary) {
-                return readBinary(file);
-            }
-            throw "both async and sync fetching of the wasm failed";
-        }
-        catch (err) {
-            abort(err);
-        } }
-        function getBinaryPromise(binaryFile) { if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
-            if (typeof fetch == "function" && !isFileURI(binaryFile)) {
-                return fetch(binaryFile, { credentials: "same-origin" }).then(function (response) { if (!response["ok"]) {
-                    throw "failed to load wasm binary file at '" + binaryFile + "'";
-                } return response["arrayBuffer"](); }).catch(function () { return getBinary(binaryFile); });
-            }
-            else {
-                if (readAsync) {
-                    return new Promise(function (resolve, reject) { readAsync(binaryFile, function (response) { resolve(new Uint8Array(response)); }, reject); });
-                }
-            }
-        } return Promise.resolve().then(function () { return getBinary(binaryFile); }); }
-        function instantiateArrayBuffer(binaryFile, imports, receiver) { return getBinaryPromise(binaryFile).then(function (binary) { return WebAssembly.instantiate(binary, imports); }).then(function (instance) { return instance; }).then(receiver, function (reason) { err("failed to asynchronously prepare wasm: " + reason); abort(reason); }); }
-        function instantiateAsync(binary, binaryFile, imports, callback) { if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
-            return fetch(binaryFile, { credentials: "same-origin" }).then(function (response) { var result = WebAssembly.instantiateStreaming(response, imports); return result.then(callback, function (reason) { err("wasm streaming compile failed: " + reason); err("falling back to ArrayBuffer instantiation"); return instantiateArrayBuffer(binaryFile, imports, callback); }); });
-        }
-        else {
-            return instantiateArrayBuffer(binaryFile, imports, callback);
-        } }
-        function createWasm() { var info = { "env": wasmImports, "wasi_snapshot_preview1": wasmImports }; function receiveInstance(instance, module) { var exports = instance.exports; Module["asm"] = exports; wasmMemory = Module["asm"]["memory"]; updateMemoryViews(); wasmTable = Module["asm"]["__indirect_function_table"]; addOnInit(Module["asm"]["__wasm_call_ctors"]); removeRunDependency("wasm-instantiate"); return exports; } addRunDependency("wasm-instantiate"); function receiveInstantiationResult(result) { receiveInstance(result["instance"]); } if (Module["instantiateWasm"]) {
-            try {
-                return Module["instantiateWasm"](info, receiveInstance);
-            }
-            catch (e) {
-                err("Module.instantiateWasm callback failed with error: " + e);
-                readyPromiseReject(e);
-            }
-        } instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); return {}; }
-        var tempDouble;
-        var tempI64;
-        function wasm_msgproc(line, msgcode, text, context) { const proc = globalThis[UTF8ToString(context)].message; if (!proc || typeof proc != "function") {
-            console.log(`[${line}: ${msgcode}: ${UTF8ToString(text)}]`);
-            return 0;
-        }
-        else {
-            return proc(line, msgcode, UTF8ToString(text));
-        } }
-        function wasm_loadfileproc(filename, baseFilename, buffer, bufferSize, context) { const proc = globalThis[UTF8ToString(context)].loadFile; if (!proc || typeof proc != "function") {
-            return 0;
-        }
-        else {
-            if (buffer == 0) {
-                return proc(UTF8ToString(filename), UTF8ToString(baseFilename), 0, 0);
-            }
-            else {
-                return proc(UTF8ToString(filename), UTF8ToString(baseFilename), buffer, bufferSize);
-            }
-        } }
-        function ExitStatus(status) { this.name = "ExitStatus"; this.message = "Program terminated with exit(" + status + ")"; this.status = status; }
-        function callRuntimeCallbacks(callbacks) { while (callbacks.length > 0) {
-            callbacks.shift()(Module);
-        } }
-        function ___assert_fail(condition, filename, line, func) { abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]); }
-        function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) { }
-        function getShiftFromSize(size) { switch (size) {
-            case 1: return 0;
-            case 2: return 1;
-            case 4: return 2;
-            case 8: return 3;
-            default: throw new TypeError("Unknown type size: " + size);
-        } }
-        function embind_init_charCodes() { var codes = new Array(256); for (var i = 0; i < 256; ++i) {
-            codes[i] = String.fromCharCode(i);
-        } embind_charCodes = codes; }
-        var embind_charCodes = undefined;
-        function readLatin1String(ptr) { var ret = ""; var c = ptr; while (HEAPU8[c]) {
-            ret += embind_charCodes[HEAPU8[c++]];
-        } return ret; }
-        var awaitingDependencies = {};
-        var registeredTypes = {};
-        var typeDependencies = {};
-        var char_0 = 48;
-        var char_9 = 57;
-        function makeLegalFunctionName(name) { if (undefined === name) {
-            return "_unknown";
-        } 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 createNamedFunction(name, body) { name = makeLegalFunctionName(name); return { [name]: function () { return body.apply(this, arguments); } }[name]; }
-        function extendError(baseErrorType, errorName) { var errorClass = createNamedFunction(errorName, function (message) { this.name = errorName; this.message = message; var stack = new Error(message).stack; if (stack !== undefined) {
-            this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
-        } }); errorClass.prototype = Object.create(baseErrorType.prototype); errorClass.prototype.constructor = errorClass; errorClass.prototype.toString = function () { if (this.message === undefined) {
-            return this.name;
-        }
-        else {
-            return this.name + ": " + this.message;
-        } }; return errorClass; }
-        var BindingError = undefined;
-        function throwBindingError(message) { throw new BindingError(message); }
-        var InternalError = undefined;
-        function throwInternalError(message) { throw new InternalError(message); }
-        function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { myTypes.forEach(function (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; dependentTypes.forEach((dt, i) => { 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);
-        } }
-        function registerType(rawType, registeredInstance, options = {}) { if (!("argPackAdvance" in registeredInstance)) {
-            throw new TypeError("registerType registeredInstance requires argPackAdvance");
-        } 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 __embind_register_bool(rawType, name, size, trueValue, falseValue) { var shift = getShiftFromSize(size); name = readLatin1String(name); registerType(rawType, { name: name, "fromWireType": function (wt) { return !!wt; }, "toWireType": function (destructors, o) { return o ? trueValue : falseValue; }, "argPackAdvance": 8, "readValueFromPointer": function (pointer) { var heap; if (size === 1) {
-                heap = HEAP8;
-            }
-            else if (size === 2) {
-                heap = HEAP16;
-            }
-            else if (size === 4) {
-                heap = HEAP32;
-            }
-            else {
-                throw new TypeError("Unknown boolean type size: " + name);
-            } return this["fromWireType"](heap[pointer >> shift]); }, destructorFunction: null }); }
-        function ClassHandle_isAliasOf(other) { if (!(this instanceof ClassHandle)) {
-            return false;
-        } if (!(other instanceof ClassHandle)) {
-            return false;
-        } var leftClass = this.$$.ptrType.registeredClass; var left = this.$$.ptr; 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; }
-        function shallowCopyInternalPointer(o) { return { count: o.count, deleteScheduled: o.deleteScheduled, preservePointerOnDelete: o.preservePointerOnDelete, ptr: o.ptr, ptrType: o.ptrType, smartPtr: o.smartPtr, smartPtrType: o.smartPtrType }; }
-        function throwInstanceAlreadyDeleted(obj) { function getInstanceTypeName(handle) { return handle.$$.ptrType.registeredClass.name; } throwBindingError(getInstanceTypeName(obj) + " instance already deleted"); }
-        var finalizationRegistry = false;
-        function detachFinalizer(handle) { }
-        function runDestructor($$) { if ($$.smartPtr) {
-            $$.smartPtrType.rawDestructor($$.smartPtr);
-        }
-        else {
-            $$.ptrType.registeredClass.rawDestructor($$.ptr);
-        } }
-        function releaseClassHandle($$) { $$.count.value -= 1; var toDelete = 0 === $$.count.value; if (toDelete) {
-            runDestructor($$);
-        } }
-        function 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 registeredPointers = {};
-        function getInheritedInstanceCount() { return Object.keys(registeredInstances).length; }
-        function getLiveInheritedInstances() { var rv = []; for (var k in registeredInstances) {
-            if (registeredInstances.hasOwnProperty(k)) {
-                rv.push(registeredInstances[k]);
-            }
-        } return rv; }
-        var deletionQueue = [];
-        function flushPendingDeletes() { while (deletionQueue.length) {
-            var obj = deletionQueue.pop();
-            obj.$$.deleteScheduled = false;
-            obj["delete"]();
-        } }
-        var delayFunction = undefined;
-        function setDelayFunction(fn) { delayFunction = fn; if (deletionQueue.length && delayFunction) {
-            delayFunction(flushPendingDeletes);
-        } }
-        function init_embind() { Module["getInheritedInstanceCount"] = getInheritedInstanceCount; Module["getLiveInheritedInstances"] = getLiveInheritedInstances; Module["flushPendingDeletes"] = flushPendingDeletes; Module["setDelayFunction"] = setDelayFunction; }
-        var registeredInstances = {};
-        function getBasestPointer(class_, ptr) { if (ptr === undefined) {
-            throwBindingError("ptr should not be undefined");
-        } while (class_.baseClass) {
-            ptr = class_.upcast(ptr);
-            class_ = class_.baseClass;
-        } return ptr; }
-        function getInheritedInstance(class_, ptr) { ptr = getBasestPointer(class_, ptr); return registeredInstances[ptr]; }
-        function 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 } })); }
-        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: 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 });
-        } }
-        function attachFinalizer(handle) { if ("undefined" === typeof 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); }
-        function ClassHandle_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;
-        } }
-        function ClassHandle_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;
-        } }
-        function ClassHandle_isDeleted() { return !this.$$.ptr; }
-        function ClassHandle_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; }
-        function init_ClassHandle() { ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf; ClassHandle.prototype["clone"] = ClassHandle_clone; ClassHandle.prototype["delete"] = ClassHandle_delete; ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted; ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater; }
-        function ClassHandle() { }
-        function ensureOverloadTable(proto, methodName, humanName) { if (undefined === proto[methodName].overloadTable) {
-            var prevFunc = proto[methodName];
-            proto[methodName] = function () { if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
-                throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
-            } return proto[methodName].overloadTable[arguments.length].apply(this, arguments); };
-            proto[methodName].overloadTable = [];
-            proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
-        } }
-        function 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.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;
-            if (undefined !== numArguments) {
-                Module[name].numArguments = numArguments;
-            }
-        } }
-        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 = []; }
-        function 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; }
-        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.$$) {
-            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(function () { 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 simpleReadValueFromPointer(pointer) { return this["fromWireType"](HEAP32[pointer >> 2]); }
-        function RegisteredPointer_getPointee(ptr) { if (this.rawGetPointee) {
-            ptr = this.rawGetPointee(ptr);
-        } return ptr; }
-        function RegisteredPointer_destructor(ptr) { if (this.rawDestructor) {
-            this.rawDestructor(ptr);
-        } }
-        function RegisteredPointer_deleteObject(handle) { if (handle !== null) {
-            handle["delete"]();
-        } }
-        function init_RegisteredPointer() { RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; RegisteredPointer.prototype["argPackAdvance"] = 8; RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer; RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject; RegisteredPointer.prototype["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;
-        } }
-        function replacePublicSymbol(name, value, numArguments) { if (!Module.hasOwnProperty(name)) {
-            throwInternalError("Replacing nonexistant public symbol");
-        } if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
-            Module[name].overloadTable[numArguments] = value;
-        }
-        else {
-            Module[name] = value;
-            Module[name].argCount = numArguments;
-        } }
-        function dynCallLegacy(sig, ptr, args) { var f = Module["dynCall_" + sig]; return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); }
-        var wasmTableMirror = [];
-        function getWasmTableEntry(funcPtr) { var func = wasmTableMirror[funcPtr]; if (!func) {
-            if (funcPtr >= wasmTableMirror.length)
-                wasmTableMirror.length = funcPtr + 1;
-            wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
-        } return func; }
-        function dynCall(sig, ptr, args) { if (sig.includes("j")) {
-            return dynCallLegacy(sig, ptr, args);
-        } var rtn = getWasmTableEntry(ptr).apply(null, args); return rtn; }
-        function getDynCaller(sig, ptr) { var argCache = []; return function () { argCache.length = 0; Object.assign(argCache, arguments); return dynCall(sig, ptr, argCache); }; }
-        function embind__requireFunction(signature, rawFunction) { signature = readLatin1String(signature); function makeDynCaller() { if (signature.includes("j")) {
-            return getDynCaller(signature, rawFunction);
-        } return getWasmTableEntry(rawFunction); } var fp = makeDynCaller(); if (typeof fp != "function") {
-            throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
-        } return fp; }
-        var UnboundTypeError = undefined;
-        function getTypeName(type) { var ptr = ___getTypeName(type); var rv = readLatin1String(ptr); _free(ptr); return rv; }
-        function 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([", "])); }
-        function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) { name = readLatin1String(name); getActualType = embind__requireFunction(getActualTypeSignature, getActualType); if (upcast) {
-            upcast = embind__requireFunction(upcastSignature, upcast);
-        } if (downcast) {
-            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] : [], function (base) { base = base[0]; var baseClass; var basePrototype; if (baseClassRawType) {
-            baseClass = base.registeredClass;
-            basePrototype = baseClass.instancePrototype;
-        }
-        else {
-            basePrototype = ClassHandle.prototype;
-        } var constructor = createNamedFunction(legalFunctionName, function () { 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[arguments.length]; if (undefined === body) {
-            throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!");
-        } return body.apply(this, arguments); }); var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } }); constructor.prototype = instancePrototype; var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast); 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]; }); }
-        function heap32VectorToArray(count, firstElement) { var array = []; for (var i = 0; i < count; i++) {
-            array.push(HEAPU32[firstElement + i * 4 >> 2]);
-        } return array; }
-        function runDestructors(destructors) { while (destructors.length) {
-            var ptr = destructors.pop();
-            var del = destructors.pop();
-            del(ptr);
-        } }
-        function new_(constructor, argumentList) { if (!(constructor instanceof Function)) {
-            throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function");
-        } var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function () { }); dummy.prototype = constructor.prototype; var obj = new dummy; var r = constructor.apply(obj, argumentList); return r instanceof Object ? r : obj; }
-        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 = false; for (var i = 1; i < argTypes.length; ++i) {
-            if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
-                needsDestructorStack = true;
-                break;
-            }
-        } var returns = argTypes[0].name !== "void"; var argsList = ""; var argsListWired = ""; for (var i = 0; i < argCount - 2; ++i) {
-            argsList += (i !== 0 ? ", " : "") + "arg" + i;
-            argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
-        } var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n"; if (needsDestructorStack) {
-            invokerFnBody += "var destructors = [];\n";
-        } var dtorStack = needsDestructorStack ? "destructors" : "null"; var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"]; var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; if (isClassMethodFunc) {
-            invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
-        } for (var i = 0; i < argCount - 2; ++i) {
-            invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
-            args1.push("argType" + i);
-            args2.push(argTypes[i + 2]);
-        } if (isClassMethodFunc) {
-            argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
-        } invokerFnBody += (returns || isAsync ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + 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 + "); // " + argTypes[i].name + "\n";
-                    args1.push(paramName + "_dtor");
-                    args2.push(argTypes[i].destructorFunction);
-                }
-            }
-        } if (returns) {
-            invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n";
-        }
-        else { } invokerFnBody += "}\n"; args1.push(invokerFnBody); var invokerFunction = new_(Function, args1).apply(null, args2); return invokerFunction; }
-        function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) { assert(argCount > 0); var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); invoker = embind__requireFunction(invokerSignature, invoker); whenDependentTypesAreResolved([], [rawClassType], function (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, function (argTypes) { argTypes.splice(1, 0, null); classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); return []; }); return []; }); }
-        function 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); }
-        function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { fieldName = readLatin1String(fieldName); getter = embind__requireFunction(getterSignature, getter); whenDependentTypesAreResolved([], [classType], function (classType) { classType = classType[0]; var humanName = classType.name + "." + fieldName; var desc = { get: function () { 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], function (types) { var getterReturnType = types[0]; var desc = { get: function () { 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_free_list = [];
-        var emval_handle_array = [{}, { value: undefined }, { value: null }, { value: true }, { value: false }];
-        function __emval_decref(handle) { if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
-            emval_handle_array[handle] = undefined;
-            emval_free_list.push(handle);
-        } }
-        function count_emval_handles() { var count = 0; for (var i = 5; i < emval_handle_array.length; ++i) {
-            if (emval_handle_array[i] !== undefined) {
-                ++count;
-            }
-        } return count; }
-        function get_first_emval() { for (var i = 5; i < emval_handle_array.length; ++i) {
-            if (emval_handle_array[i] !== undefined) {
-                return emval_handle_array[i];
-            }
-        } return null; }
-        function init_emval() { Module["count_emval_handles"] = count_emval_handles; Module["get_first_emval"] = get_first_emval; }
-        var Emval = { toValue: handle => { if (!handle) {
-                throwBindingError("Cannot use deleted val. handle = " + handle);
-            } return emval_handle_array[handle].value; }, toHandle: value => { switch (value) {
-                case undefined: return 1;
-                case null: return 2;
-                case true: return 3;
-                case false: return 4;
-                default: {
-                    var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
-                    emval_handle_array[handle] = { refcount: 1, value: value };
-                    return handle;
-                }
-            } } };
-        function __embind_register_emval(rawType, name) { name = readLatin1String(name); registerType(rawType, { name: name, "fromWireType": function (handle) { var rv = Emval.toValue(handle); __emval_decref(handle); return rv; }, "toWireType": function (destructors, value) { return Emval.toHandle(value); }, "argPackAdvance": 8, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: null }); }
-        function 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 floatReadValueFromPointer(name, shift) { switch (shift) {
-            case 2: return function (pointer) { return this["fromWireType"](HEAPF32[pointer >> 2]); };
-            case 3: return function (pointer) { return this["fromWireType"](HEAPF64[pointer >> 3]); };
-            default: throw new TypeError("Unknown float type: " + name);
-        } }
-        function __embind_register_float(rawType, name, size) { var shift = getShiftFromSize(size); name = readLatin1String(name); registerType(rawType, { name: name, "fromWireType": function (value) { return value; }, "toWireType": function (destructors, value) { return value; }, "argPackAdvance": 8, "readValueFromPointer": floatReadValueFromPointer(name, shift), destructorFunction: null }); }
-        function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) { var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); name = readLatin1String(name); rawInvoker = embind__requireFunction(signature, rawInvoker); exposePublicSymbol(name, function () { throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes); }, argCount - 1); whenDependentTypesAreResolved([], argTypes, function (argTypes) { var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1); return []; }); }
-        function integerReadValueFromPointer(name, shift, signed) { switch (shift) {
-            case 0: return signed ? function readS8FromPointer(pointer) { return HEAP8[pointer]; } : function readU8FromPointer(pointer) { return HEAPU8[pointer]; };
-            case 1: return signed ? function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; };
-            case 2: return signed ? function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; };
-            default: throw new TypeError("Unknown integer type: " + name);
-        } }
-        function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { name = readLatin1String(name); if (maxRange === -1) {
-            maxRange = 4294967295;
-        } var shift = getShiftFromSize(size); var fromWireType = value => value; if (minRange === 0) {
-            var bitshift = 32 - 8 * size;
-            fromWireType = value => value << bitshift >>> bitshift;
-        } var isUnsignedType = name.includes("unsigned"); var checkAssertions = (value, toTypeName) => { }; var toWireType; if (isUnsignedType) {
-            toWireType = function (destructors, value) { checkAssertions(value, this.name); return value >>> 0; };
-        }
-        else {
-            toWireType = function (destructors, value) { checkAssertions(value, this.name); return value; };
-        } registerType(primitiveType, { name: name, "fromWireType": fromWireType, "toWireType": toWireType, "argPackAdvance": 8, "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0), destructorFunction: null }); }
-        function __embind_register_memory_view(rawType, dataTypeIndex, name) { var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]; var TA = typeMapping[dataTypeIndex]; function decodeMemoryView(handle) { handle = handle >> 2; var heap = HEAPU32; var size = heap[handle]; var data = heap[handle + 1]; return new TA(heap.buffer, data, size); } name = readLatin1String(name); registerType(rawType, { name: name, "fromWireType": decodeMemoryView, "argPackAdvance": 8, "readValueFromPointer": decodeMemoryView }, { ignoreDuplicateRegistrations: true }); }
-        function __embind_register_std_string(rawType, name) { name = readLatin1String(name); var stdStringIsUTF8 = name === "std::string"; registerType(rawType, { name: name, "fromWireType": function (value) { var length = HEAPU32[value >> 2]; var payload = value + 4; var str; if (stdStringIsUTF8) {
-                var decodeStartPtr = payload;
-                for (var i = 0; i <= length; ++i) {
-                    var currentBytePtr = payload + i;
-                    if (i == length || HEAPU8[currentBytePtr] == 0) {
-                        var maxRead = currentBytePtr - decodeStartPtr;
-                        var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
-                        if (str === undefined) {
-                            str = stringSegment;
-                        }
-                        else {
-                            str += String.fromCharCode(0);
-                            str += stringSegment;
-                        }
-                        decodeStartPtr = currentBytePtr + 1;
-                    }
-                }
-            }
-            else {
-                var a = new Array(length);
-                for (var i = 0; i < length; ++i) {
-                    a[i] = String.fromCharCode(HEAPU8[payload + i]);
-                }
-                str = a.join("");
-            } _free(value); return str; }, "toWireType": function (destructors, value) { if (value instanceof ArrayBuffer) {
-                value = new Uint8Array(value);
-            } var length; var valueIsOfTypeString = typeof value == "string"; if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
-                throwBindingError("Cannot pass non-string to std::string");
-            } if (stdStringIsUTF8 && valueIsOfTypeString) {
-                length = lengthBytesUTF8(value);
-            }
-            else {
-                length = value.length;
-            } var base = _malloc(4 + length + 1); var ptr = base + 4; HEAPU32[base >> 2] = length; if (stdStringIsUTF8 && valueIsOfTypeString) {
-                stringToUTF8(value, ptr, length + 1);
-            }
-            else {
-                if (valueIsOfTypeString) {
-                    for (var i = 0; i < length; ++i) {
-                        var charCode = value.charCodeAt(i);
-                        if (charCode > 255) {
-                            _free(ptr);
-                            throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
-                        }
-                        HEAPU8[ptr + i] = charCode;
-                    }
-                }
-                else {
-                    for (var i = 0; i < length; ++i) {
-                        HEAPU8[ptr + i] = value[i];
-                    }
-                }
-            } if (destructors !== null) {
-                destructors.push(_free, base);
-            } return base; }, "argPackAdvance": 8, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: function (ptr) { _free(ptr); } }); }
-        var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;
-        function UTF16ToString(ptr, maxBytesToRead) { var endPtr = ptr; var idx = endPtr >> 1; var maxIdx = idx + maxBytesToRead / 2; while (!(idx >= maxIdx) && HEAPU16[idx])
-            ++idx; endPtr = idx << 1; if (endPtr - ptr > 32 && UTF16Decoder)
-            return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); var str = ""; for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
-            var codeUnit = HEAP16[ptr + i * 2 >> 1];
-            if (codeUnit == 0)
-                break;
-            str += String.fromCharCode(codeUnit);
-        } return str; }
-        function stringToUTF16(str, outPtr, maxBytesToWrite) { if (maxBytesToWrite === undefined) {
-            maxBytesToWrite = 2147483647;
-        } if (maxBytesToWrite < 2)
-            return 0; maxBytesToWrite -= 2; var startPtr = outPtr; var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; for (var i = 0; i < numCharsToWrite; ++i) {
-            var codeUnit = str.charCodeAt(i);
-            HEAP16[outPtr >> 1] = codeUnit;
-            outPtr += 2;
-        } HEAP16[outPtr >> 1] = 0; return outPtr - startPtr; }
-        function lengthBytesUTF16(str) { return str.length * 2; }
-        function UTF32ToString(ptr, maxBytesToRead) { var i = 0; var str = ""; while (!(i >= maxBytesToRead / 4)) {
-            var utf32 = HEAP32[ptr + i * 4 >> 2];
-            if (utf32 == 0)
-                break;
-            ++i;
-            if (utf32 >= 65536) {
-                var ch = utf32 - 65536;
-                str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
-            }
-            else {
-                str += String.fromCharCode(utf32);
-            }
-        } return str; }
-        function stringToUTF32(str, outPtr, maxBytesToWrite) { if (maxBytesToWrite === undefined) {
-            maxBytesToWrite = 2147483647;
-        } if (maxBytesToWrite < 4)
-            return 0; var startPtr = outPtr; var endPtr = startPtr + maxBytesToWrite - 4; for (var i = 0; i < str.length; ++i) {
-            var codeUnit = str.charCodeAt(i);
-            if (codeUnit >= 55296 && codeUnit <= 57343) {
-                var trailSurrogate = str.charCodeAt(++i);
-                codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
-            }
-            HEAP32[outPtr >> 2] = codeUnit;
-            outPtr += 4;
-            if (outPtr + 4 > endPtr)
-                break;
-        } HEAP32[outPtr >> 2] = 0; return outPtr - startPtr; }
-        function lengthBytesUTF32(str) { var len = 0; for (var i = 0; i < str.length; ++i) {
-            var codeUnit = str.charCodeAt(i);
-            if (codeUnit >= 55296 && codeUnit <= 57343)
-                ++i;
-            len += 4;
-        } return len; }
-        function __embind_register_std_wstring(rawType, charSize, name) { name = readLatin1String(name); var decodeString, encodeString, getHeap, lengthBytesUTF, shift; if (charSize === 2) {
-            decodeString = UTF16ToString;
-            encodeString = stringToUTF16;
-            lengthBytesUTF = lengthBytesUTF16;
-            getHeap = () => HEAPU16;
-            shift = 1;
-        }
-        else if (charSize === 4) {
-            decodeString = UTF32ToString;
-            encodeString = stringToUTF32;
-            lengthBytesUTF = lengthBytesUTF32;
-            getHeap = () => HEAPU32;
-            shift = 2;
-        } registerType(rawType, { name: name, "fromWireType": function (value) { var length = HEAPU32[value >> 2]; var HEAP = getHeap(); var str; var decodeStartPtr = value + 4; for (var i = 0; i <= length; ++i) {
-                var currentBytePtr = value + 4 + i * charSize;
-                if (i == length || HEAP[currentBytePtr >> shift] == 0) {
-                    var maxReadBytes = currentBytePtr - decodeStartPtr;
-                    var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
-                    if (str === undefined) {
-                        str = stringSegment;
-                    }
-                    else {
-                        str += String.fromCharCode(0);
-                        str += stringSegment;
-                    }
-                    decodeStartPtr = currentBytePtr + charSize;
-                }
-            } _free(value); return str; }, "toWireType": function (destructors, value) { if (!(typeof value == "string")) {
-                throwBindingError("Cannot pass non-string to C++ string type " + name);
-            } var length = lengthBytesUTF(value); var ptr = _malloc(4 + length + charSize); HEAPU32[ptr >> 2] = length >> shift; encodeString(value, ptr + 4, length + charSize); if (destructors !== null) {
-                destructors.push(_free, ptr);
-            } return ptr; }, "argPackAdvance": 8, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: function (ptr) { _free(ptr); } }); }
-        function __embind_register_void(rawType, name) { name = readLatin1String(name); registerType(rawType, { isVoid: true, name: name, "argPackAdvance": 0, "fromWireType": function () { return undefined; }, "toWireType": function (destructors, o) { return undefined; } }); }
-        function _abort() { abort(""); }
-        function _emscripten_memcpy_big(dest, src, num) { HEAPU8.copyWithin(dest, src, src + num); }
-        function abortOnCannotGrowMemory(requestedSize) { abort("OOM"); }
-        function _emscripten_resize_heap(requestedSize) { var oldSize = HEAPU8.length; requestedSize = requestedSize >>> 0; abortOnCannotGrowMemory(requestedSize); }
-        var ENV = {};
-        function getExecutableName() { return thisProgram || "./this.program"; }
-        function getEnvStrings() { if (!getEnvStrings.strings) {
-            var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
-            var env = { "USER": "web_user", "LOGNAME": "web_user", "PATH": "/", "PWD": "/", "HOME": "/home/web_user", "LANG": lang, "_": getExecutableName() };
-            for (var x in ENV) {
-                if (ENV[x] === undefined)
-                    delete env[x];
-                else
-                    env[x] = ENV[x];
-            }
-            var strings = [];
-            for (var x in env) {
-                strings.push(x + "=" + env[x]);
-            }
-            getEnvStrings.strings = strings;
-        } return getEnvStrings.strings; }
-        function writeAsciiToMemory(str, buffer, dontAddNull) { for (var i = 0; i < str.length; ++i) {
-            HEAP8[buffer++ >> 0] = str.charCodeAt(i);
-        } if (!dontAddNull)
-            HEAP8[buffer >> 0] = 0; }
-        var SYSCALLS = { varargs: undefined, get: function () { SYSCALLS.varargs += 4; var ret = HEAP32[SYSCALLS.varargs - 4 >> 2]; return ret; }, getStr: function (ptr) { var ret = UTF8ToString(ptr); return ret; } };
-        function _environ_get(__environ, environ_buf) { var bufSize = 0; getEnvStrings().forEach(function (string, i) { var ptr = environ_buf + bufSize; HEAPU32[__environ + i * 4 >> 2] = ptr; writeAsciiToMemory(string, ptr); bufSize += string.length + 1; }); return 0; }
-        function _environ_sizes_get(penviron_count, penviron_buf_size) { var strings = getEnvStrings(); HEAPU32[penviron_count >> 2] = strings.length; var bufSize = 0; strings.forEach(function (string) { bufSize += string.length + 1; }); HEAPU32[penviron_buf_size >> 2] = bufSize; return 0; }
-        function __isLeapYear(year) { return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); }
-        function __arraySum(array, index) { var sum = 0; for (var i = 0; i <= index; sum += array[i++]) { } return sum; }
-        var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        function __addDays(date, days) { var newDate = new Date(date.getTime()); while (days > 0) {
-            var leap = __isLeapYear(newDate.getFullYear());
-            var currentMonth = newDate.getMonth();
-            var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
-            if (days > daysInCurrentMonth - newDate.getDate()) {
-                days -= daysInCurrentMonth - newDate.getDate() + 1;
-                newDate.setDate(1);
-                if (currentMonth < 11) {
-                    newDate.setMonth(currentMonth + 1);
-                }
-                else {
-                    newDate.setMonth(0);
-                    newDate.setFullYear(newDate.getFullYear() + 1);
-                }
-            }
-            else {
-                newDate.setDate(newDate.getDate() + days);
-                return newDate;
-            }
-        } return newDate; }
-        function intArrayFromString(stringy, dontAddNull, length) { var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; var u8array = new Array(len); var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); if (dontAddNull)
-            u8array.length = numBytesWritten; return u8array; }
-        function writeArrayToMemory(array, buffer) { HEAP8.set(array, buffer); }
-        function _strftime(s, maxsize, format, tm) { var tm_zone = HEAP32[tm + 40 >> 2]; var date = { tm_sec: HEAP32[tm >> 2], tm_min: HEAP32[tm + 4 >> 2], tm_hour: HEAP32[tm + 8 >> 2], tm_mday: HEAP32[tm + 12 >> 2], tm_mon: HEAP32[tm + 16 >> 2], tm_year: HEAP32[tm + 20 >> 2], tm_wday: HEAP32[tm + 24 >> 2], tm_yday: HEAP32[tm + 28 >> 2], tm_isdst: HEAP32[tm + 32 >> 2], tm_gmtoff: HEAP32[tm + 36 >> 2], tm_zone: tm_zone ? UTF8ToString(tm_zone) : "" }; var pattern = UTF8ToString(format); var EXPANSION_RULES_1 = { "%c": "%a %b %d %H:%M:%S %Y", "%D": "%m/%d/%y", "%F": "%Y-%m-%d", "%h": "%b", "%r": "%I:%M:%S %p", "%R": "%H:%M", "%T": "%H:%M:%S", "%x": "%m/%d/%y", "%X": "%H:%M:%S", "%Ec": "%c", "%EC": "%C", "%Ex": "%m/%d/%y", "%EX": "%H:%M:%S", "%Ey": "%y", "%EY": "%Y", "%Od": "%d", "%Oe": "%e", "%OH": "%H", "%OI": "%I", "%Om": "%m", "%OM": "%M", "%OS": "%S", "%Ou": "%u", "%OU": "%U", "%OV": "%V", "%Ow": "%w", "%OW": "%W", "%Oy": "%y" }; for (var rule in EXPANSION_RULES_1) {
-            pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
-        } var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]; function leadingSomething(value, digits, character) { var str = typeof value == "number" ? value.toString() : value || ""; while (str.length < digits) {
-            str = character[0] + str;
-        } return str; } function leadingNulls(value, digits) { return leadingSomething(value, digits, "0"); } function compareByDay(date1, date2) { function sgn(value) { return value < 0 ? -1 : value > 0 ? 1 : 0; } var compare; if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
-            if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
-                compare = sgn(date1.getDate() - date2.getDate());
-            }
-        } return compare; } function getFirstWeekStartDate(janFourth) { switch (janFourth.getDay()) {
-            case 0: return new Date(janFourth.getFullYear() - 1, 11, 29);
-            case 1: return janFourth;
-            case 2: return new Date(janFourth.getFullYear(), 0, 3);
-            case 3: return new Date(janFourth.getFullYear(), 0, 2);
-            case 4: return new Date(janFourth.getFullYear(), 0, 1);
-            case 5: return new Date(janFourth.getFullYear() - 1, 11, 31);
-            case 6: return new Date(janFourth.getFullYear() - 1, 11, 30);
-        } } function getWeekBasedYear(date) { var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
-            if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
-                return thisDate.getFullYear() + 1;
-            }
-            return thisDate.getFullYear();
-        } return thisDate.getFullYear() - 1; } var EXPANSION_RULES_2 = { "%a": function (date) { return WEEKDAYS[date.tm_wday].substring(0, 3); }, "%A": function (date) { return WEEKDAYS[date.tm_wday]; }, "%b": function (date) { return MONTHS[date.tm_mon].substring(0, 3); }, "%B": function (date) { return MONTHS[date.tm_mon]; }, "%C": function (date) { var year = date.tm_year + 1900; return leadingNulls(year / 100 | 0, 2); }, "%d": function (date) { return leadingNulls(date.tm_mday, 2); }, "%e": function (date) { return leadingSomething(date.tm_mday, 2, " "); }, "%g": function (date) { return getWeekBasedYear(date).toString().substring(2); }, "%G": function (date) { return getWeekBasedYear(date); }, "%H": function (date) { return leadingNulls(date.tm_hour, 2); }, "%I": function (date) { var twelveHour = date.tm_hour; if (twelveHour == 0)
-                twelveHour = 12;
-            else if (twelveHour > 12)
-                twelveHour -= 12; return leadingNulls(twelveHour, 2); }, "%j": function (date) { return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3); }, "%m": function (date) { return leadingNulls(date.tm_mon + 1, 2); }, "%M": function (date) { return leadingNulls(date.tm_min, 2); }, "%n": function () { return "\n"; }, "%p": function (date) { if (date.tm_hour >= 0 && date.tm_hour < 12) {
-                return "AM";
-            } return "PM"; }, "%S": function (date) { return leadingNulls(date.tm_sec, 2); }, "%t": function () { return "\t"; }, "%u": function (date) { return date.tm_wday || 7; }, "%U": function (date) { var days = date.tm_yday + 7 - date.tm_wday; return leadingNulls(Math.floor(days / 7), 2); }, "%V": function (date) { var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7) / 7); if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
-                val++;
-            } if (!val) {
-                val = 52;
-                var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
-                if (dec31 == 4 || dec31 == 5 && __isLeapYear(date.tm_year % 400 - 1)) {
-                    val++;
-                }
-            }
-            else if (val == 53) {
-                var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
-                if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year)))
-                    val = 1;
-            } return leadingNulls(val, 2); }, "%w": function (date) { return date.tm_wday; }, "%W": function (date) { var days = date.tm_yday + 7 - (date.tm_wday + 6) % 7; return leadingNulls(Math.floor(days / 7), 2); }, "%y": function (date) { return (date.tm_year + 1900).toString().substring(2); }, "%Y": function (date) { return date.tm_year + 1900; }, "%z": function (date) { var off = date.tm_gmtoff; var ahead = off >= 0; off = Math.abs(off) / 60; off = off / 60 * 100 + off % 60; return (ahead ? "+" : "-") + String("0000" + off).slice(-4); }, "%Z": function (date) { return date.tm_zone; }, "%%": function () { return "%"; } }; pattern = pattern.replace(/%%/g, "\0\0"); for (var rule in EXPANSION_RULES_2) {
-            if (pattern.includes(rule)) {
-                pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
-            }
-        } pattern = pattern.replace(/\0\0/g, "%"); var bytes = intArrayFromString(pattern, false); if (bytes.length > maxsize) {
-            return 0;
-        } writeArrayToMemory(bytes, s); return bytes.length - 1; }
-        function _strftime_l(s, maxsize, format, tm, loc) { return _strftime(s, maxsize, format, tm); }
-        embind_init_charCodes();
-        BindingError = Module["BindingError"] = extendError(Error, "BindingError");
-        InternalError = Module["InternalError"] = extendError(Error, "InternalError");
-        init_ClassHandle();
-        init_embind();
-        init_RegisteredPointer();
-        UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
-        init_emval();
-        var wasmImports = { "__assert_fail": ___assert_fail, "_embind_register_bigint": __embind_register_bigint, "_embind_register_bool": __embind_register_bool, "_embind_register_class": __embind_register_class, "_embind_register_class_constructor": __embind_register_class_constructor, "_embind_register_class_property": __embind_register_class_property, "_embind_register_emval": __embind_register_emval, "_embind_register_float": __embind_register_float, "_embind_register_function": __embind_register_function, "_embind_register_integer": __embind_register_integer, "_embind_register_memory_view": __embind_register_memory_view, "_embind_register_std_string": __embind_register_std_string, "_embind_register_std_wstring": __embind_register_std_wstring, "_embind_register_void": __embind_register_void, "abort": _abort, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "strftime_l": _strftime_l, "wasm_loadfileproc": wasm_loadfileproc, "wasm_msgproc": wasm_msgproc };
-        var asm = createWasm();
-        var ___wasm_call_ctors = function () { return (___wasm_call_ctors = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments); };
-        var _kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = function () { return (_kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = Module["asm"]["kmcmp_CompileKeyboard"]).apply(null, arguments); };
-        var _kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = function () { return (_kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = Module["asm"]["kmcmp_parseUnicodeSet"]).apply(null, arguments); };
-        var _malloc = function () { return (_malloc = Module["asm"]["malloc"]).apply(null, arguments); };
-        var _free = function () { return (_free = Module["asm"]["free"]).apply(null, arguments); };
-        var ___getTypeName = Module["___getTypeName"] = function () { return (___getTypeName = Module["___getTypeName"] = Module["asm"]["__getTypeName"]).apply(null, arguments); };
-        var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = function () { return (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = Module["asm"]["_embind_initialize_bindings"]).apply(null, arguments); };
-        var ___errno_location = function () { return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments); };
-        var ___trap = function () { return (___trap = Module["asm"]["__trap"]).apply(null, arguments); };
-        var stackSave = function () { return (stackSave = Module["asm"]["stackSave"]).apply(null, arguments); };
-        var stackRestore = function () { return (stackRestore = Module["asm"]["stackRestore"]).apply(null, arguments); };
-        var stackAlloc = function () { return (stackAlloc = Module["asm"]["stackAlloc"]).apply(null, arguments); };
-        var dynCall_viijii = Module["dynCall_viijii"] = function () { return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["dynCall_viijii"]).apply(null, arguments); };
-        var dynCall_iiiiij = Module["dynCall_iiiiij"] = function () { return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["dynCall_iiiiij"]).apply(null, arguments); };
-        var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function () { return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments); };
-        var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function () { return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments); };
-        var ___start_em_js = Module["___start_em_js"] = 58144;
-        var ___stop_em_js = Module["___stop_em_js"] = 58840;
-        Module["UTF8ToString"] = UTF8ToString;
-        var calledRun;
-        dependenciesFulfilled = function runCaller() { if (!calledRun)
-            run(); if (!calledRun)
-            dependenciesFulfilled = runCaller; };
-        function run() { if (runDependencies > 0) {
-            return;
-        } preRun(); if (runDependencies > 0) {
-            return;
-        } function doRun() { if (calledRun)
-            return; calledRun = true; Module["calledRun"] = true; if (ABORT)
-            return; initRuntime(); readyPromiseResolve(Module); if (Module["onRuntimeInitialized"])
-            Module["onRuntimeInitialized"](); postRun(); } if (Module["setStatus"]) {
-            Module["setStatus"]("Running...");
-            setTimeout(function () { setTimeout(function () { Module["setStatus"](""); }, 1); doRun(); }, 1);
-        }
-        else {
-            doRun();
-        } }
-        if (Module["preInit"]) {
-            if (typeof Module["preInit"] == "function")
-                Module["preInit"] = [Module["preInit"]];
-            while (Module["preInit"].length > 0) {
-                Module["preInit"].pop()();
-            }
-        }
-        run();
-        return Module.ready;
-    });
-})();
-export default Module;
-//# sourceMappingURL=wasm-host.js.map
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e74e4a68-a330-5169-afb5-9cc31699f8ce")}catch(e){}}();
+var Module = (() => {
+    var _scriptDir = import.meta.url;
+    return (async function (Module = {}) {
+        // include: shell.js
+        // The Module object: Our interface to the outside world. We import
+        // and export values on it. There are various ways Module can be used:
+        // 1. Not defined. We create it here
+        // 2. A function parameter, function(Module) { ..generated code.. }
+        // 3. pre-run appended it, var Module = {}; ..generated code..
+        // 4. External script tag defines var Module.
+        // We need to check if Module already exists (e.g. case 3 above).
+        // Substitution will be replaced with actual code on later stage of the build,
+        // this way Closure Compiler will not mangle it (e.g. case 4. above).
+        // Note that if you want to run closure, and also to use Module
+        // after the generated code, you will need to define   var Module = {};
+        // before the code. Then that object will be used in the code, and you
+        // can continue to use Module afterwards as well.
+        var Module = typeof Module != 'undefined' ? Module : {};
+        // Set up the promise that indicates the Module is initialized
+        var readyPromiseResolve, readyPromiseReject;
+        Module['ready'] = new Promise(function (resolve, reject) {
+            readyPromiseResolve = resolve;
+            readyPromiseReject = reject;
+        });
+        // --pre-jses are emitted after the Module integration code, so that they can
+        // refer to Module (if they choose; they can also define Module)
+        // Sometimes an existing Module object exists with properties
+        // meant to overwrite the default module functionality. Here
+        // we collect those properties and reapply _after_ we configure
+        // the current environment's defaults to avoid having to be so
+        // defensive during initialization.
+        var moduleOverrides = Object.assign({}, Module);
+        var arguments_ = [];
+        var thisProgram = './this.program';
+        var quit_ = (status, toThrow) => {
+            throw toThrow;
+        };
+        // Determine the runtime environment we are in. You can customize this by
+        // setting the ENVIRONMENT setting at compile time (see settings.js).
+        // Attempt to auto-detect the environment
+        var ENVIRONMENT_IS_WEB = typeof window == 'object';
+        var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
+        // N.b. Electron.js environment is simultaneously a NODE-environment, but
+        // also a web environment.
+        var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
+        var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+        // `/` should be present at the end if `scriptDirectory` is not empty
+        var scriptDirectory = '';
+        function locateFile(path) {
+            if (Module['locateFile']) {
+                return Module['locateFile'](path, scriptDirectory);
+            }
+            return scriptDirectory + path;
+        }
+        // Hooks that are implemented differently in different runtime environments.
+        var read_, readAsync, readBinary, setWindowTitle;
+        if (ENVIRONMENT_IS_NODE) {
+            // `require()` is no-op in an ESM module, use `createRequire()` to construct
+            // the require()` function.  This is only necessary for multi-environment
+            // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
+            // TODO: Swap all `require()`'s with `import()`'s?
+            const { createRequire } = await import('module');
+            /** @suppress{duplicate} */
+            var require = createRequire(import.meta.url);
+            // These modules will usually be used on Node.js. Load them eagerly to avoid
+            // the complexity of lazy-loading.
+            var fs = require('fs');
+            var nodePath = require('path');
+            if (ENVIRONMENT_IS_WORKER) {
+                scriptDirectory = nodePath.dirname(scriptDirectory) + '/';
+            }
+            else {
+                // EXPORT_ES6 + ENVIRONMENT_IS_NODE always requires use of import.meta.url,
+                // since there's no way getting the current absolute path of the module when
+                // support for that is not available.
+                scriptDirectory = require('url').fileURLToPath(new URL('./', import.meta.url)); // includes trailing slash
+            }
+            // include: node_shell_read.js
+            read_ = (filename, binary) => {
+                // We need to re-wrap `file://` strings to URLs. Normalizing isn't
+                // necessary in that case, the path should already be absolute.
+                filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+                return fs.readFileSync(filename, binary ? undefined : 'utf8');
+            };
+            readBinary = (filename) => {
+                var ret = read_(filename, true);
+                if (!ret.buffer) {
+                    ret = new Uint8Array(ret);
+                }
+                return ret;
+            };
+            readAsync = (filename, onload, onerror) => {
+                // See the comment in the `read_` function.
+                filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+                fs.readFile(filename, function (err, data) {
+                    if (err)
+                        onerror(err);
+                    else
+                        onload(data.buffer);
+                });
+            };
+            // end include: node_shell_read.js
+            if (process.argv.length > 1) {
+                thisProgram = process.argv[1].replace(/\\/g, '/');
+            }
+            arguments_ = process.argv.slice(2);
+            // MODULARIZE will export the module in the proper place outside, we don't need to export here
+            process.on('uncaughtException', function (ex) {
+                // suppress ExitStatus exceptions from showing an error
+                if (ex !== 'unwind' && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
+                    throw ex;
+                }
+            });
+            // Without this older versions of node (< v15) will log unhandled rejections
+            // but return 0, which is not normally the desired behaviour.  This is
+            // not be needed with node v15 and about because it is now the default
+            // behaviour:
+            // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
+            var nodeMajor = process.versions.node.split(".")[0];
+            if (nodeMajor < 15) {
+                process.on('unhandledRejection', function (reason) { throw reason; });
+            }
+            quit_ = (status, toThrow) => {
+                process.exitCode = status;
+                throw toThrow;
+            };
+            Module['inspect'] = function () { return '[Emscripten Module object]'; };
+        }
+        else 
+        // Note that this includes Node.js workers when relevant (pthreads is enabled).
+        // Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
+        // ENVIRONMENT_IS_NODE.
+        if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+            if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
+                scriptDirectory = self.location.href;
+            }
+            else if (typeof document != 'undefined' && document.currentScript) { // web
+                scriptDirectory = document.currentScript.src;
+            }
+            // When MODULARIZE, this JS may be executed later, after document.currentScript
+            // is gone, so we saved it, and we use it here instead of any other info.
+            if (_scriptDir) {
+                scriptDirectory = _scriptDir;
+            }
+            // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
+            // otherwise, slice off the final part of the url to find the script directory.
+            // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
+            // and scriptDirectory will correctly be replaced with an empty string.
+            // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
+            // they are removed because they could contain a slash.
+            if (scriptDirectory.indexOf('blob:') !== 0) {
+                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/') + 1);
+            }
+            else {
+                scriptDirectory = '';
+            }
+            // Differentiate the Web Worker from the Node Worker case, as reading must
+            // be done differently.
+            {
+                // include: web_or_worker_shell_read.js
+                read_ = (url) => {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open('GET', url, false);
+                    xhr.send(null);
+                    return xhr.responseText;
+                };
+                if (ENVIRONMENT_IS_WORKER) {
+                    readBinary = (url) => {
+                        var xhr = new XMLHttpRequest();
+                        xhr.open('GET', url, false);
+                        xhr.responseType = 'arraybuffer';
+                        xhr.send(null);
+                        return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
+                    };
+                }
+                readAsync = (url, onload, onerror) => {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open('GET', url, true);
+                    xhr.responseType = 'arraybuffer';
+                    xhr.onload = () => {
+                        if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+                            onload(xhr.response);
+                            return;
+                        }
+                        onerror();
+                    };
+                    xhr.onerror = onerror;
+                    xhr.send(null);
+                };
+                // end include: web_or_worker_shell_read.js
+            }
+            setWindowTitle = (title) => document.title = title;
+        }
+        else {
+        }
+        var out = Module['print'] || console.log.bind(console);
+        var err = Module['printErr'] || console.warn.bind(console);
+        // Merge back in the overrides
+        Object.assign(Module, moduleOverrides);
+        // Free the object hierarchy contained in the overrides, this lets the GC
+        // reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
+        moduleOverrides = null;
+        // Emit code to handle expected values on the Module object. This applies Module.x
+        // to the proper local x. This has two benefits: first, we only emit it if it is
+        // expected to arrive, and second, by using a local everywhere else that can be
+        // minified.
+        if (Module['arguments'])
+            arguments_ = Module['arguments'];
+        if (Module['thisProgram'])
+            thisProgram = Module['thisProgram'];
+        if (Module['quit'])
+            quit_ = Module['quit'];
+        // perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
+        // end include: shell.js
+        // include: preamble.js
+        // === Preamble library stuff ===
+        // Documentation for the public APIs defined in this file must be updated in:
+        //    site/source/docs/api_reference/preamble.js.rst
+        // A prebuilt local version of the documentation is available at:
+        //    site/build/text/docs/api_reference/preamble.js.txt
+        // You can also build docs locally as HTML or other formats in site/
+        // An online HTML version (which may be of a different version of Emscripten)
+        //    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
+        var wasmBinary;
+        if (Module['wasmBinary'])
+            wasmBinary = Module['wasmBinary'];
+        var noExitRuntime = Module['noExitRuntime'] || true;
+        if (typeof WebAssembly != 'object') {
+            abort('no native wasm support detected');
+        }
+        // Wasm globals
+        var wasmMemory;
+        //========================================
+        // Runtime essentials
+        //========================================
+        // whether we are quitting the application. no code should run after this.
+        // set in exit() and abort()
+        var ABORT = false;
+        // set by exit() and abort().  Passed to 'onExit' handler.
+        // NOTE: This is also used as the process return code code in shell environments
+        // but only when noExitRuntime is false.
+        var EXITSTATUS;
+        /** @type {function(*, string=)} */
+        function assert(condition, text) {
+            if (!condition) {
+                // This build was created without ASSERTIONS defined.  `assert()` should not
+                // ever be called in this configuration but in case there are callers in
+                // the wild leave this simple abort() implemenation here for now.
+                abort(text);
+            }
+        }
+        // include: runtime_strings.js
+        // runtime_strings.js: String related runtime functions that are part of both
+        // MINIMAL_RUNTIME and regular runtime.
+        var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
+        /**
+         * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
+         * array that contains uint8 values, returns a copy of that string as a
+         * Javascript String object.
+         * heapOrArray is either a regular array, or a JavaScript typed array view.
+         * @param {number} idx
+         * @param {number=} maxBytesToRead
+         * @return {string}
+         */
+        function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+            var endIdx = idx + maxBytesToRead;
+            var endPtr = idx;
+            // TextDecoder needs to know the byte length in advance, it doesn't stop on
+            // null terminator by itself.  Also, use the length info to avoid running tiny
+            // strings through TextDecoder, since .subarray() allocates garbage.
+            // (As a tiny code save trick, compare endPtr against endIdx using a negation,
+            // so that undefined means Infinity)
+            while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+                ++endPtr;
+            if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+            }
+            var str = '';
+            // If building with TextDecoder, we have already computed the string length
+            // above, so test loop end condition against that
+            while (idx < endPtr) {
+                // For UTF8 byte structure, see:
+                // http://en.wikipedia.org/wiki/UTF-8#Description
+                // https://www.ietf.org/rfc/rfc2279.txt
+                // https://tools.ietf.org/html/rfc3629
+                var u0 = heapOrArray[idx++];
+                if (!(u0 & 0x80)) {
+                    str += String.fromCharCode(u0);
+                    continue;
+                }
+                var u1 = heapOrArray[idx++] & 63;
+                if ((u0 & 0xE0) == 0xC0) {
+                    str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                    continue;
+                }
+                var u2 = heapOrArray[idx++] & 63;
+                if ((u0 & 0xF0) == 0xE0) {
+                    u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+                }
+                else {
+                    u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+                }
+                if (u0 < 0x10000) {
+                    str += String.fromCharCode(u0);
+                }
+                else {
+                    var ch = u0 - 0x10000;
+                    str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+                }
+            }
+            return str;
+        }
+        /**
+         * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+         * emscripten HEAP, returns a copy of that string as a Javascript String object.
+         *
+         * @param {number} ptr
+         * @param {number=} maxBytesToRead - An optional length that specifies the
+         *   maximum number of bytes to read. You can omit this parameter to scan the
+         *   string until the first \0 byte. If maxBytesToRead is passed, and the string
+         *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+         *   string will cut short at that byte index (i.e. maxBytesToRead will not
+         *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+         *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+         *   JS JIT optimizations off, so it is worth to consider consistently using one
+         * @return {string}
+         */
+        function UTF8ToString(ptr, maxBytesToRead) {
+            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+        }
+        /**
+         * Copies the given Javascript String object 'str' to the given byte array at
+         * address 'outIdx', encoded in UTF8 form and null-terminated. The copy will
+         * require at most str.length*4+1 bytes of space in the HEAP.  Use the function
+         * lengthBytesUTF8 to compute the exact number of bytes (excluding null
+         * terminator) that this function will write.
+         *
+         * @param {string} str - The Javascript string to copy.
+         * @param {ArrayBufferView|Array<number>} heap - The array to copy to. Each
+         *                                               index in this array is assumed
+         *                                               to be one 8-byte element.
+         * @param {number} outIdx - The starting offset in the array to begin the copying.
+         * @param {number} maxBytesToWrite - The maximum number of bytes this function
+         *                                   can write to the array.  This count should
+         *                                   include the null terminator, i.e. if
+         *                                   maxBytesToWrite=1, only the null terminator
+         *                                   will be written and nothing else.
+         *                                   maxBytesToWrite=0 does not write any bytes
+         *                                   to the output, not even the null
+         *                                   terminator.
+         * @return {number} The number of bytes written, EXCLUDING the null terminator.
+         */
+        function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+            // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
+            // undefined and false each don't write out any bytes.
+            if (!(maxBytesToWrite > 0))
+                return 0;
+            var startIdx = outIdx;
+            var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
+            for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+                // unit, not a Unicode code point of the character! So decode
+                // UTF16->UTF32->UTF8.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
+                // and https://www.ietf.org/rfc/rfc2279.txt
+                // and https://tools.ietf.org/html/rfc3629
+                var u = str.charCodeAt(i); // possibly a lead surrogate
+                if (u >= 0xD800 && u <= 0xDFFF) {
+                    var u1 = str.charCodeAt(++i);
+                    u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
+                }
+                if (u <= 0x7F) {
+                    if (outIdx >= endIdx)
+                        break;
+                    heap[outIdx++] = u;
+                }
+                else if (u <= 0x7FF) {
+                    if (outIdx + 1 >= endIdx)
+                        break;
+                    heap[outIdx++] = 0xC0 | (u >> 6);
+                    heap[outIdx++] = 0x80 | (u & 63);
+                }
+                else if (u <= 0xFFFF) {
+                    if (outIdx + 2 >= endIdx)
+                        break;
+                    heap[outIdx++] = 0xE0 | (u >> 12);
+                    heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+                    heap[outIdx++] = 0x80 | (u & 63);
+                }
+                else {
+                    if (outIdx + 3 >= endIdx)
+                        break;
+                    heap[outIdx++] = 0xF0 | (u >> 18);
+                    heap[outIdx++] = 0x80 | ((u >> 12) & 63);
+                    heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+                    heap[outIdx++] = 0x80 | (u & 63);
+                }
+            }
+            // Null-terminate the pointer to the buffer.
+            heap[outIdx] = 0;
+            return outIdx - startIdx;
+        }
+        /**
+         * Copies the given Javascript String object 'str' to the emscripten HEAP at
+         * address 'outPtr', null-terminated and encoded in UTF8 form. The copy will
+         * require at most str.length*4+1 bytes of space in the HEAP.
+         * Use the function lengthBytesUTF8 to compute the exact number of bytes
+         * (excluding null terminator) that this function will write.
+         *
+         * @return {number} The number of bytes written, EXCLUDING the null terminator.
+         */
+        function stringToUTF8(str, outPtr, maxBytesToWrite) {
+            return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+        }
+        /**
+         * Returns the number of bytes the given Javascript string takes if encoded as a
+         * UTF8 byte array, EXCLUDING the null terminator byte.
+         *
+         * @param {string} str - JavaScript string to operator on
+         * @return {number} Length, in bytes, of the UTF8 encoded string.
+         */
+        function lengthBytesUTF8(str) {
+            var len = 0;
+            for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+                // unit, not a Unicode code point of the character! So decode
+                // UTF16->UTF32->UTF8.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                var c = str.charCodeAt(i); // possibly a lead surrogate
+                if (c <= 0x7F) {
+                    len++;
+                }
+                else if (c <= 0x7FF) {
+                    len += 2;
+                }
+                else if (c >= 0xD800 && c <= 0xDFFF) {
+                    len += 4;
+                    ++i;
+                }
+                else {
+                    len += 3;
+                }
+            }
+            return len;
+        }
+        // end include: runtime_strings.js
+        // Memory management
+        var HEAP, 
+        /** @type {!Int8Array} */
+        HEAP8, 
+        /** @type {!Uint8Array} */
+        HEAPU8, 
+        /** @type {!Int16Array} */
+        HEAP16, 
+        /** @type {!Uint16Array} */
+        HEAPU16, 
+        /** @type {!Int32Array} */
+        HEAP32, 
+        /** @type {!Uint32Array} */
+        HEAPU32, 
+        /** @type {!Float32Array} */
+        HEAPF32, 
+        /** @type {!Float64Array} */
+        HEAPF64;
+        function updateMemoryViews() {
+            var b = wasmMemory.buffer;
+            Module['HEAP8'] = HEAP8 = new Int8Array(b);
+            Module['HEAP16'] = HEAP16 = new Int16Array(b);
+            Module['HEAP32'] = HEAP32 = new Int32Array(b);
+            Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
+            Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
+            Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
+            Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
+            Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
+        }
+        // include: runtime_init_table.js
+        // In regular non-RELOCATABLE mode the table is exported
+        // from the wasm module and this will be assigned once
+        // the exports are available.
+        var wasmTable;
+        // end include: runtime_init_table.js
+        // include: runtime_stack_check.js
+        // end include: runtime_stack_check.js
+        // include: runtime_assertions.js
+        // end include: runtime_assertions.js
+        var __ATPRERUN__ = []; // functions called before the runtime is initialized
+        var __ATINIT__ = []; // functions called during startup
+        var __ATEXIT__ = []; // functions called during shutdown
+        var __ATPOSTRUN__ = []; // functions called after the main() is called
+        var runtimeInitialized = false;
+        var runtimeKeepaliveCounter = 0;
+        function keepRuntimeAlive() {
+            return noExitRuntime || runtimeKeepaliveCounter > 0;
+        }
+        function preRun() {
+            if (Module['preRun']) {
+                if (typeof Module['preRun'] == 'function')
+                    Module['preRun'] = [Module['preRun']];
+                while (Module['preRun'].length) {
+                    addOnPreRun(Module['preRun'].shift());
+                }
+            }
+            callRuntimeCallbacks(__ATPRERUN__);
+        }
+        function initRuntime() {
+            runtimeInitialized = true;
+            callRuntimeCallbacks(__ATINIT__);
+        }
+        function postRun() {
+            if (Module['postRun']) {
+                if (typeof Module['postRun'] == 'function')
+                    Module['postRun'] = [Module['postRun']];
+                while (Module['postRun'].length) {
+                    addOnPostRun(Module['postRun'].shift());
+                }
+            }
+            callRuntimeCallbacks(__ATPOSTRUN__);
+        }
+        function addOnPreRun(cb) {
+            __ATPRERUN__.unshift(cb);
+        }
+        function addOnInit(cb) {
+            __ATINIT__.unshift(cb);
+        }
+        function addOnExit(cb) {
+        }
+        function addOnPostRun(cb) {
+            __ATPOSTRUN__.unshift(cb);
+        }
+        // include: runtime_math.js
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
+        // end include: runtime_math.js
+        // A counter of dependencies for calling run(). If we need to
+        // do asynchronous work before running, increment this and
+        // decrement it. Incrementing must happen in a place like
+        // Module.preRun (used by emcc to add file preloading).
+        // Note that you can add dependencies in preRun, even though
+        // it happens right before run - run will be postponed until
+        // the dependencies are met.
+        var runDependencies = 0;
+        var runDependencyWatcher = null;
+        var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+        function getUniqueRunDependency(id) {
+            return id;
+        }
+        function addRunDependency(id) {
+            runDependencies++;
+            if (Module['monitorRunDependencies']) {
+                Module['monitorRunDependencies'](runDependencies);
+            }
+        }
+        function removeRunDependency(id) {
+            runDependencies--;
+            if (Module['monitorRunDependencies']) {
+                Module['monitorRunDependencies'](runDependencies);
+            }
+            if (runDependencies == 0) {
+                if (runDependencyWatcher !== null) {
+                    clearInterval(runDependencyWatcher);
+                    runDependencyWatcher = null;
+                }
+                if (dependenciesFulfilled) {
+                    var callback = dependenciesFulfilled;
+                    dependenciesFulfilled = null;
+                    callback(); // can add another dependenciesFulfilled
+                }
+            }
+        }
+        /** @param {string|number=} what */
+        function abort(what) {
+            if (Module['onAbort']) {
+                Module['onAbort'](what);
+            }
+            what = 'Aborted(' + what + ')';
+            // TODO(sbc): Should we remove printing and leave it up to whoever
+            // catches the exception?
+            err(what);
+            ABORT = true;
+            EXITSTATUS = 1;
+            what += '. Build with -sASSERTIONS for more info.';
+            // Use a wasm runtime error, because a JS error might be seen as a foreign
+            // exception, which means we'd run destructors on it. We need the error to
+            // simply make the program stop.
+            // FIXME This approach does not work in Wasm EH because it currently does not assume
+            // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
+            // a trap or not based on a hidden field within the object. So at the moment
+            // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
+            // allows this in the wasm spec.
+            // Suppress closure compiler warning here. Closure compiler's builtin extern
+            // defintion for WebAssembly.RuntimeError claims it takes no arguments even
+            // though it can.
+            // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
+            // See above, in the meantime, we resort to wasm code for trapping.
+            //
+            // In case abort() is called before the module is initialized, Module['asm']
+            // and its exported '__trap' function is not available, in which case we throw
+            // a RuntimeError.
+            //
+            // We trap instead of throwing RuntimeError to prevent infinite-looping in
+            // Wasm EH code (because RuntimeError is considered as a foreign exception and
+            // caught by 'catch_all'), but in case throwing RuntimeError is fine because
+            // the module has not even been instantiated, even less running.
+            if (runtimeInitialized) {
+                ___trap();
+            }
+            /** @suppress {checkTypes} */
+            var e = new WebAssembly.RuntimeError(what);
+            readyPromiseReject(e);
+            // Throw the error whether or not MODULARIZE is set because abort is used
+            // in code paths apart from instantiation where an exception is expected
+            // to be thrown when abort is called.
+            throw e;
+        }
+        // include: memoryprofiler.js
+        // end include: memoryprofiler.js
+        // include: URIUtils.js
+        // Prefix of data URIs emitted by SINGLE_FILE and related options.
+        var dataURIPrefix = 'data:application/octet-stream;base64,';
+        // Indicates whether filename is a base64 data URI.
+        function isDataURI(filename) {
+            // Prefix of data URIs emitted by SINGLE_FILE and related options.
+            return filename.startsWith(dataURIPrefix);
+        }
+        // Indicates whether filename is delivered via file protocol (as opposed to http/https)
+        function isFileURI(filename) {
+            return filename.startsWith('file://');
+        }
+        // end include: URIUtils.js
+        // include: runtime_exceptions.js
+        // end include: runtime_exceptions.js
+        var wasmBinaryFile;
+        if (Module['locateFile']) {
+            wasmBinaryFile = 'wasm-host.wasm';
+            if (!isDataURI(wasmBinaryFile)) {
+                wasmBinaryFile = locateFile(wasmBinaryFile);
+            }
+        }
+        else {
+            // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
+            wasmBinaryFile = new URL('wasm-host.wasm', import.meta.url).href;
+        }
+        function getBinary(file) {
+            try {
+                if (file == wasmBinaryFile && wasmBinary) {
+                    return new Uint8Array(wasmBinary);
+                }
+                if (readBinary) {
+                    return readBinary(file);
+                }
+                throw "both async and sync fetching of the wasm failed";
+            }
+            catch (err) {
+                abort(err);
+            }
+        }
+        function getBinaryPromise(binaryFile) {
+            // If we don't have the binary yet, try to to load it asynchronously.
+            // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
+            // See https://github.com/github/fetch/pull/92#issuecomment-140665932
+            // Cordova or Electron apps are typically loaded from a file:// url.
+            // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
+            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+                if (typeof fetch == 'function'
+                    && !isFileURI(binaryFile)) {
+                    return fetch(binaryFile, { credentials: 'same-origin' }).then(function (response) {
+                        if (!response['ok']) {
+                            throw "failed to load wasm binary file at '" + binaryFile + "'";
+                        }
+                        return response['arrayBuffer']();
+                    }).catch(function () {
+                        return getBinary(binaryFile);
+                    });
+                }
+                else {
+                    if (readAsync) {
+                        // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
+                        return new Promise(function (resolve, reject) {
+                            readAsync(binaryFile, function (response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */ (response))); }, reject);
+                        });
+                    }
+                }
+            }
+            // Otherwise, getBinary should be able to get it synchronously
+            return Promise.resolve().then(function () { return getBinary(binaryFile); });
+        }
+        function instantiateArrayBuffer(binaryFile, imports, receiver) {
+            return getBinaryPromise(binaryFile).then(function (binary) {
+                return WebAssembly.instantiate(binary, imports);
+            }).then(function (instance) {
+                return instance;
+            }).then(receiver, function (reason) {
+                err('failed to asynchronously prepare wasm: ' + reason);
+                abort(reason);
+            });
+        }
+        function instantiateAsync(binary, binaryFile, imports, callback) {
+            if (!binary &&
+                typeof WebAssembly.instantiateStreaming == 'function' &&
+                !isDataURI(binaryFile) &&
+                // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
+                !isFileURI(binaryFile) &&
+                // Avoid instantiateStreaming() on Node.js environment for now, as while
+                // Node.js v18.1.0 implements it, it does not have a full fetch()
+                // implementation yet.
+                //
+                // Reference:
+                //   https://github.com/emscripten-core/emscripten/pull/16917
+                !ENVIRONMENT_IS_NODE &&
+                typeof fetch == 'function') {
+                return fetch(binaryFile, { credentials: 'same-origin' }).then(function (response) {
+                    // Suppress closure warning here since the upstream definition for
+                    // instantiateStreaming only allows Promise<Repsponse> rather than
+                    // an actual Response.
+                    // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
+                    /** @suppress {checkTypes} */
+                    var result = WebAssembly.instantiateStreaming(response, imports);
+                    return result.then(callback, function (reason) {
+                        // We expect the most common failure cause to be a bad MIME type for the binary,
+                        // in which case falling back to ArrayBuffer instantiation should work.
+                        err('wasm streaming compile failed: ' + reason);
+                        err('falling back to ArrayBuffer instantiation');
+                        return instantiateArrayBuffer(binaryFile, imports, callback);
+                    });
+                });
+            }
+            else {
+                return instantiateArrayBuffer(binaryFile, imports, callback);
+            }
+        }
+        // Create the wasm instance.
+        // Receives the wasm imports, returns the exports.
+        function createWasm() {
+            // prepare imports
+            var info = {
+                'env': wasmImports,
+                'wasi_snapshot_preview1': wasmImports,
+            };
+            // Load the wasm module and create an instance of using native support in the JS engine.
+            // handle a generated wasm instance, receiving its exports and
+            // performing other necessary setup
+            /** @param {WebAssembly.Module=} module*/
+            function receiveInstance(instance, module) {
+                var exports = instance.exports;
+                Module['asm'] = exports;
+                wasmMemory = Module['asm']['memory'];
+                updateMemoryViews();
+                wasmTable = Module['asm']['__indirect_function_table'];
+                addOnInit(Module['asm']['__wasm_call_ctors']);
+                removeRunDependency('wasm-instantiate');
+                return exports;
+            }
+            // wait for the pthread pool (if any)
+            addRunDependency('wasm-instantiate');
+            // Prefer streaming instantiation if available.
+            function receiveInstantiationResult(result) {
+                // 'result' is a ResultObject object which has both the module and instance.
+                // receiveInstance() will swap in the exports (to Module.asm) so they can be called
+                // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
+                // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
+                receiveInstance(result['instance']);
+            }
+            // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
+            // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
+            // to any other async startup actions they are performing.
+            // Also pthreads and wasm workers initialize the wasm instance through this path.
+            if (Module['instantiateWasm']) {
+                try {
+                    return Module['instantiateWasm'](info, receiveInstance);
+                }
+                catch (e) {
+                    err('Module.instantiateWasm callback failed with error: ' + e);
+                    // If instantiation fails, reject the module ready promise.
+                    readyPromiseReject(e);
+                }
+            }
+            // If instantiation fails, reject the module ready promise.
+            instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
+            return {}; // no exports yet; we'll fill them in later
+        }
+        // Globals used by JS i64 conversions (see makeSetValue)
+        var tempDouble;
+        var tempI64;
+        // include: runtime_debug.js
+        // end include: runtime_debug.js
+        // === Body ===
+        function wasm_msgproc(line, msgcode, text, context) { const proc = globalThis[UTF8ToString(context)].message; if (!proc || typeof proc != 'function') {
+            console.log(`[${line}: ${msgcode}: ${UTF8ToString(text)}]`);
+            return 0;
+        }
+        else {
+            return proc(line, msgcode, UTF8ToString(text));
+        } }
+        function wasm_loadfileproc(filename, baseFilename, buffer, bufferSize, context) { const proc = globalThis[UTF8ToString(context)].loadFile; if (!proc || typeof proc != 'function') {
+            return 0;
+        }
+        else {
+            if (buffer == 0) {
+                return proc(UTF8ToString(filename), UTF8ToString(baseFilename), 0, 0);
+            }
+            else {
+                return proc(UTF8ToString(filename), UTF8ToString(baseFilename), buffer, bufferSize);
+            }
+        } }
+        // end include: preamble.js
+        /** @constructor */
+        function ExitStatus(status) {
+            this.name = 'ExitStatus';
+            this.message = 'Program terminated with exit(' + status + ')';
+            this.status = status;
+        }
+        function callRuntimeCallbacks(callbacks) {
+            while (callbacks.length > 0) {
+                // Pass the module as the first argument.
+                callbacks.shift()(Module);
+            }
+        }
+        /**
+         * @param {number} ptr
+         * @param {string} type
+         */
+        function getValue(ptr, type = 'i8') {
+            if (type.endsWith('*'))
+                type = '*';
+            switch (type) {
+                case 'i1': return HEAP8[((ptr) >> 0)];
+                case 'i8': return HEAP8[((ptr) >> 0)];
+                case 'i16': return HEAP16[((ptr) >> 1)];
+                case 'i32': return HEAP32[((ptr) >> 2)];
+                case 'i64': return HEAP32[((ptr) >> 2)];
+                case 'float': return HEAPF32[((ptr) >> 2)];
+                case 'double': return HEAPF64[((ptr) >> 3)];
+                case '*': return HEAPU32[((ptr) >> 2)];
+                default: abort('invalid type for getValue: ' + type);
+            }
+        }
+        /**
+         * @param {number} ptr
+         * @param {number} value
+         * @param {string} type
+         */
+        function setValue(ptr, value, type = 'i8') {
+            if (type.endsWith('*'))
+                type = '*';
+            switch (type) {
+                case 'i1':
+                    HEAP8[((ptr) >> 0)] = value;
+                    break;
+                case 'i8':
+                    HEAP8[((ptr) >> 0)] = value;
+                    break;
+                case 'i16':
+                    HEAP16[((ptr) >> 1)] = value;
+                    break;
+                case 'i32':
+                    HEAP32[((ptr) >> 2)] = value;
+                    break;
+                case 'i64':
+                    (tempI64 = [value >>> 0, (tempDouble = value, (+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble) / 4294967296.0))), 4294967295.0)) | 0) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296.0))))) >>> 0) : 0)], HEAP32[((ptr) >> 2)] = tempI64[0], HEAP32[(((ptr) + (4)) >> 2)] = tempI64[1]);
+                    break;
+                case 'float':
+                    HEAPF32[((ptr) >> 2)] = value;
+                    break;
+                case 'double':
+                    HEAPF64[((ptr) >> 3)] = value;
+                    break;
+                case '*':
+                    HEAPU32[((ptr) >> 2)] = value;
+                    break;
+                default: abort('invalid type for setValue: ' + type);
+            }
+        }
+        function ___assert_fail(condition, filename, line, func) {
+            abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
+        }
+        var structRegistrations = {};
+        function runDestructors(destructors) {
+            while (destructors.length) {
+                var ptr = destructors.pop();
+                var del = destructors.pop();
+                del(ptr);
+            }
+        }
+        function simpleReadValueFromPointer(pointer) {
+            return this['fromWireType'](HEAP32[((pointer) >> 2)]);
+        }
+        var awaitingDependencies = {};
+        var registeredTypes = {};
+        var typeDependencies = {};
+        var char_0 = 48;
+        var char_9 = 57;
+        function makeLegalFunctionName(name) {
+            if (undefined === name) {
+                return '_unknown';
+            }
+            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 createNamedFunction(name, body) {
+            name = makeLegalFunctionName(name);
+            // Use an abject with a computed property name to create a new function with
+            // a name specified at runtime, but without using `new Function` or `eval`.
+            return {
+                [name]: function () {
+                    return body.apply(this, arguments);
+                }
+            }[name];
+        }
+        function extendError(baseErrorType, errorName) {
+            var errorClass = createNamedFunction(errorName, function (message) {
+                this.name = errorName;
+                this.message = message;
+                var stack = (new Error(message)).stack;
+                if (stack !== undefined) {
+                    this.stack = this.toString() + '\n' +
+                        stack.replace(/^Error(:[^\n]*)?\n/, '');
+                }
+            });
+            errorClass.prototype = Object.create(baseErrorType.prototype);
+            errorClass.prototype.constructor = errorClass;
+            errorClass.prototype.toString = function () {
+                if (this.message === undefined) {
+                    return this.name;
+                }
+                else {
+                    return this.name + ': ' + this.message;
+                }
+            };
+            return errorClass;
+        }
+        var InternalError = undefined;
+        function throwInternalError(message) {
+            throw new InternalError(message);
+        }
+        function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
+            myTypes.forEach(function (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;
+            dependentTypes.forEach((dt, i) => {
+                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);
+            }
+        }
+        function __embind_finalize_value_object(structType) {
+            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, (fieldTypes) => {
+                var fields = {};
+                fieldRecords.forEach((field, i) => {
+                    var fieldName = field.fieldName;
+                    var getterReturnType = fieldTypes[i];
+                    var getter = field.getter;
+                    var getterContext = field.getterContext;
+                    var setterArgumentType = fieldTypes[i + fieldRecords.length];
+                    var setter = field.setter;
+                    var setterContext = field.setterContext;
+                    fields[fieldName] = {
+                        read: (ptr) => {
+                            return getterReturnType['fromWireType'](getter(getterContext, ptr));
+                        },
+                        write: (ptr, o) => {
+                            var destructors = [];
+                            setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o));
+                            runDestructors(destructors);
+                        }
+                    };
+                });
+                return [{
+                        name: reg.name,
+                        'fromWireType': function (ptr) {
+                            var rv = {};
+                            for (var i in fields) {
+                                rv[i] = fields[i].read(ptr);
+                            }
+                            rawDestructor(ptr);
+                            return rv;
+                        },
+                        'toWireType': function (destructors, o) {
+                            // todo: Here we have an opportunity for -O3 level "unsafe" optimizations:
+                            // assume all fields are present without checking.
+                            for (var fieldName in fields) {
+                                if (!(fieldName in o)) {
+                                    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;
+                        },
+                        'argPackAdvance': 8,
+                        'readValueFromPointer': simpleReadValueFromPointer,
+                        destructorFunction: rawDestructor,
+                    }];
+            });
+        }
+        function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) { }
+        function getShiftFromSize(size) {
+            switch (size) {
+                case 1: return 0;
+                case 2: return 1;
+                case 4: return 2;
+                case 8: return 3;
+                default:
+                    throw new TypeError('Unknown type size: ' + size);
+            }
+        }
+        function embind_init_charCodes() {
+            var codes = new Array(256);
+            for (var i = 0; i < 256; ++i) {
+                codes[i] = String.fromCharCode(i);
+            }
+            embind_charCodes = codes;
+        }
+        var embind_charCodes = undefined;
+        function readLatin1String(ptr) {
+            var ret = "";
+            var c = ptr;
+            while (HEAPU8[c]) {
+                ret += embind_charCodes[HEAPU8[c++]];
+            }
+            return ret;
+        }
+        var BindingError = undefined;
+        function throwBindingError(message) {
+            throw new BindingError(message);
+        }
+        /** @param {Object=} options */
+        function registerType(rawType, registeredInstance, options = {}) {
+            if (!('argPackAdvance' in registeredInstance)) {
+                throw new TypeError('registerType registeredInstance requires argPackAdvance');
+            }
+            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 __embind_register_bool(rawType, name, size, trueValue, falseValue) {
+            var shift = getShiftFromSize(size);
+            name = readLatin1String(name);
+            registerType(rawType, {
+                name: name,
+                'fromWireType': function (wt) {
+                    // ambiguous emscripten ABI: sometimes return values are
+                    // true or false, and sometimes integers (0 or 1)
+                    return !!wt;
+                },
+                'toWireType': function (destructors, o) {
+                    return o ? trueValue : falseValue;
+                },
+                'argPackAdvance': 8,
+                'readValueFromPointer': function (pointer) {
+                    // TODO: if heap is fixed (like in asm.js) this could be executed outside
+                    var heap;
+                    if (size === 1) {
+                        heap = HEAP8;
+                    }
+                    else if (size === 2) {
+                        heap = HEAP16;
+                    }
+                    else if (size === 4) {
+                        heap = HEAP32;
+                    }
+                    else {
+                        throw new TypeError("Unknown boolean type size: " + name);
+                    }
+                    return this['fromWireType'](heap[pointer >> shift]);
+                },
+                destructorFunction: null, // This type does not need a destructor
+            });
+        }
+        function ClassHandle_isAliasOf(other) {
+            if (!(this instanceof ClassHandle)) {
+                return false;
+            }
+            if (!(other instanceof ClassHandle)) {
+                return false;
+            }
+            var leftClass = this.$$.ptrType.registeredClass;
+            var left = this.$$.ptr;
+            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;
+        }
+        function shallowCopyInternalPointer(o) {
+            return {
+                count: o.count,
+                deleteScheduled: o.deleteScheduled,
+                preservePointerOnDelete: o.preservePointerOnDelete,
+                ptr: o.ptr,
+                ptrType: o.ptrType,
+                smartPtr: o.smartPtr,
+                smartPtrType: o.smartPtrType,
+            };
+        }
+        function throwInstanceAlreadyDeleted(obj) {
+            function getInstanceTypeName(handle) {
+                return handle.$$.ptrType.registeredClass.name;
+            }
+            throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
+        }
+        var finalizationRegistry = false;
+        function detachFinalizer(handle) { }
+        function runDestructor($$) {
+            if ($$.smartPtr) {
+                $$.smartPtrType.rawDestructor($$.smartPtr);
+            }
+            else {
+                $$.ptrType.registeredClass.rawDestructor($$.ptr);
+            }
+        }
+        function releaseClassHandle($$) {
+            $$.count.value -= 1;
+            var toDelete = 0 === $$.count.value;
+            if (toDelete) {
+                runDestructor($$);
+            }
+        }
+        function downcastPointer(ptr, ptrClass, desiredClass) {
+            if (ptrClass === desiredClass) {
+                return ptr;
+            }
+            if (undefined === desiredClass.baseClass) {
+                return null; // no conversion
+            }
+            var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+            if (rv === null) {
+                return null;
+            }
+            return desiredClass.downcast(rv);
+        }
+        var registeredPointers = {};
+        function getInheritedInstanceCount() {
+            return Object.keys(registeredInstances).length;
+        }
+        function getLiveInheritedInstances() {
+            var rv = [];
+            for (var k in registeredInstances) {
+                if (registeredInstances.hasOwnProperty(k)) {
+                    rv.push(registeredInstances[k]);
+                }
+            }
+            return rv;
+        }
+        var deletionQueue = [];
+        function flushPendingDeletes() {
+            while (deletionQueue.length) {
+                var obj = deletionQueue.pop();
+                obj.$$.deleteScheduled = false;
+                obj['delete']();
+            }
+        }
+        var delayFunction = undefined;
+        function setDelayFunction(fn) {
+            delayFunction = fn;
+            if (deletionQueue.length && delayFunction) {
+                delayFunction(flushPendingDeletes);
+            }
+        }
+        function init_embind() {
+            Module['getInheritedInstanceCount'] = getInheritedInstanceCount;
+            Module['getLiveInheritedInstances'] = getLiveInheritedInstances;
+            Module['flushPendingDeletes'] = flushPendingDeletes;
+            Module['setDelayFunction'] = setDelayFunction;
+        }
+        var registeredInstances = {};
+        function getBasestPointer(class_, ptr) {
+            if (ptr === undefined) {
+                throwBindingError('ptr should not be undefined');
+            }
+            while (class_.baseClass) {
+                ptr = class_.upcast(ptr);
+                class_ = class_.baseClass;
+            }
+            return ptr;
+        }
+        function getInheritedInstance(class_, ptr) {
+            ptr = getBasestPointer(class_, ptr);
+            return registeredInstances[ptr];
+        }
+        function 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,
+                },
+            }));
+        }
+        function RegisteredPointer_fromWireType(ptr) {
+            // ptr is a raw pointer (or a raw smartpointer)
+            // rawPointer is a maybe-null raw pointer
+            var rawPointer = this.getPointee(ptr);
+            if (!rawPointer) {
+                this.destructor(ptr);
+                return null;
+            }
+            var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
+            if (undefined !== registeredInstance) {
+                // JS object has been neutered, time to repopulate it
+                if (0 === registeredInstance.$$.count.value) {
+                    registeredInstance.$$.ptr = rawPointer;
+                    registeredInstance.$$.smartPtr = ptr;
+                    return registeredInstance['clone']();
+                }
+                else {
+                    // else, just increment reference count on existing object
+                    // it already has a reference to the smart pointer
+                    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: 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,
+                });
+            }
+        }
+        function attachFinalizer(handle) {
+            if ('undefined' === typeof FinalizationRegistry) {
+                attachFinalizer = (handle) => handle;
+                return handle;
+            }
+            // If the running environment has a FinalizationRegistry (see
+            // https://github.com/tc39/proposal-weakrefs), then attach finalizers
+            // for class handles.  We check for the presence of FinalizationRegistry
+            // at run-time, not build-time.
+            finalizationRegistry = new FinalizationRegistry((info) => {
+                releaseClassHandle(info.$$);
+            });
+            attachFinalizer = (handle) => {
+                var $$ = handle.$$;
+                var hasSmartPtr = !!$$.smartPtr;
+                if (hasSmartPtr) {
+                    // We should not call the destructor on raw pointers in case other code expects the pointee to live
+                    var info = { $$: $$ };
+                    finalizationRegistry.register(handle, info, handle);
+                }
+                return handle;
+            };
+            detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
+            return attachFinalizer(handle);
+        }
+        function ClassHandle_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;
+            }
+        }
+        function ClassHandle_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;
+            }
+        }
+        function ClassHandle_isDeleted() {
+            return !this.$$.ptr;
+        }
+        function ClassHandle_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;
+        }
+        function init_ClassHandle() {
+            ClassHandle.prototype['isAliasOf'] = ClassHandle_isAliasOf;
+            ClassHandle.prototype['clone'] = ClassHandle_clone;
+            ClassHandle.prototype['delete'] = ClassHandle_delete;
+            ClassHandle.prototype['isDeleted'] = ClassHandle_isDeleted;
+            ClassHandle.prototype['deleteLater'] = ClassHandle_deleteLater;
+        }
+        function ClassHandle() {
+        }
+        function ensureOverloadTable(proto, methodName, humanName) {
+            if (undefined === proto[methodName].overloadTable) {
+                var prevFunc = proto[methodName];
+                // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.
+                proto[methodName] = function () {
+                    // TODO This check can be removed in -O3 level "unsafe" optimizations.
+                    if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
+                        throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
+                    }
+                    return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
+                };
+                // Move the previous function into the overload table.
+                proto[methodName].overloadTable = [];
+                proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+            }
+        }
+        /** @param {number=} numArguments */
+        function 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");
+                }
+                // We are exposing a function with the same name as an existing function. Create an overload table and a function selector
+                // that routes between the two.
+                ensureOverloadTable(Module, name, name);
+                if (Module.hasOwnProperty(numArguments)) {
+                    throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
+                }
+                // Add the new function into the overload table.
+                Module[name].overloadTable[numArguments] = value;
+            }
+            else {
+                Module[name] = value;
+                if (undefined !== numArguments) {
+                    Module[name].numArguments = numArguments;
+                }
+            }
+        }
+        /** @constructor */
+        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 = [];
+        }
+        function 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;
+        }
+        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.$$) {
+                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) {
+                // TODO: this is not strictly true
+                // We could support BY_EMVAL conversions from raw pointers to smart pointers
+                // because the smart pointer can hold a reference to the handle
+                if (undefined === handle.$$.smartPtr) {
+                    throwBindingError('Passing raw pointer to smart pointer is illegal');
+                }
+                switch (this.sharingPolicy) {
+                    case 0: // NONE
+                        // no upcasting
+                        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: // INTRUSIVE
+                        ptr = handle.$$.smartPtr;
+                        break;
+                    case 2: // BY_EMVAL
+                        if (handle.$$.smartPtrType === this) {
+                            ptr = handle.$$.smartPtr;
+                        }
+                        else {
+                            var clonedHandle = handle['clone']();
+                            ptr = this.rawShare(ptr, Emval.toHandle(function () {
+                                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 RegisteredPointer_getPointee(ptr) {
+            if (this.rawGetPointee) {
+                ptr = this.rawGetPointee(ptr);
+            }
+            return ptr;
+        }
+        function RegisteredPointer_destructor(ptr) {
+            if (this.rawDestructor) {
+                this.rawDestructor(ptr);
+            }
+        }
+        function RegisteredPointer_deleteObject(handle) {
+            if (handle !== null) {
+                handle['delete']();
+            }
+        }
+        function init_RegisteredPointer() {
+            RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
+            RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
+            RegisteredPointer.prototype['argPackAdvance'] = 8;
+            RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer;
+            RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject;
+            RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType;
+        }
+        /** @constructor
+            @param {*=} pointeeType,
+            @param {*=} sharingPolicy,
+            @param {*=} rawGetPointee,
+            @param {*=} rawConstructor,
+            @param {*=} rawShare,
+            @param {*=} rawDestructor,
+             */
+        function RegisteredPointer(name, registeredClass, isReference, isConst, 
+        // smart pointer properties
+        isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
+            this.name = name;
+            this.registeredClass = registeredClass;
+            this.isReference = isReference;
+            this.isConst = isConst;
+            // smart pointer properties
+            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;
+                // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns
+                // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time.
+                // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in
+                //       craftInvokerFunction altogether.
+            }
+        }
+        /** @param {number=} numArguments */
+        function replacePublicSymbol(name, value, numArguments) {
+            if (!Module.hasOwnProperty(name)) {
+                throwInternalError('Replacing nonexistant public symbol');
+            }
+            // If there's an overload table for this symbol, replace the symbol in the overload table instead.
+            if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
+                Module[name].overloadTable[numArguments] = value;
+            }
+            else {
+                Module[name] = value;
+                Module[name].argCount = numArguments;
+            }
+        }
+        function dynCallLegacy(sig, ptr, args) {
+            var f = Module['dynCall_' + sig];
+            return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
+        }
+        var wasmTableMirror = [];
+        function getWasmTableEntry(funcPtr) {
+            var func = wasmTableMirror[funcPtr];
+            if (!func) {
+                if (funcPtr >= wasmTableMirror.length)
+                    wasmTableMirror.length = funcPtr + 1;
+                wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+            }
+            return func;
+        }
+        /** @param {Object=} args */
+        function dynCall(sig, ptr, args) {
+            // Without WASM_BIGINT support we cannot directly call function with i64 as
+            // part of thier signature, so we rely the dynCall functions generated by
+            // wasm-emscripten-finalize
+            if (sig.includes('j')) {
+                return dynCallLegacy(sig, ptr, args);
+            }
+            var rtn = getWasmTableEntry(ptr).apply(null, args);
+            return rtn;
+        }
+        function getDynCaller(sig, ptr) {
+            var argCache = [];
+            return function () {
+                argCache.length = 0;
+                Object.assign(argCache, arguments);
+                return dynCall(sig, ptr, argCache);
+            };
+        }
+        function embind__requireFunction(signature, rawFunction) {
+            signature = readLatin1String(signature);
+            function makeDynCaller() {
+                if (signature.includes('j')) {
+                    return getDynCaller(signature, rawFunction);
+                }
+                return getWasmTableEntry(rawFunction);
+            }
+            var fp = makeDynCaller();
+            if (typeof fp != "function") {
+                throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
+            }
+            return fp;
+        }
+        var UnboundTypeError = undefined;
+        function getTypeName(type) {
+            var ptr = ___getTypeName(type);
+            var rv = readLatin1String(ptr);
+            _free(ptr);
+            return rv;
+        }
+        function 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([', ']));
+        }
+        function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
+            name = readLatin1String(name);
+            getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
+            if (upcast) {
+                upcast = embind__requireFunction(upcastSignature, upcast);
+            }
+            if (downcast) {
+                downcast = embind__requireFunction(downcastSignature, downcast);
+            }
+            rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+            var legalFunctionName = makeLegalFunctionName(name);
+            exposePublicSymbol(legalFunctionName, function () {
+                // this code cannot run if baseClassRawType is zero
+                throwUnboundTypeError('Cannot construct ' + name + ' due to unbound types', [baseClassRawType]);
+            });
+            whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function (base) {
+                base = base[0];
+                var baseClass;
+                var basePrototype;
+                if (baseClassRawType) {
+                    baseClass = base.registeredClass;
+                    basePrototype = baseClass.instancePrototype;
+                }
+                else {
+                    basePrototype = ClassHandle.prototype;
+                }
+                var constructor = createNamedFunction(legalFunctionName, function () {
+                    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[arguments.length];
+                    if (undefined === body) {
+                        throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!");
+                    }
+                    return body.apply(this, arguments);
+                });
+                var instancePrototype = Object.create(basePrototype, {
+                    constructor: { value: constructor },
+                });
+                constructor.prototype = instancePrototype;
+                var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+                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];
+            });
+        }
+        function heap32VectorToArray(count, firstElement) {
+            var array = [];
+            for (var i = 0; i < count; i++) {
+                // TODO(https://github.com/emscripten-core/emscripten/issues/17310):
+                // Find a way to hoist the `>> 2` or `>> 3` out of this loop.
+                array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]);
+            }
+            return array;
+        }
+        function new_(constructor, argumentList) {
+            if (!(constructor instanceof Function)) {
+                throw new TypeError('new_ called with constructor type ' + typeof (constructor) + " which is not a function");
+            }
+            /*
+             * Previously, the following line was just:
+             *   function dummy() {};
+             * Unfortunately, Chrome was preserving 'dummy' as the object's name, even
+             * though at creation, the 'dummy' has the correct constructor name.  Thus,
+             * objects created with IMVU.new would show up in the debugger as 'dummy',
+             * which isn't very helpful.  Using IMVU.createNamedFunction addresses the
+             * issue.  Doublely-unfortunately, there's no way to write a test for this
+             * behavior.  -NRD 2013.02.22
+             */
+            var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function () { });
+            dummy.prototype = constructor.prototype;
+            var obj = new dummy;
+            var r = constructor.apply(obj, argumentList);
+            return (r instanceof Object) ? r : obj;
+        }
+        function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
+            // humanName: a human-readable string name for the function to be generated.
+            // argTypes: An array that contains the embind type objects for all types in the function signature.
+            //    argTypes[0] is the type object for the function return value.
+            //    argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.
+            //    argTypes[2...] are the actual function parameters.
+            // classType: The embind type object for the class to be bound, or null if this is not a method of a class.
+            // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.
+            // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.
+            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);
+            // Free functions with signature "void function()" do not need an invoker that marshalls between wire types.
+            // TODO: This omits argument count check - enable only at -O3 or similar.
+            //    if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) {
+            //       return FUNCTION_TABLE[fn];
+            //    }
+            // Determine if we need to use a dynamic stack to store the destructors for the function parameters.
+            // TODO: Remove this completely once all function invokers are being dynamically generated.
+            var needsDestructorStack = false;
+            for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here.
+                if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack
+                    needsDestructorStack = true;
+                    break;
+                }
+            }
+            var returns = (argTypes[0].name !== "void");
+            var argsList = "";
+            var argsListWired = "";
+            for (var i = 0; i < argCount - 2; ++i) {
+                argsList += (i !== 0 ? ", " : "") + "arg" + i;
+                argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
+            }
+            var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" +
+                "if (arguments.length !== " + (argCount - 2) + ") {\n" +
+                "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" +
+                "}\n";
+            if (needsDestructorStack) {
+                invokerFnBody += "var destructors = [];\n";
+            }
+            var dtorStack = needsDestructorStack ? "destructors" : "null";
+            var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
+            var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
+            if (isClassMethodFunc) {
+                invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
+            }
+            for (var i = 0; i < argCount - 2; ++i) {
+                invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
+                args1.push("argType" + i);
+                args2.push(argTypes[i + 2]);
+            }
+            if (isClassMethodFunc) {
+                argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
+            }
+            invokerFnBody +=
+                (returns || isAsync ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
+            if (needsDestructorStack) {
+                invokerFnBody += "runDestructors(destructors);\n";
+            }
+            else {
+                for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.
+                    var paramName = (i === 1 ? "thisWired" : ("arg" + (i - 2) + "Wired"));
+                    if (argTypes[i].destructorFunction !== null) {
+                        invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
+                        args1.push(paramName + "_dtor");
+                        args2.push(argTypes[i].destructorFunction);
+                    }
+                }
+            }
+            if (returns) {
+                invokerFnBody += "var ret = retType.fromWireType(rv);\n" +
+                    "return ret;\n";
+            }
+            else {
+            }
+            invokerFnBody += "}\n";
+            args1.push(invokerFnBody);
+            var invokerFunction = new_(Function, args1).apply(null, args2);
+            return invokerFunction;
+        }
+        function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
+            assert(argCount > 0);
+            var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+            invoker = embind__requireFunction(invokerSignature, invoker);
+            var args = [rawConstructor];
+            var destructors = [];
+            whenDependentTypesAreResolved([], [rawClassType], function (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, function (argTypes) {
+                    // Insert empty slot for context type (argTypes[1]).
+                    argTypes.splice(1, 0, null);
+                    classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
+                    return [];
+                });
+                return [];
+            });
+        }
+        function 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');
+            }
+            // todo: kill this
+            return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass);
+        }
+        function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+            fieldName = readLatin1String(fieldName);
+            getter = embind__requireFunction(getterSignature, getter);
+            whenDependentTypesAreResolved([], [classType], function (classType) {
+                classType = classType[0];
+                var humanName = classType.name + '.' + fieldName;
+                var desc = {
+                    get: function () {
+                        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]), function (types) {
+                    var getterReturnType = types[0];
+                    var desc = {
+                        get: function () {
+                            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_free_list = [];
+        var emval_handle_array = [{}, { value: undefined }, { value: null }, { value: true }, { value: false }];
+        function __emval_decref(handle) {
+            if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
+                emval_handle_array[handle] = undefined;
+                emval_free_list.push(handle);
+            }
+        }
+        function count_emval_handles() {
+            var count = 0;
+            for (var i = 5; i < emval_handle_array.length; ++i) {
+                if (emval_handle_array[i] !== undefined) {
+                    ++count;
+                }
+            }
+            return count;
+        }
+        function get_first_emval() {
+            for (var i = 5; i < emval_handle_array.length; ++i) {
+                if (emval_handle_array[i] !== undefined) {
+                    return emval_handle_array[i];
+                }
+            }
+            return null;
+        }
+        function init_emval() {
+            Module['count_emval_handles'] = count_emval_handles;
+            Module['get_first_emval'] = get_first_emval;
+        }
+        var Emval = { toValue: (handle) => {
+                if (!handle) {
+                    throwBindingError('Cannot use deleted val. handle = ' + handle);
+                }
+                return emval_handle_array[handle].value;
+            }, toHandle: (value) => {
+                switch (value) {
+                    case undefined: return 1;
+                    case null: return 2;
+                    case true: return 3;
+                    case false: return 4;
+                    default: {
+                        var handle = emval_free_list.length ?
+                            emval_free_list.pop() :
+                            emval_handle_array.length;
+                        emval_handle_array[handle] = { refcount: 1, value: value };
+                        return handle;
+                    }
+                }
+            } };
+        function __embind_register_emval(rawType, name) {
+            name = readLatin1String(name);
+            registerType(rawType, {
+                name: name,
+                'fromWireType': function (handle) {
+                    var rv = Emval.toValue(handle);
+                    __emval_decref(handle);
+                    return rv;
+                },
+                'toWireType': function (destructors, value) {
+                    return Emval.toHandle(value);
+                },
+                'argPackAdvance': 8,
+                'readValueFromPointer': simpleReadValueFromPointer,
+                destructorFunction: null, // This type does not need a destructor
+                // TODO: do we need a deleteObject here?  write a test where
+                // emval is passed into JS via an interface
+            });
+        }
+        function 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 floatReadValueFromPointer(name, shift) {
+            switch (shift) {
+                case 2: return function (pointer) {
+                    return this['fromWireType'](HEAPF32[pointer >> 2]);
+                };
+                case 3: return function (pointer) {
+                    return this['fromWireType'](HEAPF64[pointer >> 3]);
+                };
+                default:
+                    throw new TypeError("Unknown float type: " + name);
+            }
+        }
+        function __embind_register_float(rawType, name, size) {
+            var shift = getShiftFromSize(size);
+            name = readLatin1String(name);
+            registerType(rawType, {
+                name: name,
+                'fromWireType': function (value) {
+                    return value;
+                },
+                'toWireType': function (destructors, value) {
+                    // The VM will perform JS to Wasm value conversion, according to the spec:
+                    // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
+                    return value;
+                },
+                'argPackAdvance': 8,
+                'readValueFromPointer': floatReadValueFromPointer(name, shift),
+                destructorFunction: null, // This type does not need a destructor
+            });
+        }
+        function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) {
+            var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+            name = readLatin1String(name);
+            rawInvoker = embind__requireFunction(signature, rawInvoker);
+            exposePublicSymbol(name, function () {
+                throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes);
+            }, argCount - 1);
+            whenDependentTypesAreResolved([], argTypes, function (argTypes) {
+                var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);
+                replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1);
+                return [];
+            });
+        }
+        function integerReadValueFromPointer(name, shift, signed) {
+            // integers are quite common, so generate very specialized functions
+            switch (shift) {
+                case 0: return signed ?
+                    function readS8FromPointer(pointer) { return HEAP8[pointer]; } :
+                    function readU8FromPointer(pointer) { return HEAPU8[pointer]; };
+                case 1: return signed ?
+                    function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } :
+                    function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; };
+                case 2: return signed ?
+                    function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } :
+                    function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; };
+                default:
+                    throw new TypeError("Unknown integer type: " + name);
+            }
+        }
+        function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+            name = readLatin1String(name);
+            // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come
+            // out as 'i32 -1'. Always treat those as max u32.
+            if (maxRange === -1) {
+                maxRange = 4294967295;
+            }
+            var shift = getShiftFromSize(size);
+            var fromWireType = (value) => value;
+            if (minRange === 0) {
+                var bitshift = 32 - 8 * size;
+                fromWireType = (value) => (value << bitshift) >>> bitshift;
+            }
+            var isUnsignedType = (name.includes('unsigned'));
+            var checkAssertions = (value, toTypeName) => {
+            };
+            var toWireType;
+            if (isUnsignedType) {
+                toWireType = function (destructors, value) {
+                    checkAssertions(value, this.name);
+                    return value >>> 0;
+                };
+            }
+            else {
+                toWireType = function (destructors, value) {
+                    checkAssertions(value, this.name);
+                    // The VM will perform JS to Wasm value conversion, according to the spec:
+                    // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
+                    return value;
+                };
+            }
+            registerType(primitiveType, {
+                name: name,
+                'fromWireType': fromWireType,
+                'toWireType': toWireType,
+                'argPackAdvance': 8,
+                'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0),
+                destructorFunction: null, // This type does not need a destructor
+            });
+        }
+        function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+            var typeMapping = [
+                Int8Array,
+                Uint8Array,
+                Int16Array,
+                Uint16Array,
+                Int32Array,
+                Uint32Array,
+                Float32Array,
+                Float64Array,
+            ];
+            var TA = typeMapping[dataTypeIndex];
+            function decodeMemoryView(handle) {
+                handle = handle >> 2;
+                var heap = HEAPU32;
+                var size = heap[handle]; // in elements
+                var data = heap[handle + 1]; // byte offset into emscripten heap
+                return new TA(heap.buffer, data, size);
+            }
+            name = readLatin1String(name);
+            registerType(rawType, {
+                name: name,
+                'fromWireType': decodeMemoryView,
+                'argPackAdvance': 8,
+                'readValueFromPointer': decodeMemoryView,
+            }, {
+                ignoreDuplicateRegistrations: true,
+            });
+        }
+        function __embind_register_std_string(rawType, name) {
+            name = readLatin1String(name);
+            var stdStringIsUTF8 
+            //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string<unsigned char>
+            = (name === "std::string");
+            registerType(rawType, {
+                name: name,
+                'fromWireType': function (value) {
+                    var length = HEAPU32[((value) >> 2)];
+                    var payload = value + 4;
+                    var str;
+                    if (stdStringIsUTF8) {
+                        var decodeStartPtr = payload;
+                        // Looping here to support possible embedded '0' bytes
+                        for (var i = 0; i <= length; ++i) {
+                            var currentBytePtr = payload + i;
+                            if (i == length || HEAPU8[currentBytePtr] == 0) {
+                                var maxRead = currentBytePtr - decodeStartPtr;
+                                var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+                                if (str === undefined) {
+                                    str = stringSegment;
+                                }
+                                else {
+                                    str += String.fromCharCode(0);
+                                    str += stringSegment;
+                                }
+                                decodeStartPtr = currentBytePtr + 1;
+                            }
+                        }
+                    }
+                    else {
+                        var a = new Array(length);
+                        for (var i = 0; i < length; ++i) {
+                            a[i] = String.fromCharCode(HEAPU8[payload + i]);
+                        }
+                        str = a.join('');
+                    }
+                    _free(value);
+                    return str;
+                },
+                'toWireType': function (destructors, value) {
+                    if (value instanceof ArrayBuffer) {
+                        value = new Uint8Array(value);
+                    }
+                    var length;
+                    var valueIsOfTypeString = (typeof value == 'string');
+                    if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
+                        throwBindingError('Cannot pass non-string to std::string');
+                    }
+                    if (stdStringIsUTF8 && valueIsOfTypeString) {
+                        length = lengthBytesUTF8(value);
+                    }
+                    else {
+                        length = value.length;
+                    }
+                    // assumes 4-byte alignment
+                    var base = _malloc(4 + length + 1);
+                    var ptr = base + 4;
+                    HEAPU32[((base) >> 2)] = length;
+                    if (stdStringIsUTF8 && valueIsOfTypeString) {
+                        stringToUTF8(value, ptr, length + 1);
+                    }
+                    else {
+                        if (valueIsOfTypeString) {
+                            for (var i = 0; i < length; ++i) {
+                                var charCode = value.charCodeAt(i);
+                                if (charCode > 255) {
+                                    _free(ptr);
+                                    throwBindingError('String has UTF-16 code units that do not fit in 8 bits');
+                                }
+                                HEAPU8[ptr + i] = charCode;
+                            }
+                        }
+                        else {
+                            for (var i = 0; i < length; ++i) {
+                                HEAPU8[ptr + i] = value[i];
+                            }
+                        }
+                    }
+                    if (destructors !== null) {
+                        destructors.push(_free, base);
+                    }
+                    return base;
+                },
+                'argPackAdvance': 8,
+                'readValueFromPointer': simpleReadValueFromPointer,
+                destructorFunction: function (ptr) { _free(ptr); },
+            });
+        }
+        var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;
+        ;
+        function UTF16ToString(ptr, maxBytesToRead) {
+            var endPtr = ptr;
+            // TextDecoder needs to know the byte length in advance, it doesn't stop on
+            // null terminator by itself.
+            // Also, use the length info to avoid running tiny strings through
+            // TextDecoder, since .subarray() allocates garbage.
+            var idx = endPtr >> 1;
+            var maxIdx = idx + maxBytesToRead / 2;
+            // If maxBytesToRead is not passed explicitly, it will be undefined, and this
+            // will always evaluate to true. This saves on code size.
+            while (!(idx >= maxIdx) && HEAPU16[idx])
+                ++idx;
+            endPtr = idx << 1;
+            if (endPtr - ptr > 32 && UTF16Decoder)
+                return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+            // Fallback: decode without UTF16Decoder
+            var str = '';
+            // If maxBytesToRead is not passed explicitly, it will be undefined, and the
+            // for-loop's condition will always evaluate to true. The loop is then
+            // terminated on the first null char.
+            for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
+                var codeUnit = HEAP16[(((ptr) + (i * 2)) >> 1)];
+                if (codeUnit == 0)
+                    break;
+                // fromCharCode constructs a character from a UTF-16 code unit, so we can
+                // pass the UTF16 string right through.
+                str += String.fromCharCode(codeUnit);
+            }
+            return str;
+        }
+        function stringToUTF16(str, outPtr, maxBytesToWrite) {
+            // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
+            if (maxBytesToWrite === undefined) {
+                maxBytesToWrite = 0x7FFFFFFF;
+            }
+            if (maxBytesToWrite < 2)
+                return 0;
+            maxBytesToWrite -= 2; // Null terminator.
+            var startPtr = outPtr;
+            var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length;
+            for (var i = 0; i < numCharsToWrite; ++i) {
+                // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+                var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+                HEAP16[((outPtr) >> 1)] = codeUnit;
+                outPtr += 2;
+            }
+            // Null-terminate the pointer to the HEAP.
+            HEAP16[((outPtr) >> 1)] = 0;
+            return outPtr - startPtr;
+        }
+        function lengthBytesUTF16(str) {
+            return str.length * 2;
+        }
+        function UTF32ToString(ptr, maxBytesToRead) {
+            var i = 0;
+            var str = '';
+            // If maxBytesToRead is not passed explicitly, it will be undefined, and this
+            // will always evaluate to true. This saves on code size.
+            while (!(i >= maxBytesToRead / 4)) {
+                var utf32 = HEAP32[(((ptr) + (i * 4)) >> 2)];
+                if (utf32 == 0)
+                    break;
+                ++i;
+                // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                if (utf32 >= 0x10000) {
+                    var ch = utf32 - 0x10000;
+                    str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+                }
+                else {
+                    str += String.fromCharCode(utf32);
+                }
+            }
+            return str;
+        }
+        function stringToUTF32(str, outPtr, maxBytesToWrite) {
+            // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
+            if (maxBytesToWrite === undefined) {
+                maxBytesToWrite = 0x7FFFFFFF;
+            }
+            if (maxBytesToWrite < 4)
+                return 0;
+            var startPtr = outPtr;
+            var endPtr = startPtr + maxBytesToWrite - 4;
+            for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+                if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+                    var trailSurrogate = str.charCodeAt(++i);
+                    codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+                }
+                HEAP32[((outPtr) >> 2)] = codeUnit;
+                outPtr += 4;
+                if (outPtr + 4 > endPtr)
+                    break;
+            }
+            // Null-terminate the pointer to the HEAP.
+            HEAP32[((outPtr) >> 2)] = 0;
+            return outPtr - startPtr;
+        }
+        function lengthBytesUTF32(str) {
+            var len = 0;
+            for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                var codeUnit = str.charCodeAt(i);
+                if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF)
+                    ++i; // possibly a lead surrogate, so skip over the tail surrogate.
+                len += 4;
+            }
+            return len;
+        }
+        function __embind_register_std_wstring(rawType, charSize, name) {
+            name = readLatin1String(name);
+            var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+            if (charSize === 2) {
+                decodeString = UTF16ToString;
+                encodeString = stringToUTF16;
+                lengthBytesUTF = lengthBytesUTF16;
+                getHeap = () => HEAPU16;
+                shift = 1;
+            }
+            else if (charSize === 4) {
+                decodeString = UTF32ToString;
+                encodeString = stringToUTF32;
+                lengthBytesUTF = lengthBytesUTF32;
+                getHeap = () => HEAPU32;
+                shift = 2;
+            }
+            registerType(rawType, {
+                name: name,
+                'fromWireType': function (value) {
+                    // Code mostly taken from _embind_register_std_string fromWireType
+                    var length = HEAPU32[value >> 2];
+                    var HEAP = getHeap();
+                    var str;
+                    var decodeStartPtr = value + 4;
+                    // Looping here to support possible embedded '0' bytes
+                    for (var i = 0; i <= length; ++i) {
+                        var currentBytePtr = value + 4 + i * charSize;
+                        if (i == length || HEAP[currentBytePtr >> shift] == 0) {
+                            var maxReadBytes = currentBytePtr - decodeStartPtr;
+                            var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+                            if (str === undefined) {
+                                str = stringSegment;
+                            }
+                            else {
+                                str += String.fromCharCode(0);
+                                str += stringSegment;
+                            }
+                            decodeStartPtr = currentBytePtr + charSize;
+                        }
+                    }
+                    _free(value);
+                    return str;
+                },
+                'toWireType': function (destructors, value) {
+                    if (!(typeof value == 'string')) {
+                        throwBindingError('Cannot pass non-string to C++ string type ' + name);
+                    }
+                    // assumes 4-byte alignment
+                    var length = lengthBytesUTF(value);
+                    var ptr = _malloc(4 + length + charSize);
+                    HEAPU32[ptr >> 2] = length >> shift;
+                    encodeString(value, ptr + 4, length + charSize);
+                    if (destructors !== null) {
+                        destructors.push(_free, ptr);
+                    }
+                    return ptr;
+                },
+                'argPackAdvance': 8,
+                'readValueFromPointer': simpleReadValueFromPointer,
+                destructorFunction: function (ptr) { _free(ptr); },
+            });
+        }
+        function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
+            structRegistrations[rawType] = {
+                name: readLatin1String(name),
+                rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
+                rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
+                fields: [],
+            };
+        }
+        function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+            structRegistrations[structType].fields.push({
+                fieldName: readLatin1String(fieldName),
+                getterReturnType: getterReturnType,
+                getter: embind__requireFunction(getterSignature, getter),
+                getterContext: getterContext,
+                setterArgumentType: setterArgumentType,
+                setter: embind__requireFunction(setterSignature, setter),
+                setterContext: setterContext,
+            });
+        }
+        function __embind_register_void(rawType, name) {
+            name = readLatin1String(name);
+            registerType(rawType, {
+                isVoid: true,
+                name: name,
+                'argPackAdvance': 0,
+                'fromWireType': function () {
+                    return undefined;
+                },
+                'toWireType': function (destructors, o) {
+                    // TODO: assert if anything else is given?
+                    return undefined;
+                },
+            });
+        }
+        function requireRegisteredType(rawType, humanName) {
+            var impl = registeredTypes[rawType];
+            if (undefined === impl) {
+                throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
+            }
+            return impl;
+        }
+        function __emval_as(handle, returnType, destructorsRef) {
+            handle = Emval.toValue(handle);
+            returnType = requireRegisteredType(returnType, 'emval::as');
+            var destructors = [];
+            var rd = Emval.toHandle(destructors);
+            HEAPU32[((destructorsRef) >> 2)] = rd;
+            return returnType['toWireType'](destructors, handle);
+        }
+        function emval_allocateDestructors(destructorsRef) {
+            var destructors = [];
+            HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors);
+            return destructors;
+        }
+        var emval_symbols = {};
+        function getStringOrSymbol(address) {
+            var symbol = emval_symbols[address];
+            if (symbol === undefined) {
+                return readLatin1String(address);
+            }
+            return symbol;
+        }
+        var emval_methodCallers = [];
+        function __emval_call_void_method(caller, handle, methodName, args) {
+            caller = emval_methodCallers[caller];
+            handle = Emval.toValue(handle);
+            methodName = getStringOrSymbol(methodName);
+            caller(handle, methodName, null, args);
+        }
+        function emval_addMethodCaller(caller) {
+            var id = emval_methodCallers.length;
+            emval_methodCallers.push(caller);
+            return id;
+        }
+        function emval_lookupTypes(argCount, argTypes) {
+            var a = new Array(argCount);
+            for (var i = 0; i < argCount; ++i) {
+                a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], "parameter " + i);
+            }
+            return a;
+        }
+        var emval_registeredMethods = [];
+        function __emval_get_method_caller(argCount, argTypes) {
+            var types = emval_lookupTypes(argCount, argTypes);
+            var retType = types[0];
+            var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$";
+            var returnId = emval_registeredMethods[signatureName];
+            if (returnId !== undefined) {
+                return returnId;
+            }
+            var params = ["retType"];
+            var args = [retType];
+            var argsList = ""; // 'arg0, arg1, arg2, ... , argN'
+            for (var i = 0; i < argCount - 1; ++i) {
+                argsList += (i !== 0 ? ", " : "") + "arg" + i;
+                params.push("argType" + i);
+                args.push(types[1 + i]);
+            }
+            var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
+            var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n";
+            var offset = 0;
+            for (var i = 0; i < argCount - 1; ++i) {
+                functionBody +=
+                    "    var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? ("+" + offset) : "") + ");\n";
+                offset += types[i + 1]['argPackAdvance'];
+            }
+            functionBody +=
+                "    var rv = handle[name](" + argsList + ");\n";
+            for (var i = 0; i < argCount - 1; ++i) {
+                if (types[i + 1]['deleteObject']) {
+                    functionBody +=
+                        "    argType" + i + ".deleteObject(arg" + i + ");\n";
+                }
+            }
+            if (!retType.isVoid) {
+                functionBody +=
+                    "    return retType.toWireType(destructors, rv);\n";
+            }
+            functionBody +=
+                "};\n";
+            params.push(functionBody);
+            var invokerFunction = new_(Function, params).apply(null, args);
+            returnId = emval_addMethodCaller(invokerFunction);
+            emval_registeredMethods[signatureName] = returnId;
+            return returnId;
+        }
+        function __emval_get_property(handle, key) {
+            handle = Emval.toValue(handle);
+            key = Emval.toValue(key);
+            return Emval.toHandle(handle[key]);
+        }
+        function __emval_incref(handle) {
+            if (handle > 4) {
+                emval_handle_array[handle].refcount += 1;
+            }
+        }
+        function __emval_new_array() {
+            return Emval.toHandle([]);
+        }
+        function __emval_new_cstring(v) {
+            return Emval.toHandle(getStringOrSymbol(v));
+        }
+        function __emval_run_destructors(handle) {
+            var destructors = Emval.toValue(handle);
+            runDestructors(destructors);
+            __emval_decref(handle);
+        }
+        function __emval_take_value(type, arg) {
+            type = requireRegisteredType(type, '_emval_take_value');
+            var v = type['readValueFromPointer'](arg);
+            return Emval.toHandle(v);
+        }
+        function _abort() {
+            abort('');
+        }
+        function _emscripten_memcpy_big(dest, src, num) {
+            HEAPU8.copyWithin(dest, src, src + num);
+        }
+        function getHeapMax() {
+            // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+            // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+            // for any code that deals with heap sizes, which would require special
+            // casing all heap size related code to treat 0 specially.
+            return 2147483648;
+        }
+        function emscripten_realloc_buffer(size) {
+            var b = wasmMemory.buffer;
+            try {
+                // round size grow request up to wasm page size (fixed 64KB per spec)
+                wasmMemory.grow((size - b.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size
+                updateMemoryViews();
+                return 1 /*success*/;
+            }
+            catch (e) {
+            }
+            // implicit 0 return to save code size (caller will cast "undefined" into 0
+            // anyhow)
+        }
+        function _emscripten_resize_heap(requestedSize) {
+            var oldSize = HEAPU8.length;
+            requestedSize = requestedSize >>> 0;
+            // With multithreaded builds, races can happen (another thread might increase the size
+            // in between), so return a failure, and let the caller retry.
+            // Memory resize rules:
+            // 1.  Always increase heap size to at least the requested size, rounded up
+            //     to next page multiple.
+            // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+            //     geometrically: increase the heap size according to
+            //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+            //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+            // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+            //     linearly: increase the heap size by at least
+            //     MEMORY_GROWTH_LINEAR_STEP bytes.
+            // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+            //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+            // 4.  If we were unable to allocate as much memory, it may be due to
+            //     over-eager decision to excessively reserve due to (3) above.
+            //     Hence if an allocation fails, cut down on the amount of excess
+            //     growth, in an attempt to succeed to perform a smaller allocation.
+            // A limit is set for how much we can grow. We should not exceed that
+            // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+            var maxHeapSize = getHeapMax();
+            if (requestedSize > maxHeapSize) {
+                return false;
+            }
+            let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+            // Loop through potential heap size increases. If we attempt a too eager
+            // reservation that fails, cut down on the attempted size and reserve a
+            // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+            for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
+                // but limit overreserving (default to capping at +96MB overgrowth at most)
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = emscripten_realloc_buffer(newSize);
+                if (replacement) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        var ENV = {};
+        function getExecutableName() {
+            return thisProgram || './this.program';
+        }
+        function getEnvStrings() {
+            if (!getEnvStrings.strings) {
+                // Default values.
+                // Browser language detection #8751
+                var lang = ((typeof navigator == 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8';
+                var env = {
+                    'USER': 'web_user',
+                    'LOGNAME': 'web_user',
+                    'PATH': '/',
+                    'PWD': '/',
+                    'HOME': '/home/web_user',
+                    'LANG': lang,
+                    '_': getExecutableName()
+                };
+                // Apply the user-provided values, if any.
+                for (var x in ENV) {
+                    // x is a key in ENV; if ENV[x] is undefined, that means it was
+                    // explicitly set to be so. We allow user code to do that to
+                    // force variables with default values to remain unset.
+                    if (ENV[x] === undefined)
+                        delete env[x];
+                    else
+                        env[x] = ENV[x];
+                }
+                var strings = [];
+                for (var x in env) {
+                    strings.push(x + '=' + env[x]);
+                }
+                getEnvStrings.strings = strings;
+            }
+            return getEnvStrings.strings;
+        }
+        /** @param {boolean=} dontAddNull */
+        function writeAsciiToMemory(str, buffer, dontAddNull) {
+            for (var i = 0; i < str.length; ++i) {
+                HEAP8[((buffer++) >> 0)] = str.charCodeAt(i);
+            }
+            // Null-terminate the pointer to the HEAP.
+            if (!dontAddNull)
+                HEAP8[((buffer) >> 0)] = 0;
+        }
+        var SYSCALLS = { varargs: undefined, get: function () {
+                SYSCALLS.varargs += 4;
+                var ret = HEAP32[(((SYSCALLS.varargs) - (4)) >> 2)];
+                return ret;
+            }, getStr: function (ptr) {
+                var ret = UTF8ToString(ptr);
+                return ret;
+            } };
+        function _environ_get(__environ, environ_buf) {
+            var bufSize = 0;
+            getEnvStrings().forEach(function (string, i) {
+                var ptr = environ_buf + bufSize;
+                HEAPU32[(((__environ) + (i * 4)) >> 2)] = ptr;
+                writeAsciiToMemory(string, ptr);
+                bufSize += string.length + 1;
+            });
+            return 0;
+        }
+        function _environ_sizes_get(penviron_count, penviron_buf_size) {
+            var strings = getEnvStrings();
+            HEAPU32[((penviron_count) >> 2)] = strings.length;
+            var bufSize = 0;
+            strings.forEach(function (string) {
+                bufSize += string.length + 1;
+            });
+            HEAPU32[((penviron_buf_size) >> 2)] = bufSize;
+            return 0;
+        }
+        function __isLeapYear(year) {
+            return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        }
+        function __arraySum(array, index) {
+            var sum = 0;
+            for (var i = 0; i <= index; sum += array[i++]) {
+                // no-op
+            }
+            return sum;
+        }
+        var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        function __addDays(date, days) {
+            var newDate = new Date(date.getTime());
+            while (days > 0) {
+                var leap = __isLeapYear(newDate.getFullYear());
+                var currentMonth = newDate.getMonth();
+                var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
+                if (days > daysInCurrentMonth - newDate.getDate()) {
+                    // we spill over to next month
+                    days -= (daysInCurrentMonth - newDate.getDate() + 1);
+                    newDate.setDate(1);
+                    if (currentMonth < 11) {
+                        newDate.setMonth(currentMonth + 1);
+                    }
+                    else {
+                        newDate.setMonth(0);
+                        newDate.setFullYear(newDate.getFullYear() + 1);
+                    }
+                }
+                else {
+                    // we stay in current month
+                    newDate.setDate(newDate.getDate() + days);
+                    return newDate;
+                }
+            }
+            return newDate;
+        }
+        /** @type {function(string, boolean=, number=)} */
+        function intArrayFromString(stringy, dontAddNull, length) {
+            var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+            var u8array = new Array(len);
+            var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+            if (dontAddNull)
+                u8array.length = numBytesWritten;
+            return u8array;
+        }
+        function writeArrayToMemory(array, buffer) {
+            HEAP8.set(array, buffer);
+        }
+        function _strftime(s, maxsize, format, tm) {
+            // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
+            // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
+            var tm_zone = HEAP32[(((tm) + (40)) >> 2)];
+            var date = {
+                tm_sec: HEAP32[((tm) >> 2)],
+                tm_min: HEAP32[(((tm) + (4)) >> 2)],
+                tm_hour: HEAP32[(((tm) + (8)) >> 2)],
+                tm_mday: HEAP32[(((tm) + (12)) >> 2)],
+                tm_mon: HEAP32[(((tm) + (16)) >> 2)],
+                tm_year: HEAP32[(((tm) + (20)) >> 2)],
+                tm_wday: HEAP32[(((tm) + (24)) >> 2)],
+                tm_yday: HEAP32[(((tm) + (28)) >> 2)],
+                tm_isdst: HEAP32[(((tm) + (32)) >> 2)],
+                tm_gmtoff: HEAP32[(((tm) + (36)) >> 2)],
+                tm_zone: tm_zone ? UTF8ToString(tm_zone) : ''
+            };
+            var pattern = UTF8ToString(format);
+            // expand format
+            var EXPANSION_RULES_1 = {
+                '%c': '%a %b %d %H:%M:%S %Y',
+                '%D': '%m/%d/%y',
+                '%F': '%Y-%m-%d',
+                '%h': '%b',
+                '%r': '%I:%M:%S %p',
+                '%R': '%H:%M',
+                '%T': '%H:%M:%S',
+                '%x': '%m/%d/%y',
+                '%X': '%H:%M:%S',
+                // Modified Conversion Specifiers
+                '%Ec': '%c',
+                '%EC': '%C',
+                '%Ex': '%m/%d/%y',
+                '%EX': '%H:%M:%S',
+                '%Ey': '%y',
+                '%EY': '%Y',
+                '%Od': '%d',
+                '%Oe': '%e',
+                '%OH': '%H',
+                '%OI': '%I',
+                '%Om': '%m',
+                '%OM': '%M',
+                '%OS': '%S',
+                '%Ou': '%u',
+                '%OU': '%U',
+                '%OV': '%V',
+                '%Ow': '%w',
+                '%OW': '%W',
+                '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols.
+            };
+            for (var rule in EXPANSION_RULES_1) {
+                pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]);
+            }
+            var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+            var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+            function leadingSomething(value, digits, character) {
+                var str = typeof value == 'number' ? value.toString() : (value || '');
+                while (str.length < digits) {
+                    str = character[0] + str;
+                }
+                return str;
+            }
+            function leadingNulls(value, digits) {
+                return leadingSomething(value, digits, '0');
+            }
+            function compareByDay(date1, date2) {
+                function sgn(value) {
+                    return value < 0 ? -1 : (value > 0 ? 1 : 0);
+                }
+                var compare;
+                if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
+                    if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
+                        compare = sgn(date1.getDate() - date2.getDate());
+                    }
+                }
+                return compare;
+            }
+            function getFirstWeekStartDate(janFourth) {
+                switch (janFourth.getDay()) {
+                    case 0: // Sunday
+                        return new Date(janFourth.getFullYear() - 1, 11, 29);
+                    case 1: // Monday
+                        return janFourth;
+                    case 2: // Tuesday
+                        return new Date(janFourth.getFullYear(), 0, 3);
+                    case 3: // Wednesday
+                        return new Date(janFourth.getFullYear(), 0, 2);
+                    case 4: // Thursday
+                        return new Date(janFourth.getFullYear(), 0, 1);
+                    case 5: // Friday
+                        return new Date(janFourth.getFullYear() - 1, 11, 31);
+                    case 6: // Saturday
+                        return new Date(janFourth.getFullYear() - 1, 11, 30);
+                }
+            }
+            function getWeekBasedYear(date) {
+                var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
+                var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+                var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
+                var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+                var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+                if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+                    // this date is after the start of the first week of this year
+                    if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+                        return thisDate.getFullYear() + 1;
+                    }
+                    return thisDate.getFullYear();
+                }
+                return thisDate.getFullYear() - 1;
+            }
+            var EXPANSION_RULES_2 = {
+                '%a': function (date) {
+                    return WEEKDAYS[date.tm_wday].substring(0, 3);
+                },
+                '%A': function (date) {
+                    return WEEKDAYS[date.tm_wday];
+                },
+                '%b': function (date) {
+                    return MONTHS[date.tm_mon].substring(0, 3);
+                },
+                '%B': function (date) {
+                    return MONTHS[date.tm_mon];
+                },
+                '%C': function (date) {
+                    var year = date.tm_year + 1900;
+                    return leadingNulls((year / 100) | 0, 2);
+                },
+                '%d': function (date) {
+                    return leadingNulls(date.tm_mday, 2);
+                },
+                '%e': function (date) {
+                    return leadingSomething(date.tm_mday, 2, ' ');
+                },
+                '%g': function (date) {
+                    // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
+                    // In this system, weeks begin on a Monday and week 1 of the year is the week that includes
+                    // January 4th, which is also the week that includes the first Thursday of the year, and
+                    // is also the first week that contains at least four days in the year.
+                    // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of
+                    // the last week of the preceding year; thus, for Saturday 2nd January 1999,
+                    // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th,
+                    // or 31st is a Monday, it and any following days are part of week 1 of the following year.
+                    // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01.
+                    return getWeekBasedYear(date).toString().substring(2);
+                },
+                '%G': function (date) {
+                    return getWeekBasedYear(date);
+                },
+                '%H': function (date) {
+                    return leadingNulls(date.tm_hour, 2);
+                },
+                '%I': function (date) {
+                    var twelveHour = date.tm_hour;
+                    if (twelveHour == 0)
+                        twelveHour = 12;
+                    else if (twelveHour > 12)
+                        twelveHour -= 12;
+                    return leadingNulls(twelveHour, 2);
+                },
+                '%j': function (date) {
+                    // Day of the year (001-366)
+                    return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
+                },
+                '%m': function (date) {
+                    return leadingNulls(date.tm_mon + 1, 2);
+                },
+                '%M': function (date) {
+                    return leadingNulls(date.tm_min, 2);
+                },
+                '%n': function () {
+                    return '\n';
+                },
+                '%p': function (date) {
+                    if (date.tm_hour >= 0 && date.tm_hour < 12) {
+                        return 'AM';
+                    }
+                    return 'PM';
+                },
+                '%S': function (date) {
+                    return leadingNulls(date.tm_sec, 2);
+                },
+                '%t': function () {
+                    return '\t';
+                },
+                '%u': function (date) {
+                    return date.tm_wday || 7;
+                },
+                '%U': function (date) {
+                    var days = date.tm_yday + 7 - date.tm_wday;
+                    return leadingNulls(Math.floor(days / 7), 2);
+                },
+                '%V': function (date) {
+                    // Replaced by the week number of the year (Monday as the first day of the week)
+                    // as a decimal number [01,53]. If the week containing 1 January has four
+                    // or more days in the new year, then it is considered week 1.
+                    // Otherwise, it is the last week of the previous year, and the next week is week 1.
+                    // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday]
+                    var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7) / 7);
+                    // If 1 Jan is just 1-3 days past Monday, the previous week
+                    // is also in this year.
+                    if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
+                        val++;
+                    }
+                    if (!val) {
+                        val = 52;
+                        // If 31 December of prev year a Thursday, or Friday of a
+                        // leap year, then the prev year has 53 weeks.
+                        var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
+                        if (dec31 == 4 || (dec31 == 5 && __isLeapYear(date.tm_year % 400 - 1))) {
+                            val++;
+                        }
+                    }
+                    else if (val == 53) {
+                        // If 1 January is not a Thursday, and not a Wednesday of a
+                        // leap year, then this year has only 52 weeks.
+                        var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
+                        if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year)))
+                            val = 1;
+                    }
+                    return leadingNulls(val, 2);
+                },
+                '%w': function (date) {
+                    return date.tm_wday;
+                },
+                '%W': function (date) {
+                    var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
+                    return leadingNulls(Math.floor(days / 7), 2);
+                },
+                '%y': function (date) {
+                    // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
+                    return (date.tm_year + 1900).toString().substring(2);
+                },
+                '%Y': function (date) {
+                    // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
+                    return date.tm_year + 1900;
+                },
+                '%z': function (date) {
+                    // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ).
+                    // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
+                    var off = date.tm_gmtoff;
+                    var ahead = off >= 0;
+                    off = Math.abs(off) / 60;
+                    // convert from minutes into hhmm format (which means 60 minutes = 100 units)
+                    off = (off / 60) * 100 + (off % 60);
+                    return (ahead ? '+' : '-') + String("0000" + off).slice(-4);
+                },
+                '%Z': function (date) {
+                    return date.tm_zone;
+                },
+                '%%': function () {
+                    return '%';
+                }
+            };
+            // Replace %% with a pair of NULLs (which cannot occur in a C string), then
+            // re-inject them after processing.
+            pattern = pattern.replace(/%%/g, '\0\0');
+            for (var rule in EXPANSION_RULES_2) {
+                if (pattern.includes(rule)) {
+                    pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
+                }
+            }
+            pattern = pattern.replace(/\0\0/g, '%');
+            var bytes = intArrayFromString(pattern, false);
+            if (bytes.length > maxsize) {
+                return 0;
+            }
+            writeArrayToMemory(bytes, s);
+            return bytes.length - 1;
+        }
+        function _strftime_l(s, maxsize, format, tm, loc) {
+            return _strftime(s, maxsize, format, tm); // no locale support yet
+        }
+        InternalError = Module['InternalError'] = extendError(Error, 'InternalError');
+        ;
+        embind_init_charCodes();
+        BindingError = Module['BindingError'] = extendError(Error, 'BindingError');
+        ;
+        init_ClassHandle();
+        init_embind();
+        ;
+        init_RegisteredPointer();
+        UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');
+        ;
+        init_emval();
+        ;
+        var wasmImports = {
+            "__assert_fail": ___assert_fail,
+            "_embind_finalize_value_object": __embind_finalize_value_object,
+            "_embind_register_bigint": __embind_register_bigint,
+            "_embind_register_bool": __embind_register_bool,
+            "_embind_register_class": __embind_register_class,
+            "_embind_register_class_constructor": __embind_register_class_constructor,
+            "_embind_register_class_property": __embind_register_class_property,
+            "_embind_register_emval": __embind_register_emval,
+            "_embind_register_float": __embind_register_float,
+            "_embind_register_function": __embind_register_function,
+            "_embind_register_integer": __embind_register_integer,
+            "_embind_register_memory_view": __embind_register_memory_view,
+            "_embind_register_std_string": __embind_register_std_string,
+            "_embind_register_std_wstring": __embind_register_std_wstring,
+            "_embind_register_value_object": __embind_register_value_object,
+            "_embind_register_value_object_field": __embind_register_value_object_field,
+            "_embind_register_void": __embind_register_void,
+            "_emval_as": __emval_as,
+            "_emval_call_void_method": __emval_call_void_method,
+            "_emval_decref": __emval_decref,
+            "_emval_get_method_caller": __emval_get_method_caller,
+            "_emval_get_property": __emval_get_property,
+            "_emval_incref": __emval_incref,
+            "_emval_new_array": __emval_new_array,
+            "_emval_new_cstring": __emval_new_cstring,
+            "_emval_run_destructors": __emval_run_destructors,
+            "_emval_take_value": __emval_take_value,
+            "abort": _abort,
+            "emscripten_memcpy_big": _emscripten_memcpy_big,
+            "emscripten_resize_heap": _emscripten_resize_heap,
+            "environ_get": _environ_get,
+            "environ_sizes_get": _environ_sizes_get,
+            "strftime_l": _strftime_l,
+            "wasm_loadfileproc": wasm_loadfileproc,
+            "wasm_msgproc": wasm_msgproc
+        };
+        var asm = createWasm();
+        /** @type {function(...*):?} */
+        var ___wasm_call_ctors = function () {
+            return (___wasm_call_ctors = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = function () {
+            return (_kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = Module["asm"]["kmcmp_CompileKeyboard"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = function () {
+            return (_kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = Module["asm"]["kmcmp_parseUnicodeSet"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _malloc = function () {
+            return (_malloc = Module["asm"]["malloc"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _free = function () {
+            return (_free = Module["asm"]["free"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var ___getTypeName = Module["___getTypeName"] = function () {
+            return (___getTypeName = Module["___getTypeName"] = Module["asm"]["__getTypeName"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = function () {
+            return (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = Module["asm"]["_embind_initialize_bindings"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var ___errno_location = function () {
+            return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var ___trap = function () {
+            return (___trap = Module["asm"]["__trap"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var stackSave = function () {
+            return (stackSave = Module["asm"]["stackSave"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var stackRestore = function () {
+            return (stackRestore = Module["asm"]["stackRestore"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var stackAlloc = function () {
+            return (stackAlloc = Module["asm"]["stackAlloc"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_viijii = Module["dynCall_viijii"] = function () {
+            return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["dynCall_viijii"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_iiiiij = Module["dynCall_iiiiij"] = function () {
+            return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["dynCall_iiiiij"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function () {
+            return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function () {
+            return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments);
+        };
+        var ___start_em_js = Module['___start_em_js'] = 58784;
+        var ___stop_em_js = Module['___stop_em_js'] = 59480;
+        // include: postamble.js
+        // === Auto-generated postamble setup entry stuff ===
+        Module["UTF8ToString"] = UTF8ToString;
+        var calledRun;
+        dependenciesFulfilled = function runCaller() {
+            // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+            if (!calledRun)
+                run();
+            if (!calledRun)
+                dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+        };
+        function run() {
+            if (runDependencies > 0) {
+                return;
+            }
+            preRun();
+            // a preRun added a dependency, run will be called later
+            if (runDependencies > 0) {
+                return;
+            }
+            function doRun() {
+                // run may have just been called through dependencies being fulfilled just in this very frame,
+                // or while the async setStatus time below was happening
+                if (calledRun)
+                    return;
+                calledRun = true;
+                Module['calledRun'] = true;
+                if (ABORT)
+                    return;
+                initRuntime();
+                readyPromiseResolve(Module);
+                if (Module['onRuntimeInitialized'])
+                    Module['onRuntimeInitialized']();
+                postRun();
+            }
+            if (Module['setStatus']) {
+                Module['setStatus']('Running...');
+                setTimeout(function () {
+                    setTimeout(function () {
+                        Module['setStatus']('');
+                    }, 1);
+                    doRun();
+                }, 1);
+            }
+            else {
+                doRun();
+            }
+        }
+        if (Module['preInit']) {
+            if (typeof Module['preInit'] == 'function')
+                Module['preInit'] = [Module['preInit']];
+            while (Module['preInit'].length > 0) {
+                Module['preInit'].pop()();
+            }
+        }
+        run();
+        // end include: postamble.js
+        return Module.ready;
+    });
+})();
+export default Module;
+//# debugId=e74e4a68-a330-5169-afb5-9cc31699f8ce
+//# sourceMappingURL=wasm-host.js.map