@keymanapp/kmc-kmn 18.0.29-alpha-local → 18.0.31-alpha

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

@@ -1,6 +1,8 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c211f816-44aa-5eab-8f12-fbd1b87e723f")}catch(e){}}();
 var Module = (() => {
     var _scriptDir = import.meta.url;
-    return (async function (moduleArg = {}) {
+    return (async function (Module = {}) {
         // include: shell.js
         // The Module object: Our interface to the outside world. We import
         // and export values on it. There are various ways Module can be used:
@@ -15,10 +17,10 @@ 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 = moduleArg;
+        var Module = typeof Module != 'undefined' ? Module : {};
         // Set up the promise that indicates the Module is initialized
         var readyPromiseResolve, readyPromiseReject;
-        Module['ready'] = new Promise((resolve, reject) => {
+        Module['ready'] = new Promise(function (resolve, reject) {
             readyPromiseResolve = resolve;
             readyPromiseReject = reject;
         });
@@ -53,7 +55,7 @@ var Module = (() => {
             return scriptDirectory + path;
         }
         // Hooks that are implemented differently in different runtime environments.
-        var read_, readAsync, readBinary;
+        var read_, readAsync, readBinary, setWindowTitle;
         if (ENVIRONMENT_IS_NODE) {
             // `require()` is no-op in an ESM module, use `createRequire()` to construct
             // the require()` function.  This is only necessary for multi-environment
@@ -89,27 +91,42 @@ var Module = (() => {
                 }
                 return ret;
             };
-            readAsync = (filename, onload, onerror, binary = true) => {
+            readAsync = (filename, onload, onerror) => {
                 // See the comment in the `read_` function.
                 filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-                fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
+                fs.readFile(filename, function (err, data) {
                     if (err)
                         onerror(err);
                     else
-                        onload(binary ? data.buffer : data);
+                        onload(data.buffer);
                 });
             };
             // end include: node_shell_read.js
-            if (!Module['thisProgram'] && process.argv.length > 1) {
+            if (process.argv.length > 1) {
                 thisProgram = process.argv[1].replace(/\\/g, '/');
             }
             arguments_ = process.argv.slice(2);
             // MODULARIZE will export the module in the proper place outside, we don't need to export here
+            process.on('uncaughtException', function (ex) {
+                // suppress ExitStatus exceptions from showing an error
+                if (ex !== 'unwind' && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
+                    throw ex;
+                }
+            });
+            // Without this older versions of node (< v15) will log unhandled rejections
+            // but return 0, which is not normally the desired behaviour.  This is
+            // not be needed with node v15 and about because it is now the default
+            // behaviour:
+            // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
+            var nodeMajor = process.versions.node.split(".")[0];
+            if (nodeMajor < 15) {
+                process.on('unhandledRejection', function (reason) { throw reason; });
+            }
             quit_ = (status, toThrow) => {
                 process.exitCode = status;
                 throw toThrow;
             };
-            Module['inspect'] = () => '[Emscripten Module object]';
+            Module['inspect'] = function () { return '[Emscripten Module object]'; };
         }
         else 
         // Note that this includes Node.js workers when relevant (pthreads is enabled).
@@ -174,11 +191,12 @@ 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.error.bind(console);
+        var err = Module['printErr'] || console.warn.bind(console);
         // Merge back in the overrides
         Object.assign(Module, moduleOverrides);
         // Free the object hierarchy contained in the overrides, this lets the GC
@@ -233,6 +251,202 @@ var Module = (() => {
                 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} */
@@ -255,13 +469,19 @@ var Module = (() => {
             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
         // include: runtime_stack_check.js
         // end include: runtime_stack_check.js
         // include: runtime_assertions.js
@@ -378,7 +598,7 @@ var Module = (() => {
             // 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, wasmExports
+            // In case abort() is called before the module is initialized, Module['asm']
             // and its exported '__trap' function is not available, in which case we throw
             // a RuntimeError.
             //
@@ -425,49 +645,57 @@ 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 getBinarySync(file) {
-            if (file == wasmBinaryFile && wasmBinary) {
-                return new Uint8Array(wasmBinary);
+        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";
             }
-            if (readBinary) {
-                return readBinary(file);
+            catch (err) {
+                abort(err);
             }
-            throw "both async and sync fetching of the wasm failed";
         }
         function getBinaryPromise(binaryFile) {
-            // If we don't have the binary yet, try to load it asynchronously.
+            // If we don't have the binary yet, try to to load it asynchronously.
             // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
             // See https://github.com/github/fetch/pull/92#issuecomment-140665932
             // Cordova or Electron apps are typically loaded from a file:// url.
             // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
-            if (!wasmBinary
-                && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
                 if (typeof fetch == 'function'
                     && !isFileURI(binaryFile)) {
-                    return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
+                    return fetch(binaryFile, { credentials: 'same-origin' }).then(function (response) {
                         if (!response['ok']) {
                             throw "failed to load wasm binary file at '" + binaryFile + "'";
                         }
                         return response['arrayBuffer']();
-                    }).catch(() => getBinarySync(binaryFile));
-                }
-                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);
+                    }).catch(function () {
+                        return getBinary(binaryFile);
                     });
                 }
+                else {
+                    if (readAsync) {
+                        // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
+                        return new Promise(function (resolve, reject) {
+                            readAsync(binaryFile, function (response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */ (response))); }, reject);
+                        });
+                    }
+                }
             }
-            // Otherwise, getBinarySync should be able to get it synchronously
-            return Promise.resolve().then(() => getBinarySync(binaryFile));
+            // Otherwise, getBinary should be able to get it synchronously
+            return Promise.resolve().then(function () { return getBinary(binaryFile); });
         }
         function instantiateArrayBuffer(binaryFile, imports, receiver) {
-            return getBinaryPromise(binaryFile).then((binary) => {
+            return getBinaryPromise(binaryFile).then(function (binary) {
                 return WebAssembly.instantiate(binary, imports);
-            }).then((instance) => {
+            }).then(function (instance) {
                 return instance;
-            }).then(receiver, (reason) => {
-                err(`failed to asynchronously prepare wasm: ${reason}`);
+            }).then(receiver, function (reason) {
+                err('failed to asynchronously prepare wasm: ' + reason);
                 abort(reason);
             });
         }
@@ -485,7 +713,7 @@ var Module = (() => {
                 //   https://github.com/emscripten-core/emscripten/pull/16917
                 !ENVIRONMENT_IS_NODE &&
                 typeof fetch == 'function') {
-                return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {
+                return fetch(binaryFile, { credentials: 'same-origin' }).then(function (response) {
                     // Suppress closure warning here since the upstream definition for
                     // instantiateStreaming only allows Promise<Repsponse> rather than
                     // an actual Response.
@@ -495,13 +723,15 @@ 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);
                     });
                 });
             }
-            return instantiateArrayBuffer(binaryFile, imports, callback);
+            else {
+                return instantiateArrayBuffer(binaryFile, imports, callback);
+            }
         }
         // Create the wasm instance.
         // Receives the wasm imports, returns the exports.
@@ -516,14 +746,14 @@ var Module = (() => {
             // performing other necessary setup
             /** @param {WebAssembly.Module=} module*/
             function receiveInstance(instance, module) {
-                wasmExports = instance.exports;
-                Module['wasmExports'] = wasmExports;
-                wasmMemory = wasmExports['memory'];
+                var exports = instance.exports;
+                Module['asm'] = exports;
+                wasmMemory = Module['asm']['memory'];
                 updateMemoryViews();
-                wasmTable = wasmExports['__indirect_function_table'];
-                addOnInit(wasmExports['__wasm_call_ctors']);
+                wasmTable = Module['asm']['__indirect_function_table'];
+                addOnInit(Module['asm']['__wasm_call_ctors']);
                 removeRunDependency('wasm-instantiate');
-                return wasmExports;
+                return exports;
             }
             // wait for the pthread pool (if any)
             addRunDependency('wasm-instantiate');
@@ -532,21 +762,19 @@ 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 PTHREADS-enabled path.
+                // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
                 receiveInstance(result['instance']);
             }
             // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
-            // to manually instantiate the Wasm module themselves. This allows pages to
-            // run the instantiation parallel to any other async startup actions they are
-            // performing.
-            // Also pthreads and wasm workers initialize the wasm instance through this
-            // path.
+            // 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);
                 }
@@ -583,15 +811,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;
         }
-        var callRuntimeCallbacks = (callbacks) => {
+        function callRuntimeCallbacks(callbacks) {
             while (callbacks.length > 0) {
                 // Pass the module as the first argument.
                 callbacks.shift()(Module);
             }
-        };
+        }
         /**
          * @param {number} ptr
          * @param {string} type
@@ -604,11 +832,11 @@ var Module = (() => {
                 case 'i8': return HEAP8[((ptr) >> 0)];
                 case 'i16': return HEAP16[((ptr) >> 1)];
                 case 'i32': return HEAP32[((ptr) >> 2)];
-                case 'i64': abort('to do getValue(i64) use WASM_BIGINT');
+                case 'i64': return HEAP32[((ptr) >> 2)];
                 case 'float': return HEAPF32[((ptr) >> 2)];
                 case 'double': return HEAPF64[((ptr) >> 3)];
                 case '*': return HEAPU32[((ptr) >> 2)];
-                default: abort(`invalid type for getValue: ${type}`);
+                default: abort('invalid type for getValue: ' + type);
             }
         }
         /**
@@ -632,7 +860,9 @@ var Module = (() => {
                 case 'i32':
                     HEAP32[((ptr) >> 2)] = value;
                     break;
-                case 'i64': abort('to do setValue(i64) use WASM_BIGINT');
+                case 'i64':
+                    (tempI64 = [value >>> 0, (tempDouble = value, (+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble) / 4294967296.0))), 4294967295.0)) | 0) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296.0))))) >>> 0) : 0)], HEAP32[((ptr) >> 2)] = tempI64[0], HEAP32[(((ptr) + (4)) >> 2)] = tempI64[1]);
+                    break;
                 case 'float':
                     HEAPF32[((ptr) >> 2)] = value;
                     break;
@@ -642,106 +872,76 @@ var Module = (() => {
                 case '*':
                     HEAPU32[((ptr) >> 2)] = value;
                     break;
-                default: abort(`invalid type for setValue: ${type}`);
+                default: abort('invalid type for setValue: ' + type);
             }
         }
-        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));
-            }
-            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}
-         */
-        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']);
-        };
+        function ___assert_fail(condition, filename, line, func) {
+            abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
+        }
         var structRegistrations = {};
-        var runDestructors = (destructors) => {
+        function runDestructors(destructors) {
             while (destructors.length) {
                 var ptr = destructors.pop();
                 var del = destructors.pop();
                 del(ptr);
             }
-        };
-        /** @suppress {globalThis} */
+        }
         function simpleReadValueFromPointer(pointer) {
             return this['fromWireType'](HEAP32[((pointer) >> 2)]);
         }
         var awaitingDependencies = {};
         var registeredTypes = {};
         var typeDependencies = {};
-        var InternalError;
-        var throwInternalError = (message) => { throw new InternalError(message); };
-        var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
+        var char_0 = 48;
+        var char_9 = 57;
+        function makeLegalFunctionName(name) {
+            if (undefined === name) {
+                return '_unknown';
+            }
+            name = name.replace(/[^a-zA-Z0-9_]/g, '$');
+            var f = name.charCodeAt(0);
+            if (f >= char_0 && f <= char_9) {
+                return '_' + name;
+            }
+            return name;
+        }
+        function createNamedFunction(name, body) {
+            name = makeLegalFunctionName(name);
+            // Use an abject with a computed property name to create a new function with
+            // a name specified at runtime, but without using `new Function` or `eval`.
+            return {
+                [name]: function () {
+                    return body.apply(this, arguments);
+                }
+            }[name];
+        }
+        function extendError(baseErrorType, errorName) {
+            var errorClass = createNamedFunction(errorName, function (message) {
+                this.name = errorName;
+                this.message = message;
+                var stack = (new Error(message)).stack;
+                if (stack !== undefined) {
+                    this.stack = this.toString() + '\n' +
+                        stack.replace(/^Error(:[^\n]*)?\n/, '');
+                }
+            });
+            errorClass.prototype = Object.create(baseErrorType.prototype);
+            errorClass.prototype.constructor = errorClass;
+            errorClass.prototype.toString = function () {
+                if (this.message === undefined) {
+                    return this.name;
+                }
+                else {
+                    return this.name + ': ' + this.message;
+                }
+            };
+            return errorClass;
+        }
+        var InternalError = undefined;
+        function throwInternalError(message) {
+            throw new InternalError(message);
+        }
+        function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
             myTypes.forEach(function (type) {
                 typeDependencies[type] = dependentTypes;
             });
@@ -778,8 +978,8 @@ var Module = (() => {
             if (0 === unregisteredTypes.length) {
                 onComplete(typeConverters);
             }
-        };
-        var __embind_finalize_value_object = (structType) => {
+        }
+        function __embind_finalize_value_object(structType) {
             var reg = structRegistrations[structType];
             delete structRegistrations[structType];
             var rawConstructor = reg.rawConstructor;
@@ -810,7 +1010,7 @@ var Module = (() => {
                 });
                 return [{
                         name: reg.name,
-                        'fromWireType': (ptr) => {
+                        'fromWireType': function (ptr) {
                             var rv = {};
                             for (var i in fields) {
                                 rv[i] = fields[i].read(ptr);
@@ -818,12 +1018,12 @@ var Module = (() => {
                             rawDestructor(ptr);
                             return rv;
                         },
-                        'toWireType': (destructors, o) => {
+                        'toWireType': function (destructors, o) {
                             // todo: Here we have an opportunity for -O3 level "unsafe" optimizations:
                             // assume all fields are present without checking.
                             for (var fieldName in fields) {
                                 if (!(fieldName in o)) {
-                                    throw new TypeError(`Missing field: "${fieldName}"`);
+                                    throw new TypeError('Missing field:  "' + fieldName + '"');
                                 }
                             }
                             var ptr = rawConstructor();
@@ -835,43 +1035,58 @@ var Module = (() => {
                             }
                             return ptr;
                         },
-                        'argPackAdvance': GenericWireTypeSize,
+                        'argPackAdvance': 8,
                         'readValueFromPointer': simpleReadValueFromPointer,
                         destructorFunction: rawDestructor,
                     }];
             });
-        };
-        var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { };
-        var embind_init_charCodes = () => {
+        }
+        function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) { }
+        function getShiftFromSize(size) {
+            switch (size) {
+                case 1: return 0;
+                case 2: return 1;
+                case 4: return 2;
+                case 8: return 3;
+                default:
+                    throw new TypeError('Unknown type size: ' + size);
+            }
+        }
+        function embind_init_charCodes() {
             var codes = new Array(256);
             for (var i = 0; i < 256; ++i) {
                 codes[i] = String.fromCharCode(i);
             }
             embind_charCodes = codes;
-        };
-        var embind_charCodes;
-        var readLatin1String = (ptr) => {
+        }
+        var embind_charCodes = undefined;
+        function readLatin1String(ptr) {
             var ret = "";
             var c = ptr;
             while (HEAPU8[c]) {
                 ret += embind_charCodes[HEAPU8[c++]];
             }
             return ret;
-        };
-        var BindingError;
-        var throwBindingError = (message) => { throw new BindingError(message); };
+        }
+        var BindingError = undefined;
+        function throwBindingError(message) {
+            throw new BindingError(message);
+        }
         /** @param {Object=} options */
-        function sharedRegisterType(rawType, registeredInstance, options = {}) {
+        function registerType(rawType, registeredInstance, options = {}) {
+            if (!('argPackAdvance' in registeredInstance)) {
+                throw new TypeError('registerType registeredInstance requires argPackAdvance');
+            }
             var name = registeredInstance.name;
             if (!rawType) {
-                throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
+                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;
@@ -882,19 +1097,11 @@ var Module = (() => {
                 callbacks.forEach((cb) => cb());
             }
         }
-        /** @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) => {
+        function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
+            var shift = getShiftFromSize(size);
             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)
@@ -903,14 +1110,49 @@ var Module = (() => {
                 'toWireType': function (destructors, o) {
                     return o ? trueValue : falseValue;
                 },
-                'argPackAdvance': GenericWireTypeSize,
+                'argPackAdvance': 8,
                 'readValueFromPointer': function (pointer) {
-                    return this['fromWireType'](HEAPU8[pointer]);
+                    // TODO: if heap is fixed (like in asm.js) this could be executed outside
+                    var heap;
+                    if (size === 1) {
+                        heap = HEAP8;
+                    }
+                    else if (size === 2) {
+                        heap = HEAP16;
+                    }
+                    else if (size === 4) {
+                        heap = HEAP32;
+                    }
+                    else {
+                        throw new TypeError("Unknown boolean type size: " + name);
+                    }
+                    return this['fromWireType'](heap[pointer >> shift]);
                 },
                 destructorFunction: null, // This type does not need a destructor
             });
-        };
-        var shallowCopyInternalPointer = (o) => {
+        }
+        function ClassHandle_isAliasOf(other) {
+            if (!(this instanceof ClassHandle)) {
+                return false;
+            }
+            if (!(other instanceof ClassHandle)) {
+                return false;
+            }
+            var leftClass = this.$$.ptrType.registeredClass;
+            var left = this.$$.ptr;
+            var rightClass = other.$$.ptrType.registeredClass;
+            var right = other.$$.ptr;
+            while (leftClass.baseClass) {
+                left = leftClass.upcast(left);
+                leftClass = leftClass.baseClass;
+            }
+            while (rightClass.baseClass) {
+                right = rightClass.upcast(right);
+                rightClass = rightClass.baseClass;
+            }
+            return leftClass === rightClass && left === right;
+        }
+        function shallowCopyInternalPointer(o) {
             return {
                 count: o.count,
                 deleteScheduled: o.deleteScheduled,
@@ -920,31 +1162,31 @@ var Module = (() => {
                 smartPtr: o.smartPtr,
                 smartPtrType: o.smartPtrType,
             };
-        };
-        var throwInstanceAlreadyDeleted = (obj) => {
+        }
+        function throwInstanceAlreadyDeleted(obj) {
             function getInstanceTypeName(handle) {
                 return handle.$$.ptrType.registeredClass.name;
             }
             throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
-        };
+        }
         var finalizationRegistry = false;
-        var detachFinalizer = (handle) => { };
-        var runDestructor = ($$) => {
+        function detachFinalizer(handle) { }
+        function runDestructor($$) {
             if ($$.smartPtr) {
                 $$.smartPtrType.rawDestructor($$.smartPtr);
             }
             else {
                 $$.ptrType.registeredClass.rawDestructor($$.ptr);
             }
-        };
-        var releaseClassHandle = ($$) => {
+        }
+        function releaseClassHandle($$) {
             $$.count.value -= 1;
             var toDelete = 0 === $$.count.value;
             if (toDelete) {
                 runDestructor($$);
             }
-        };
-        var downcastPointer = (ptr, ptrClass, desiredClass) => {
+        }
+        function downcastPointer(ptr, ptrClass, desiredClass) {
             if (ptrClass === desiredClass) {
                 return ptr;
             }
@@ -956,12 +1198,12 @@ var Module = (() => {
                 return null;
             }
             return desiredClass.downcast(rv);
-        };
+        }
         var registeredPointers = {};
-        var getInheritedInstanceCount = () => {
+        function getInheritedInstanceCount() {
             return Object.keys(registeredInstances).length;
-        };
-        var getLiveInheritedInstances = () => {
+        }
+        function getLiveInheritedInstances() {
             var rv = [];
             for (var k in registeredInstances) {
                 if (registeredInstances.hasOwnProperty(k)) {
@@ -969,30 +1211,30 @@ var Module = (() => {
                 }
             }
             return rv;
-        };
+        }
         var deletionQueue = [];
-        var flushPendingDeletes = () => {
+        function flushPendingDeletes() {
             while (deletionQueue.length) {
                 var obj = deletionQueue.pop();
                 obj.$$.deleteScheduled = false;
                 obj['delete']();
             }
-        };
-        var delayFunction;
-        var setDelayFunction = (fn) => {
+        }
+        var delayFunction = undefined;
+        function setDelayFunction(fn) {
             delayFunction = fn;
             if (deletionQueue.length && delayFunction) {
                 delayFunction(flushPendingDeletes);
             }
-        };
-        var init_embind = () => {
+        }
+        function init_embind() {
             Module['getInheritedInstanceCount'] = getInheritedInstanceCount;
             Module['getLiveInheritedInstances'] = getLiveInheritedInstances;
             Module['flushPendingDeletes'] = flushPendingDeletes;
             Module['setDelayFunction'] = setDelayFunction;
-        };
+        }
         var registeredInstances = {};
-        var getBasestPointer = (class_, ptr) => {
+        function getBasestPointer(class_, ptr) {
             if (ptr === undefined) {
                 throwBindingError('ptr should not be undefined');
             }
@@ -1001,12 +1243,12 @@ var Module = (() => {
                 class_ = class_.baseClass;
             }
             return ptr;
-        };
-        var getInheritedInstance = (class_, ptr) => {
+        }
+        function getInheritedInstance(class_, ptr) {
             ptr = getBasestPointer(class_, ptr);
             return registeredInstances[ptr];
-        };
-        var makeClassHandle = (prototype, record) => {
+        }
+        function makeClassHandle(prototype, record) {
             if (!record.ptrType || !record.ptr) {
                 throwInternalError('makeClassHandle requires ptr and ptrType');
             }
@@ -1021,8 +1263,7 @@ var Module = (() => {
                     value: record,
                 },
             }));
-        };
-        /** @suppress {globalThis} */
+        }
         function RegisteredPointer_fromWireType(ptr) {
             // ptr is a raw pointer (or a raw smartpointer)
             // rawPointer is a maybe-null raw pointer
@@ -1059,7 +1300,7 @@ var Module = (() => {
                 else {
                     return makeClassHandle(this.registeredClass.instancePrototype, {
                         ptrType: this,
-                        ptr,
+                        ptr: ptr,
                     });
                 }
             }
@@ -1094,7 +1335,7 @@ var Module = (() => {
                 });
             }
         }
-        var attachFinalizer = (handle) => {
+        function attachFinalizer(handle) {
             if ('undefined' === typeof FinalizationRegistry) {
                 attachFinalizer = (handle) => handle;
                 return handle;
@@ -1118,117 +1359,74 @@ var Module = (() => {
             };
             detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
             return attachFinalizer(handle);
-        };
-        var init_ClassHandle = () => {
-            Object.assign(ClassHandle.prototype, {
-                "isAliasOf"(other) {
-                    if (!(this instanceof ClassHandle)) {
-                        return false;
-                    }
-                    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);
+        }
+        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.$$),
                     }
-                    this.$$.deleteScheduled = true;
-                    return this;
-                },
-            });
-        };
-        /** @constructor */
-        function ClassHandle() {
+                }));
+                clone.$$.count.value += 1;
+                clone.$$.deleteScheduled = false;
+                return clone;
+            }
         }
-        var char_0 = 48;
-        var char_9 = 57;
-        var makeLegalFunctionName = (name) => {
-            if (undefined === name) {
-                return '_unknown';
+        function ClassHandle_delete() {
+            if (!this.$$.ptr) {
+                throwInstanceAlreadyDeleted(this);
             }
-            name = name.replace(/[^a-zA-Z0-9_]/g, '$');
-            var f = name.charCodeAt(0);
-            if (f >= char_0 && f <= char_9) {
-                return `_${name}`;
+            if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+                throwBindingError('Object already scheduled for deletion');
             }
-            return name;
-        };
-        function createNamedFunction(name, body) {
-            name = makeLegalFunctionName(name);
-            // Use an abject with a computed property name to create a new function with
-            // a name specified at runtime, but without using `new Function` or `eval`.
-            return {
-                [name]: function () {
-                    return body.apply(this, arguments);
-                }
-            }[name];
+            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;
         }
-        var ensureOverloadTable = (proto, methodName, humanName) => {
+        function ClassHandle() {
+        }
+        function ensureOverloadTable(proto, methodName, humanName) {
             if (undefined === proto[methodName].overloadTable) {
                 var prevFunc = proto[methodName];
                 // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.
                 proto[methodName] = function () {
                     // TODO This check can be removed in -O3 level "unsafe" optimizations.
                     if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
-                        throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`);
+                        throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
                     }
                     return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
                 };
@@ -1236,18 +1434,18 @@ var Module = (() => {
                 proto[methodName].overloadTable = [];
                 proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
             }
-        };
+        }
         /** @param {number=} numArguments */
-        var exposePublicSymbol = (name, value, numArguments) => {
+        function exposePublicSymbol(name, value, numArguments) {
             if (Module.hasOwnProperty(name)) {
                 if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) {
-                    throwBindingError(`Cannot register public name '${name}' twice`);
+                    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;
@@ -1258,7 +1456,7 @@ var Module = (() => {
                     Module[name].numArguments = numArguments;
                 }
             }
-        };
+        }
         /** @constructor */
         function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
             this.name = name;
@@ -1271,40 +1469,38 @@ var Module = (() => {
             this.downcast = downcast;
             this.pureVirtualFunctions = [];
         }
-        var upcastPointer = (ptr, ptrClass, desiredClass) => {
+        function upcastPointer(ptr, ptrClass, desiredClass) {
             while (ptrClass !== desiredClass) {
                 if (!ptrClass.upcast) {
-                    throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`);
+                    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();
@@ -1318,13 +1514,13 @@ var Module = (() => {
                 }
             }
             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 (!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);
@@ -1342,7 +1538,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
@@ -1354,7 +1550,9 @@ var Module = (() => {
                         }
                         else {
                             var clonedHandle = handle['clone']();
-                            ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle['delete']()));
+                            ptr = this.rawShare(ptr, Emval.toHandle(function () {
+                                clonedHandle['delete']();
+                            }));
                             if (destructors !== null) {
                                 destructors.push(this.rawDestructor, ptr);
                             }
@@ -1366,54 +1564,50 @@ 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;
         }
-        /** @suppress {globalThis} */
-        function readPointer(pointer) {
-            return this['fromWireType'](HEAPU32[((pointer) >> 2)]);
+        function RegisteredPointer_getPointee(ptr) {
+            if (this.rawGetPointee) {
+                ptr = this.rawGetPointee(ptr);
+            }
+            return ptr;
+        }
+        function RegisteredPointer_destructor(ptr) {
+            if (this.rawDestructor) {
+                this.rawDestructor(ptr);
+            }
+        }
+        function RegisteredPointer_deleteObject(handle) {
+            if (handle !== null) {
+                handle['delete']();
+            }
+        }
+        function init_RegisteredPointer() {
+            RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
+            RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
+            RegisteredPointer.prototype['argPackAdvance'] = 8;
+            RegisteredPointer.prototype['readValueFromPointer'] = simpleReadValueFromPointer;
+            RegisteredPointer.prototype['deleteObject'] = RegisteredPointer_deleteObject;
+            RegisteredPointer.prototype['fromWireType'] = RegisteredPointer_fromWireType;
         }
-        var init_RegisteredPointer = () => {
-            Object.assign(RegisteredPointer.prototype, {
-                getPointee(ptr) {
-                    if (this.rawGetPointee) {
-                        ptr = this.rawGetPointee(ptr);
-                    }
-                    return ptr;
-                },
-                destructor(ptr) {
-                    if (this.rawDestructor) {
-                        this.rawDestructor(ptr);
-                    }
-                },
-                'argPackAdvance': GenericWireTypeSize,
-                'readValueFromPointer': readPointer,
-                'deleteObject'(handle) {
-                    if (handle !== null) {
-                        handle['delete']();
-                    }
-                },
-                'fromWireType': RegisteredPointer_fromWireType,
-            });
-        };
         /** @constructor
             @param {*=} pointeeType,
             @param {*=} sharingPolicy,
@@ -1456,7 +1650,7 @@ var Module = (() => {
             }
         }
         /** @param {number=} numArguments */
-        var replacePublicSymbol = (name, value, numArguments) => {
+        function replacePublicSymbol(name, value, numArguments) {
             if (!Module.hasOwnProperty(name)) {
                 throwInternalError('Replacing nonexistant public symbol');
             }
@@ -1468,14 +1662,13 @@ var Module = (() => {
                 Module[name] = value;
                 Module[name].argCount = numArguments;
             }
-        };
-        var dynCallLegacy = (sig, ptr, args) => {
+        }
+        function dynCallLegacy(sig, ptr, args) {
             var f = Module['dynCall_' + sig];
             return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
-        };
+        }
         var wasmTableMirror = [];
-        var wasmTable;
-        var getWasmTableEntry = (funcPtr) => {
+        function getWasmTableEntry(funcPtr) {
             var func = wasmTableMirror[funcPtr];
             if (!func) {
                 if (funcPtr >= wasmTableMirror.length)
@@ -1483,9 +1676,9 @@ var Module = (() => {
                 wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
             }
             return func;
-        };
+        }
         /** @param {Object=} args */
-        var dynCall = (sig, ptr, args) => {
+        function dynCall(sig, ptr, args) {
             // Without WASM_BIGINT support we cannot directly call function with i64 as
             // part of thier signature, so we rely the dynCall functions generated by
             // wasm-emscripten-finalize
@@ -1494,59 +1687,37 @@ var Module = (() => {
             }
             var rtn = getWasmTableEntry(ptr).apply(null, args);
             return rtn;
-        };
-        var getDynCaller = (sig, ptr) => {
+        }
+        function getDynCaller(sig, ptr) {
             var argCache = [];
             return function () {
                 argCache.length = 0;
                 Object.assign(argCache, arguments);
                 return dynCall(sig, ptr, argCache);
             };
-        };
-        var embind__requireFunction = (signature, rawFunction) => {
+        }
+        function embind__requireFunction(signature, rawFunction) {
             signature = readLatin1String(signature);
-            function makeDynCaller() {
-                if (signature.includes('j')) {
-                    return getDynCaller(signature, rawFunction);
-                }
-                return getWasmTableEntry(rawFunction);
-            }
-            var fp = makeDynCaller();
-            if (typeof fp != "function") {
-                throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
-            }
-            return fp;
-        };
-        var extendError = (baseErrorType, errorName) => {
-            var errorClass = createNamedFunction(errorName, function (message) {
-                this.name = errorName;
-                this.message = message;
-                var stack = (new Error(message)).stack;
-                if (stack !== undefined) {
-                    this.stack = this.toString() + '\n' +
-                        stack.replace(/^Error(:[^\n]*)?\n/, '');
-                }
-            });
-            errorClass.prototype = Object.create(baseErrorType.prototype);
-            errorClass.prototype.constructor = errorClass;
-            errorClass.prototype.toString = function () {
-                if (this.message === undefined) {
-                    return this.name;
-                }
-                else {
-                    return `${this.name}: ${this.message}`;
+            function makeDynCaller() {
+                if (signature.includes('j')) {
+                    return getDynCaller(signature, rawFunction);
                 }
-            };
-            return errorClass;
-        };
-        var UnboundTypeError;
-        var getTypeName = (type) => {
+                return getWasmTableEntry(rawFunction);
+            }
+            var fp = makeDynCaller();
+            if (typeof fp != "function") {
+                throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
+            }
+            return fp;
+        }
+        var UnboundTypeError = undefined;
+        function getTypeName(type) {
             var ptr = ___getTypeName(type);
             var rv = readLatin1String(ptr);
             _free(ptr);
             return rv;
-        };
-        var throwUnboundTypeError = (message, types) => {
+        }
+        function throwUnboundTypeError(message, types) {
             var unboundTypes = [];
             var seen = {};
             function visit(type) {
@@ -1564,9 +1735,9 @@ var Module = (() => {
                 seen[type] = true;
             }
             types.forEach(visit);
-            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) => {
+            throw new UnboundTypeError(message + ': ' + unboundTypes.map(getTypeName).join([', ']));
+        }
+        function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
             name = readLatin1String(name);
             getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
             if (upcast) {
@@ -1579,7 +1750,7 @@ var Module = (() => {
             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) {
                 base = base[0];
@@ -1601,7 +1772,7 @@ var Module = (() => {
                     }
                     var body = registeredClass.constructor_body[arguments.length];
                     if (undefined === body) {
-                        throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
+                        throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!");
                     }
                     return body.apply(this, arguments);
                 });
@@ -1610,13 +1781,6 @@ var Module = (() => {
                 });
                 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.
-                    if (registeredClass.baseClass.__derivedClasses === undefined) {
-                        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);
@@ -1627,8 +1791,8 @@ var Module = (() => {
                 replacePublicSymbol(legalFunctionName, constructor);
                 return [referenceConverter, pointerConverter, constPointerConverter];
             });
-        };
-        var heap32VectorToArray = (count, firstElement) => {
+        }
+        function heap32VectorToArray(count, firstElement) {
             var array = [];
             for (var i = 0; i < count; i++) {
                 // TODO(https://github.com/emscripten-core/emscripten/issues/17310):
@@ -1636,10 +1800,10 @@ var Module = (() => {
                 array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]);
             }
             return array;
-        };
-        function newFunc(constructor, argumentList) {
+        }
+        function new_(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:
@@ -1657,7 +1821,7 @@ var Module = (() => {
             var r = constructor.apply(obj, argumentList);
             return (r instanceof Object) ? r : obj;
         }
-        function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) {
+        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.
@@ -1666,7 +1830,6 @@ var Module = (() => {
             // 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!");
@@ -1693,11 +1856,10 @@ var Module = (() => {
                 argsList += (i !== 0 ? ", " : "") + "arg" + i;
                 argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
             }
-            var invokerFnBody = `
-        return function ${makeLegalFunctionName(humanName)}(${argsList}) {
-        if (arguments.length !== ${argCount - 2}) {
-          throwBindingError('function ${humanName} called with ' + arguments.length + ' arguments, expected ${argCount - 2}');
-        }`;
+            var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" +
+                "if (arguments.length !== " + (argCount - 2) + ") {\n" +
+                "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" +
+                "}\n";
             if (needsDestructorStack) {
                 invokerFnBody += "var destructors = [];\n";
             }
@@ -1738,26 +1900,28 @@ var Module = (() => {
             }
             invokerFnBody += "}\n";
             args1.push(invokerFnBody);
-            return newFunc(Function, args1).apply(null, args2);
+            var invokerFunction = new_(Function, args1).apply(null, args2);
+            return invokerFunction;
         }
-        var __embind_register_class_constructor = (rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) => {
+        function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
+            assert(argCount > 0);
             var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
             invoker = embind__requireFunction(invokerSignature, invoker);
             var args = [rawConstructor];
             var destructors = [];
             whenDependentTypesAreResolved([], [rawClassType], function (classType) {
                 classType = classType[0];
-                var humanName = `constructor ${classType.name}`;
+                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, (argTypes) => {
+                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
                     // Insert empty slot for context type (argTypes[1]).
                     argTypes.splice(1, 0, null);
                     classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
@@ -1765,44 +1929,48 @@ var Module = (() => {
                 });
                 return [];
             });
-        };
-        var validateThis = (this_, classType, humanName) => {
+        }
+        function 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);
-        };
-        var __embind_register_class_property = (classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => {
+        }
+        function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
             fieldName = readLatin1String(fieldName);
             getter = embind__requireFunction(getterSignature, getter);
             whenDependentTypesAreResolved([], [classType], function (classType) {
                 classType = classType[0];
-                var humanName = `${classType.name}.${fieldName}`;
+                var humanName = classType.name + '.' + fieldName;
                 var desc = {
-                    get() {
-                        throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]);
+                    get: function () {
+                        throwUnboundTypeError('Cannot access ' + humanName + ' due to unbound types', [getterReturnType, setterArgumentType]);
                     },
                     enumerable: true,
                     configurable: true
                 };
                 if (setter) {
-                    desc.set = () => throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [getterReturnType, setterArgumentType]);
+                    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) {
                     var getterReturnType = types[0];
                     var desc = {
-                        get() {
+                        get: function () {
                             var ptr = validateThis(this, classType, humanName + ' getter');
                             return getterReturnType['fromWireType'](getter(getterContext, ptr));
                         },
@@ -1823,94 +1991,76 @@ var Module = (() => {
                 });
                 return [];
             });
-        };
-        function handleAllocatorInit() {
-            Object.assign(HandleAllocator.prototype, /** @lends {HandleAllocator.prototype} */ {
-                get(id) {
-                    return this.allocated[id];
-                },
-                has(id) {
-                    return this.allocated[id] !== undefined;
-                },
-                allocate(handle) {
-                    var id = this.freelist.pop() || this.allocated.length;
-                    this.allocated[id] = handle;
-                    return id;
-                },
-                free(id) {
-                    // Set the slot to `undefined` rather than using `delete` here since
-                    // apparently arrays with holes in them can be less efficient.
-                    this.allocated[id] = undefined;
-                    this.freelist.push(id);
-                }
-            });
-        }
-        /** @constructor */
-        function HandleAllocator() {
-            // Reserve slot 0 so that 0 is always an invalid handle
-            this.allocated = [undefined];
-            this.freelist = [];
         }
-        var emval_handles = new HandleAllocator();
-        ;
-        var __emval_decref = (handle) => {
-            if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) {
-                emval_handles.free(handle);
+        var emval_free_list = [];
+        var emval_handle_array = [{}, { value: undefined }, { value: null }, { value: true }, { value: false }];
+        function __emval_decref(handle) {
+            if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
+                emval_handle_array[handle] = undefined;
+                emval_free_list.push(handle);
             }
-        };
-        var count_emval_handles = () => {
+        }
+        function count_emval_handles() {
             var count = 0;
-            for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) {
-                if (emval_handles.allocated[i] !== undefined) {
+            for (var i = 5; i < emval_handle_array.length; ++i) {
+                if (emval_handle_array[i] !== undefined) {
                     ++count;
                 }
             }
             return count;
-        };
-        var init_emval = () => {
-            // reserve some special values. These never get de-allocated.
-            // The HandleAllocator takes care of reserving zero.
-            emval_handles.allocated.push({ value: undefined }, { value: null }, { value: true }, { value: false });
-            emval_handles.reserved = emval_handles.allocated.length;
+        }
+        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;
-        };
-        var Emval = {
-            toValue: (handle) => {
+            Module['get_first_emval'] = get_first_emval;
+        }
+        var Emval = { toValue: (handle) => {
                 if (!handle) {
                     throwBindingError('Cannot use deleted val. handle = ' + handle);
                 }
-                return emval_handles.get(handle).value;
-            },
-            toHandle: (value) => {
+                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: {
-                        return emval_handles.allocate({ refcount: 1, value: value });
+                        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 __embind_register_emval = (rawType, name) => {
+            } };
+        function __embind_register_emval(rawType, name) {
             name = readLatin1String(name);
             registerType(rawType, {
-                name,
-                'fromWireType': (handle) => {
+                name: name,
+                'fromWireType': function (handle) {
                     var rv = Emval.toValue(handle);
                     __emval_decref(handle);
                     return rv;
                 },
-                'toWireType': (destructors, value) => Emval.toHandle(value),
-                'argPackAdvance': GenericWireTypeSize,
+                '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
             });
-        };
-        var embindRepr = (v) => {
+        }
+        function embindRepr(v) {
             if (v === null) {
                 return 'null';
             }
@@ -1921,71 +2071,74 @@ var Module = (() => {
             else {
                 return '' + v;
             }
-        };
-        var floatReadValueFromPointer = (name, width) => {
-            switch (width) {
-                case 4: return function (pointer) {
-                    return this['fromWireType'](HEAPF32[((pointer) >> 2)]);
+        }
+        function floatReadValueFromPointer(name, shift) {
+            switch (shift) {
+                case 2: return function (pointer) {
+                    return this['fromWireType'](HEAPF32[pointer >> 2]);
                 };
-                case 8: return function (pointer) {
-                    return this['fromWireType'](HEAPF64[((pointer) >> 3)]);
+                case 3: return function (pointer) {
+                    return this['fromWireType'](HEAPF64[pointer >> 3]);
                 };
                 default:
-                    throw new TypeError(`invalid float width (${width}): ${name}`);
+                    throw new TypeError("Unknown float type: " + name);
             }
-        };
-        var __embind_register_float = (rawType, name, size) => {
+        }
+        function __embind_register_float(rawType, name, size) {
+            var shift = getShiftFromSize(size);
             name = readLatin1String(name);
             registerType(rawType, {
-                name,
-                'fromWireType': (value) => value,
-                'toWireType': (destructors, value) => {
+                name: name,
+                'fromWireType': function (value) {
+                    return value;
+                },
+                'toWireType': function (destructors, value) {
                     // The VM will perform JS to Wasm value conversion, according to the spec:
                     // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
                     return value;
                 },
-                'argPackAdvance': GenericWireTypeSize,
-                'readValueFromPointer': floatReadValueFromPointer(name, size),
+                'argPackAdvance': 8,
+                'readValueFromPointer': floatReadValueFromPointer(name, shift),
                 destructorFunction: null, // This type does not need a destructor
             });
-        };
-        var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => {
+        }
+        function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) {
             var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
             name = readLatin1String(name);
             rawInvoker = embind__requireFunction(signature, rawInvoker);
             exposePublicSymbol(name, function () {
-                throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
+                throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes);
             }, argCount - 1);
             whenDependentTypesAreResolved([], argTypes, function (argTypes) {
                 var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);
                 replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1);
                 return [];
             });
-        };
-        var integerReadValueFromPointer = (name, width, signed) => {
+        }
+        function integerReadValueFromPointer(name, shift, signed) {
             // integers are quite common, so generate very specialized functions
-            switch (width) {
+            switch (shift) {
+                case 0: return signed ?
+                    function readS8FromPointer(pointer) { return HEAP8[pointer]; } :
+                    function readU8FromPointer(pointer) { return HEAPU8[pointer]; };
                 case 1: return signed ?
-                    (pointer) => HEAP8[((pointer) >> 0)] :
-                    (pointer) => HEAPU8[((pointer) >> 0)];
+                    function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } :
+                    function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; };
                 case 2: return signed ?
-                    (pointer) => HEAP16[((pointer) >> 1)] :
-                    (pointer) => HEAPU16[((pointer) >> 1)];
-                case 4: return signed ?
-                    (pointer) => HEAP32[((pointer) >> 2)] :
-                    (pointer) => HEAPU32[((pointer) >> 2)];
+                    function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } :
+                    function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; };
                 default:
-                    throw new TypeError(`invalid integer width (${width}): ${name}`);
+                    throw new TypeError("Unknown integer type: " + name);
             }
-        };
-        /** @suppress {globalThis} */
-        var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
+        }
+        function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
             name = readLatin1String(name);
             // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come
             // out as 'i32 -1'. Always treat those as max u32.
             if (maxRange === -1) {
                 maxRange = 4294967295;
             }
+            var shift = getShiftFromSize(size);
             var fromWireType = (value) => value;
             if (minRange === 0) {
                 var bitshift = 32 - 8 * size;
@@ -2010,15 +2163,15 @@ var Module = (() => {
                 };
             }
             registerType(primitiveType, {
-                name,
+                name: name,
                 'fromWireType': fromWireType,
                 'toWireType': toWireType,
-                'argPackAdvance': GenericWireTypeSize,
-                'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0),
+                'argPackAdvance': 8,
+                'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0),
                 destructorFunction: null, // This type does not need a destructor
             });
-        };
-        var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
+        }
+        function __embind_register_memory_view(rawType, dataTypeIndex, name) {
             var typeMapping = [
                 Int8Array,
                 Uint8Array,
@@ -2031,108 +2184,30 @@ var Module = (() => {
             ];
             var TA = typeMapping[dataTypeIndex];
             function decodeMemoryView(handle) {
-                var size = HEAPU32[((handle) >> 2)];
-                var data = HEAPU32[(((handle) + (4)) >> 2)];
-                return new TA(HEAP8.buffer, data, size);
+                handle = handle >> 2;
+                var heap = HEAPU32;
+                var size = heap[handle]; // in elements
+                var data = heap[handle + 1]; // byte offset into emscripten heap
+                return new TA(heap.buffer, data, size);
             }
             name = readLatin1String(name);
             registerType(rawType, {
-                name,
+                name: name,
                 'fromWireType': decodeMemoryView,
-                'argPackAdvance': GenericWireTypeSize,
+                'argPackAdvance': 8,
                 'readValueFromPointer': decodeMemoryView,
             }, {
                 ignoreDuplicateRegistrations: true,
             });
-        };
-        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) => {
+        }
+        function __embind_register_std_string(rawType, name) {
             name = readLatin1String(name);
             var stdStringIsUTF8 
             //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string<unsigned char>
             = (name === "std::string");
             registerType(rawType, {
-                name,
-                // 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) {
+                name: name,
+                'fromWireType': function (value) {
                     var length = HEAPU32[((value) >> 2)];
                     var payload = value + 4;
                     var str;
@@ -2165,7 +2240,7 @@ var Module = (() => {
                     _free(value);
                     return str;
                 },
-                'toWireType'(destructors, value) {
+                'toWireType': function (destructors, value) {
                     if (value instanceof ArrayBuffer) {
                         value = new Uint8Array(value);
                     }
@@ -2209,16 +2284,14 @@ var Module = (() => {
                     }
                     return base;
                 },
-                'argPackAdvance': GenericWireTypeSize,
-                'readValueFromPointer': readPointer,
-                destructorFunction(ptr) {
-                    _free(ptr);
-                },
+                'argPackAdvance': 8,
+                'readValueFromPointer': simpleReadValueFromPointer,
+                destructorFunction: function (ptr) { _free(ptr); },
             });
-        };
+        }
         var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;
         ;
-        var UTF16ToString = (ptr, maxBytesToRead) => {
+        function UTF16ToString(ptr, maxBytesToRead) {
             var endPtr = ptr;
             // TextDecoder needs to know the byte length in advance, it doesn't stop on
             // null terminator by itself.
@@ -2247,8 +2320,8 @@ var Module = (() => {
                 str += String.fromCharCode(codeUnit);
             }
             return str;
-        };
-        var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+        }
+        function stringToUTF16(str, outPtr, maxBytesToWrite) {
             // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
             if (maxBytesToWrite === undefined) {
                 maxBytesToWrite = 0x7FFFFFFF;
@@ -2267,11 +2340,11 @@ var Module = (() => {
             // Null-terminate the pointer to the HEAP.
             HEAP16[((outPtr) >> 1)] = 0;
             return outPtr - startPtr;
-        };
-        var lengthBytesUTF16 = (str) => {
+        }
+        function lengthBytesUTF16(str) {
             return str.length * 2;
-        };
-        var UTF32ToString = (ptr, maxBytesToRead) => {
+        }
+        function UTF32ToString(ptr, maxBytesToRead) {
             var i = 0;
             var str = '';
             // If maxBytesToRead is not passed explicitly, it will be undefined, and this
@@ -2292,8 +2365,8 @@ var Module = (() => {
                 }
             }
             return str;
-        };
-        var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
+        }
+        function stringToUTF32(str, outPtr, maxBytesToWrite) {
             // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
             if (maxBytesToWrite === undefined) {
                 maxBytesToWrite = 0x7FFFFFFF;
@@ -2318,8 +2391,8 @@ var Module = (() => {
             // Null-terminate the pointer to the HEAP.
             HEAP32[((outPtr) >> 2)] = 0;
             return outPtr - startPtr;
-        };
-        var lengthBytesUTF32 = (str) => {
+        }
+        function lengthBytesUTF32(str) {
             var len = 0;
             for (var i = 0; i < str.length; ++i) {
                 // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
@@ -2330,8 +2403,8 @@ var Module = (() => {
                 len += 4;
             }
             return len;
-        };
-        var __embind_register_std_wstring = (rawType, charSize, name) => {
+        }
+        function __embind_register_std_wstring(rawType, charSize, name) {
             name = readLatin1String(name);
             var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
             if (charSize === 2) {
@@ -2349,10 +2422,10 @@ var Module = (() => {
                 shift = 2;
             }
             registerType(rawType, {
-                name,
-                'fromWireType': (value) => {
+                name: name,
+                'fromWireType': function (value) {
                     // Code mostly taken from _embind_register_std_string fromWireType
-                    var length = HEAPU32[((value) >> 2)];
+                    var length = HEAPU32[value >> 2];
                     var HEAP = getHeap();
                     var str;
                     var decodeStartPtr = value + 4;
@@ -2375,9 +2448,9 @@ var Module = (() => {
                     _free(value);
                     return str;
                 },
-                'toWireType': (destructors, value) => {
+                'toWireType': function (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
                     var length = lengthBytesUTF(value);
@@ -2389,92 +2462,94 @@ var Module = (() => {
                     }
                     return ptr;
                 },
-                'argPackAdvance': GenericWireTypeSize,
+                'argPackAdvance': 8,
                 'readValueFromPointer': simpleReadValueFromPointer,
-                destructorFunction(ptr) {
-                    _free(ptr);
-                }
+                destructorFunction: function (ptr) { _free(ptr); },
             });
-        };
-        var __embind_register_value_object = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => {
+        }
+        function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
             structRegistrations[rawType] = {
                 name: readLatin1String(name),
                 rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
                 rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
                 fields: [],
             };
-        };
-        var __embind_register_value_object_field = (structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => {
+        }
+        function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
             structRegistrations[structType].fields.push({
                 fieldName: readLatin1String(fieldName),
-                getterReturnType,
+                getterReturnType: getterReturnType,
                 getter: embind__requireFunction(getterSignature, getter),
-                getterContext,
-                setterArgumentType,
+                getterContext: getterContext,
+                setterArgumentType: setterArgumentType,
                 setter: embind__requireFunction(setterSignature, setter),
-                setterContext,
+                setterContext: setterContext,
             });
-        };
-        var __embind_register_void = (rawType, name) => {
+        }
+        function __embind_register_void(rawType, name) {
             name = readLatin1String(name);
             registerType(rawType, {
                 isVoid: true,
-                name,
+                name: name,
                 'argPackAdvance': 0,
-                'fromWireType': () => undefined,
-                // TODO: assert if anything else is given?
-                'toWireType': (destructors, o) => undefined,
+                'fromWireType': function () {
+                    return undefined;
+                },
+                'toWireType': function (destructors, o) {
+                    // TODO: assert if anything else is given?
+                    return undefined;
+                },
             });
-        };
-        var requireRegisteredType = (rawType, humanName) => {
+        }
+        function requireRegisteredType(rawType, humanName) {
             var impl = registeredTypes[rawType];
             if (undefined === impl) {
                 throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
             }
             return impl;
-        };
-        var __emval_as = (handle, returnType, destructorsRef) => {
+        }
+        function __emval_as(handle, returnType, destructorsRef) {
             handle = Emval.toValue(handle);
             returnType = requireRegisteredType(returnType, 'emval::as');
             var destructors = [];
             var rd = Emval.toHandle(destructors);
             HEAPU32[((destructorsRef) >> 2)] = rd;
             return returnType['toWireType'](destructors, handle);
-        };
-        var emval_allocateDestructors = (destructorsRef) => {
+        }
+        function emval_allocateDestructors(destructorsRef) {
             var destructors = [];
             HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors);
             return destructors;
-        };
+        }
         var emval_symbols = {};
-        var getStringOrSymbol = (address) => {
+        function getStringOrSymbol(address) {
             var symbol = emval_symbols[address];
             if (symbol === undefined) {
                 return readLatin1String(address);
             }
             return symbol;
-        };
+        }
         var emval_methodCallers = [];
-        var __emval_call_void_method = (caller, handle, methodName, args) => {
+        function __emval_call_void_method(caller, handle, methodName, args) {
             caller = emval_methodCallers[caller];
             handle = Emval.toValue(handle);
             methodName = getStringOrSymbol(methodName);
             caller(handle, methodName, null, args);
-        };
-        var emval_addMethodCaller = (caller) => {
+        }
+        function emval_addMethodCaller(caller) {
             var id = emval_methodCallers.length;
             emval_methodCallers.push(caller);
             return id;
-        };
-        var emval_lookupTypes = (argCount, argTypes) => {
+        }
+        function emval_lookupTypes(argCount, argTypes) {
             var a = new Array(argCount);
             for (var i = 0; i < argCount; ++i) {
                 a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], "parameter " + i);
             }
             return a;
-        };
-        var emval_registeredMethods = {};
-        var __emval_get_method_caller = (argCount, argTypes) => {
+        }
+        var emval_registeredMethods = [];
+        function __emval_get_method_caller(argCount, argTypes) {
             var types = emval_lookupTypes(argCount, argTypes);
             var retType = types[0];
             var signatureName = retType.name + "_$" + types.slice(1).map(function (t) { return t.name; }).join("_") + "$";
@@ -2513,53 +2588,55 @@ var Module = (() => {
             functionBody +=
                 "};\n";
             params.push(functionBody);
-            var invokerFunction = newFunc(Function, params).apply(null, args);
+            var invokerFunction = new_(Function, params).apply(null, args);
             returnId = emval_addMethodCaller(invokerFunction);
             emval_registeredMethods[signatureName] = returnId;
             return returnId;
-        };
-        var __emval_get_property = (handle, key) => {
+        }
+        function __emval_get_property(handle, key) {
             handle = Emval.toValue(handle);
             key = Emval.toValue(key);
             return Emval.toHandle(handle[key]);
-        };
-        var __emval_incref = (handle) => {
+        }
+        function __emval_incref(handle) {
             if (handle > 4) {
-                emval_handles.get(handle).refcount += 1;
+                emval_handle_array[handle].refcount += 1;
             }
-        };
-        var __emval_new_array = () => {
+        }
+        function __emval_new_array() {
             return Emval.toHandle([]);
-        };
-        var __emval_new_cstring = (v) => {
+        }
+        function __emval_new_cstring(v) {
             return Emval.toHandle(getStringOrSymbol(v));
-        };
-        var __emval_run_destructors = (handle) => {
+        }
+        function __emval_run_destructors(handle) {
             var destructors = Emval.toValue(handle);
             runDestructors(destructors);
             __emval_decref(handle);
-        };
-        var __emval_take_value = (type, arg) => {
+        }
+        function __emval_take_value(type, arg) {
             type = requireRegisteredType(type, '_emval_take_value');
             var v = type['readValueFromPointer'](arg);
             return Emval.toHandle(v);
-        };
-        var _abort = () => {
+        }
+        function _abort() {
             abort('');
-        };
-        var _emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
-        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) => {
+        }
+        function _emscripten_memcpy_big(dest, src, num) {
+            HEAPU8.copyWithin(dest, src, src + num);
+        }
+        function getHeapMax() {
+            // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+            // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+            // for any code that deals with heap sizes, which would require special
+            // casing all heap size related code to treat 0 specially.
+            return 2147483648;
+        }
+        function emscripten_realloc_buffer(size) {
             var b = wasmMemory.buffer;
-            var pages = (size - b.byteLength + 65535) / 65536;
             try {
                 // round size grow request up to wasm page size (fixed 64KB per spec)
-                wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
+                wasmMemory.grow((size - b.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size
                 updateMemoryViews();
                 return 1 /*success*/;
             }
@@ -2567,11 +2644,10 @@ var Module = (() => {
             }
             // implicit 0 return to save code size (caller will cast "undefined" into 0
             // anyhow)
-        };
-        var _emscripten_resize_heap = (requestedSize) => {
+        }
+        function _emscripten_resize_heap(requestedSize) {
             var oldSize = HEAPU8.length;
-            // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
-            requestedSize >>>= 0;
+            requestedSize = requestedSize >>> 0;
             // With multithreaded builds, races can happen (another thread might increase the size
             // in between), so return a failure, and let the caller retry.
             // Memory resize rules:
@@ -2596,7 +2672,7 @@ var Module = (() => {
             if (requestedSize > maxHeapSize) {
                 return false;
             }
-            var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+            let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
             // Loop through potential heap size increases. If we attempt a too eager
             // reservation that fails, cut down on the attempted size and reserve a
             // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
@@ -2605,18 +2681,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 = growMemory(newSize);
+                var replacement = emscripten_realloc_buffer(newSize);
                 if (replacement) {
                     return true;
                 }
             }
             return false;
-        };
+        }
         var ENV = {};
-        var getExecutableName = () => {
+        function getExecutableName() {
             return thisProgram || './this.program';
-        };
-        var getEnvStrings = () => {
+        }
+        function getEnvStrings() {
             if (!getEnvStrings.strings) {
                 // Default values.
                 // Browser language detection #8751
@@ -2642,69 +2718,67 @@ 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;
-        };
-        var stringToAscii = (str, buffer) => {
+        }
+        /** @param {boolean=} dontAddNull */
+        function writeAsciiToMemory(str, buffer, dontAddNull) {
             for (var i = 0; i < str.length; ++i) {
                 HEAP8[((buffer++) >> 0)] = str.charCodeAt(i);
             }
-            // Null-terminate the string
-            HEAP8[((buffer) >> 0)] = 0;
-        };
-        var SYSCALLS = {
-            varargs: undefined,
-            get() {
-                // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number.
-                var ret = HEAP32[((+SYSCALLS.varargs) >> 2)];
+            // 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;
-            },
-            getp() { return SYSCALLS.get(); },
-            getStr(ptr) {
+            }, getStr: function (ptr) {
                 var ret = UTF8ToString(ptr);
                 return ret;
-            },
-        };
-        var _environ_get = (__environ, environ_buf) => {
+            } };
+        function _environ_get(__environ, environ_buf) {
             var bufSize = 0;
-            getEnvStrings().forEach((string, i) => {
+            getEnvStrings().forEach(function (string, i) {
                 var ptr = environ_buf + bufSize;
                 HEAPU32[(((__environ) + (i * 4)) >> 2)] = ptr;
-                stringToAscii(string, ptr);
+                writeAsciiToMemory(string, ptr);
                 bufSize += string.length + 1;
             });
             return 0;
-        };
-        var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+        }
+        function _environ_sizes_get(penviron_count, penviron_buf_size) {
             var strings = getEnvStrings();
             HEAPU32[((penviron_count) >> 2)] = strings.length;
             var bufSize = 0;
-            strings.forEach((string) => bufSize += string.length + 1);
+            strings.forEach(function (string) {
+                bufSize += string.length + 1;
+            });
             HEAPU32[((penviron_buf_size) >> 2)] = bufSize;
             return 0;
-        };
-        var isLeapYear = (year) => {
+        }
+        function __isLeapYear(year) {
             return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-        };
-        var arraySum = (array, index) => {
+        }
+        function __arraySum(array, index) {
             var sum = 0;
             for (var i = 0; i <= index; sum += array[i++]) {
                 // no-op
             }
             return sum;
-        };
-        var MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        var MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        var 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];
+        function __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);
@@ -2724,7 +2798,7 @@ var Module = (() => {
                 }
             }
             return newDate;
-        };
+        }
         /** @type {function(string, boolean=, number=)} */
         function intArrayFromString(stringy, dontAddNull, length) {
             var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
@@ -2734,13 +2808,13 @@ var Module = (() => {
                 u8array.length = numBytesWritten;
             return u8array;
         }
-        var writeArrayToMemory = (array, buffer) => {
+        function writeArrayToMemory(array, buffer) {
             HEAP8.set(array, buffer);
-        };
-        var _strftime = (s, maxsize, format, tm) => {
+        }
+        function _strftime(s, maxsize, format, tm) {
             // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
             // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
-            var tm_zone = HEAPU32[(((tm) + (40)) >> 2)];
+            var tm_zone = HEAP32[(((tm) + (40)) >> 2)];
             var date = {
                 tm_sec: HEAP32[((tm) >> 2)],
                 tm_min: HEAP32[(((tm) + (4)) >> 2)],
@@ -2833,7 +2907,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);
@@ -2848,17 +2922,29 @@ var Module = (() => {
                 return thisDate.getFullYear() - 1;
             }
             var EXPANSION_RULES_2 = {
-                '%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) => {
+                '%a': function (date) {
+                    return WEEKDAYS[date.tm_wday].substring(0, 3);
+                },
+                '%A': function (date) {
+                    return WEEKDAYS[date.tm_wday];
+                },
+                '%b': function (date) {
+                    return MONTHS[date.tm_mon].substring(0, 3);
+                },
+                '%B': function (date) {
+                    return MONTHS[date.tm_mon];
+                },
+                '%C': function (date) {
                     var year = date.tm_year + 1900;
                     return leadingNulls((year / 100) | 0, 2);
                 },
-                '%d': (date) => leadingNulls(date.tm_mday, 2),
-                '%e': (date) => leadingSomething(date.tm_mday, 2, ' '),
-                '%g': (date) => {
+                '%d': function (date) {
+                    return leadingNulls(date.tm_mday, 2);
+                },
+                '%e': function (date) {
+                    return leadingSomething(date.tm_mday, 2, ' ');
+                },
+                '%g': function (date) {
                     // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
                     // In this system, weeks begin on a Monday and week 1 of the year is the week that includes
                     // January 4th, which is also the week that includes the first Thursday of the year, and
@@ -2870,9 +2956,13 @@ 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': (date) => getWeekBasedYear(date),
-                '%H': (date) => leadingNulls(date.tm_hour, 2),
-                '%I': (date) => {
+                '%G': function (date) {
+                    return getWeekBasedYear(date);
+                },
+                '%H': function (date) {
+                    return leadingNulls(date.tm_hour, 2);
+                },
+                '%I': function (date) {
                     var twelveHour = date.tm_hour;
                     if (twelveHour == 0)
                         twelveHour = 12;
@@ -2880,27 +2970,39 @@ var Module = (() => {
                         twelveHour -= 12;
                     return leadingNulls(twelveHour, 2);
                 },
-                '%j': (date) => {
+                '%j': function (date) {
                     // Day of the year (001-366)
-                    return leadingNulls(date.tm_mday + arraySum(isLeapYear(date.tm_year + 1900) ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
+                    return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
+                },
+                '%m': function (date) {
+                    return leadingNulls(date.tm_mon + 1, 2);
+                },
+                '%M': function (date) {
+                    return leadingNulls(date.tm_min, 2);
+                },
+                '%n': function () {
+                    return '\n';
                 },
-                '%m': (date) => leadingNulls(date.tm_mon + 1, 2),
-                '%M': (date) => leadingNulls(date.tm_min, 2),
-                '%n': () => '\n',
-                '%p': (date) => {
+                '%p': function (date) {
                     if (date.tm_hour >= 0 && date.tm_hour < 12) {
                         return 'AM';
                     }
                     return 'PM';
                 },
-                '%S': (date) => leadingNulls(date.tm_sec, 2),
-                '%t': () => '\t',
-                '%u': (date) => date.tm_wday || 7,
-                '%U': (date) => {
+                '%S': function (date) {
+                    return leadingNulls(date.tm_sec, 2);
+                },
+                '%t': function () {
+                    return '\t';
+                },
+                '%u': function (date) {
+                    return date.tm_wday || 7;
+                },
+                '%U': function (date) {
                     var days = date.tm_yday + 7 - date.tm_wday;
                     return leadingNulls(Math.floor(days / 7), 2);
                 },
-                '%V': (date) => {
+                '%V': function (date) {
                     // Replaced by the week number of the year (Monday as the first day of the week)
                     // as a decimal number [01,53]. If the week containing 1 January has four
                     // or more days in the new year, then it is considered week 1.
@@ -2917,7 +3019,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++;
                         }
                     }
@@ -2925,23 +3027,27 @@ 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': (date) => date.tm_wday,
-                '%W': (date) => {
+                '%w': function (date) {
+                    return date.tm_wday;
+                },
+                '%W': function (date) {
                     var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
                     return leadingNulls(Math.floor(days / 7), 2);
                 },
-                '%y': (date) => {
+                '%y': function (date) {
                     // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
                     return (date.tm_year + 1900).toString().substring(2);
                 },
-                // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
-                '%Y': (date) => date.tm_year + 1900,
-                '%z': (date) => {
+                '%Y': function (date) {
+                    // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
+                    return date.tm_year + 1900;
+                },
+                '%z': function (date) {
                     // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ).
                     // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
                     var off = date.tm_gmtoff;
@@ -2951,8 +3057,12 @@ var Module = (() => {
                     off = (off / 60) * 100 + (off % 60);
                     return (ahead ? '+' : '-') + String("0000" + off).slice(-4);
                 },
-                '%Z': (date) => date.tm_zone,
-                '%%': () => '%'
+                '%Z': function (date) {
+                    return date.tm_zone;
+                },
+                '%%': function () {
+                    return '%';
+                }
             };
             // Replace %% with a pair of NULLs (which cannot occur in a C string), then
             // re-inject them after processing.
@@ -2969,122 +3079,130 @@ var Module = (() => {
             }
             writeArrayToMemory(bytes, s);
             return bytes.length - 1;
-        };
-        var _strftime_l = (s, maxsize, format, tm, loc) => {
+        }
+        function _strftime_l(s, maxsize, format, tm, loc) {
             return _strftime(s, maxsize, format, tm); // no locale support yet
-        };
-        InternalError = Module['InternalError'] = class InternalError extends Error {
-            constructor(message) { super(message); this.name = 'InternalError'; }
-        };
+        }
+        InternalError = Module['InternalError'] = extendError(Error, 'InternalError');
+        ;
         embind_init_charCodes();
-        BindingError = Module['BindingError'] = class BindingError extends Error {
-            constructor(message) { super(message); this.name = 'BindingError'; }
-        };
+        BindingError = Module['BindingError'] = extendError(Error, 'BindingError');
+        ;
         init_ClassHandle();
         init_embind();
         ;
         init_RegisteredPointer();
         UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');
         ;
-        handleAllocatorInit();
         init_emval();
         ;
         var wasmImports = {
-            /** @export */
-            __assert_fail: ___assert_fail,
-            /** @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_constructor: __embind_register_class_constructor,
-            /** @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 */
-            _emval_as: __emval_as,
-            /** @export */
-            _emval_call_void_method: __emval_call_void_method,
-            /** @export */
-            _emval_decref: __emval_decref,
-            /** @export */
-            _emval_get_method_caller: __emval_get_method_caller,
-            /** @export */
-            _emval_get_property: __emval_get_property,
-            /** @export */
-            _emval_incref: __emval_incref,
-            /** @export */
-            _emval_new_array: __emval_new_array,
-            /** @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_memcpy_js: _emscripten_memcpy_js,
-            /** @export */
-            emscripten_resize_heap: _emscripten_resize_heap,
-            /** @export */
-            environ_get: _environ_get,
-            /** @export */
-            environ_sizes_get: _environ_sizes_get,
-            /** @export */
-            strftime_l: _strftime_l,
-            /** @export */
-            wasm_loadfileproc: wasm_loadfileproc,
-            /** @export */
-            wasm_msgproc: wasm_msgproc
-        };
-        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 __embind_initialize_bindings = Module['__embind_initialize_bindings'] = () => (__embind_initialize_bindings = Module['__embind_initialize_bindings'] = wasmExports['_embind_initialize_bindings'])();
-        var ___errno_location = () => (___errno_location = wasmExports['__errno_location'])();
-        var ___trap = () => (___trap = wasmExports['__trap'])();
-        var setTempRet0 = (a0) => (setTempRet0 = wasmExports['setTempRet0'])(a0);
-        var stackSave = () => (stackSave = wasmExports['stackSave'])();
-        var stackRestore = (a0) => (stackRestore = wasmExports['stackRestore'])(a0);
-        var stackAlloc = (a0) => (stackAlloc = wasmExports['stackAlloc'])(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);
-        var ___start_em_js = Module['___start_em_js'] = 59184;
-        var ___stop_em_js = Module['___stop_em_js'] = 59880;
+            "__assert_fail": ___assert_fail,
+            "_embind_finalize_value_object": __embind_finalize_value_object,
+            "_embind_register_bigint": __embind_register_bigint,
+            "_embind_register_bool": __embind_register_bool,
+            "_embind_register_class": __embind_register_class,
+            "_embind_register_class_constructor": __embind_register_class_constructor,
+            "_embind_register_class_property": __embind_register_class_property,
+            "_embind_register_emval": __embind_register_emval,
+            "_embind_register_float": __embind_register_float,
+            "_embind_register_function": __embind_register_function,
+            "_embind_register_integer": __embind_register_integer,
+            "_embind_register_memory_view": __embind_register_memory_view,
+            "_embind_register_std_string": __embind_register_std_string,
+            "_embind_register_std_wstring": __embind_register_std_wstring,
+            "_embind_register_value_object": __embind_register_value_object,
+            "_embind_register_value_object_field": __embind_register_value_object_field,
+            "_embind_register_void": __embind_register_void,
+            "_emval_as": __emval_as,
+            "_emval_call_void_method": __emval_call_void_method,
+            "_emval_decref": __emval_decref,
+            "_emval_get_method_caller": __emval_get_method_caller,
+            "_emval_get_property": __emval_get_property,
+            "_emval_incref": __emval_incref,
+            "_emval_new_array": __emval_new_array,
+            "_emval_new_cstring": __emval_new_cstring,
+            "_emval_run_destructors": __emval_run_destructors,
+            "_emval_take_value": __emval_take_value,
+            "abort": _abort,
+            "emscripten_memcpy_big": _emscripten_memcpy_big,
+            "emscripten_resize_heap": _emscripten_resize_heap,
+            "environ_get": _environ_get,
+            "environ_sizes_get": _environ_sizes_get,
+            "strftime_l": _strftime_l,
+            "wasm_loadfileproc": wasm_loadfileproc,
+            "wasm_msgproc": wasm_msgproc
+        };
+        var asm = createWasm();
+        /** @type {function(...*):?} */
+        var ___wasm_call_ctors = function () {
+            return (___wasm_call_ctors = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = function () {
+            return (_kmcmp_CompileKeyboard = Module["_kmcmp_CompileKeyboard"] = Module["asm"]["kmcmp_CompileKeyboard"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = function () {
+            return (_kmcmp_parseUnicodeSet = Module["_kmcmp_parseUnicodeSet"] = Module["asm"]["kmcmp_parseUnicodeSet"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _malloc = function () {
+            return (_malloc = Module["asm"]["malloc"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var _free = function () {
+            return (_free = Module["asm"]["free"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var ___getTypeName = Module["___getTypeName"] = function () {
+            return (___getTypeName = Module["___getTypeName"] = Module["asm"]["__getTypeName"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = function () {
+            return (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = Module["asm"]["_embind_initialize_bindings"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var ___errno_location = function () {
+            return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var ___trap = function () {
+            return (___trap = Module["asm"]["__trap"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var stackSave = function () {
+            return (stackSave = Module["asm"]["stackSave"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var stackRestore = function () {
+            return (stackRestore = Module["asm"]["stackRestore"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var stackAlloc = function () {
+            return (stackAlloc = Module["asm"]["stackAlloc"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_viijii = Module["dynCall_viijii"] = function () {
+            return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["dynCall_viijii"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_iiiiij = Module["dynCall_iiiiij"] = function () {
+            return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["dynCall_iiiiij"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function () {
+            return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments);
+        };
+        /** @type {function(...*):?} */
+        var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function () {
+            return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments);
+        };
+        var ___start_em_js = Module['___start_em_js'] = 59072;
+        var ___stop_em_js = Module['___stop_em_js'] = 59768;
         // include: postamble.js
         // === Auto-generated postamble setup entry stuff ===
-        Module['wasmExports'] = wasmExports;
-        Module['UTF8ToString'] = UTF8ToString;
+        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)
@@ -3139,8 +3257,9 @@ var Module = (() => {
         }
         run();
         // end include: postamble.js
-        return moduleArg.ready;
+        return Module.ready;
     });
 })();
 export default Module;
-//# sourceMappingURL=wasm-host.js.map
+//# sourceMappingURL=wasm-host.js.map
+//# debugId=c211f816-44aa-5eab-8f12-fbd1b87e723f