@keymanapp/kmc-kmn 18.0.79-alpha → 18.0.81-alpha

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

@@ -787,24 +787,6 @@ var Module = (() => {
         // 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) {
@@ -876,20 +858,6 @@ var 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']);
         }
-        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) {
@@ -913,6 +881,8 @@ var Module = (() => {
                 }
             }[name];
         }
+        var emval_handle_array = [{}, { value: undefined }, { value: null }, { value: true }, { value: false }];
+        var emval_free_list = [];
         function extendError(baseErrorType, errorName) {
             var errorClass = createNamedFunction(errorName, function (message) {
                 this.name = errorName;
@@ -935,121 +905,52 @@ var Module = (() => {
             };
             return errorClass;
         }
-        var InternalError = undefined;
-        function throwInternalError(message) {
-            throw new InternalError(message);
+        var BindingError = undefined;
+        function throwBindingError(message) {
+            throw new BindingError(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]);
+        function count_emval_handles() {
+            var count = 0;
+            for (var i = 5; i < emval_handle_array.length; ++i) {
+                if (emval_handle_array[i] !== undefined) {
+                    ++count;
                 }
             }
-            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);
-                        }
-                    });
+            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];
                 }
-            });
-            if (0 === unregisteredTypes.length) {
-                onComplete(typeConverters);
             }
+            return null;
         }
-        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 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;
+                    }
+                }
+            } };
+        var PureVirtualError = undefined;
         function embind_init_charCodes() {
             var codes = new Array(256);
             for (var i = 0; i < 256; ++i) {
@@ -1066,109 +967,84 @@ var Module = (() => {
             }
             return ret;
         }
-        var BindingError = undefined;
-        function throwBindingError(message) {
-            throw new BindingError(message);
+        function getInheritedInstanceCount() {
+            return Object.keys(registeredInstances).length;
         }
-        /** @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");
+        function getLiveInheritedInstances() {
+            var rv = [];
+            for (var k in registeredInstances) {
+                if (registeredInstances.hasOwnProperty(k)) {
+                    rv.push(registeredInstances[k]);
                 }
             }
-            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
-            });
+            return rv;
         }
-        function ClassHandle_isAliasOf(other) {
-            if (!(this instanceof ClassHandle)) {
-                return false;
+        var deletionQueue = [];
+        function flushPendingDeletes() {
+            while (deletionQueue.length) {
+                var obj = deletionQueue.pop();
+                obj.$$.deleteScheduled = false;
+                obj['delete']();
             }
-            if (!(other instanceof ClassHandle)) {
-                return false;
+        }
+        var delayFunction = undefined;
+        function setDelayFunction(fn) {
+            delayFunction = fn;
+            if (deletionQueue.length && delayFunction) {
+                delayFunction(flushPendingDeletes);
             }
-            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;
+        }
+        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 (rightClass.baseClass) {
-                right = rightClass.upcast(right);
-                rightClass = rightClass.baseClass;
+            while (class_.baseClass) {
+                ptr = class_.upcast(ptr);
+                class_ = class_.baseClass;
             }
-            return leftClass === rightClass && left === right;
+            return ptr;
         }
-        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 registerInheritedInstance(class_, ptr, instance) {
+            ptr = getBasestPointer(class_, ptr);
+            if (registeredInstances.hasOwnProperty(ptr)) {
+                throwBindingError('Tried to register registered instance: ' + ptr);
+            }
+            else {
+                registeredInstances[ptr] = instance;
+            }
         }
-        function throwInstanceAlreadyDeleted(obj) {
-            function getInstanceTypeName(handle) {
-                return handle.$$.ptrType.registeredClass.name;
+        var registeredTypes = {};
+        function getTypeName(type) {
+            var ptr = ___getTypeName(type);
+            var rv = readLatin1String(ptr);
+            _free(ptr);
+            return rv;
+        }
+        function requireRegisteredType(rawType, humanName) {
+            var impl = registeredTypes[rawType];
+            if (undefined === impl) {
+                throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
+            }
+            return impl;
+        }
+        function unregisterInheritedInstance(class_, ptr) {
+            ptr = getBasestPointer(class_, ptr);
+            if (registeredInstances.hasOwnProperty(ptr)) {
+                delete registeredInstances[ptr];
+            }
+            else {
+                throwBindingError('Tried to unregister unregistered instance: ' + ptr);
             }
-            throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
         }
-        var finalizationRegistry = false;
         function detachFinalizer(handle) { }
+        var finalizationRegistry = false;
         function runDestructor($$) {
             if ($$.smartPtr) {
                 $$.smartPtrType.rawDestructor($$.smartPtr);
@@ -1198,54 +1074,14 @@ var Module = (() => {
             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];
         }
+        var InternalError = undefined;
+        function throwInternalError(message) {
+            throw new InternalError(message);
+        }
         function makeClassHandle(prototype, record) {
             if (!record.ptrType || !record.ptr) {
                 throwInternalError('makeClassHandle requires ptr and ptrType');
@@ -1296,67 +1132,338 @@ var Module = (() => {
                     });
                 }
                 else {
-                    return makeClassHandle(this.registeredClass.instancePrototype, {
-                        ptrType: this,
-                        ptr: ptr,
-                    });
+                    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 __embind_create_inheriting_constructor(constructorName, wrapperType, properties) {
+            constructorName = readLatin1String(constructorName);
+            wrapperType = requireRegisteredType(wrapperType, 'wrapper');
+            properties = Emval.toValue(properties);
+            var arraySlice = [].slice;
+            var registeredClass = wrapperType.registeredClass;
+            var wrapperPrototype = registeredClass.instancePrototype;
+            var baseClass = registeredClass.baseClass;
+            var baseClassPrototype = baseClass.instancePrototype;
+            var baseConstructor = registeredClass.baseClass.constructor;
+            var ctor = createNamedFunction(constructorName, function () {
+                registeredClass.baseClass.pureVirtualFunctions.forEach(function (name) {
+                    if (this[name] === baseClassPrototype[name]) {
+                        throw new PureVirtualError('Pure virtual function ' + name + ' must be implemented in JavaScript');
+                    }
+                }.bind(this));
+                Object.defineProperty(this, '__parent', {
+                    value: wrapperPrototype
+                });
+                this["__construct"].apply(this, arraySlice.call(arguments));
+            });
+            // It's a little nasty that we're modifying the wrapper prototype here.
+            wrapperPrototype["__construct"] = function __construct() {
+                if (this === wrapperPrototype) {
+                    throwBindingError("Pass correct 'this' to __construct");
+                }
+                var inner = baseConstructor["implement"].apply(undefined, [this].concat(arraySlice.call(arguments)));
+                detachFinalizer(inner);
+                var $$ = inner.$$;
+                inner["notifyOnDestruction"]();
+                $$.preservePointerOnDelete = true;
+                Object.defineProperties(this, { $$: {
+                        value: $$
+                    } });
+                attachFinalizer(this);
+                registerInheritedInstance(registeredClass, $$.ptr, this);
+            };
+            wrapperPrototype["__destruct"] = function __destruct() {
+                if (this === wrapperPrototype) {
+                    throwBindingError("Pass correct 'this' to __destruct");
+                }
+                detachFinalizer(this);
+                unregisterInheritedInstance(registeredClass, this.$$.ptr);
+            };
+            ctor.prototype = Object.create(wrapperPrototype);
+            for (var p in properties) {
+                ctor.prototype[p] = properties[p];
+            }
+            return Emval.toHandle(ctor);
+        }
+        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 typeDependencies = {};
+        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);
+            }
+        }
+        /** @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");
                 }
             }
-            var actualType = this.registeredClass.getActualType(rawPointer);
-            var registeredPointerRecord = registeredPointers[actualType];
-            if (!registeredPointerRecord) {
-                return makeDefaultHandle.call(this);
-            }
-            var toType;
-            if (this.isConst) {
-                toType = registeredPointerRecord.constPointerType;
+            registeredTypes[rawType] = registeredInstance;
+            delete typeDependencies[rawType];
+            if (awaitingDependencies.hasOwnProperty(rawType)) {
+                var callbacks = awaitingDependencies[rawType];
+                delete awaitingDependencies[rawType];
+                callbacks.forEach((cb) => cb());
             }
-            else {
-                toType = registeredPointerRecord.pointerType;
+        }
+        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;
             }
-            var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
-            if (dp === null) {
-                return makeDefaultHandle.call(this);
+            if (!(other instanceof ClassHandle)) {
+                return false;
             }
-            if (this.isSmartPointer) {
-                return makeClassHandle(toType.registeredClass.instancePrototype, {
-                    ptrType: toType,
-                    ptr: dp,
-                    smartPtrType: this,
-                    smartPtr: ptr,
-                });
+            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;
             }
-            else {
-                return makeClassHandle(toType.registeredClass.instancePrototype, {
-                    ptrType: toType,
-                    ptr: dp,
-                });
+            while (rightClass.baseClass) {
+                right = rightClass.upcast(right);
+                rightClass = rightClass.baseClass;
             }
+            return leftClass === rightClass && left === right;
         }
-        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;
+        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,
             };
-            detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
-            return attachFinalizer(handle);
+        }
+        function throwInstanceAlreadyDeleted(obj) {
+            function getInstanceTypeName(handle) {
+                return handle.$$.ptrType.registeredClass.name;
+            }
+            throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
         }
         function ClassHandle_clone() {
             if (!this.$$.ptr) {
@@ -1709,12 +1816,6 @@ var Module = (() => {
             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 = {};
@@ -1790,15 +1891,6 @@ var Module = (() => {
                 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");
@@ -1901,6 +1993,58 @@ var Module = (() => {
             var invokerFunction = new_(Function, args1).apply(null, args2);
             return invokerFunction;
         }
+        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 __embind_register_class_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn, isAsync) {
+            var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+            methodName = readLatin1String(methodName);
+            rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+            whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+                classType = classType[0];
+                var humanName = classType.name + '.' + methodName;
+                function unboundTypesHandler() {
+                    throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);
+                }
+                if (methodName.startsWith("@@")) {
+                    methodName = Symbol[methodName.substring(2)];
+                }
+                var proto = classType.registeredClass.constructor;
+                if (undefined === proto[methodName]) {
+                    // This is the first function to be registered with this name.
+                    unboundTypesHandler.argCount = argCount - 1;
+                    proto[methodName] = unboundTypesHandler;
+                }
+                else {
+                    // There was an existing function with the same name registered. Set up
+                    // a function overload routing table.
+                    ensureOverloadTable(proto, methodName, humanName);
+                    proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler;
+                }
+                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                    // Replace the initial unbound-types-handler stub with the proper
+                    // function. If multiple overloads are registered, the function handlers
+                    // go into an overload table.
+                    var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);
+                    var func = craftInvokerFunction(humanName, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync);
+                    if (undefined === proto[methodName].overloadTable) {
+                        func.argCount = argCount - 1;
+                        proto[methodName] = func;
+                    }
+                    else {
+                        proto[methodName].overloadTable[argCount - 1] = func;
+                    }
+                    return [];
+                });
+                return [];
+            });
+        }
         function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
             assert(argCount > 0);
             var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
@@ -1928,6 +2072,55 @@ var Module = (() => {
                 return [];
             });
         }
+        function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, // [ReturnType, ThisType, Args...]
+        invokerSignature, rawInvoker, context, isPureVirtual, isAsync) {
+            var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+            methodName = readLatin1String(methodName);
+            rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+            whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+                classType = classType[0];
+                var humanName = classType.name + '.' + methodName;
+                if (methodName.startsWith("@@")) {
+                    methodName = Symbol[methodName.substring(2)];
+                }
+                if (isPureVirtual) {
+                    classType.registeredClass.pureVirtualFunctions.push(methodName);
+                }
+                function unboundTypesHandler() {
+                    throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);
+                }
+                var proto = classType.registeredClass.instancePrototype;
+                var method = proto[methodName];
+                if (undefined === method || (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)) {
+                    // This is the first overload to be registered, OR we are replacing a
+                    // function in the base class with a function in the derived class.
+                    unboundTypesHandler.argCount = argCount - 2;
+                    unboundTypesHandler.className = classType.name;
+                    proto[methodName] = unboundTypesHandler;
+                }
+                else {
+                    // There was an existing function with the same name registered. Set up
+                    // a function overload routing table.
+                    ensureOverloadTable(proto, methodName, humanName);
+                    proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+                }
+                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                    var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync);
+                    // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types
+                    // are resolved. If multiple overloads are registered for this function, the function goes into an overload table.
+                    if (undefined === proto[methodName].overloadTable) {
+                        // Set argCount in case an overload is registered later
+                        memberFunction.argCount = argCount - 2;
+                        proto[methodName] = memberFunction;
+                    }
+                    else {
+                        proto[methodName].overloadTable[argCount - 2] = memberFunction;
+                    }
+                    return [];
+                });
+                return [];
+            });
+        }
         function validateThis(this_, classType, humanName) {
             if (!(this_ instanceof Object)) {
                 throwBindingError(humanName + ' with invalid "this": ' + this_);
@@ -1990,55 +2183,12 @@ var Module = (() => {
                 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, {
@@ -2499,13 +2649,6 @@ var Module = (() => {
                 },
             });
         }
-        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');
@@ -2528,6 +2671,12 @@ var Module = (() => {
             return symbol;
         }
         var emval_methodCallers = [];
+        function __emval_call_method(caller, handle, methodName, destructorsRef, args) {
+            caller = emval_methodCallers[caller];
+            handle = Emval.toValue(handle);
+            methodName = getStringOrSymbol(methodName);
+            return caller(handle, methodName, emval_allocateDestructors(destructorsRef), args);
+        }
         function __emval_call_void_method(caller, handle, methodName, args) {
             caller = emval_methodCallers[caller];
             handle = Emval.toValue(handle);
@@ -2604,6 +2753,14 @@ var Module = (() => {
         function __emval_new_array() {
             return Emval.toHandle([]);
         }
+        function __emval_new_array_from_memory_view(view) {
+            view = Emval.toValue(view);
+            // using for..loop is faster than Array.from
+            var a = new Array(view.length);
+            for (var i = 0; i < view.length; i++)
+                a[i] = view[i];
+            return Emval.toHandle(a);
+        }
         function __emval_new_cstring(v) {
             return Emval.toHandle(getStringOrSymbol(v));
         }
@@ -3081,26 +3238,31 @@ var Module = (() => {
         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_emval();
+        ;
+        PureVirtualError = Module['PureVirtualError'] = extendError(Error, 'PureVirtualError');
+        ;
+        embind_init_charCodes();
         init_embind();
         ;
+        InternalError = Module['InternalError'] = extendError(Error, 'InternalError');
+        ;
+        init_ClassHandle();
         init_RegisteredPointer();
         UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');
         ;
-        init_emval();
-        ;
         var wasmImports = {
             "__assert_fail": ___assert_fail,
+            "_embind_create_inheriting_constructor": __embind_create_inheriting_constructor,
             "_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_class_function": __embind_register_class_class_function,
             "_embind_register_class_constructor": __embind_register_class_constructor,
+            "_embind_register_class_function": __embind_register_class_function,
             "_embind_register_class_property": __embind_register_class_property,
             "_embind_register_emval": __embind_register_emval,
             "_embind_register_float": __embind_register_float,
@@ -3113,12 +3275,14 @@ var Module = (() => {
             "_embind_register_value_object_field": __embind_register_value_object_field,
             "_embind_register_void": __embind_register_void,
             "_emval_as": __emval_as,
+            "_emval_call_method": __emval_call_method,
             "_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_array_from_memory_view": __emval_new_array_from_memory_view,
             "_emval_new_cstring": __emval_new_cstring,
             "_emval_run_destructors": __emval_run_destructors,
             "_emval_take_value": __emval_take_value,
@@ -3127,9 +3291,7 @@ var Module = (() => {
             "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
+            "strftime_l": _strftime_l
         };
         var asm = createWasm();
         /** @type {function(...*):?} */
@@ -3196,8 +3358,6 @@ var Module = (() => {
         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'] = 59888;
-        var ___stop_em_js = Module['___stop_em_js'] = 60584;
         // include: postamble.js
         // === Auto-generated postamble setup entry stuff ===
         Module["UTF8ToString"] = UTF8ToString;