@keymanapp/kmc-kmn 18.0.92-alpha → 18.0.94-alpha

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

@@ -1,11 +1,12 @@
 var Module = (() => {
-    var _scriptDir = import.meta.url;
-    return (async function (Module = {}) {
+    var _scriptName = import.meta.url;
+    return (async function (moduleArg = {}) {
+        var moduleRtn;
         // include: shell.js
         // The Module object: Our interface to the outside world. We import
         // and export values on it. There are various ways Module can be used:
         // 1. Not defined. We create it here
-        // 2. A function parameter, function(Module) { ..generated code.. }
+        // 2. A function parameter, function(moduleArg) => Promise<Module>
         // 3. pre-run appended it, var Module = {}; ..generated code..
         // 4. External script tag defines var Module.
         // We need to check if Module already exists (e.g. case 3 above).
@@ -15,13 +16,31 @@ var Module = (() => {
         // after the generated code, you will need to define   var Module = {};
         // before the code. Then that object will be used in the code, and you
         // can continue to use Module afterwards as well.
-        var Module = typeof Module != 'undefined' ? Module : {};
+        var Module = Object.assign({}, moduleArg);
         // Set up the promise that indicates the Module is initialized
         var readyPromiseResolve, readyPromiseReject;
-        Module['ready'] = new Promise(function (resolve, reject) {
+        var readyPromise = new Promise((resolve, reject) => {
             readyPromiseResolve = resolve;
             readyPromiseReject = reject;
         });
+        // Determine the runtime environment we are in. You can customize this by
+        // setting the ENVIRONMENT setting at compile time (see settings.js).
+        // Attempt to auto-detect the environment
+        var ENVIRONMENT_IS_WEB = typeof window == 'object';
+        var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
+        // N.b. Electron.js environment is simultaneously a NODE-environment, but
+        // also a web environment.
+        var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
+        var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+        if (ENVIRONMENT_IS_NODE) {
+            // `require()` is no-op in an ESM module, use `createRequire()` to construct
+            // the require()` function.  This is only necessary for multi-environment
+            // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
+            // TODO: Swap all `require()`'s with `import()`'s?
+            const { createRequire } = await import('module');
+            /** @suppress{duplicate} */
+            var require = createRequire(import.meta.url);
+        }
         // --pre-jses are emitted after the Module integration code, so that they can
         // refer to Module (if they choose; they can also define Module)
         // Sometimes an existing Module object exists with properties
@@ -35,15 +54,6 @@ var Module = (() => {
         var quit_ = (status, toThrow) => {
             throw toThrow;
         };
-        // Determine the runtime environment we are in. You can customize this by
-        // setting the ENVIRONMENT setting at compile time (see settings.js).
-        // Attempt to auto-detect the environment
-        var ENVIRONMENT_IS_WEB = typeof window == 'object';
-        var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
-        // N.b. Electron.js environment is simultaneously a NODE-environment, but
-        // also a web environment.
-        var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
-        var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
         // `/` should be present at the end if `scriptDirectory` is not empty
         var scriptDirectory = '';
         function locateFile(path) {
@@ -53,15 +63,8 @@ var Module = (() => {
             return scriptDirectory + path;
         }
         // Hooks that are implemented differently in different runtime environments.
-        var read_, readAsync, readBinary, setWindowTitle;
+        var read_, readAsync, readBinary;
         if (ENVIRONMENT_IS_NODE) {
-            // `require()` is no-op in an ESM module, use `createRequire()` to construct
-            // the require()` function.  This is only necessary for multi-environment
-            // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
-            // TODO: Swap all `require()`'s with `import()`'s?
-            const { createRequire } = await import('module');
-            /** @suppress{duplicate} */
-            var require = createRequire(import.meta.url);
             // These modules will usually be used on Node.js. Load them eagerly to avoid
             // the complexity of lazy-loading.
             var fs = require('fs');
@@ -89,42 +92,26 @@ var Module = (() => {
                 }
                 return ret;
             };
-            readAsync = (filename, onload, onerror) => {
+            readAsync = (filename, onload, onerror, binary = true) => {
                 // See the comment in the `read_` function.
                 filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-                fs.readFile(filename, function (err, data) {
+                fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
                     if (err)
                         onerror(err);
                     else
-                        onload(data.buffer);
+                        onload(binary ? data.buffer : data);
                 });
             };
             // end include: node_shell_read.js
-            if (process.argv.length > 1) {
+            if (!Module['thisProgram'] && process.argv.length > 1) {
                 thisProgram = process.argv[1].replace(/\\/g, '/');
             }
             arguments_ = process.argv.slice(2);
             // MODULARIZE will export the module in the proper place outside, we don't need to export here
-            process.on('uncaughtException', function (ex) {
-                // suppress ExitStatus exceptions from showing an error
-                if (ex !== 'unwind' && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
-                    throw ex;
-                }
-            });
-            // Without this older versions of node (< v15) will log unhandled rejections
-            // but return 0, which is not normally the desired behaviour.  This is
-            // not be needed with node v15 and about because it is now the default
-            // behaviour:
-            // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
-            var nodeMajor = process.versions.node.split(".")[0];
-            if (nodeMajor < 15) {
-                process.on('unhandledRejection', function (reason) { throw reason; });
-            }
             quit_ = (status, toThrow) => {
                 process.exitCode = status;
                 throw toThrow;
             };
-            Module['inspect'] = function () { return '[Emscripten Module object]'; };
         }
         else 
         // Note that this includes Node.js workers when relevant (pthreads is enabled).
@@ -139,8 +126,8 @@ var Module = (() => {
             }
             // When MODULARIZE, this JS may be executed later, after document.currentScript
             // is gone, so we saved it, and we use it here instead of any other info.
-            if (_scriptDir) {
-                scriptDirectory = _scriptDir;
+            if (_scriptName) {
+                scriptDirectory = _scriptName;
             }
             // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
             // otherwise, slice off the final part of the url to find the script directory.
@@ -148,14 +135,12 @@ var Module = (() => {
             // and scriptDirectory will correctly be replaced with an empty string.
             // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
             // they are removed because they could contain a slash.
-            if (scriptDirectory.indexOf('blob:') !== 0) {
-                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/') + 1);
+            if (scriptDirectory.startsWith('blob:')) {
+                scriptDirectory = '';
             }
             else {
-                scriptDirectory = '';
+                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1);
             }
-            // Differentiate the Web Worker from the Node Worker case, as reading must
-            // be done differently.
             {
                 // include: web_or_worker_shell_read.js
                 read_ = (url) => {
@@ -189,16 +174,15 @@ var Module = (() => {
                 };
                 // end include: web_or_worker_shell_read.js
             }
-            setWindowTitle = (title) => document.title = title;
         }
         else {
         }
         var out = Module['print'] || console.log.bind(console);
-        var err = Module['printErr'] || console.warn.bind(console);
+        var err = Module['printErr'] || console.error.bind(console);
         // Merge back in the overrides
         Object.assign(Module, moduleOverrides);
         // Free the object hierarchy contained in the overrides, this lets the GC
-        // reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
+        // reclaim data used.
         moduleOverrides = null;
         // Emit code to handle expected values on the Module object. This applies Module.x
         // to the proper local x. This has two benefits: first, we only emit it if it is
@@ -224,10 +208,6 @@ var Module = (() => {
         var wasmBinary;
         if (Module['wasmBinary'])
             wasmBinary = Module['wasmBinary'];
-        var noExitRuntime = Module['noExitRuntime'] || true;
-        if (typeof WebAssembly != 'object') {
-            abort('no native wasm support detected');
-        }
         // Wasm globals
         var wasmMemory;
         //========================================
@@ -240,211 +220,19 @@ var Module = (() => {
         // NOTE: This is also used as the process return code code in shell environments
         // but only when noExitRuntime is false.
         var EXITSTATUS;
+        // In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we
+        // don't define it at all in release modes.  This matches the behaviour of
+        // MINIMAL_RUNTIME.
+        // TODO(sbc): Make this the default even without STRICT enabled.
         /** @type {function(*, string=)} */
         function assert(condition, text) {
             if (!condition) {
                 // This build was created without ASSERTIONS defined.  `assert()` should not
                 // ever be called in this configuration but in case there are callers in
-                // the wild leave this simple abort() implemenation here for now.
+                // the wild leave this simple abort() implementation here for now.
                 abort(text);
             }
         }
-        // include: runtime_strings.js
-        // runtime_strings.js: String related runtime functions that are part of both
-        // MINIMAL_RUNTIME and regular runtime.
-        var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
-        /**
-         * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
-         * array that contains uint8 values, returns a copy of that string as a
-         * Javascript String object.
-         * heapOrArray is either a regular array, or a JavaScript typed array view.
-         * @param {number} idx
-         * @param {number=} maxBytesToRead
-         * @return {string}
-         */
-        function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
-            var endIdx = idx + maxBytesToRead;
-            var endPtr = idx;
-            // TextDecoder needs to know the byte length in advance, it doesn't stop on
-            // null terminator by itself.  Also, use the length info to avoid running tiny
-            // strings through TextDecoder, since .subarray() allocates garbage.
-            // (As a tiny code save trick, compare endPtr against endIdx using a negation,
-            // so that undefined means Infinity)
-            while (heapOrArray[endPtr] && !(endPtr >= endIdx))
-                ++endPtr;
-            if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-            }
-            var str = '';
-            // If building with TextDecoder, we have already computed the string length
-            // above, so test loop end condition against that
-            while (idx < endPtr) {
-                // For UTF8 byte structure, see:
-                // http://en.wikipedia.org/wiki/UTF-8#Description
-                // https://www.ietf.org/rfc/rfc2279.txt
-                // https://tools.ietf.org/html/rfc3629
-                var u0 = heapOrArray[idx++];
-                if (!(u0 & 0x80)) {
-                    str += String.fromCharCode(u0);
-                    continue;
-                }
-                var u1 = heapOrArray[idx++] & 63;
-                if ((u0 & 0xE0) == 0xC0) {
-                    str += String.fromCharCode(((u0 & 31) << 6) | u1);
-                    continue;
-                }
-                var u2 = heapOrArray[idx++] & 63;
-                if ((u0 & 0xF0) == 0xE0) {
-                    u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
-                }
-                else {
-                    u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
-                }
-                if (u0 < 0x10000) {
-                    str += String.fromCharCode(u0);
-                }
-                else {
-                    var ch = u0 - 0x10000;
-                    str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
-                }
-            }
-            return str;
-        }
-        /**
-         * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
-         * emscripten HEAP, returns a copy of that string as a Javascript String object.
-         *
-         * @param {number} ptr
-         * @param {number=} maxBytesToRead - An optional length that specifies the
-         *   maximum number of bytes to read. You can omit this parameter to scan the
-         *   string until the first \0 byte. If maxBytesToRead is passed, and the string
-         *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
-         *   string will cut short at that byte index (i.e. maxBytesToRead will not
-         *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
-         *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
-         *   JS JIT optimizations off, so it is worth to consider consistently using one
-         * @return {string}
-         */
-        function UTF8ToString(ptr, maxBytesToRead) {
-            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
-        }
-        /**
-         * Copies the given Javascript String object 'str' to the given byte array at
-         * address 'outIdx', encoded in UTF8 form and null-terminated. The copy will
-         * require at most str.length*4+1 bytes of space in the HEAP.  Use the function
-         * lengthBytesUTF8 to compute the exact number of bytes (excluding null
-         * terminator) that this function will write.
-         *
-         * @param {string} str - The Javascript string to copy.
-         * @param {ArrayBufferView|Array<number>} heap - The array to copy to. Each
-         *                                               index in this array is assumed
-         *                                               to be one 8-byte element.
-         * @param {number} outIdx - The starting offset in the array to begin the copying.
-         * @param {number} maxBytesToWrite - The maximum number of bytes this function
-         *                                   can write to the array.  This count should
-         *                                   include the null terminator, i.e. if
-         *                                   maxBytesToWrite=1, only the null terminator
-         *                                   will be written and nothing else.
-         *                                   maxBytesToWrite=0 does not write any bytes
-         *                                   to the output, not even the null
-         *                                   terminator.
-         * @return {number} The number of bytes written, EXCLUDING the null terminator.
-         */
-        function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
-            // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
-            // undefined and false each don't write out any bytes.
-            if (!(maxBytesToWrite > 0))
-                return 0;
-            var startIdx = outIdx;
-            var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
-            for (var i = 0; i < str.length; ++i) {
-                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
-                // unit, not a Unicode code point of the character! So decode
-                // UTF16->UTF32->UTF8.
-                // See http://unicode.org/faq/utf_bom.html#utf16-3
-                // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
-                // and https://www.ietf.org/rfc/rfc2279.txt
-                // and https://tools.ietf.org/html/rfc3629
-                var u = str.charCodeAt(i); // possibly a lead surrogate
-                if (u >= 0xD800 && u <= 0xDFFF) {
-                    var u1 = str.charCodeAt(++i);
-                    u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
-                }
-                if (u <= 0x7F) {
-                    if (outIdx >= endIdx)
-                        break;
-                    heap[outIdx++] = u;
-                }
-                else if (u <= 0x7FF) {
-                    if (outIdx + 1 >= endIdx)
-                        break;
-                    heap[outIdx++] = 0xC0 | (u >> 6);
-                    heap[outIdx++] = 0x80 | (u & 63);
-                }
-                else if (u <= 0xFFFF) {
-                    if (outIdx + 2 >= endIdx)
-                        break;
-                    heap[outIdx++] = 0xE0 | (u >> 12);
-                    heap[outIdx++] = 0x80 | ((u >> 6) & 63);
-                    heap[outIdx++] = 0x80 | (u & 63);
-                }
-                else {
-                    if (outIdx + 3 >= endIdx)
-                        break;
-                    heap[outIdx++] = 0xF0 | (u >> 18);
-                    heap[outIdx++] = 0x80 | ((u >> 12) & 63);
-                    heap[outIdx++] = 0x80 | ((u >> 6) & 63);
-                    heap[outIdx++] = 0x80 | (u & 63);
-                }
-            }
-            // Null-terminate the pointer to the buffer.
-            heap[outIdx] = 0;
-            return outIdx - startIdx;
-        }
-        /**
-         * Copies the given Javascript String object 'str' to the emscripten HEAP at
-         * address 'outPtr', null-terminated and encoded in UTF8 form. The copy will
-         * require at most str.length*4+1 bytes of space in the HEAP.
-         * Use the function lengthBytesUTF8 to compute the exact number of bytes
-         * (excluding null terminator) that this function will write.
-         *
-         * @return {number} The number of bytes written, EXCLUDING the null terminator.
-         */
-        function stringToUTF8(str, outPtr, maxBytesToWrite) {
-            return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
-        }
-        /**
-         * Returns the number of bytes the given Javascript string takes if encoded as a
-         * UTF8 byte array, EXCLUDING the null terminator byte.
-         *
-         * @param {string} str - JavaScript string to operator on
-         * @return {number} Length, in bytes, of the UTF8 encoded string.
-         */
-        function lengthBytesUTF8(str) {
-            var len = 0;
-            for (var i = 0; i < str.length; ++i) {
-                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
-                // unit, not a Unicode code point of the character! So decode
-                // UTF16->UTF32->UTF8.
-                // See http://unicode.org/faq/utf_bom.html#utf16-3
-                var c = str.charCodeAt(i); // possibly a lead surrogate
-                if (c <= 0x7F) {
-                    len++;
-                }
-                else if (c <= 0x7FF) {
-                    len += 2;
-                }
-                else if (c >= 0xD800 && c <= 0xDFFF) {
-                    len += 4;
-                    ++i;
-                }
-                else {
-                    len += 3;
-                }
-            }
-            return len;
-        }
-        // end include: runtime_strings.js
         // Memory management
         var HEAP, 
         /** @type {!Int8Array} */
@@ -463,23 +251,19 @@ var Module = (() => {
         HEAPF32, 
         /** @type {!Float64Array} */
         HEAPF64;
+        // include: runtime_shared.js
         function updateMemoryViews() {
             var b = wasmMemory.buffer;
             Module['HEAP8'] = HEAP8 = new Int8Array(b);
             Module['HEAP16'] = HEAP16 = new Int16Array(b);
-            Module['HEAP32'] = HEAP32 = new Int32Array(b);
             Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
             Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
+            Module['HEAP32'] = HEAP32 = new Int32Array(b);
             Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
             Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
             Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
         }
-        // include: runtime_init_table.js
-        // In regular non-RELOCATABLE mode the table is exported
-        // from the wasm module and this will be assigned once
-        // the exports are available.
-        var wasmTable;
-        // end include: runtime_init_table.js
+        // end include: runtime_shared.js
         // include: runtime_stack_check.js
         // end include: runtime_stack_check.js
         // include: runtime_assertions.js
@@ -489,10 +273,6 @@ var Module = (() => {
         var __ATEXIT__ = []; // functions called during shutdown
         var __ATPOSTRUN__ = []; // functions called after the main() is called
         var runtimeInitialized = false;
-        var runtimeKeepaliveCounter = 0;
-        function keepRuntimeAlive() {
-            return noExitRuntime || runtimeKeepaliveCounter > 0;
-        }
         function preRun() {
             if (Module['preRun']) {
                 if (typeof Module['preRun'] == 'function')
@@ -549,15 +329,11 @@ var Module = (() => {
         }
         function addRunDependency(id) {
             runDependencies++;
-            if (Module['monitorRunDependencies']) {
-                Module['monitorRunDependencies'](runDependencies);
-            }
+            Module['monitorRunDependencies']?.(runDependencies);
         }
         function removeRunDependency(id) {
             runDependencies--;
-            if (Module['monitorRunDependencies']) {
-                Module['monitorRunDependencies'](runDependencies);
-            }
+            Module['monitorRunDependencies']?.(runDependencies);
             if (runDependencies == 0) {
                 if (runDependencyWatcher !== null) {
                     clearInterval(runDependencyWatcher);
@@ -572,9 +348,7 @@ var Module = (() => {
         }
         /** @param {string|number=} what */
         function abort(what) {
-            if (Module['onAbort']) {
-                Module['onAbort'](what);
-            }
+            Module['onAbort']?.(what);
             what = 'Aborted(' + what + ')';
             // TODO(sbc): Should we remove printing and leave it up to whoever
             // catches the exception?
@@ -591,12 +365,12 @@ var Module = (() => {
             // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
             // allows this in the wasm spec.
             // Suppress closure compiler warning here. Closure compiler's builtin extern
-            // defintion for WebAssembly.RuntimeError claims it takes no arguments even
+            // definition for WebAssembly.RuntimeError claims it takes no arguments even
             // though it can.
             // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
             // See above, in the meantime, we resort to wasm code for trapping.
             //
-            // In case abort() is called before the module is initialized, Module['asm']
+            // In case abort() is called before the module is initialized, wasmExports
             // and its exported '__trap' function is not available, in which case we throw
             // a RuntimeError.
             //
@@ -620,15 +394,16 @@ var Module = (() => {
         // include: URIUtils.js
         // Prefix of data URIs emitted by SINGLE_FILE and related options.
         var dataURIPrefix = 'data:application/octet-stream;base64,';
-        // Indicates whether filename is a base64 data URI.
-        function isDataURI(filename) {
-            // Prefix of data URIs emitted by SINGLE_FILE and related options.
-            return filename.startsWith(dataURIPrefix);
-        }
-        // Indicates whether filename is delivered via file protocol (as opposed to http/https)
-        function isFileURI(filename) {
-            return filename.startsWith('file://');
-        }
+        /**
+         * Indicates whether filename is a base64 data URI.
+         * @noinline
+         */
+        var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+        /**
+         * Indicates whether filename is delivered via file protocol (as opposed to http/https)
+         * @noinline
+         */
+        var isFileURI = (filename) => filename.startsWith('file://');
         // end include: URIUtils.js
         // include: runtime_exceptions.js
         // end include: runtime_exceptions.js
@@ -643,57 +418,47 @@ var Module = (() => {
             // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
             wasmBinaryFile = new URL('wasm-host.wasm', import.meta.url).href;
         }
-        function getBinary(file) {
-            try {
-                if (file == wasmBinaryFile && wasmBinary) {
-                    return new Uint8Array(wasmBinary);
-                }
-                if (readBinary) {
-                    return readBinary(file);
-                }
-                throw "both async and sync fetching of the wasm failed";
+        function getBinarySync(file) {
+            if (file == wasmBinaryFile && wasmBinary) {
+                return new Uint8Array(wasmBinary);
             }
-            catch (err) {
-                abort(err);
+            if (readBinary) {
+                return readBinary(file);
             }
+            throw 'both async and sync fetching of the wasm failed';
         }
         function getBinaryPromise(binaryFile) {
-            // If we don't have the binary yet, try to to load it asynchronously.
+            // If we don't have the binary yet, try to load it asynchronously.
             // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
             // See https://github.com/github/fetch/pull/92#issuecomment-140665932
             // Cordova or Electron apps are typically loaded from a file:// url.
             // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
-            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+            if (!wasmBinary
+                && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
                 if (typeof fetch == 'function'
                     && !isFileURI(binaryFile)) {
-                    return fetch(binaryFile, { credentials: 'same-origin' }).then(function (response) {
+                    return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
                         if (!response['ok']) {
-                            throw "failed to load wasm binary file at '" + binaryFile + "'";
+                            throw `failed to load wasm binary file at '${binaryFile}'`;
                         }
                         return response['arrayBuffer']();
-                    }).catch(function () {
-                        return getBinary(binaryFile);
-                    });
+                    }).catch(() => getBinarySync(binaryFile));
                 }
-                else {
-                    if (readAsync) {
-                        // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
-                        return new Promise(function (resolve, reject) {
-                            readAsync(binaryFile, function (response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */ (response))); }, reject);
-                        });
-                    }
+                else if (readAsync) {
+                    // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
+                    return new Promise((resolve, reject) => {
+                        readAsync(binaryFile, (response) => resolve(new Uint8Array(/** @type{!ArrayBuffer} */ (response))), reject);
+                    });
                 }
             }
-            // Otherwise, getBinary should be able to get it synchronously
-            return Promise.resolve().then(function () { return getBinary(binaryFile); });
+            // Otherwise, getBinarySync should be able to get it synchronously
+            return Promise.resolve().then(() => getBinarySync(binaryFile));
         }
         function instantiateArrayBuffer(binaryFile, imports, receiver) {
-            return getBinaryPromise(binaryFile).then(function (binary) {
+            return getBinaryPromise(binaryFile).then((binary) => {
                 return WebAssembly.instantiate(binary, imports);
-            }).then(function (instance) {
-                return instance;
-            }).then(receiver, function (reason) {
-                err('failed to asynchronously prepare wasm: ' + reason);
+            }).then(receiver, (reason) => {
+                err(`failed to asynchronously prepare wasm: ${reason}`);
                 abort(reason);
             });
         }
@@ -711,7 +476,7 @@ var Module = (() => {
                 //   https://github.com/emscripten-core/emscripten/pull/16917
                 !ENVIRONMENT_IS_NODE &&
                 typeof fetch == 'function') {
-                return fetch(binaryFile, { credentials: 'same-origin' }).then(function (response) {
+                return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
                     // Suppress closure warning here since the upstream definition for
                     // instantiateStreaming only allows Promise<Repsponse> rather than
                     // an actual Response.
@@ -721,37 +486,38 @@ var Module = (() => {
                     return result.then(callback, function (reason) {
                         // We expect the most common failure cause to be a bad MIME type for the binary,
                         // in which case falling back to ArrayBuffer instantiation should work.
-                        err('wasm streaming compile failed: ' + reason);
+                        err(`wasm streaming compile failed: ${reason}`);
                         err('falling back to ArrayBuffer instantiation');
                         return instantiateArrayBuffer(binaryFile, imports, callback);
                     });
                 });
             }
-            else {
-                return instantiateArrayBuffer(binaryFile, imports, callback);
-            }
+            return instantiateArrayBuffer(binaryFile, imports, callback);
         }
-        // Create the wasm instance.
-        // Receives the wasm imports, returns the exports.
-        function createWasm() {
+        function getWasmImports() {
             // prepare imports
-            var info = {
+            return {
                 'env': wasmImports,
                 'wasi_snapshot_preview1': wasmImports,
             };
+        }
+        // Create the wasm instance.
+        // Receives the wasm imports, returns the exports.
+        function createWasm() {
+            var info = getWasmImports();
             // Load the wasm module and create an instance of using native support in the JS engine.
             // handle a generated wasm instance, receiving its exports and
             // performing other necessary setup
             /** @param {WebAssembly.Module=} module*/
             function receiveInstance(instance, module) {
-                var exports = instance.exports;
-                Module['asm'] = exports;
-                wasmMemory = Module['asm']['memory'];
+                wasmExports = instance.exports;
+                Module['wasmExports'] = wasmExports;
+                wasmMemory = wasmExports['memory'];
                 updateMemoryViews();
-                wasmTable = Module['asm']['__indirect_function_table'];
-                addOnInit(Module['asm']['__wasm_call_ctors']);
+                wasmTable = wasmExports['__indirect_function_table'];
+                addOnInit(wasmExports['__wasm_call_ctors']);
                 removeRunDependency('wasm-instantiate');
-                return exports;
+                return wasmExports;
             }
             // wait for the pthread pool (if any)
             addRunDependency('wasm-instantiate');
@@ -760,19 +526,21 @@ var Module = (() => {
                 // 'result' is a ResultObject object which has both the module and instance.
                 // receiveInstance() will swap in the exports (to Module.asm) so they can be called
                 // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
-                // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
+                // When the regression is fixed, can restore the above PTHREADS-enabled path.
                 receiveInstance(result['instance']);
             }
             // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
-            // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
-            // to any other async startup actions they are performing.
-            // Also pthreads and wasm workers initialize the wasm instance through this path.
+            // to manually instantiate the Wasm module themselves. This allows pages to
+            // run the instantiation parallel to any other async startup actions they are
+            // performing.
+            // Also pthreads and wasm workers initialize the wasm instance through this
+            // path.
             if (Module['instantiateWasm']) {
                 try {
                     return Module['instantiateWasm'](info, receiveInstance);
                 }
                 catch (e) {
-                    err('Module.instantiateWasm callback failed with error: ' + e);
+                    err(`Module.instantiateWasm callback failed with error: ${e}`);
                     // If instantiation fails, reject the module ready promise.
                     readyPromiseReject(e);
                 }
@@ -791,15 +559,15 @@ var Module = (() => {
         /** @constructor */
         function ExitStatus(status) {
             this.name = 'ExitStatus';
-            this.message = 'Program terminated with exit(' + status + ')';
+            this.message = `Program terminated with exit(${status})`;
             this.status = status;
         }
-        function callRuntimeCallbacks(callbacks) {
+        var callRuntimeCallbacks = (callbacks) => {
             while (callbacks.length > 0) {
                 // Pass the module as the first argument.
                 callbacks.shift()(Module);
             }
-        }
+        };
         /**
          * @param {number} ptr
          * @param {string} type
@@ -808,17 +576,18 @@ var Module = (() => {
             if (type.endsWith('*'))
                 type = '*';
             switch (type) {
-                case 'i1': return HEAP8[((ptr) >> 0)];
-                case 'i8': return HEAP8[((ptr) >> 0)];
+                case 'i1': return HEAP8[ptr];
+                case 'i8': return HEAP8[ptr];
                 case 'i16': return HEAP16[((ptr) >> 1)];
                 case 'i32': return HEAP32[((ptr) >> 2)];
-                case 'i64': return HEAP32[((ptr) >> 2)];
+                case 'i64': abort('to do getValue(i64) use WASM_BIGINT');
                 case 'float': return HEAPF32[((ptr) >> 2)];
                 case 'double': return HEAPF64[((ptr) >> 3)];
                 case '*': return HEAPU32[((ptr) >> 2)];
-                default: abort('invalid type for getValue: ' + type);
+                default: abort(`invalid type for getValue: ${type}`);
             }
         }
+        var noExitRuntime = Module['noExitRuntime'] || true;
         /**
          * @param {number} ptr
          * @param {number} value
@@ -829,10 +598,10 @@ var Module = (() => {
                 type = '*';
             switch (type) {
                 case 'i1':
-                    HEAP8[((ptr) >> 0)] = value;
+                    HEAP8[ptr] = value;
                     break;
                 case 'i8':
-                    HEAP8[((ptr) >> 0)] = value;
+                    HEAP8[ptr] = value;
                     break;
                 case 'i16':
                     HEAP16[((ptr) >> 1)] = value;
@@ -840,9 +609,7 @@ var Module = (() => {
                 case 'i32':
                     HEAP32[((ptr) >> 2)] = value;
                     break;
-                case 'i64':
-                    (tempI64 = [value >>> 0, (tempDouble = value, (+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble) / 4294967296.0))), 4294967295.0)) | 0) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296.0))))) >>> 0) : 0)], HEAP32[((ptr) >> 2)] = tempI64[0], HEAP32[(((ptr) + (4)) >> 2)] = tempI64[1]);
-                    break;
+                case 'i64': abort('to do setValue(i64) use WASM_BIGINT');
                 case 'float':
                     HEAPF32[((ptr) >> 2)] = value;
                     break;
@@ -852,38 +619,126 @@ var Module = (() => {
                 case '*':
                     HEAPU32[((ptr) >> 2)] = value;
                     break;
-                default: abort('invalid type for setValue: ' + type);
+                default: abort(`invalid type for setValue: ${type}`);
             }
         }
-        function ___assert_fail(condition, filename, line, func) {
-            abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
-        }
-        var char_0 = 48;
-        var char_9 = 57;
-        function makeLegalFunctionName(name) {
-            if (undefined === name) {
-                return '_unknown';
+        var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
+        /**
+         * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
+         * array that contains uint8 values, returns a copy of that string as a
+         * Javascript String object.
+         * heapOrArray is either a regular array, or a JavaScript typed array view.
+         * @param {number} idx
+         * @param {number=} maxBytesToRead
+         * @return {string}
+         */
+        var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
+            var endIdx = idx + maxBytesToRead;
+            var endPtr = idx;
+            // TextDecoder needs to know the byte length in advance, it doesn't stop on
+            // null terminator by itself.  Also, use the length info to avoid running tiny
+            // strings through TextDecoder, since .subarray() allocates garbage.
+            // (As a tiny code save trick, compare endPtr against endIdx using a negation,
+            // so that undefined means Infinity)
+            while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+                ++endPtr;
+            if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
             }
-            name = name.replace(/[^a-zA-Z0-9_]/g, '$');
-            var f = name.charCodeAt(0);
-            if (f >= char_0 && f <= char_9) {
-                return '_' + name;
+            var str = '';
+            // If building with TextDecoder, we have already computed the string length
+            // above, so test loop end condition against that
+            while (idx < endPtr) {
+                // For UTF8 byte structure, see:
+                // http://en.wikipedia.org/wiki/UTF-8#Description
+                // https://www.ietf.org/rfc/rfc2279.txt
+                // https://tools.ietf.org/html/rfc3629
+                var u0 = heapOrArray[idx++];
+                if (!(u0 & 0x80)) {
+                    str += String.fromCharCode(u0);
+                    continue;
+                }
+                var u1 = heapOrArray[idx++] & 63;
+                if ((u0 & 0xE0) == 0xC0) {
+                    str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                    continue;
+                }
+                var u2 = heapOrArray[idx++] & 63;
+                if ((u0 & 0xF0) == 0xE0) {
+                    u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+                }
+                else {
+                    u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+                }
+                if (u0 < 0x10000) {
+                    str += String.fromCharCode(u0);
+                }
+                else {
+                    var ch = u0 - 0x10000;
+                    str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+                }
             }
-            return name;
-        }
-        function createNamedFunction(name, body) {
-            name = makeLegalFunctionName(name);
-            // Use an abject with a computed property name to create a new function with
-            // a name specified at runtime, but without using `new Function` or `eval`.
-            return {
-                [name]: function () {
-                    return body.apply(this, arguments);
+            return str;
+        };
+        /**
+         * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+         * emscripten HEAP, returns a copy of that string as a Javascript String object.
+         *
+         * @param {number} ptr
+         * @param {number=} maxBytesToRead - An optional length that specifies the
+         *   maximum number of bytes to read. You can omit this parameter to scan the
+         *   string until the first 0 byte. If maxBytesToRead is passed, and the string
+         *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+         *   string will cut short at that byte index (i.e. maxBytesToRead will not
+         *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+         *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+         *   JS JIT optimizations off, so it is worth to consider consistently using one
+         * @return {string}
+         */
+        var UTF8ToString = (ptr, maxBytesToRead) => {
+            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+        };
+        var ___assert_fail = (condition, filename, line, func) => {
+            abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
+        };
+        var createNamedFunction = (name, body) => Object.defineProperty(body, 'name', {
+            value: name
+        });
+        var emval_freelist = [];
+        var emval_handles = [];
+        var BindingError;
+        var throwBindingError = (message) => { throw new BindingError(message); };
+        var count_emval_handles = () => {
+            return emval_handles.length / 2 - 5 - emval_freelist.length;
+        };
+        var init_emval = () => {
+            // reserve 0 and some special values. These never get de-allocated.
+            emval_handles.push(0, 1, undefined, 1, null, 1, true, 1, false, 1);
+            Module['count_emval_handles'] = count_emval_handles;
+        };
+        var Emval = {
+            toValue: (handle) => {
+                if (!handle) {
+                    throwBindingError('Cannot use deleted val. handle = ' + handle);
                 }
-            }[name];
-        }
-        var emval_handle_array = [{}, { value: undefined }, { value: null }, { value: true }, { value: false }];
-        var emval_free_list = [];
-        function extendError(baseErrorType, errorName) {
+                return emval_handles[handle];
+            },
+            toHandle: (value) => {
+                switch (value) {
+                    case undefined: return 2;
+                    case null: return 4;
+                    case true: return 6;
+                    case false: return 8;
+                    default: {
+                        const handle = emval_freelist.pop() || emval_handles.length;
+                        emval_handles[handle] = value;
+                        emval_handles[handle + 1] = 1;
+                        return handle;
+                    }
+                }
+            },
+        };
+        var extendError = (baseErrorType, errorName) => {
             var errorClass = createNamedFunction(errorName, function (message) {
                 this.name = errorName;
                 this.message = message;
@@ -900,77 +755,30 @@ var Module = (() => {
                     return this.name;
                 }
                 else {
-                    return this.name + ': ' + this.message;
+                    return `${this.name}: ${this.message}`;
                 }
             };
             return errorClass;
-        }
-        var BindingError = undefined;
-        function throwBindingError(message) {
-            throw new BindingError(message);
-        }
-        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;
-                    }
-                }
-            } };
-        var PureVirtualError = undefined;
-        function embind_init_charCodes() {
+        };
+        var PureVirtualError;
+        var 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 embind_charCodes;
+        var readLatin1String = (ptr) => {
             var ret = "";
             var c = ptr;
             while (HEAPU8[c]) {
                 ret += embind_charCodes[HEAPU8[c++]];
             }
             return ret;
-        }
-        function getInheritedInstanceCount() {
-            return Object.keys(registeredInstances).length;
-        }
-        function getLiveInheritedInstances() {
+        };
+        var getInheritedInstanceCount = () => Object.keys(registeredInstances).length;
+        var getLiveInheritedInstances = () => {
             var rv = [];
             for (var k in registeredInstances) {
                 if (registeredInstances.hasOwnProperty(k)) {
@@ -978,30 +786,30 @@ var Module = (() => {
                 }
             }
             return rv;
-        }
+        };
         var deletionQueue = [];
-        function flushPendingDeletes() {
+        var flushPendingDeletes = () => {
             while (deletionQueue.length) {
                 var obj = deletionQueue.pop();
                 obj.$$.deleteScheduled = false;
                 obj['delete']();
             }
-        }
-        var delayFunction = undefined;
-        function setDelayFunction(fn) {
+        };
+        var delayFunction;
+        var setDelayFunction = (fn) => {
             delayFunction = fn;
             if (deletionQueue.length && delayFunction) {
                 delayFunction(flushPendingDeletes);
             }
-        }
-        function init_embind() {
+        };
+        var init_embind = () => {
             Module['getInheritedInstanceCount'] = getInheritedInstanceCount;
             Module['getLiveInheritedInstances'] = getLiveInheritedInstances;
             Module['flushPendingDeletes'] = flushPendingDeletes;
             Module['setDelayFunction'] = setDelayFunction;
-        }
+        };
         var registeredInstances = {};
-        function getBasestPointer(class_, ptr) {
+        var getBasestPointer = (class_, ptr) => {
             if (ptr === undefined) {
                 throwBindingError('ptr should not be undefined');
             }
@@ -1010,57 +818,57 @@ var Module = (() => {
                 class_ = class_.baseClass;
             }
             return ptr;
-        }
-        function registerInheritedInstance(class_, ptr, instance) {
+        };
+        var registerInheritedInstance = (class_, ptr, instance) => {
             ptr = getBasestPointer(class_, ptr);
             if (registeredInstances.hasOwnProperty(ptr)) {
-                throwBindingError('Tried to register registered instance: ' + ptr);
+                throwBindingError(`Tried to register registered instance: ${ptr}`);
             }
             else {
                 registeredInstances[ptr] = instance;
             }
-        }
+        };
         var registeredTypes = {};
-        function getTypeName(type) {
+        var getTypeName = (type) => {
             var ptr = ___getTypeName(type);
             var rv = readLatin1String(ptr);
             _free(ptr);
             return rv;
-        }
-        function requireRegisteredType(rawType, humanName) {
+        };
+        var requireRegisteredType = (rawType, humanName) => {
             var impl = registeredTypes[rawType];
             if (undefined === impl) {
-                throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
+                throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
             }
             return impl;
-        }
-        function unregisterInheritedInstance(class_, ptr) {
+        };
+        var unregisterInheritedInstance = (class_, ptr) => {
             ptr = getBasestPointer(class_, ptr);
             if (registeredInstances.hasOwnProperty(ptr)) {
                 delete registeredInstances[ptr];
             }
             else {
-                throwBindingError('Tried to unregister unregistered instance: ' + ptr);
+                throwBindingError(`Tried to unregister unregistered instance: ${ptr}`);
             }
-        }
-        function detachFinalizer(handle) { }
+        };
+        var detachFinalizer = (handle) => { };
         var finalizationRegistry = false;
-        function runDestructor($$) {
+        var runDestructor = ($$) => {
             if ($$.smartPtr) {
                 $$.smartPtrType.rawDestructor($$.smartPtr);
             }
             else {
                 $$.ptrType.registeredClass.rawDestructor($$.ptr);
             }
-        }
-        function releaseClassHandle($$) {
+        };
+        var releaseClassHandle = ($$) => {
             $$.count.value -= 1;
             var toDelete = 0 === $$.count.value;
             if (toDelete) {
                 runDestructor($$);
             }
-        }
-        function downcastPointer(ptr, ptrClass, desiredClass) {
+        };
+        var downcastPointer = (ptr, ptrClass, desiredClass) => {
             if (ptrClass === desiredClass) {
                 return ptr;
             }
@@ -1072,17 +880,15 @@ var Module = (() => {
                 return null;
             }
             return desiredClass.downcast(rv);
-        }
+        };
         var registeredPointers = {};
-        function getInheritedInstance(class_, ptr) {
+        var getInheritedInstance = (class_, ptr) => {
             ptr = getBasestPointer(class_, ptr);
             return registeredInstances[ptr];
-        }
-        var InternalError = undefined;
-        function throwInternalError(message) {
-            throw new InternalError(message);
-        }
-        function makeClassHandle(prototype, record) {
+        };
+        var InternalError;
+        var throwInternalError = (message) => { throw new InternalError(message); };
+        var makeClassHandle = (prototype, record) => {
             if (!record.ptrType || !record.ptr) {
                 throwInternalError('makeClassHandle requires ptr and ptrType');
             }
@@ -1095,9 +901,11 @@ var Module = (() => {
             return attachFinalizer(Object.create(prototype, {
                 $$: {
                     value: record,
+                    writable: true,
                 },
             }));
-        }
+        };
+        /** @suppress {globalThis} */
         function RegisteredPointer_fromWireType(ptr) {
             // ptr is a raw pointer (or a raw smartpointer)
             // rawPointer is a maybe-null raw pointer
@@ -1134,7 +942,7 @@ var Module = (() => {
                 else {
                     return makeClassHandle(this.registeredClass.instancePrototype, {
                         ptrType: this,
-                        ptr: ptr,
+                        ptr,
                     });
                 }
             }
@@ -1169,7 +977,7 @@ var Module = (() => {
                 });
             }
         }
-        function attachFinalizer(handle) {
+        var attachFinalizer = (handle) => {
             if ('undefined' === typeof FinalizationRegistry) {
                 attachFinalizer = (handle) => handle;
                 return handle;
@@ -1193,34 +1001,33 @@ var Module = (() => {
             };
             detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
             return attachFinalizer(handle);
-        }
-        function __embind_create_inheriting_constructor(constructorName, wrapperType, properties) {
+        };
+        var __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 () {
+            var ctor = createNamedFunction(constructorName, function (...args) {
                 registeredClass.baseClass.pureVirtualFunctions.forEach(function (name) {
                     if (this[name] === baseClassPrototype[name]) {
-                        throw new PureVirtualError('Pure virtual function ' + name + ' must be implemented in JavaScript');
+                        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));
+                this["__construct"](...args);
             });
             // It's a little nasty that we're modifying the wrapper prototype here.
-            wrapperPrototype["__construct"] = function __construct() {
+            wrapperPrototype["__construct"] = function __construct(...args) {
                 if (this === wrapperPrototype) {
                     throwBindingError("Pass correct 'this' to __construct");
                 }
-                var inner = baseConstructor["implement"].apply(undefined, [this].concat(arraySlice.call(arguments)));
+                var inner = baseConstructor["implement"](this, ...args);
                 detachFinalizer(inner);
                 var $$ = inner.$$;
                 inner["notifyOnDestruction"]();
@@ -1239,25 +1046,24 @@ var Module = (() => {
                 unregisterInheritedInstance(registeredClass, this.$$.ptr);
             };
             ctor.prototype = Object.create(wrapperPrototype);
-            for (var p in properties) {
-                ctor.prototype[p] = properties[p];
-            }
+            Object.assign(ctor.prototype, properties);
             return Emval.toHandle(ctor);
-        }
+        };
         var structRegistrations = {};
-        function runDestructors(destructors) {
+        var runDestructors = (destructors) => {
             while (destructors.length) {
                 var ptr = destructors.pop();
                 var del = destructors.pop();
                 del(ptr);
             }
-        }
-        function simpleReadValueFromPointer(pointer) {
-            return this['fromWireType'](HEAP32[((pointer) >> 2)]);
+        };
+        /** @suppress {globalThis} */
+        function readPointer(pointer) {
+            return this['fromWireType'](HEAPU32[((pointer) >> 2)]);
         }
         var awaitingDependencies = {};
         var typeDependencies = {};
-        function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
+        var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
             myTypes.forEach(function (type) {
                 typeDependencies[type] = dependentTypes;
             });
@@ -1294,8 +1100,8 @@ var Module = (() => {
             if (0 === unregisteredTypes.length) {
                 onComplete(typeConverters);
             }
-        }
-        function __embind_finalize_value_object(structType) {
+        };
+        var __embind_finalize_value_object = (structType) => {
             var reg = structRegistrations[structType];
             delete structRegistrations[structType];
             var rawConstructor = reg.rawConstructor;
@@ -1314,9 +1120,7 @@ var Module = (() => {
                     var setter = field.setter;
                     var setterContext = field.setterContext;
                     fields[fieldName] = {
-                        read: (ptr) => {
-                            return getterReturnType['fromWireType'](getter(getterContext, ptr));
-                        },
+                        read: (ptr) => getterReturnType['fromWireType'](getter(getterContext, ptr)),
                         write: (ptr, o) => {
                             var destructors = [];
                             setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o));
@@ -1326,7 +1130,7 @@ var Module = (() => {
                 });
                 return [{
                         name: reg.name,
-                        'fromWireType': function (ptr) {
+                        'fromWireType': (ptr) => {
                             var rv = {};
                             for (var i in fields) {
                                 rv[i] = fields[i].read(ptr);
@@ -1334,12 +1138,12 @@ var Module = (() => {
                             rawDestructor(ptr);
                             return rv;
                         },
-                        'toWireType': function (destructors, o) {
+                        'toWireType': (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 + '"');
+                                    throw new TypeError(`Missing field: "${fieldName}"`);
                                 }
                             }
                             var ptr = rawConstructor();
@@ -1351,38 +1155,25 @@ var Module = (() => {
                             }
                             return ptr;
                         },
-                        'argPackAdvance': 8,
-                        'readValueFromPointer': simpleReadValueFromPointer,
+                        'argPackAdvance': GenericWireTypeSize,
+                        'readValueFromPointer': readPointer,
                         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);
-            }
-        }
+        };
+        var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { };
         /** @param {Object=} options */
-        function registerType(rawType, registeredInstance, options = {}) {
-            if (!('argPackAdvance' in registeredInstance)) {
-                throw new TypeError('registerType registeredInstance requires argPackAdvance');
-            }
+        function sharedRegisterType(rawType, registeredInstance, options = {}) {
             var name = registeredInstance.name;
             if (!rawType) {
-                throwBindingError('type "' + name + '" must have a positive integer typeid pointer');
+                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");
+                    throwBindingError(`Cannot register type '${name}' twice`);
                 }
             }
             registeredTypes[rawType] = registeredInstance;
@@ -1393,11 +1184,19 @@ var Module = (() => {
                 callbacks.forEach((cb) => cb());
             }
         }
-        function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
-            var shift = getShiftFromSize(size);
+        /** @param {Object=} options */
+        function registerType(rawType, registeredInstance, options = {}) {
+            if (!('argPackAdvance' in registeredInstance)) {
+                throw new TypeError('registerType registeredInstance requires argPackAdvance');
+            }
+            return sharedRegisterType(rawType, registeredInstance, options);
+        }
+        var GenericWireTypeSize = 8;
+        /** @suppress {globalThis} */
+        var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
             name = readLatin1String(name);
             registerType(rawType, {
-                name: name,
+                name,
                 'fromWireType': function (wt) {
                     // ambiguous emscripten ABI: sometimes return values are
                     // true or false, and sometimes integers (0 or 1)
@@ -1406,49 +1205,14 @@ var Module = (() => {
                 'toWireType': function (destructors, o) {
                     return o ? trueValue : falseValue;
                 },
-                'argPackAdvance': 8,
+                'argPackAdvance': GenericWireTypeSize,
                 '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]);
+                    return this['fromWireType'](HEAPU8[pointer]);
                 },
                 destructorFunction: null, // This type does not need a destructor
             });
-        }
-        function ClassHandle_isAliasOf(other) {
-            if (!(this instanceof ClassHandle)) {
-                return false;
-            }
-            if (!(other instanceof ClassHandle)) {
-                return false;
-            }
-            var leftClass = this.$$.ptrType.registeredClass;
-            var left = this.$$.ptr;
-            var rightClass = other.$$.ptrType.registeredClass;
-            var right = other.$$.ptr;
-            while (leftClass.baseClass) {
-                left = leftClass.upcast(left);
-                leftClass = leftClass.baseClass;
-            }
-            while (rightClass.baseClass) {
-                right = rightClass.upcast(right);
-                rightClass = rightClass.baseClass;
-            }
-            return leftClass === rightClass && left === right;
-        }
-        function shallowCopyInternalPointer(o) {
+        };
+        var shallowCopyInternalPointer = (o) => {
             return {
                 count: o.count,
                 deleteScheduled: o.deleteScheduled,
@@ -1458,99 +1222,119 @@ var Module = (() => {
                 smartPtr: o.smartPtr,
                 smartPtrType: o.smartPtrType,
             };
-        }
-        function throwInstanceAlreadyDeleted(obj) {
+        };
+        var throwInstanceAlreadyDeleted = (obj) => {
             function getInstanceTypeName(handle) {
                 return handle.$$.ptrType.registeredClass.name;
             }
             throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
-        }
-        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.$$),
+        };
+        var init_ClassHandle = () => {
+            Object.assign(ClassHandle.prototype, {
+                "isAliasOf"(other) {
+                    if (!(this instanceof ClassHandle)) {
+                        return false;
                     }
-                }));
-                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;
-        }
+                    if (!(other instanceof ClassHandle)) {
+                        return false;
+                    }
+                    var leftClass = this.$$.ptrType.registeredClass;
+                    var left = this.$$.ptr;
+                    other.$$ = /** @type {Object} */ (other.$$);
+                    var rightClass = other.$$.ptrType.registeredClass;
+                    var right = other.$$.ptr;
+                    while (leftClass.baseClass) {
+                        left = leftClass.upcast(left);
+                        leftClass = leftClass.baseClass;
+                    }
+                    while (rightClass.baseClass) {
+                        right = rightClass.upcast(right);
+                        rightClass = rightClass.baseClass;
+                    }
+                    return leftClass === rightClass && left === right;
+                },
+                "clone"() {
+                    if (!this.$$.ptr) {
+                        throwInstanceAlreadyDeleted(this);
+                    }
+                    if (this.$$.preservePointerOnDelete) {
+                        this.$$.count.value += 1;
+                        return this;
+                    }
+                    else {
+                        var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), {
+                            $$: {
+                                value: shallowCopyInternalPointer(this.$$),
+                            }
+                        }));
+                        clone.$$.count.value += 1;
+                        clone.$$.deleteScheduled = false;
+                        return clone;
+                    }
+                },
+                "delete"() {
+                    if (!this.$$.ptr) {
+                        throwInstanceAlreadyDeleted(this);
+                    }
+                    if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+                        throwBindingError('Object already scheduled for deletion');
+                    }
+                    detachFinalizer(this);
+                    releaseClassHandle(this.$$);
+                    if (!this.$$.preservePointerOnDelete) {
+                        this.$$.smartPtr = undefined;
+                        this.$$.ptr = undefined;
+                    }
+                },
+                "isDeleted"() {
+                    return !this.$$.ptr;
+                },
+                "deleteLater"() {
+                    if (!this.$$.ptr) {
+                        throwInstanceAlreadyDeleted(this);
+                    }
+                    if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+                        throwBindingError('Object already scheduled for deletion');
+                    }
+                    deletionQueue.push(this);
+                    if (deletionQueue.length === 1 && delayFunction) {
+                        delayFunction(flushPendingDeletes);
+                    }
+                    this.$$.deleteScheduled = true;
+                    return this;
+                },
+            });
+        };
+        /** @constructor */
         function ClassHandle() {
         }
-        function ensureOverloadTable(proto, methodName, humanName) {
+        var ensureOverloadTable = (proto, methodName, humanName) => {
             if (undefined === proto[methodName].overloadTable) {
                 var prevFunc = proto[methodName];
                 // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.
-                proto[methodName] = function () {
+                proto[methodName] = function (...args) {
                     // TODO This check can be removed in -O3 level "unsafe" optimizations.
-                    if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
-                        throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
+                    if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
+                        throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
                     }
-                    return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
+                    return proto[methodName].overloadTable[args.length].apply(this, args);
                 };
                 // Move the previous function into the overload table.
                 proto[methodName].overloadTable = [];
                 proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
             }
-        }
+        };
         /** @param {number=} numArguments */
-        function exposePublicSymbol(name, value, numArguments) {
+        var exposePublicSymbol = (name, value, numArguments) => {
             if (Module.hasOwnProperty(name)) {
                 if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) {
-                    throwBindingError("Cannot register public name '" + name + "' twice");
+                    throwBindingError(`Cannot register public name '${name}' twice`);
                 }
                 // We are exposing a function with the same name as an existing function. Create an overload table and a function selector
                 // that routes between the two.
                 ensureOverloadTable(Module, name, name);
                 if (Module.hasOwnProperty(numArguments)) {
-                    throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
+                    throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
                 }
                 // Add the new function into the overload table.
                 Module[name].overloadTable[numArguments] = value;
@@ -1561,7 +1345,20 @@ var Module = (() => {
                     Module[name].numArguments = numArguments;
                 }
             }
-        }
+        };
+        var char_0 = 48;
+        var char_9 = 57;
+        var 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;
+        };
         /** @constructor */
         function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
             this.name = name;
@@ -1574,38 +1371,40 @@ var Module = (() => {
             this.downcast = downcast;
             this.pureVirtualFunctions = [];
         }
-        function upcastPointer(ptr, ptrClass, desiredClass) {
+        var upcastPointer = (ptr, ptrClass, desiredClass) => {
             while (ptrClass !== desiredClass) {
                 if (!ptrClass.upcast) {
-                    throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name);
+                    throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`);
                 }
                 ptr = ptrClass.upcast(ptr);
                 ptrClass = ptrClass.baseClass;
             }
             return ptr;
-        }
+        };
+        /** @suppress {globalThis} */
         function constNoSmartPtrRawPointerToWireType(destructors, handle) {
             if (handle === null) {
                 if (this.isReference) {
-                    throwBindingError('null is not a valid ' + this.name);
+                    throwBindingError(`null is not a valid ${this.name}`);
                 }
                 return 0;
             }
             if (!handle.$$) {
-                throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name);
+                throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
             }
             if (!handle.$$.ptr) {
-                throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);
+                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;
         }
+        /** @suppress {globalThis} */
         function genericPointerToWireType(destructors, handle) {
             var ptr;
             if (handle === null) {
                 if (this.isReference) {
-                    throwBindingError('null is not a valid ' + this.name);
+                    throwBindingError(`null is not a valid ${this.name}`);
                 }
                 if (this.isSmartPointer) {
                     ptr = this.rawConstructor();
@@ -1618,14 +1417,14 @@ var Module = (() => {
                     return 0;
                 }
             }
-            if (!handle.$$) {
-                throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name);
+            if (!handle || !handle.$$) {
+                throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
             }
             if (!handle.$$.ptr) {
-                throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);
+                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);
+                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);
@@ -1643,7 +1442,7 @@ var Module = (() => {
                             ptr = handle.$$.smartPtr;
                         }
                         else {
-                            throwBindingError('Cannot convert argument of type ' + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + ' to parameter type ' + this.name);
+                            throwBindingError(`Cannot convert argument of type ${(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name)} to parameter type ${this.name}`);
                         }
                         break;
                     case 1: // INTRUSIVE
@@ -1655,9 +1454,7 @@ var Module = (() => {
                         }
                         else {
                             var clonedHandle = handle['clone']();
-                            ptr = this.rawShare(ptr, Emval.toHandle(function () {
-                                clonedHandle['delete']();
-                            }));
+                            ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle['delete']()));
                             if (destructors !== null) {
                                 destructors.push(this.rawDestructor, ptr);
                             }
@@ -1669,50 +1466,43 @@ var Module = (() => {
             }
             return ptr;
         }
+        /** @suppress {globalThis} */
         function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
             if (handle === null) {
                 if (this.isReference) {
-                    throwBindingError('null is not a valid ' + this.name);
+                    throwBindingError(`null is not a valid ${this.name}`);
                 }
                 return 0;
             }
             if (!handle.$$) {
-                throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name);
+                throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
             }
             if (!handle.$$.ptr) {
-                throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);
+                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);
+                throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`);
             }
             var handleClass = handle.$$.ptrType.registeredClass;
             var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
             return ptr;
         }
-        function RegisteredPointer_getPointee(ptr) {
-            if (this.rawGetPointee) {
-                ptr = this.rawGetPointee(ptr);
-            }
-            return ptr;
-        }
-        function RegisteredPointer_destructor(ptr) {
-            if (this.rawDestructor) {
-                this.rawDestructor(ptr);
-            }
-        }
-        function RegisteredPointer_deleteObject(handle) {
-            if (handle !== null) {
-                handle['delete']();
-            }
-        }
-        function init_RegisteredPointer() {
-            RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
-            RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
-            RegisteredPointer.prototype['argPackAdvance'] = 8;
-            RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer;
-            RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject;
-            RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType;
-        }
+        var init_RegisteredPointer = () => {
+            Object.assign(RegisteredPointer.prototype, {
+                getPointee(ptr) {
+                    if (this.rawGetPointee) {
+                        ptr = this.rawGetPointee(ptr);
+                    }
+                    return ptr;
+                },
+                destructor(ptr) {
+                    this.rawDestructor?.(ptr);
+                },
+                'argPackAdvance': GenericWireTypeSize,
+                'readValueFromPointer': readPointer,
+                'fromWireType': RegisteredPointer_fromWireType,
+            });
+        };
         /** @constructor
             @param {*=} pointeeType,
             @param {*=} sharingPolicy,
@@ -1755,9 +1545,9 @@ var Module = (() => {
             }
         }
         /** @param {number=} numArguments */
-        function replacePublicSymbol(name, value, numArguments) {
+        var replacePublicSymbol = (name, value, numArguments) => {
             if (!Module.hasOwnProperty(name)) {
-                throwInternalError('Replacing nonexistant public symbol');
+                throwInternalError('Replacing nonexistent public symbol');
             }
             // If there's an overload table for this symbol, replace the symbol in the overload table instead.
             if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
@@ -1767,13 +1557,15 @@ var Module = (() => {
                 Module[name] = value;
                 Module[name].argCount = numArguments;
             }
-        }
-        function dynCallLegacy(sig, ptr, args) {
+        };
+        var dynCallLegacy = (sig, ptr, args) => {
+            sig = sig.replace(/p/g, 'i');
             var f = Module['dynCall_' + sig];
-            return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
-        }
+            return f(ptr, ...args);
+        };
         var wasmTableMirror = [];
-        function getWasmTableEntry(funcPtr) {
+        var wasmTable;
+        var getWasmTableEntry = (funcPtr) => {
             var func = wasmTableMirror[funcPtr];
             if (!func) {
                 if (funcPtr >= wasmTableMirror.length)
@@ -1781,27 +1573,21 @@ var Module = (() => {
                 wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
             }
             return func;
-        }
-        /** @param {Object=} args */
-        function dynCall(sig, ptr, args) {
+        };
+        var dynCall = (sig, ptr, args = []) => {
             // Without WASM_BIGINT support we cannot directly call function with i64 as
-            // part of thier signature, so we rely the dynCall functions generated by
+            // part of their signature, so we rely on the dynCall functions generated by
             // wasm-emscripten-finalize
             if (sig.includes('j')) {
                 return dynCallLegacy(sig, ptr, args);
             }
-            var rtn = getWasmTableEntry(ptr).apply(null, args);
+            var rtn = getWasmTableEntry(ptr)(...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) {
+        };
+        var getDynCaller = (sig, ptr) => {
+            return (...args) => dynCall(sig, ptr, args);
+        };
+        var embind__requireFunction = (signature, rawFunction) => {
             signature = readLatin1String(signature);
             function makeDynCaller() {
                 if (signature.includes('j')) {
@@ -1811,12 +1597,12 @@ var Module = (() => {
             }
             var fp = makeDynCaller();
             if (typeof fp != "function") {
-                throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
+                throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
             }
             return fp;
-        }
-        var UnboundTypeError = undefined;
-        function throwUnboundTypeError(message, types) {
+        };
+        var UnboundTypeError;
+        var throwUnboundTypeError = (message, types) => {
             var unboundTypes = [];
             var seen = {};
             function visit(type) {
@@ -1834,24 +1620,20 @@ var Module = (() => {
                 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) {
+            throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', ']));
+        };
+        var __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);
-            }
+            upcast &&= embind__requireFunction(upcastSignature, upcast);
+            downcast &&= embind__requireFunction(downcastSignature, downcast);
             rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
             var legalFunctionName = makeLegalFunctionName(name);
             exposePublicSymbol(legalFunctionName, function () {
                 // this code cannot run if baseClassRawType is zero
-                throwUnboundTypeError('Cannot construct ' + name + ' due to unbound types', [baseClassRawType]);
+                throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]);
             });
-            whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function (base) {
+            whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], (base) => {
                 base = base[0];
                 var baseClass;
                 var basePrototype;
@@ -1862,24 +1644,29 @@ var Module = (() => {
                 else {
                     basePrototype = ClassHandle.prototype;
                 }
-                var constructor = createNamedFunction(legalFunctionName, function () {
+                var constructor = createNamedFunction(name, function (...args) {
                     if (Object.getPrototypeOf(this) !== instancePrototype) {
                         throw new BindingError("Use 'new' to construct " + name);
                     }
                     if (undefined === registeredClass.constructor_body) {
                         throw new BindingError(name + " has no accessible constructor");
                     }
-                    var body = registeredClass.constructor_body[arguments.length];
+                    var body = registeredClass.constructor_body[args.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!");
+                        throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
                     }
-                    return body.apply(this, arguments);
+                    return body.apply(this, args);
                 });
                 var instancePrototype = Object.create(basePrototype, {
                     constructor: { value: constructor },
                 });
                 constructor.prototype = instancePrototype;
                 var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+                if (registeredClass.baseClass) {
+                    // Keep track of class hierarchy. Used to allow sub-classes to inherit class functions.
+                    registeredClass.baseClass.__derivedClasses ??= [];
+                    registeredClass.baseClass.__derivedClasses.push(registeredClass);
+                }
                 var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
                 var pointerConverter = new RegisteredPointer(name + '*', registeredClass, false, false, false);
                 var constPointerConverter = new RegisteredPointer(name + ' const*', registeredClass, false, true, false);
@@ -1890,10 +1677,20 @@ var Module = (() => {
                 replacePublicSymbol(legalFunctionName, constructor);
                 return [referenceConverter, pointerConverter, constPointerConverter];
             });
+        };
+        function usesDestructorStack(argTypes) {
+            // Skip return value at index 0 - it's not deleted here.
+            for (var i = 1; i < argTypes.length; ++i) {
+                // The type does not define a destructor function - must use dynamic stack
+                if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
+                    return true;
+                }
+            }
+            return false;
         }
-        function new_(constructor, argumentList) {
+        function newFunc(constructor, argumentList) {
             if (!(constructor instanceof Function)) {
-                throw new TypeError('new_ called with constructor type ' + typeof (constructor) + " which is not a function");
+                throw new TypeError(`new_ called with constructor type ${typeof (constructor)} which is not a function`);
             }
             /*
              * Previously, the following line was just:
@@ -1902,7 +1699,7 @@ var Module = (() => {
              * though at creation, the 'dummy' has the correct constructor name.  Thus,
              * objects created with IMVU.new would show up in the debugger as 'dummy',
              * which isn't very helpful.  Using IMVU.createNamedFunction addresses the
-             * issue.  Doublely-unfortunately, there's no way to write a test for this
+             * issue.  Doubly-unfortunately, there's no way to write a test for this
              * behavior.  -NRD 2013.02.22
              */
             var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function () { });
@@ -1911,64 +1708,38 @@ var Module = (() => {
             var r = constructor.apply(obj, argumentList);
             return (r instanceof Object) ? r : obj;
         }
-        function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
-            // humanName: a human-readable string name for the function to be generated.
-            // argTypes: An array that contains the embind type objects for all types in the function signature.
-            //    argTypes[0] is the type object for the function return value.
-            //    argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.
-            //    argTypes[2...] are the actual function parameters.
-            // classType: The embind type object for the class to be bound, or null if this is not a method of a class.
-            // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.
-            // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.
+        function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
+            var needsDestructorStack = usesDestructorStack(argTypes);
             var argCount = argTypes.length;
-            if (argCount < 2) {
-                throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
-            }
-            var isClassMethodFunc = (argTypes[1] !== null && classType !== null);
-            // Free functions with signature "void function()" do not need an invoker that marshalls between wire types.
-            // TODO: This omits argument count check - enable only at -O3 or similar.
-            //    if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) {
-            //       return FUNCTION_TABLE[fn];
-            //    }
-            // Determine if we need to use a dynamic stack to store the destructors for the function parameters.
-            // TODO: Remove this completely once all function invokers are being dynamically generated.
-            var needsDestructorStack = false;
-            for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here.
-                if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack
-                    needsDestructorStack = true;
-                    break;
-                }
-            }
-            var returns = (argTypes[0].name !== "void");
             var argsList = "";
             var argsListWired = "";
             for (var i = 0; i < argCount - 2; ++i) {
                 argsList += (i !== 0 ? ", " : "") + "arg" + i;
                 argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
             }
-            var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" +
-                "if (arguments.length !== " + (argCount - 2) + ") {\n" +
-                "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" +
-                "}\n";
+            var invokerFnBody = `
+        return function (${argsList}) {
+        if (arguments.length !== ${argCount - 2}) {
+          throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected ${argCount - 2}');
+        }`;
             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]];
+            var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
             if (isClassMethodFunc) {
-                invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
+                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";
+                invokerFnBody += "var arg" + i + "Wired = argType" + i + "['toWireType'](" + dtorStack + ", arg" + i + ");\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";
+            var returnVal = returns ? "rv" : "";
             if (needsDestructorStack) {
                 invokerFnBody += "runDestructors(destructors);\n";
             }
@@ -1976,24 +1747,63 @@ var Module = (() => {
                 for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.
                     var paramName = (i === 1 ? "thisWired" : ("arg" + (i - 2) + "Wired"));
                     if (argTypes[i].destructorFunction !== null) {
-                        invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
-                        args1.push(paramName + "_dtor");
-                        args2.push(argTypes[i].destructorFunction);
+                        invokerFnBody += `${paramName}_dtor(${paramName});\n`;
+                        args1.push(`${paramName}_dtor`);
                     }
                 }
             }
             if (returns) {
-                invokerFnBody += "var ret = retType.fromWireType(rv);\n" +
+                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;
+            invokerFnBody += "}\n";
+            return [args1, invokerFnBody];
+        }
+        function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) {
+            // humanName: a human-readable string name for the function to be generated.
+            // argTypes: An array that contains the embind type objects for all types in the function signature.
+            //    argTypes[0] is the type object for the function return value.
+            //    argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.
+            //    argTypes[2...] are the actual function parameters.
+            // classType: The embind type object for the class to be bound, or null if this is not a method of a class.
+            // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.
+            // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.
+            // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI.
+            var argCount = argTypes.length;
+            if (argCount < 2) {
+                throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+            }
+            var isClassMethodFunc = (argTypes[1] !== null && classType !== null);
+            // Free functions with signature "void function()" do not need an invoker that marshalls between wire types.
+            // TODO: This omits argument count check - enable only at -O3 or similar.
+            //    if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) {
+            //       return FUNCTION_TABLE[fn];
+            //    }
+            // Determine if we need to use a dynamic stack to store the destructors for the function parameters.
+            // TODO: Remove this completely once all function invokers are being dynamically generated.
+            var needsDestructorStack = usesDestructorStack(argTypes);
+            var returns = (argTypes[0].name !== "void");
+            // Builld the arguments that will be passed into the closure around the invoker
+            // function.
+            var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
+            for (var i = 0; i < argCount - 2; ++i) {
+                closureArgs.push(argTypes[i + 2]);
+            }
+            if (!needsDestructorStack) {
+                for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.
+                    if (argTypes[i].destructorFunction !== null) {
+                        closureArgs.push(argTypes[i].destructorFunction);
+                    }
+                }
+            }
+            let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);
+            args.push(invokerFnBody);
+            var invokerFn = newFunc(Function, args)(...closureArgs);
+            return createNamedFunction(humanName, invokerFn);
         }
-        function heap32VectorToArray(count, firstElement) {
+        var heap32VectorToArray = (count, firstElement) => {
             var array = [];
             for (var i = 0; i < count; i++) {
                 // TODO(https://github.com/emscripten-core/emscripten/issues/17310):
@@ -2001,16 +1811,27 @@ var Module = (() => {
                 array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]);
             }
             return array;
-        }
-        function __embind_register_class_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn, isAsync) {
+        };
+        var getFunctionName = (signature) => {
+            signature = signature.trim();
+            const argsIndex = signature.indexOf("(");
+            if (argsIndex !== -1) {
+                return signature.substr(0, argsIndex);
+            }
+            else {
+                return signature;
+            }
+        };
+        var __embind_register_class_class_function = (rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn, isAsync) => {
             var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
             methodName = readLatin1String(methodName);
+            methodName = getFunctionName(methodName);
             rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
-            whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+            whenDependentTypesAreResolved([], [rawClassType], (classType) => {
                 classType = classType[0];
-                var humanName = classType.name + '.' + methodName;
+                var humanName = `${classType.name}.${methodName}`;
                 function unboundTypesHandler() {
-                    throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);
+                    throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes);
                 }
                 if (methodName.startsWith("@@")) {
                     methodName = Symbol[methodName.substring(2)];
@@ -2027,7 +1848,7 @@ var Module = (() => {
                     ensureOverloadTable(proto, methodName, humanName);
                     proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler;
                 }
-                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                whenDependentTypesAreResolved([], rawArgTypes, (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.
@@ -2040,30 +1861,37 @@ var Module = (() => {
                     else {
                         proto[methodName].overloadTable[argCount - 1] = func;
                     }
+                    if (classType.registeredClass.__derivedClasses) {
+                        for (const derivedClass of classType.registeredClass.__derivedClasses) {
+                            if (!derivedClass.constructor.hasOwnProperty(methodName)) {
+                                // TODO: Add support for overloads
+                                derivedClass.constructor[methodName] = func;
+                            }
+                        }
+                    }
                     return [];
                 });
                 return [];
             });
-        }
-        function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
-            assert(argCount > 0);
+        };
+        var __embind_register_class_constructor = (rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) => {
             var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
             invoker = embind__requireFunction(invokerSignature, invoker);
             var args = [rawConstructor];
             var destructors = [];
-            whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+            whenDependentTypesAreResolved([], [rawClassType], (classType) => {
                 classType = classType[0];
-                var humanName = 'constructor ' + classType.name;
+                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!");
+                    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);
+                    throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes);
                 };
-                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
                     // Insert empty slot for context type (argTypes[1]).
                     argTypes.splice(1, 0, null);
                     classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
@@ -2071,15 +1899,16 @@ var Module = (() => {
                 });
                 return [];
             });
-        }
-        function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, // [ReturnType, ThisType, Args...]
-        invokerSignature, rawInvoker, context, isPureVirtual, isAsync) {
+        };
+        var __embind_register_class_function = (rawClassType, methodName, argCount, rawArgTypesAddr, // [ReturnType, ThisType, Args...]
+        invokerSignature, rawInvoker, context, isPureVirtual, isAsync) => {
             var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
             methodName = readLatin1String(methodName);
+            methodName = getFunctionName(methodName);
             rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
-            whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+            whenDependentTypesAreResolved([], [rawClassType], (classType) => {
                 classType = classType[0];
-                var humanName = classType.name + '.' + methodName;
+                var humanName = `${classType.name}.${methodName}`;
                 if (methodName.startsWith("@@")) {
                     methodName = Symbol[methodName.substring(2)];
                 }
@@ -2087,7 +1916,7 @@ var Module = (() => {
                     classType.registeredClass.pureVirtualFunctions.push(methodName);
                 }
                 function unboundTypesHandler() {
-                    throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);
+                    throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes);
                 }
                 var proto = classType.registeredClass.instancePrototype;
                 var method = proto[methodName];
@@ -2104,10 +1933,12 @@ var Module = (() => {
                     ensureOverloadTable(proto, methodName, humanName);
                     proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
                 }
-                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                whenDependentTypesAreResolved([], rawArgTypes, (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.
+                    // 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;
@@ -2120,48 +1951,44 @@ var Module = (() => {
                 });
                 return [];
             });
-        }
-        function validateThis(this_, classType, humanName) {
+        };
+        var validateThis = (this_, classType, humanName) => {
             if (!(this_ instanceof Object)) {
-                throwBindingError(humanName + ' with invalid "this": ' + this_);
+                throwBindingError(`${humanName} with invalid "this": ${this_}`);
             }
             if (!(this_ instanceof classType.registeredClass.constructor)) {
-                throwBindingError(humanName + ' incompatible with "this" of type ' + this_.constructor.name);
+                throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`);
             }
             if (!this_.$$.ptr) {
-                throwBindingError('cannot call emscripten binding method ' + humanName + ' on deleted object');
+                throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`);
             }
             // todo: kill this
             return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass);
-        }
-        function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+        };
+        var __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) {
+            whenDependentTypesAreResolved([], [classType], (classType) => {
                 classType = classType[0];
-                var humanName = classType.name + '.' + fieldName;
+                var humanName = `${classType.name}.${fieldName}`;
                 var desc = {
-                    get: function () {
-                        throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]);
+                    get() {
+                        throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]);
                     },
                     enumerable: true,
                     configurable: true
                 };
                 if (setter) {
-                    desc.set = () => {
-                        throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]);
-                    };
+                    desc.set = () => throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]);
                 }
                 else {
-                    desc.set = (v) => {
-                        throwBindingError(humanName + ' is a read-only property');
-                    };
+                    desc.set = (v) => throwBindingError(humanName + ' is a read-only property');
                 }
                 Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
-                whenDependentTypesAreResolved([], (setter ? [getterReturnType, setterArgumentType] : [getterReturnType]), function (types) {
+                whenDependentTypesAreResolved([], (setter ? [getterReturnType, setterArgumentType] : [getterReturnType]), (types) => {
                     var getterReturnType = types[0];
                     var desc = {
-                        get: function () {
+                        get() {
                             var ptr = validateThis(this, classType, humanName + ' getter');
                             return getterReturnType['fromWireType'](getter(getterContext, ptr));
                         },
@@ -2182,33 +2009,29 @@ var Module = (() => {
                 });
                 return [];
             });
-        }
-        function __emval_decref(handle) {
-            if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
-                emval_handle_array[handle] = undefined;
-                emval_free_list.push(handle);
+        };
+        var __emval_decref = (handle) => {
+            if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+                emval_handles[handle] = undefined;
+                emval_freelist.push(handle);
             }
-        }
-        function __embind_register_emval(rawType, name) {
-            name = readLatin1String(name);
-            registerType(rawType, {
-                name: name,
-                'fromWireType': function (handle) {
-                    var rv = Emval.toValue(handle);
-                    __emval_decref(handle);
-                    return rv;
-                },
-                'toWireType': function (destructors, value) {
-                    return Emval.toHandle(value);
-                },
-                'argPackAdvance': 8,
-                'readValueFromPointer': simpleReadValueFromPointer,
-                destructorFunction: null, // This type does not need a destructor
-                // TODO: do we need a deleteObject here?  write a test where
-                // emval is passed into JS via an interface
-            });
-        }
-        function embindRepr(v) {
+        };
+        var EmValType = {
+            name: 'emscripten::val',
+            'fromWireType': (handle) => {
+                var rv = Emval.toValue(handle);
+                __emval_decref(handle);
+                return rv;
+            },
+            'toWireType': (destructors, value) => Emval.toHandle(value),
+            'argPackAdvance': GenericWireTypeSize,
+            'readValueFromPointer': readPointer,
+            destructorFunction: null, // This type does not need a destructor
+            // TODO: do we need a deleteObject here?  write a test where
+            // emval is passed into JS via an interface
+        };
+        var __embind_register_emval = (rawType) => registerType(rawType, EmValType);
+        var embindRepr = (v) => {
             if (v === null) {
                 return 'null';
             }
@@ -2219,74 +2042,72 @@ var Module = (() => {
             else {
                 return '' + v;
             }
-        }
-        function floatReadValueFromPointer(name, shift) {
-            switch (shift) {
-                case 2: return function (pointer) {
-                    return this['fromWireType'](HEAPF32[pointer >> 2]);
+        };
+        var floatReadValueFromPointer = (name, width) => {
+            switch (width) {
+                case 4: return function (pointer) {
+                    return this['fromWireType'](HEAPF32[((pointer) >> 2)]);
                 };
-                case 3: return function (pointer) {
-                    return this['fromWireType'](HEAPF64[pointer >> 3]);
+                case 8: return function (pointer) {
+                    return this['fromWireType'](HEAPF64[((pointer) >> 3)]);
                 };
                 default:
-                    throw new TypeError("Unknown float type: " + name);
+                    throw new TypeError(`invalid float width (${width}): ${name}`);
             }
-        }
-        function __embind_register_float(rawType, name, size) {
-            var shift = getShiftFromSize(size);
+        };
+        var __embind_register_float = (rawType, name, size) => {
             name = readLatin1String(name);
             registerType(rawType, {
-                name: name,
-                'fromWireType': function (value) {
-                    return value;
-                },
-                'toWireType': function (destructors, value) {
+                name,
+                'fromWireType': (value) => value,
+                'toWireType': (destructors, value) => {
                     // The VM will perform JS to Wasm value conversion, according to the spec:
                     // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
                     return value;
                 },
-                'argPackAdvance': 8,
-                'readValueFromPointer': floatReadValueFromPointer(name, shift),
+                'argPackAdvance': GenericWireTypeSize,
+                'readValueFromPointer': floatReadValueFromPointer(name, size),
                 destructorFunction: null, // This type does not need a destructor
             });
-        }
-        function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) {
+        };
+        var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => {
             var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
             name = readLatin1String(name);
+            name = getFunctionName(name);
             rawInvoker = embind__requireFunction(signature, rawInvoker);
             exposePublicSymbol(name, function () {
-                throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes);
+                throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
             }, argCount - 1);
-            whenDependentTypesAreResolved([], argTypes, function (argTypes) {
+            whenDependentTypesAreResolved([], argTypes, (argTypes) => {
                 var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);
                 replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1);
                 return [];
             });
-        }
-        function integerReadValueFromPointer(name, shift, signed) {
+        };
+        var integerReadValueFromPointer = (name, width, signed) => {
             // integers are quite common, so generate very specialized functions
-            switch (shift) {
-                case 0: return signed ?
-                    function readS8FromPointer(pointer) { return HEAP8[pointer]; } :
-                    function readU8FromPointer(pointer) { return HEAPU8[pointer]; };
+            switch (width) {
                 case 1: return signed ?
-                    function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } :
-                    function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; };
+                    (pointer) => HEAP8[pointer] :
+                    (pointer) => HEAPU8[pointer];
                 case 2: return signed ?
-                    function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } :
-                    function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; };
+                    (pointer) => HEAP16[((pointer) >> 1)] :
+                    (pointer) => HEAPU16[((pointer) >> 1)];
+                case 4: return signed ?
+                    (pointer) => HEAP32[((pointer) >> 2)] :
+                    (pointer) => HEAPU32[((pointer) >> 2)];
                 default:
-                    throw new TypeError("Unknown integer type: " + name);
+                    throw new TypeError(`invalid integer width (${width}): ${name}`);
             }
-        }
-        function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+        };
+        /** @suppress {globalThis} */
+        var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
             name = readLatin1String(name);
             // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come
             // out as 'i32 -1'. Always treat those as max u32.
             if (maxRange === -1) {
                 maxRange = 4294967295;
             }
-            var shift = getShiftFromSize(size);
             var fromWireType = (value) => value;
             if (minRange === 0) {
                 var bitshift = 32 - 8 * size;
@@ -2311,15 +2132,15 @@ var Module = (() => {
                 };
             }
             registerType(primitiveType, {
-                name: name,
+                name,
                 'fromWireType': fromWireType,
                 'toWireType': toWireType,
-                'argPackAdvance': 8,
-                'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0),
+                'argPackAdvance': GenericWireTypeSize,
+                'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0),
                 destructorFunction: null, // This type does not need a destructor
             });
-        }
-        function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+        };
+        var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
             var typeMapping = [
                 Int8Array,
                 Uint8Array,
@@ -2332,30 +2153,108 @@ var Module = (() => {
             ];
             var TA = typeMapping[dataTypeIndex];
             function decodeMemoryView(handle) {
-                handle = handle >> 2;
-                var heap = HEAPU32;
-                var size = heap[handle]; // in elements
-                var data = heap[handle + 1]; // byte offset into emscripten heap
-                return new TA(heap.buffer, data, size);
+                var size = HEAPU32[((handle) >> 2)];
+                var data = HEAPU32[(((handle) + (4)) >> 2)];
+                return new TA(HEAP8.buffer, data, size);
             }
             name = readLatin1String(name);
             registerType(rawType, {
-                name: name,
+                name,
                 'fromWireType': decodeMemoryView,
-                'argPackAdvance': 8,
+                'argPackAdvance': GenericWireTypeSize,
                 'readValueFromPointer': decodeMemoryView,
             }, {
                 ignoreDuplicateRegistrations: true,
             });
-        }
-        function __embind_register_std_string(rawType, name) {
+        };
+        var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+            // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
+            // undefined and false each don't write out any bytes.
+            if (!(maxBytesToWrite > 0))
+                return 0;
+            var startIdx = outIdx;
+            var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
+            for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+                // unit, not a Unicode code point of the character! So decode
+                // UTF16->UTF32->UTF8.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
+                // and https://www.ietf.org/rfc/rfc2279.txt
+                // and https://tools.ietf.org/html/rfc3629
+                var u = str.charCodeAt(i); // possibly a lead surrogate
+                if (u >= 0xD800 && u <= 0xDFFF) {
+                    var u1 = str.charCodeAt(++i);
+                    u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
+                }
+                if (u <= 0x7F) {
+                    if (outIdx >= endIdx)
+                        break;
+                    heap[outIdx++] = u;
+                }
+                else if (u <= 0x7FF) {
+                    if (outIdx + 1 >= endIdx)
+                        break;
+                    heap[outIdx++] = 0xC0 | (u >> 6);
+                    heap[outIdx++] = 0x80 | (u & 63);
+                }
+                else if (u <= 0xFFFF) {
+                    if (outIdx + 2 >= endIdx)
+                        break;
+                    heap[outIdx++] = 0xE0 | (u >> 12);
+                    heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+                    heap[outIdx++] = 0x80 | (u & 63);
+                }
+                else {
+                    if (outIdx + 3 >= endIdx)
+                        break;
+                    heap[outIdx++] = 0xF0 | (u >> 18);
+                    heap[outIdx++] = 0x80 | ((u >> 12) & 63);
+                    heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+                    heap[outIdx++] = 0x80 | (u & 63);
+                }
+            }
+            // Null-terminate the pointer to the buffer.
+            heap[outIdx] = 0;
+            return outIdx - startIdx;
+        };
+        var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
+            return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+        };
+        var lengthBytesUTF8 = (str) => {
+            var len = 0;
+            for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+                // unit, not a Unicode code point of the character! So decode
+                // UTF16->UTF32->UTF8.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                var c = str.charCodeAt(i); // possibly a lead surrogate
+                if (c <= 0x7F) {
+                    len++;
+                }
+                else if (c <= 0x7FF) {
+                    len += 2;
+                }
+                else if (c >= 0xD800 && c <= 0xDFFF) {
+                    len += 4;
+                    ++i;
+                }
+                else {
+                    len += 3;
+                }
+            }
+            return len;
+        };
+        var __embind_register_std_string = (rawType, name) => {
             name = readLatin1String(name);
             var stdStringIsUTF8 
             //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string<unsigned char>
             = (name === "std::string");
             registerType(rawType, {
-                name: name,
-                'fromWireType': function (value) {
+                name,
+                // For some method names we use string keys here since they are part of
+                // the public/external API and/or used by the runtime-generated code.
+                'fromWireType'(value) {
                     var length = HEAPU32[((value) >> 2)];
                     var payload = value + 4;
                     var str;
@@ -2388,7 +2287,7 @@ var Module = (() => {
                     _free(value);
                     return str;
                 },
-                'toWireType': function (destructors, value) {
+                'toWireType'(destructors, value) {
                     if (value instanceof ArrayBuffer) {
                         value = new Uint8Array(value);
                     }
@@ -2403,7 +2302,7 @@ var Module = (() => {
                     else {
                         length = value.length;
                     }
-                    // assumes 4-byte alignment
+                    // assumes POINTER_SIZE alignment
                     var base = _malloc(4 + length + 1);
                     var ptr = base + 4;
                     HEAPU32[((base) >> 2)] = length;
@@ -2432,14 +2331,16 @@ var Module = (() => {
                     }
                     return base;
                 },
-                'argPackAdvance': 8,
-                'readValueFromPointer': simpleReadValueFromPointer,
-                destructorFunction: function (ptr) { _free(ptr); },
+                'argPackAdvance': GenericWireTypeSize,
+                'readValueFromPointer': readPointer,
+                destructorFunction(ptr) {
+                    _free(ptr);
+                },
             });
-        }
+        };
         var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;
         ;
-        function UTF16ToString(ptr, maxBytesToRead) {
+        var UTF16ToString = (ptr, maxBytesToRead) => {
             var endPtr = ptr;
             // TextDecoder needs to know the byte length in advance, it doesn't stop on
             // null terminator by itself.
@@ -2468,12 +2369,10 @@ var Module = (() => {
                 str += String.fromCharCode(codeUnit);
             }
             return str;
-        }
-        function stringToUTF16(str, outPtr, maxBytesToWrite) {
+        };
+        var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
             // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
-            if (maxBytesToWrite === undefined) {
-                maxBytesToWrite = 0x7FFFFFFF;
-            }
+            maxBytesToWrite ??= 0x7FFFFFFF;
             if (maxBytesToWrite < 2)
                 return 0;
             maxBytesToWrite -= 2; // Null terminator.
@@ -2488,11 +2387,11 @@ var Module = (() => {
             // Null-terminate the pointer to the HEAP.
             HEAP16[((outPtr) >> 1)] = 0;
             return outPtr - startPtr;
-        }
-        function lengthBytesUTF16(str) {
+        };
+        var lengthBytesUTF16 = (str) => {
             return str.length * 2;
-        }
-        function UTF32ToString(ptr, maxBytesToRead) {
+        };
+        var UTF32ToString = (ptr, maxBytesToRead) => {
             var i = 0;
             var str = '';
             // If maxBytesToRead is not passed explicitly, it will be undefined, and this
@@ -2513,12 +2412,10 @@ var Module = (() => {
                 }
             }
             return str;
-        }
-        function stringToUTF32(str, outPtr, maxBytesToWrite) {
+        };
+        var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
             // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
-            if (maxBytesToWrite === undefined) {
-                maxBytesToWrite = 0x7FFFFFFF;
-            }
+            maxBytesToWrite ??= 0x7FFFFFFF;
             if (maxBytesToWrite < 4)
                 return 0;
             var startPtr = outPtr;
@@ -2539,8 +2436,8 @@ var Module = (() => {
             // Null-terminate the pointer to the HEAP.
             HEAP32[((outPtr) >> 2)] = 0;
             return outPtr - startPtr;
-        }
-        function lengthBytesUTF32(str) {
+        };
+        var lengthBytesUTF32 = (str) => {
             var len = 0;
             for (var i = 0; i < str.length; ++i) {
                 // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
@@ -2551,36 +2448,33 @@ var Module = (() => {
                 len += 4;
             }
             return len;
-        }
-        function __embind_register_std_wstring(rawType, charSize, name) {
+        };
+        var __embind_register_std_wstring = (rawType, charSize, name) => {
             name = readLatin1String(name);
-            var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+            var decodeString, encodeString, readCharAt, lengthBytesUTF;
             if (charSize === 2) {
                 decodeString = UTF16ToString;
                 encodeString = stringToUTF16;
                 lengthBytesUTF = lengthBytesUTF16;
-                getHeap = () => HEAPU16;
-                shift = 1;
+                readCharAt = (pointer) => HEAPU16[((pointer) >> 1)];
             }
             else if (charSize === 4) {
                 decodeString = UTF32ToString;
                 encodeString = stringToUTF32;
                 lengthBytesUTF = lengthBytesUTF32;
-                getHeap = () => HEAPU32;
-                shift = 2;
+                readCharAt = (pointer) => HEAPU32[((pointer) >> 2)];
             }
             registerType(rawType, {
-                name: name,
-                'fromWireType': function (value) {
+                name,
+                'fromWireType': (value) => {
                     // Code mostly taken from _embind_register_std_string fromWireType
-                    var length = HEAPU32[value >> 2];
-                    var HEAP = getHeap();
+                    var length = HEAPU32[((value) >> 2)];
                     var str;
                     var decodeStartPtr = value + 4;
                     // Looping here to support possible embedded '0' bytes
                     for (var i = 0; i <= length; ++i) {
                         var currentBytePtr = value + 4 + i * charSize;
-                        if (i == length || HEAP[currentBytePtr >> shift] == 0) {
+                        if (i == length || readCharAt(currentBytePtr) == 0) {
                             var maxReadBytes = currentBytePtr - decodeStartPtr;
                             var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
                             if (str === undefined) {
@@ -2596,202 +2490,176 @@ var Module = (() => {
                     _free(value);
                     return str;
                 },
-                'toWireType': function (destructors, value) {
+                'toWireType': (destructors, value) => {
                     if (!(typeof value == 'string')) {
-                        throwBindingError('Cannot pass non-string to C++ string type ' + name);
+                        throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
                     }
-                    // assumes 4-byte alignment
+                    // assumes POINTER_SIZE alignment
                     var length = lengthBytesUTF(value);
                     var ptr = _malloc(4 + length + charSize);
-                    HEAPU32[ptr >> 2] = length >> shift;
+                    HEAPU32[((ptr) >> 2)] = length / charSize;
                     encodeString(value, ptr + 4, length + charSize);
                     if (destructors !== null) {
                         destructors.push(_free, ptr);
                     }
                     return ptr;
                 },
-                'argPackAdvance': 8,
-                'readValueFromPointer': simpleReadValueFromPointer,
-                destructorFunction: function (ptr) { _free(ptr); },
+                'argPackAdvance': GenericWireTypeSize,
+                'readValueFromPointer': readPointer,
+                destructorFunction(ptr) {
+                    _free(ptr);
+                }
             });
-        }
-        function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
+        };
+        var __embind_register_value_object = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => {
             structRegistrations[rawType] = {
                 name: readLatin1String(name),
                 rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
                 rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
                 fields: [],
             };
-        }
-        function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+        };
+        var __embind_register_value_object_field = (structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => {
             structRegistrations[structType].fields.push({
                 fieldName: readLatin1String(fieldName),
-                getterReturnType: getterReturnType,
+                getterReturnType,
                 getter: embind__requireFunction(getterSignature, getter),
-                getterContext: getterContext,
-                setterArgumentType: setterArgumentType,
+                getterContext,
+                setterArgumentType,
                 setter: embind__requireFunction(setterSignature, setter),
-                setterContext: setterContext,
+                setterContext,
             });
-        }
-        function __embind_register_void(rawType, name) {
+        };
+        var __embind_register_void = (rawType, name) => {
             name = readLatin1String(name);
             registerType(rawType, {
                 isVoid: true, // void return values can be optimized out sometimes
-                name: name,
+                name,
                 'argPackAdvance': 0,
-                'fromWireType': function () {
-                    return undefined;
-                },
-                'toWireType': function (destructors, o) {
-                    // TODO: assert if anything else is given?
-                    return undefined;
-                },
+                'fromWireType': () => undefined,
+                // TODO: assert if anything else is given?
+                'toWireType': (destructors, o) => undefined,
             });
-        }
-        function __emval_as(handle, returnType, destructorsRef) {
+        };
+        var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
+        var emval_returnValue = (returnType, destructorsRef, handle) => {
+            var destructors = [];
+            var result = returnType['toWireType'](destructors, handle);
+            if (destructors.length) {
+                // void, primitives and any other types w/o destructors don't need to allocate a handle
+                HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors);
+            }
+            return result;
+        };
+        var __emval_as = (handle, returnType, destructorsRef) => {
             handle = Emval.toValue(handle);
             returnType = requireRegisteredType(returnType, 'emval::as');
-            var destructors = [];
-            var rd = Emval.toHandle(destructors);
-            HEAPU32[((destructorsRef) >> 2)] = rd;
-            return returnType['toWireType'](destructors, handle);
-        }
-        function emval_allocateDestructors(destructorsRef) {
-            var destructors = [];
-            HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors);
-            return destructors;
-        }
+            return emval_returnValue(returnType, destructorsRef, handle);
+        };
         var emval_symbols = {};
-        function getStringOrSymbol(address) {
+        var getStringOrSymbol = (address) => {
             var symbol = emval_symbols[address];
             if (symbol === undefined) {
                 return readLatin1String(address);
             }
             return symbol;
-        }
+        };
         var emval_methodCallers = [];
-        function __emval_call_method(caller, handle, methodName, destructorsRef, args) {
+        var __emval_call_method = (caller, objHandle, 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);
+            objHandle = Emval.toValue(objHandle);
             methodName = getStringOrSymbol(methodName);
-            caller(handle, methodName, null, args);
-        }
-        function emval_addMethodCaller(caller) {
+            return caller(objHandle, objHandle[methodName], destructorsRef, args);
+        };
+        var emval_addMethodCaller = (caller) => {
             var id = emval_methodCallers.length;
             emval_methodCallers.push(caller);
             return id;
-        }
-        function emval_lookupTypes(argCount, argTypes) {
+        };
+        var emval_lookupTypes = (argCount, argTypes) => {
             var a = new Array(argCount);
             for (var i = 0; i < argCount; ++i) {
                 a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], "parameter " + i);
             }
             return a;
-        }
-        var emval_registeredMethods = [];
-        function __emval_get_method_caller(argCount, argTypes) {
+        };
+        var reflectConstruct = Reflect.construct;
+        var __emval_get_method_caller = (argCount, argTypes, kind) => {
             var types = emval_lookupTypes(argCount, argTypes);
-            var retType = types[0];
-            var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$";
-            var returnId = emval_registeredMethods[signatureName];
-            if (returnId !== undefined) {
-                return returnId;
+            var retType = types.shift();
+            argCount--; // remove the shifted off return type
+            var functionBody = `return function (obj, func, destructorsRef, args) {\n`;
+            var offset = 0;
+            var argsList = []; // 'obj?, arg0, arg1, arg2, ... , argN'
+            if (kind === /* FUNCTION */ 0) {
+                argsList.push("obj");
             }
             var params = ["retType"];
             var args = [retType];
-            var argsList = ""; // 'arg0, arg1, arg2, ... , argN'
-            for (var i = 0; i < argCount - 1; ++i) {
-                argsList += (i !== 0 ? ", " : "") + "arg" + i;
+            for (var i = 0; i < argCount; ++i) {
+                argsList.push("arg" + i);
                 params.push("argType" + i);
-                args.push(types[1 + i]);
-            }
-            var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
-            var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n";
-            var offset = 0;
-            for (var i = 0; i < argCount - 1; ++i) {
+                args.push(types[i]);
                 functionBody +=
-                    "    var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? ("+" + offset) : "") + ");\n";
-                offset += types[i + 1]['argPackAdvance'];
+                    `  var arg${i} = argType${i}.readValueFromPointer(args${offset ? "+" + offset : ""});\n`;
+                offset += types[i]['argPackAdvance'];
             }
+            var invoker = kind === /* CONSTRUCTOR */ 1 ? 'new func' : 'func.call';
             functionBody +=
-                "    var rv = handle[name](" + argsList + ");\n";
-            for (var i = 0; i < argCount - 1; ++i) {
-                if (types[i + 1]['deleteObject']) {
-                    functionBody +=
-                        "    argType" + i + ".deleteObject(arg" + i + ");\n";
-                }
-            }
+                `  var rv = ${invoker}(${argsList.join(", ")});\n`;
             if (!retType.isVoid) {
+                params.push("emval_returnValue");
+                args.push(emval_returnValue);
                 functionBody +=
-                    "    return retType.toWireType(destructors, rv);\n";
+                    "  return emval_returnValue(retType, destructorsRef, rv);\n";
             }
             functionBody +=
                 "};\n";
             params.push(functionBody);
-            var invokerFunction = new_(Function, params).apply(null, args);
-            returnId = emval_addMethodCaller(invokerFunction);
-            emval_registeredMethods[signatureName] = returnId;
-            return returnId;
-        }
-        function __emval_get_property(handle, key) {
+            var invokerFunction = newFunc(Function, params)(...args);
+            var functionName = `methodCaller<(${types.map(t => t.name).join(', ')}) => ${retType.name}>`;
+            return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+        };
+        var __emval_get_property = (handle, key) => {
             handle = Emval.toValue(handle);
             key = Emval.toValue(key);
             return Emval.toHandle(handle[key]);
-        }
-        function __emval_incref(handle) {
-            if (handle > 4) {
-                emval_handle_array[handle].refcount += 1;
-            }
-        }
-        function __emval_new_array() {
-            return Emval.toHandle([]);
-        }
-        function __emval_new_array_from_memory_view(view) {
+        };
+        var __emval_new_array = () => Emval.toHandle([]);
+        var __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));
-        }
-        function __emval_run_destructors(handle) {
+        };
+        var __emval_new_cstring = (v) => Emval.toHandle(getStringOrSymbol(v));
+        var __emval_run_destructors = (handle) => {
             var destructors = Emval.toValue(handle);
             runDestructors(destructors);
             __emval_decref(handle);
-        }
-        function __emval_take_value(type, arg) {
+        };
+        var __emval_take_value = (type, arg) => {
             type = requireRegisteredType(type, '_emval_take_value');
             var v = type['readValueFromPointer'](arg);
             return Emval.toHandle(v);
-        }
-        function _abort() {
+        };
+        var _abort = () => {
             abort('');
-        }
-        function _emscripten_memcpy_big(dest, src, num) {
-            HEAPU8.copyWithin(dest, src, src + num);
-        }
-        function getHeapMax() {
-            // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
-            // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
-            // for any code that deals with heap sizes, which would require special
-            // casing all heap size related code to treat 0 specially.
-            return 2147483648;
-        }
-        function emscripten_realloc_buffer(size) {
+        };
+        var getHeapMax = () => 
+        // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+        // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+        // for any code that deals with heap sizes, which would require special
+        // casing all heap size related code to treat 0 specially.
+        2147483648;
+        var growMemory = (size) => {
             var b = wasmMemory.buffer;
+            var pages = (size - b.byteLength + 65535) / 65536;
             try {
                 // round size grow request up to wasm page size (fixed 64KB per spec)
-                wasmMemory.grow((size - b.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size
+                wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
                 updateMemoryViews();
                 return 1 /*success*/;
             }
@@ -2799,10 +2667,11 @@ var Module = (() => {
             }
             // implicit 0 return to save code size (caller will cast "undefined" into 0
             // anyhow)
-        }
-        function _emscripten_resize_heap(requestedSize) {
+        };
+        var _emscripten_resize_heap = (requestedSize) => {
             var oldSize = HEAPU8.length;
-            requestedSize = requestedSize >>> 0;
+            // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+            requestedSize >>>= 0;
             // With multithreaded builds, races can happen (another thread might increase the size
             // in between), so return a failure, and let the caller retry.
             // Memory resize rules:
@@ -2827,7 +2696,7 @@ var Module = (() => {
             if (requestedSize > maxHeapSize) {
                 return false;
             }
-            let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+            var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
             // Loop through potential heap size increases. If we attempt a too eager
             // reservation that fails, cut down on the attempted size and reserve a
             // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
@@ -2836,18 +2705,18 @@ var Module = (() => {
                 // but limit overreserving (default to capping at +96MB overgrowth at most)
                 overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
                 var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
-                var replacement = emscripten_realloc_buffer(newSize);
+                var replacement = growMemory(newSize);
                 if (replacement) {
                     return true;
                 }
             }
             return false;
-        }
+        };
         var ENV = {};
-        function getExecutableName() {
+        var getExecutableName = () => {
             return thisProgram || './this.program';
-        }
-        function getEnvStrings() {
+        };
+        var getEnvStrings = () => {
             if (!getEnvStrings.strings) {
                 // Default values.
                 // Browser language detection #8751
@@ -2873,67 +2742,53 @@ var Module = (() => {
                 }
                 var strings = [];
                 for (var x in env) {
-                    strings.push(x + '=' + env[x]);
+                    strings.push(`${x}=${env[x]}`);
                 }
                 getEnvStrings.strings = strings;
             }
             return getEnvStrings.strings;
-        }
-        /** @param {boolean=} dontAddNull */
-        function writeAsciiToMemory(str, buffer, dontAddNull) {
+        };
+        var stringToAscii = (str, buffer) => {
             for (var i = 0; i < str.length; ++i) {
-                HEAP8[((buffer++) >> 0)] = str.charCodeAt(i);
+                HEAP8[buffer++] = str.charCodeAt(i);
             }
-            // Null-terminate the pointer to the HEAP.
-            if (!dontAddNull)
-                HEAP8[((buffer) >> 0)] = 0;
-        }
-        var SYSCALLS = { varargs: undefined, get: function () {
-                SYSCALLS.varargs += 4;
-                var ret = HEAP32[(((SYSCALLS.varargs) - (4)) >> 2)];
-                return ret;
-            }, getStr: function (ptr) {
-                var ret = UTF8ToString(ptr);
-                return ret;
-            } };
-        function _environ_get(__environ, environ_buf) {
+            // Null-terminate the string
+            HEAP8[buffer] = 0;
+        };
+        var _environ_get = (__environ, environ_buf) => {
             var bufSize = 0;
-            getEnvStrings().forEach(function (string, i) {
+            getEnvStrings().forEach((string, i) => {
                 var ptr = environ_buf + bufSize;
                 HEAPU32[(((__environ) + (i * 4)) >> 2)] = ptr;
-                writeAsciiToMemory(string, ptr);
+                stringToAscii(string, ptr);
                 bufSize += string.length + 1;
             });
             return 0;
-        }
-        function _environ_sizes_get(penviron_count, penviron_buf_size) {
+        };
+        var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
             var strings = getEnvStrings();
             HEAPU32[((penviron_count) >> 2)] = strings.length;
             var bufSize = 0;
-            strings.forEach(function (string) {
-                bufSize += string.length + 1;
-            });
+            strings.forEach((string) => bufSize += string.length + 1);
             HEAPU32[((penviron_buf_size) >> 2)] = bufSize;
             return 0;
-        }
-        function __isLeapYear(year) {
-            return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-        }
-        function __arraySum(array, index) {
+        };
+        var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        var arraySum = (array, index) => {
             var sum = 0;
             for (var i = 0; i <= index; sum += array[i++]) {
                 // no-op
             }
             return sum;
-        }
-        var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        function __addDays(date, days) {
+        };
+        var MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        var MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        var addDays = (date, days) => {
             var newDate = new Date(date.getTime());
             while (days > 0) {
-                var leap = __isLeapYear(newDate.getFullYear());
+                var leap = isLeapYear(newDate.getFullYear());
                 var currentMonth = newDate.getMonth();
-                var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
+                var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[currentMonth];
                 if (days > daysInCurrentMonth - newDate.getDate()) {
                     // we spill over to next month
                     days -= (daysInCurrentMonth - newDate.getDate() + 1);
@@ -2953,7 +2808,7 @@ var Module = (() => {
                 }
             }
             return newDate;
-        }
+        };
         /** @type {function(string, boolean=, number=)} */
         function intArrayFromString(stringy, dontAddNull, length) {
             var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
@@ -2963,13 +2818,13 @@ var Module = (() => {
                 u8array.length = numBytesWritten;
             return u8array;
         }
-        function writeArrayToMemory(array, buffer) {
+        var writeArrayToMemory = (array, buffer) => {
             HEAP8.set(array, buffer);
-        }
-        function _strftime(s, maxsize, format, tm) {
+        };
+        var _strftime = (s, maxsize, format, tm) => {
             // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
             // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
-            var tm_zone = HEAP32[(((tm) + (40)) >> 2)];
+            var tm_zone = HEAPU32[(((tm) + (40)) >> 2)];
             var date = {
                 tm_sec: HEAP32[((tm) >> 2)],
                 tm_min: HEAP32[(((tm) + (4)) >> 2)],
@@ -3062,7 +2917,7 @@ var Module = (() => {
                 }
             }
             function getWeekBasedYear(date) {
-                var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
+                var thisDate = addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
                 var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
                 var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
                 var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
@@ -3077,29 +2932,17 @@ var Module = (() => {
                 return thisDate.getFullYear() - 1;
             }
             var EXPANSION_RULES_2 = {
-                '%a': function (date) {
-                    return WEEKDAYS[date.tm_wday].substring(0, 3);
-                },
-                '%A': function (date) {
-                    return WEEKDAYS[date.tm_wday];
-                },
-                '%b': function (date) {
-                    return MONTHS[date.tm_mon].substring(0, 3);
-                },
-                '%B': function (date) {
-                    return MONTHS[date.tm_mon];
-                },
-                '%C': function (date) {
+                '%a': (date) => WEEKDAYS[date.tm_wday].substring(0, 3),
+                '%A': (date) => WEEKDAYS[date.tm_wday],
+                '%b': (date) => MONTHS[date.tm_mon].substring(0, 3),
+                '%B': (date) => MONTHS[date.tm_mon],
+                '%C': (date) => {
                     var year = date.tm_year + 1900;
                     return leadingNulls((year / 100) | 0, 2);
                 },
-                '%d': function (date) {
-                    return leadingNulls(date.tm_mday, 2);
-                },
-                '%e': function (date) {
-                    return leadingSomething(date.tm_mday, 2, ' ');
-                },
-                '%g': function (date) {
+                '%d': (date) => leadingNulls(date.tm_mday, 2),
+                '%e': (date) => leadingSomething(date.tm_mday, 2, ' '),
+                '%g': (date) => {
                     // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
                     // In this system, weeks begin on a Monday and week 1 of the year is the week that includes
                     // January 4th, which is also the week that includes the first Thursday of the year, and
@@ -3111,13 +2954,9 @@ var Module = (() => {
                     // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01.
                     return getWeekBasedYear(date).toString().substring(2);
                 },
-                '%G': function (date) {
-                    return getWeekBasedYear(date);
-                },
-                '%H': function (date) {
-                    return leadingNulls(date.tm_hour, 2);
-                },
-                '%I': function (date) {
+                '%G': getWeekBasedYear,
+                '%H': (date) => leadingNulls(date.tm_hour, 2),
+                '%I': (date) => {
                     var twelveHour = date.tm_hour;
                     if (twelveHour == 0)
                         twelveHour = 12;
@@ -3125,39 +2964,27 @@ var Module = (() => {
                         twelveHour -= 12;
                     return leadingNulls(twelveHour, 2);
                 },
-                '%j': function (date) {
+                '%j': (date) => {
                     // Day of the year (001-366)
-                    return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
-                },
-                '%m': function (date) {
-                    return leadingNulls(date.tm_mon + 1, 2);
-                },
-                '%M': function (date) {
-                    return leadingNulls(date.tm_min, 2);
+                    return leadingNulls(date.tm_mday + arraySum(isLeapYear(date.tm_year + 1900) ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
                 },
-                '%n': function () {
-                    return '\n';
-                },
-                '%p': function (date) {
+                '%m': (date) => leadingNulls(date.tm_mon + 1, 2),
+                '%M': (date) => leadingNulls(date.tm_min, 2),
+                '%n': () => '\n',
+                '%p': (date) => {
                     if (date.tm_hour >= 0 && date.tm_hour < 12) {
                         return 'AM';
                     }
                     return 'PM';
                 },
-                '%S': function (date) {
-                    return leadingNulls(date.tm_sec, 2);
-                },
-                '%t': function () {
-                    return '\t';
-                },
-                '%u': function (date) {
-                    return date.tm_wday || 7;
-                },
-                '%U': function (date) {
+                '%S': (date) => leadingNulls(date.tm_sec, 2),
+                '%t': () => '\t',
+                '%u': (date) => date.tm_wday || 7,
+                '%U': (date) => {
                     var days = date.tm_yday + 7 - date.tm_wday;
                     return leadingNulls(Math.floor(days / 7), 2);
                 },
-                '%V': function (date) {
+                '%V': (date) => {
                     // Replaced by the week number of the year (Monday as the first day of the week)
                     // as a decimal number [01,53]. If the week containing 1 January has four
                     // or more days in the new year, then it is considered week 1.
@@ -3174,7 +3001,7 @@ var Module = (() => {
                         // If 31 December of prev year a Thursday, or Friday of a
                         // leap year, then the prev year has 53 weeks.
                         var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
-                        if (dec31 == 4 || (dec31 == 5 && __isLeapYear(date.tm_year % 400 - 1))) {
+                        if (dec31 == 4 || (dec31 == 5 && isLeapYear(date.tm_year % 400 - 1))) {
                             val++;
                         }
                     }
@@ -3182,27 +3009,23 @@ var Module = (() => {
                         // If 1 January is not a Thursday, and not a Wednesday of a
                         // leap year, then this year has only 52 weeks.
                         var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
-                        if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year)))
+                        if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date.tm_year)))
                             val = 1;
                     }
                     return leadingNulls(val, 2);
                 },
-                '%w': function (date) {
-                    return date.tm_wday;
-                },
-                '%W': function (date) {
+                '%w': (date) => date.tm_wday,
+                '%W': (date) => {
                     var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
                     return leadingNulls(Math.floor(days / 7), 2);
                 },
-                '%y': function (date) {
+                '%y': (date) => {
                     // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
                     return (date.tm_year + 1900).toString().substring(2);
                 },
-                '%Y': function (date) {
-                    // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
-                    return date.tm_year + 1900;
-                },
-                '%z': function (date) {
+                // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
+                '%Y': (date) => date.tm_year + 1900,
+                '%z': (date) => {
                     // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ).
                     // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
                     var off = date.tm_gmtoff;
@@ -3212,12 +3035,8 @@ var Module = (() => {
                     off = (off / 60) * 100 + (off % 60);
                     return (ahead ? '+' : '-') + String("0000" + off).slice(-4);
                 },
-                '%Z': function (date) {
-                    return date.tm_zone;
-                },
-                '%%': function () {
-                    return '%';
-                }
+                '%Z': (date) => date.tm_zone,
+                '%%': () => '%'
             };
             // Replace %% with a pair of NULLs (which cannot occur in a C string), then
             // re-inject them after processing.
@@ -3234,12 +3053,13 @@ var Module = (() => {
             }
             writeArrayToMemory(bytes, s);
             return bytes.length - 1;
-        }
-        function _strftime_l(s, maxsize, format, tm, loc) {
+        };
+        var _strftime_l = (s, maxsize, format, tm, loc) => {
             return _strftime(s, maxsize, format, tm); // no locale support yet
-        }
-        BindingError = Module['BindingError'] = extendError(Error, 'BindingError');
-        ;
+        };
+        BindingError = Module['BindingError'] = class BindingError extends Error {
+            constructor(message) { super(message); this.name = 'BindingError'; }
+        };
         init_emval();
         ;
         PureVirtualError = Module['PureVirtualError'] = extendError(Error, 'PureVirtualError');
@@ -3247,120 +3067,105 @@ var Module = (() => {
         embind_init_charCodes();
         init_embind();
         ;
-        InternalError = Module['InternalError'] = extendError(Error, 'InternalError');
-        ;
+        InternalError = Module['InternalError'] = class InternalError extends Error {
+            constructor(message) { super(message); this.name = 'InternalError'; }
+        };
         init_ClassHandle();
         init_RegisteredPointer();
         UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');
         ;
         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,
-            "_embind_register_function": __embind_register_function,
-            "_embind_register_integer": __embind_register_integer,
-            "_embind_register_memory_view": __embind_register_memory_view,
-            "_embind_register_std_string": __embind_register_std_string,
-            "_embind_register_std_wstring": __embind_register_std_wstring,
-            "_embind_register_value_object": __embind_register_value_object,
-            "_embind_register_value_object_field": __embind_register_value_object_field,
-            "_embind_register_void": __embind_register_void,
-            "_emval_as": __emval_as,
-            "_emval_call_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,
-            "abort": _abort,
-            "emscripten_memcpy_big": _emscripten_memcpy_big,
-            "emscripten_resize_heap": _emscripten_resize_heap,
-            "environ_get": _environ_get,
-            "environ_sizes_get": _environ_sizes_get,
-            "strftime_l": _strftime_l
-        };
-        var asm = createWasm();
-        /** @type {function(...*):?} */
-        var ___wasm_call_ctors = function () {
-            return (___wasm_call_ctors = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var _kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = function () {
-            return (_kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = Module["asm"]["kmcmp_CompileKeyboard"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var _kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = function () {
-            return (_kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = Module["asm"]["kmcmp_parseUnicodeSet"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var _malloc = function () {
-            return (_malloc = Module["asm"]["malloc"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var _free = function () {
-            return (_free = Module["asm"]["free"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var ___getTypeName = Module["___getTypeName"] = function () {
-            return (___getTypeName = Module["___getTypeName"] = Module["asm"]["__getTypeName"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = function () {
-            return (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = Module["asm"]["_embind_initialize_bindings"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var ___errno_location = function () {
-            return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var ___trap = function () {
-            return (___trap = Module["asm"]["__trap"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var stackSave = function () {
-            return (stackSave = Module["asm"]["stackSave"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var stackRestore = function () {
-            return (stackRestore = Module["asm"]["stackRestore"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var stackAlloc = function () {
-            return (stackAlloc = Module["asm"]["stackAlloc"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var dynCall_viijii = Module["dynCall_viijii"] = function () {
-            return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["dynCall_viijii"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var dynCall_iiiiij = Module["dynCall_iiiiij"] = function () {
-            return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["dynCall_iiiiij"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function () {
-            return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments);
-        };
-        /** @type {function(...*):?} */
-        var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function () {
-            return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments);
+            /** @export */
+            __assert_fail: ___assert_fail,
+            /** @export */
+            _embind_create_inheriting_constructor: __embind_create_inheriting_constructor,
+            /** @export */
+            _embind_finalize_value_object: __embind_finalize_value_object,
+            /** @export */
+            _embind_register_bigint: __embind_register_bigint,
+            /** @export */
+            _embind_register_bool: __embind_register_bool,
+            /** @export */
+            _embind_register_class: __embind_register_class,
+            /** @export */
+            _embind_register_class_class_function: __embind_register_class_class_function,
+            /** @export */
+            _embind_register_class_constructor: __embind_register_class_constructor,
+            /** @export */
+            _embind_register_class_function: __embind_register_class_function,
+            /** @export */
+            _embind_register_class_property: __embind_register_class_property,
+            /** @export */
+            _embind_register_emval: __embind_register_emval,
+            /** @export */
+            _embind_register_float: __embind_register_float,
+            /** @export */
+            _embind_register_function: __embind_register_function,
+            /** @export */
+            _embind_register_integer: __embind_register_integer,
+            /** @export */
+            _embind_register_memory_view: __embind_register_memory_view,
+            /** @export */
+            _embind_register_std_string: __embind_register_std_string,
+            /** @export */
+            _embind_register_std_wstring: __embind_register_std_wstring,
+            /** @export */
+            _embind_register_value_object: __embind_register_value_object,
+            /** @export */
+            _embind_register_value_object_field: __embind_register_value_object_field,
+            /** @export */
+            _embind_register_void: __embind_register_void,
+            /** @export */
+            _emscripten_memcpy_js: __emscripten_memcpy_js,
+            /** @export */
+            _emval_as: __emval_as,
+            /** @export */
+            _emval_call_method: __emval_call_method,
+            /** @export */
+            _emval_decref: __emval_decref,
+            /** @export */
+            _emval_get_method_caller: __emval_get_method_caller,
+            /** @export */
+            _emval_get_property: __emval_get_property,
+            /** @export */
+            _emval_new_array: __emval_new_array,
+            /** @export */
+            _emval_new_array_from_memory_view: __emval_new_array_from_memory_view,
+            /** @export */
+            _emval_new_cstring: __emval_new_cstring,
+            /** @export */
+            _emval_run_destructors: __emval_run_destructors,
+            /** @export */
+            _emval_take_value: __emval_take_value,
+            /** @export */
+            abort: _abort,
+            /** @export */
+            emscripten_resize_heap: _emscripten_resize_heap,
+            /** @export */
+            environ_get: _environ_get,
+            /** @export */
+            environ_sizes_get: _environ_sizes_get,
+            /** @export */
+            strftime_l: _strftime_l
         };
+        var wasmExports = createWasm();
+        var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports['__wasm_call_ctors'])();
+        var _kmcmp_CompileKeyboard = Module['_kmcmp_CompileKeyboard'] = (a0, a1, a2, a3, a4, a5) => (_kmcmp_CompileKeyboard = Module['_kmcmp_CompileKeyboard'] = wasmExports['kmcmp_CompileKeyboard'])(a0, a1, a2, a3, a4, a5);
+        var _kmcmp_parseUnicodeSet = Module['_kmcmp_parseUnicodeSet'] = (a0, a1, a2) => (_kmcmp_parseUnicodeSet = Module['_kmcmp_parseUnicodeSet'] = wasmExports['kmcmp_parseUnicodeSet'])(a0, a1, a2);
+        var _malloc = (a0) => (_malloc = wasmExports['malloc'])(a0);
+        var _free = (a0) => (_free = wasmExports['free'])(a0);
+        var ___getTypeName = (a0) => (___getTypeName = wasmExports['__getTypeName'])(a0);
+        var ___trap = () => (___trap = wasmExports['__trap'])();
+        var __emscripten_tempret_set = (a0) => (__emscripten_tempret_set = wasmExports['_emscripten_tempret_set'])(a0);
+        var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'])(a0);
+        var dynCall_viijii = Module['dynCall_viijii'] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viijii = Module['dynCall_viijii'] = wasmExports['dynCall_viijii'])(a0, a1, a2, a3, a4, a5, a6);
+        var dynCall_iiiiij = Module['dynCall_iiiiij'] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiiij = Module['dynCall_iiiiij'] = wasmExports['dynCall_iiiiij'])(a0, a1, a2, a3, a4, a5, a6);
+        var dynCall_iiiiijj = Module['dynCall_iiiiijj'] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_iiiiijj = Module['dynCall_iiiiijj'] = wasmExports['dynCall_iiiiijj'])(a0, a1, a2, a3, a4, a5, a6, a7, a8);
+        var dynCall_iiiiiijj = Module['dynCall_iiiiiijj'] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_iiiiiijj = Module['dynCall_iiiiiijj'] = wasmExports['dynCall_iiiiiijj'])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
         // include: postamble.js
         // === Auto-generated postamble setup entry stuff ===
-        Module["UTF8ToString"] = UTF8ToString;
+        Module['wasmExports'] = wasmExports;
+        Module['UTF8ToString'] = UTF8ToString;
         var calledRun;
         dependenciesFulfilled = function runCaller() {
             // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
@@ -3415,7 +3220,15 @@ var Module = (() => {
         }
         run();
         // end include: postamble.js
-        return Module.ready;
+        // include: postamble_modularize.js
+        // In MODULARIZE mode we wrap the generated code in a factory function
+        // and return either the Module itself, or a promise of the module.
+        //
+        // We assign to the `moduleRtn` global here and configure closure to see
+        // this as and extern so it won't get minified.
+        moduleRtn = readyPromise;
+        // end include: postamble_modularize.js
+        return moduleRtn;
     });
 })();
 export default Module;