@keymanapp/kmc-kmn 17.0.112-alpha → 17.0.114-alpha

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

@@ -288,7 +288,7 @@ var Module = (() => {
         } instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); return {}; }
         var tempDouble;
         var tempI64;
-        var ASM_CONSTS = { 72665: $0 => { let path = Module.UTF8ToString($0); const isWin32Path = path.match(/^[a-zA-Z]:/); let root = "/nodefs-mount"; if (!FS.analyzePath(root).exists) {
+        var ASM_CONSTS = { 58057: $0 => { let path = Module.UTF8ToString($0); const isWin32Path = path.match(/^[a-zA-Z]:/); let root = "/nodefs-mount"; if (!FS.analyzePath(root).exists) {
                 FS.mkdir(root);
                 if (!isWin32Path) {
                     FS.mount(NODEFS, { root: "/" }, root);
@@ -1585,16 +1585,6 @@ var Module = (() => {
                 throw e;
             return -e.errno;
         } }
-        function ___syscall_rmdir(path) { try {
-            path = SYSCALLS.getStr(path);
-            FS.rmdir(path);
-            return 0;
-        }
-        catch (e) {
-            if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
-                throw e;
-            return -e.errno;
-        } }
         function ___syscall_unlinkat(dirfd, path, flags) { try {
             path = SYSCALLS.getStr(path);
             path = SYSCALLS.calculateAt(dirfd, path);
@@ -1614,6 +1604,676 @@ var Module = (() => {
                 throw e;
             return -e.errno;
         } }
+        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; } }); }
         var nowIsMonotonic = true;
         function __emscripten_get_now_is_monotonic() { return nowIsMonotonic; }
         function _abort() { abort(""); }
@@ -1805,31 +2465,6 @@ var Module = (() => {
             return 0;
         } writeArrayToMemory(bytes, s); return bytes.length - 1; }
         function _strftime_l(s, maxsize, format, tm, loc) { return _strftime(s, maxsize, format, tm); }
-        function getCFunc(ident) { var func = Module["_" + ident]; return func; }
-        function ccall(ident, returnType, argTypes, args, opts) { var toC = { "string": str => { var ret = 0; if (str !== null && str !== undefined && str !== 0) {
-                var len = (str.length << 2) + 1;
-                ret = stackAlloc(len);
-                stringToUTF8(str, ret, len);
-            } return ret; }, "array": arr => { var ret = stackAlloc(arr.length); writeArrayToMemory(arr, ret); return ret; } }; function convertReturnValue(ret) { if (returnType === "string") {
-            return UTF8ToString(ret);
-        } if (returnType === "boolean")
-            return Boolean(ret); return ret; } var func = getCFunc(ident); var cArgs = []; var stack = 0; if (args) {
-            for (var i = 0; i < args.length; i++) {
-                var converter = toC[argTypes[i]];
-                if (converter) {
-                    if (stack === 0)
-                        stack = stackSave();
-                    cArgs[i] = converter(args[i]);
-                }
-                else {
-                    cArgs[i] = args[i];
-                }
-            }
-        } var ret = func.apply(null, cArgs); function onDone(ret) { if (stack !== 0)
-            stackRestore(stack); return convertReturnValue(ret); } ret = onDone(ret); return ret; }
-        function cwrap(ident, returnType, argTypes, opts) { var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean"); var numericRet = returnType !== "string"; if (numericRet && numericArgs && !opts) {
-            return getCFunc(ident);
-        } return function () { return ccall(ident, returnType, argTypes, arguments, opts); }; }
         var FSNode = function (parent, name, mode, rdev) { if (!parent) {
             parent = this;
         } this.parent = parent; this.mount = parent.mount; this.mounted = null; this.id = FS.nextInode++; this.name = name; this.mode = mode; this.node_ops = {}; this.stream_ops = {}; this.rdev = rdev; };
@@ -1842,19 +2477,24 @@ var Module = (() => {
             NODEFS.staticInit();
         }
         ERRNO_CODES = { "EPERM": 63, "ENOENT": 44, "ESRCH": 71, "EINTR": 27, "EIO": 29, "ENXIO": 60, "E2BIG": 1, "ENOEXEC": 45, "EBADF": 8, "ECHILD": 12, "EAGAIN": 6, "EWOULDBLOCK": 6, "ENOMEM": 48, "EACCES": 2, "EFAULT": 21, "ENOTBLK": 105, "EBUSY": 10, "EEXIST": 20, "EXDEV": 75, "ENODEV": 43, "ENOTDIR": 54, "EISDIR": 31, "EINVAL": 28, "ENFILE": 41, "EMFILE": 33, "ENOTTY": 59, "ETXTBSY": 74, "EFBIG": 22, "ENOSPC": 51, "ESPIPE": 70, "EROFS": 69, "EMLINK": 34, "EPIPE": 64, "EDOM": 18, "ERANGE": 68, "ENOMSG": 49, "EIDRM": 24, "ECHRNG": 106, "EL2NSYNC": 156, "EL3HLT": 107, "EL3RST": 108, "ELNRNG": 109, "EUNATCH": 110, "ENOCSI": 111, "EL2HLT": 112, "EDEADLK": 16, "ENOLCK": 46, "EBADE": 113, "EBADR": 114, "EXFULL": 115, "ENOANO": 104, "EBADRQC": 103, "EBADSLT": 102, "EDEADLOCK": 16, "EBFONT": 101, "ENOSTR": 100, "ENODATA": 116, "ETIME": 117, "ENOSR": 118, "ENONET": 119, "ENOPKG": 120, "EREMOTE": 121, "ENOLINK": 47, "EADV": 122, "ESRMNT": 123, "ECOMM": 124, "EPROTO": 65, "EMULTIHOP": 36, "EDOTDOT": 125, "EBADMSG": 9, "ENOTUNIQ": 126, "EBADFD": 127, "EREMCHG": 128, "ELIBACC": 129, "ELIBBAD": 130, "ELIBSCN": 131, "ELIBMAX": 132, "ELIBEXEC": 133, "ENOSYS": 52, "ENOTEMPTY": 55, "ENAMETOOLONG": 37, "ELOOP": 32, "EOPNOTSUPP": 138, "EPFNOSUPPORT": 139, "ECONNRESET": 15, "ENOBUFS": 42, "EAFNOSUPPORT": 5, "EPROTOTYPE": 67, "ENOTSOCK": 57, "ENOPROTOOPT": 50, "ESHUTDOWN": 140, "ECONNREFUSED": 14, "EADDRINUSE": 3, "ECONNABORTED": 13, "ENETUNREACH": 40, "ENETDOWN": 38, "ETIMEDOUT": 73, "EHOSTDOWN": 142, "EHOSTUNREACH": 23, "EINPROGRESS": 26, "EALREADY": 7, "EDESTADDRREQ": 17, "EMSGSIZE": 35, "EPROTONOSUPPORT": 66, "ESOCKTNOSUPPORT": 137, "EADDRNOTAVAIL": 4, "ENETRESET": 39, "EISCONN": 30, "ENOTCONN": 53, "ETOOMANYREFS": 141, "EUSERS": 136, "EDQUOT": 19, "ESTALE": 72, "ENOTSUP": 138, "ENOMEDIUM": 148, "EILSEQ": 25, "EOVERFLOW": 61, "ECANCELED": 11, "ENOTRECOVERABLE": 56, "EOWNERDEAD": 62, "ESTRPIPE": 135 };
-        var wasmImports = { "__assert_fail": ___assert_fail, "__cxa_throw": ___cxa_throw, "__syscall_faccessat": ___syscall_faccessat, "__syscall_fcntl64": ___syscall_fcntl64, "__syscall_ioctl": ___syscall_ioctl, "__syscall_openat": ___syscall_openat, "__syscall_rmdir": ___syscall_rmdir, "__syscall_unlinkat": ___syscall_unlinkat, "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic, "abort": _abort, "emscripten_asm_const_int": _emscripten_asm_const_int, "emscripten_date_now": _emscripten_date_now, "emscripten_get_now": _emscripten_get_now, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "fd_close": _fd_close, "fd_read": _fd_read, "fd_seek": _fd_seek, "fd_write": _fd_write, "strftime_l": _strftime_l, "wasm_msgproc": wasm_msgproc };
+        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, "__cxa_throw": ___cxa_throw, "__syscall_faccessat": ___syscall_faccessat, "__syscall_fcntl64": ___syscall_fcntl64, "__syscall_ioctl": ___syscall_ioctl, "__syscall_openat": ___syscall_openat, "__syscall_unlinkat": ___syscall_unlinkat, "_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, "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic, "abort": _abort, "emscripten_asm_const_int": _emscripten_asm_const_int, "emscripten_date_now": _emscripten_date_now, "emscripten_get_now": _emscripten_get_now, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "fd_close": _fd_close, "fd_read": _fd_read, "fd_seek": _fd_seek, "fd_write": _fd_write, "strftime_l": _strftime_l, "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_SetCompilerOptions = Module["_kmcmp_SetCompilerOptions"] = function () { return (_kmcmp_SetCompilerOptions = Module["_kmcmp_SetCompilerOptions"] = Module["asm"]["kmcmp_SetCompilerOptions"]).apply(null, arguments); };
-        var _kmcmp_Wasm_SetCompilerOptions = Module["_kmcmp_Wasm_SetCompilerOptions"] = function () { return (_kmcmp_Wasm_SetCompilerOptions = Module["_kmcmp_Wasm_SetCompilerOptions"] = Module["asm"]["kmcmp_Wasm_SetCompilerOptions"]).apply(null, arguments); };
-        var _kmcmp_Wasm_CompileKeyboardFile = Module["_kmcmp_Wasm_CompileKeyboardFile"] = function () { return (_kmcmp_Wasm_CompileKeyboardFile = Module["_kmcmp_Wasm_CompileKeyboardFile"] = Module["asm"]["kmcmp_Wasm_CompileKeyboardFile"]).apply(null, arguments); };
-        var _kmcmp_CompileKeyboardFile = Module["_kmcmp_CompileKeyboardFile"] = function () { return (_kmcmp_CompileKeyboardFile = Module["_kmcmp_CompileKeyboardFile"] = Module["asm"]["kmcmp_CompileKeyboardFile"]).apply(null, arguments); };
-        var _kmcmp_Wasm_ParseUnicodeSet = Module["_kmcmp_Wasm_ParseUnicodeSet"] = function () { return (_kmcmp_Wasm_ParseUnicodeSet = Module["_kmcmp_Wasm_ParseUnicodeSet"] = Module["asm"]["kmcmp_Wasm_ParseUnicodeSet"]).apply(null, arguments); };
-        var _kmcmp_ParseUnicodeSet = Module["_kmcmp_ParseUnicodeSet"] = function () { return (_kmcmp_ParseUnicodeSet = Module["_kmcmp_ParseUnicodeSet"] = Module["asm"]["kmcmp_ParseUnicodeSet"]).apply(null, arguments); };
-        var _kmcmp_CompileKeyboardFileToBuffer = Module["_kmcmp_CompileKeyboardFileToBuffer"] = function () { return (_kmcmp_CompileKeyboardFileToBuffer = Module["_kmcmp_CompileKeyboardFileToBuffer"] = Module["asm"]["kmcmp_CompileKeyboardFileToBuffer"]).apply(null, arguments); };
-        var _kmcmp_ValidateJsonFile = Module["_kmcmp_ValidateJsonFile"] = function () { return (_kmcmp_ValidateJsonFile = Module["_kmcmp_ValidateJsonFile"] = Module["asm"]["kmcmp_ValidateJsonFile"]).apply(null, arguments); };
-        var ___errno_location = function () { return (___errno_location = Module["asm"]["__errno_location"]).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 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); };
@@ -1864,10 +2504,9 @@ var Module = (() => {
         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"] = 72388;
-        var ___stop_em_js = Module["___stop_em_js"] = 72665;
+        var ___start_em_js = Module["___start_em_js"] = 57780;
+        var ___stop_em_js = Module["___stop_em_js"] = 58057;
         Module["UTF8ToString"] = UTF8ToString;
-        Module["cwrap"] = cwrap;
         var calledRun;
         dependenciesFulfilled = function runCaller() { if (!calledRun)
             run(); if (!calledRun)