@locuschain/lib 0.1.38 → 0.1.40

package/dist/chunks/lclib-Bv86gksL.js

@@ -0,0 +1,3861 @@
+define(['module', 'require', 'exports', './tslib.es6-D29rxPkW'], (function (module, require, exports, tslib_es6) { 'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    function AimerModule() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (moduleArg = {}) {
+            var _a, _b, _c;
+            var moduleRtn;
+            var Module = moduleArg;
+            var ENVIRONMENT_IS_WEB = !!globalThis.window;
+            var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+            var ENVIRONMENT_IS_NODE = ((_b = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.versions) === null || _b === void 0 ? void 0 : _b.node) && ((_c = globalThis.process) === null || _c === void 0 ? void 0 : _c.type) != "renderer";
+            if (ENVIRONMENT_IS_NODE) {
+                const { createRequire } = yield ((m)=>(function (t) { return new Promise(function (resolve, reject) { require([t], function (m) { resolve(/*#__PURE__*/_interopNamespaceDefault(m)); }, reject); }); })(/* @vite-ignore */ /* webpackIgnore: true */ m))("node:module");
+                var require$1 = createRequire(new URL(module.uri, document.baseURI).href);
+            }
+            var quit_ = (status, toThrow) => { throw toThrow; };
+            var _scriptName = new URL(module.uri, document.baseURI).href;
+            var scriptDirectory = "";
+            function locateFile(path) { if (Module["locateFile"]) {
+                return Module["locateFile"](path, scriptDirectory);
+            } return scriptDirectory + path; }
+            var readAsync, readBinary;
+            if (ENVIRONMENT_IS_NODE) {
+                var fs = require$1("node:fs");
+                if (_scriptName.startsWith("file:")) {
+                    scriptDirectory = require$1("node:path").dirname(require$1("node:url").fileURLToPath(_scriptName)) + "/";
+                }
+                readBinary = filename => { filename = isFileURI(filename) ? new URL(filename) : filename; var ret = fs.readFileSync(filename); return ret; };
+                readAsync = (filename_1, ...args_1) => tslib_es6.__awaiter(this, [filename_1, ...args_1], void 0, function* (filename, binary = true) { filename = isFileURI(filename) ? new URL(filename) : filename; var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); return ret; });
+                if (process.argv.length > 1) {
+                    process.argv[1].replace(/\\/g, "/");
+                }
+                process.argv.slice(2);
+                quit_ = (status, toThrow) => { process.exitCode = status; throw toThrow; };
+            }
+            else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+                try {
+                    scriptDirectory = new URL(".", _scriptName).href;
+                }
+                catch (_d) { }
+                {
+                    if (ENVIRONMENT_IS_WORKER) {
+                        readBinary = url => { var xhr = new XMLHttpRequest; xhr.open("GET", url, false); xhr.responseType = "arraybuffer"; xhr.send(null); return new Uint8Array(xhr.response); };
+                    }
+                    readAsync = (url) => tslib_es6.__awaiter(this, void 0, void 0, function* () { if (isFileURI(url)) {
+                        return new Promise((resolve, reject) => { var xhr = new XMLHttpRequest; xhr.open("GET", url, true); xhr.responseType = "arraybuffer"; xhr.onload = () => { if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+                            resolve(xhr.response);
+                            return;
+                        } reject(xhr.status); }; xhr.onerror = reject; xhr.send(null); });
+                    } var response = yield fetch(url, { credentials: "same-origin" }); if (response.ok) {
+                        return response.arrayBuffer();
+                    } throw new Error(response.status + " : " + response.url); });
+                }
+            }
+            else ;
+            console.log.bind(console);
+            var err = console.error.bind(console);
+            var wasmBinary;
+            var ABORT = false;
+            var isFileURI = filename => filename.startsWith("file://");
+            var readyPromiseResolve, readyPromiseReject;
+            var HEAP8, HEAPU8;
+            var runtimeInitialized = false;
+            function updateMemoryViews() { var b = wasmMemory.buffer; HEAP8 = new Int8Array(b); Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); Module["HEAPU32"] = new Uint32Array(b); new BigInt64Array(b); new BigUint64Array(b); }
+            function preRun() { if (Module["preRun"]) {
+                if (typeof Module["preRun"] == "function")
+                    Module["preRun"] = [Module["preRun"]];
+                while (Module["preRun"].length) {
+                    addOnPreRun(Module["preRun"].shift());
+                }
+            } callRuntimeCallbacks(onPreRuns); }
+            function initRuntime() { runtimeInitialized = true; wasmExports["d"](); }
+            function postRun() { if (Module["postRun"]) {
+                if (typeof Module["postRun"] == "function")
+                    Module["postRun"] = [Module["postRun"]];
+                while (Module["postRun"].length) {
+                    addOnPostRun(Module["postRun"].shift());
+                }
+            } callRuntimeCallbacks(onPostRuns); }
+            function abort(what) { var _a; (_a = Module["onAbort"]) === null || _a === void 0 ? void 0 : _a.call(Module, what); what = "Aborted(" + what + ")"; err(what); ABORT = true; what += ". Build with -sASSERTIONS for more info."; var e = new WebAssembly.RuntimeError(what); readyPromiseReject === null || readyPromiseReject === void 0 ? void 0 : readyPromiseReject(e); throw e; }
+            var wasmBinaryFile;
+            function findWasmBinary() { if (Module["locateFile"]) {
+                return locateFile("crypto_aimer.wasm");
+            } return new URL("crypto_aimer.wasm", new URL(module.uri, document.baseURI).href).href; }
+            function getBinarySync(file) { if (file == wasmBinaryFile && wasmBinary) {
+                return new Uint8Array(wasmBinary);
+            } if (readBinary) {
+                return readBinary(file);
+            } throw "both async and sync fetching of the wasm failed"; }
+            function getWasmBinary(binaryFile) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { if (!wasmBinary) {
+                    try {
+                        var response = yield readAsync(binaryFile);
+                        return new Uint8Array(response);
+                    }
+                    catch (_a) { }
+                } return getBinarySync(binaryFile); });
+            }
+            function instantiateArrayBuffer(binaryFile, imports) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { try {
+                    var binary = yield getWasmBinary(binaryFile);
+                    var instance = yield WebAssembly.instantiate(binary, imports);
+                    return instance;
+                }
+                catch (reason) {
+                    err(`failed to asynchronously prepare wasm: ${reason}`);
+                    abort(reason);
+                } });
+            }
+            function instantiateAsync(binary, binaryFile, imports) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
+                    try {
+                        var response = fetch(binaryFile, { credentials: "same-origin" });
+                        var instantiationResult = yield WebAssembly.instantiateStreaming(response, imports);
+                        return instantiationResult;
+                    }
+                    catch (reason) {
+                        err(`wasm streaming compile failed: ${reason}`);
+                        err("falling back to ArrayBuffer instantiation");
+                    }
+                } return instantiateArrayBuffer(binaryFile, imports); });
+            }
+            function getWasmImports() { var imports = { a: wasmImports }; return imports; }
+            function createWasm() {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { function receiveInstance(instance, module) { wasmExports = instance.exports; assignWasmExports(wasmExports); updateMemoryViews(); return wasmExports; } function receiveInstantiationResult(result) { return receiveInstance(result["instance"]); } var info = getWasmImports(); if (Module["instantiateWasm"]) {
+                    return new Promise((resolve, reject) => { Module["instantiateWasm"](info, (inst, mod) => { resolve(receiveInstance(inst)); }); });
+                } wasmBinaryFile !== null && wasmBinaryFile !== void 0 ? wasmBinaryFile : (wasmBinaryFile = findWasmBinary()); var result = yield instantiateAsync(wasmBinary, wasmBinaryFile, info); var exports$1 = receiveInstantiationResult(result); return exports$1; });
+            }
+            class ExitStatus {
+                constructor(status) {
+                    this.name = "ExitStatus";
+                    this.message = `Program terminated with exit(${status})`;
+                    this.status = status;
+                }
+            }
+            var callRuntimeCallbacks = callbacks => { while (callbacks.length > 0) {
+                callbacks.shift()(Module);
+            } };
+            var onPostRuns = [];
+            var addOnPostRun = cb => onPostRuns.push(cb);
+            var onPreRuns = [];
+            var addOnPreRun = cb => onPreRuns.push(cb);
+            var noExitRuntime = true;
+            var stackRestore = val => __emscripten_stack_restore(val);
+            var stackSave = () => _emscripten_stack_get_current();
+            var getHeapMax = () => 2147483648;
+            var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+            var growMemory = size => { var oldHeapSize = wasmMemory.buffer.byteLength; var pages = (size - oldHeapSize + 65535) / 65536 | 0; try {
+                wasmMemory.grow(pages);
+                updateMemoryViews();
+                return 1;
+            }
+            catch (e) { } };
+            var _emscripten_resize_heap = requestedSize => { var oldSize = HEAPU8.length; requestedSize >>>= 0; var maxHeapSize = getHeapMax(); if (requestedSize > maxHeapSize) {
+                return false;
+            } for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = growMemory(newSize);
+                if (replacement) {
+                    return true;
+                }
+            } return false; };
+            var runtimeKeepaliveCounter = 0;
+            var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+            var _proc_exit = code => { var _a; if (!keepRuntimeAlive()) {
+                (_a = Module["onExit"]) === null || _a === void 0 ? void 0 : _a.call(Module, code);
+                ABORT = true;
+            } quit_(code, new ExitStatus(code)); };
+            var exitJS = (status, implicit) => { _proc_exit(status); };
+            var _exit = exitJS;
+            var getCFunc = ident => { var func = Module["_" + ident]; return func; };
+            var writeArrayToMemory = (array, buffer) => { HEAP8.set(array, buffer); };
+            var lengthBytesUTF8 = str => { var len = 0; for (var i = 0; i < str.length; ++i) {
+                var c = str.charCodeAt(i);
+                if (c <= 127) {
+                    len++;
+                }
+                else if (c <= 2047) {
+                    len += 2;
+                }
+                else if (c >= 55296 && c <= 57343) {
+                    len += 4;
+                    ++i;
+                }
+                else {
+                    len += 3;
+                }
+            } return len; };
+            var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { if (!(maxBytesToWrite > 0))
+                return 0; var startIdx = outIdx; var endIdx = outIdx + maxBytesToWrite - 1; for (var i = 0; i < str.length; ++i) {
+                var u = str.codePointAt(i);
+                if (u <= 127) {
+                    if (outIdx >= endIdx)
+                        break;
+                    heap[outIdx++] = u;
+                }
+                else if (u <= 2047) {
+                    if (outIdx + 1 >= endIdx)
+                        break;
+                    heap[outIdx++] = 192 | u >> 6;
+                    heap[outIdx++] = 128 | u & 63;
+                }
+                else if (u <= 65535) {
+                    if (outIdx + 2 >= endIdx)
+                        break;
+                    heap[outIdx++] = 224 | u >> 12;
+                    heap[outIdx++] = 128 | u >> 6 & 63;
+                    heap[outIdx++] = 128 | u & 63;
+                }
+                else {
+                    if (outIdx + 3 >= endIdx)
+                        break;
+                    heap[outIdx++] = 240 | u >> 18;
+                    heap[outIdx++] = 128 | u >> 12 & 63;
+                    heap[outIdx++] = 128 | u >> 6 & 63;
+                    heap[outIdx++] = 128 | u & 63;
+                    i++;
+                }
+            } heap[outIdx] = 0; return outIdx - startIdx; };
+            var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+            var stackAlloc = sz => __emscripten_stack_alloc(sz);
+            var stringToUTF8OnStack = str => { var size = lengthBytesUTF8(str) + 1; var ret = stackAlloc(size); stringToUTF8(str, ret, size); return ret; };
+            var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
+            var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { var maxIdx = idx + maxBytesToRead; while (heapOrArray[idx] && !(idx >= maxIdx))
+                ++idx; return idx; };
+            var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead); if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+            } var str = ""; while (idx < endPtr) {
+                var u0 = heapOrArray[idx++];
+                if (!(u0 & 128)) {
+                    str += String.fromCharCode(u0);
+                    continue;
+                }
+                var u1 = heapOrArray[idx++] & 63;
+                if ((u0 & 224) == 192) {
+                    str += String.fromCharCode((u0 & 31) << 6 | u1);
+                    continue;
+                }
+                var u2 = heapOrArray[idx++] & 63;
+                if ((u0 & 240) == 224) {
+                    u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+                }
+                else {
+                    u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+                }
+                if (u0 < 65536) {
+                    str += String.fromCharCode(u0);
+                }
+                else {
+                    var ch = u0 - 65536;
+                    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+                }
+            } return str; };
+            var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+            var ccall = (ident, returnType, argTypes, args, opts) => { var toC = { string: str => { var ret = 0; if (str !== null && str !== undefined && str !== 0) {
+                    ret = stringToUTF8OnStack(str);
+                } return ret; }, array: arr => { var ret = stackAlloc(arr.length); writeArrayToMemory(arr, ret); return ret; } }; function convertReturnValue(ret) { if (returnType === "string") {
+                return UTF8ToString(ret);
+            } if (returnType === "boolean")
+                return Boolean(ret); return ret; } var func = getCFunc(ident); var cArgs = []; var stack = 0; if (args) {
+                for (var i = 0; i < args.length; i++) {
+                    var converter = toC[argTypes[i]];
+                    if (converter) {
+                        if (stack === 0)
+                            stack = stackSave();
+                        cArgs[i] = converter(args[i]);
+                    }
+                    else {
+                        cArgs[i] = args[i];
+                    }
+                }
+            } var ret = func(...cArgs); function onDone(ret) { if (stack !== 0)
+                stackRestore(stack); return convertReturnValue(ret); } ret = onDone(ret); return ret; };
+            var cwrap = (ident, returnType, argTypes, opts) => { var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean"); var numericRet = returnType !== "string"; if (numericRet && numericArgs && !opts) {
+                return getCFunc(ident);
+            } return (...args) => ccall(ident, returnType, argTypes, args); };
+            {
+                if (Module["noExitRuntime"])
+                    noExitRuntime = Module["noExitRuntime"];
+                if (Module["print"])
+                    Module["print"];
+                if (Module["printErr"])
+                    err = Module["printErr"];
+                if (Module["wasmBinary"])
+                    wasmBinary = Module["wasmBinary"];
+                if (Module["arguments"])
+                    Module["arguments"];
+                if (Module["thisProgram"])
+                    Module["thisProgram"];
+                if (Module["preInit"]) {
+                    if (typeof Module["preInit"] == "function")
+                        Module["preInit"] = [Module["preInit"]];
+                    while (Module["preInit"].length > 0) {
+                        Module["preInit"].shift()();
+                    }
+                }
+            }
+            Module["ccall"] = ccall;
+            Module["cwrap"] = cwrap;
+            var __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, wasmMemory;
+            function assignWasmExports(wasmExports) { Module["_malloc"] = wasmExports["e"]; Module["_free"] = wasmExports["f"]; Module["_wasm_aimer_keypair"] = wasmExports["g"]; Module["_wasm_aimer_sign"] = wasmExports["h"]; Module["_wasm_aimer_verify"] = wasmExports["i"]; __emscripten_stack_restore = wasmExports["j"]; __emscripten_stack_alloc = wasmExports["k"]; _emscripten_stack_get_current = wasmExports["l"]; wasmMemory = wasmExports["c"]; wasmExports["__indirect_function_table"]; }
+            var wasmImports = { a: _emscripten_resize_heap, b: _exit };
+            function run() { preRun(); function doRun() { var _a; Module["calledRun"] = true; if (ABORT)
+                return; initRuntime(); readyPromiseResolve === null || readyPromiseResolve === void 0 ? void 0 : readyPromiseResolve(Module); (_a = Module["onRuntimeInitialized"]) === null || _a === void 0 ? void 0 : _a.call(Module); postRun(); } if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(() => { setTimeout(() => Module["setStatus"](""), 1); doRun(); }, 1);
+            }
+            else {
+                doRun();
+            } }
+            var wasmExports;
+            wasmExports = yield (createWasm());
+            run();
+            if (runtimeInitialized) {
+                moduleRtn = Module;
+            }
+            else {
+                moduleRtn = new Promise((resolve, reject) => { readyPromiseResolve = resolve; readyPromiseReject = reject; });
+            }
+            return moduleRtn;
+        });
+    }
+
+    function HaetaeModule() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (moduleArg = {}) {
+            var _a, _b, _c;
+            var moduleRtn;
+            var Module = moduleArg;
+            var ENVIRONMENT_IS_WEB = !!globalThis.window;
+            var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+            var ENVIRONMENT_IS_NODE = ((_b = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.versions) === null || _b === void 0 ? void 0 : _b.node) && ((_c = globalThis.process) === null || _c === void 0 ? void 0 : _c.type) != "renderer";
+            if (ENVIRONMENT_IS_NODE) {
+                const { createRequire } = yield ((m)=>(function (t) { return new Promise(function (resolve, reject) { require([t], function (m) { resolve(/*#__PURE__*/_interopNamespaceDefault(m)); }, reject); }); })(/* @vite-ignore */ /* webpackIgnore: true */ m))("node:module");
+                var require$1 = createRequire(new URL(module.uri, document.baseURI).href);
+            }
+            var _scriptName = new URL(module.uri, document.baseURI).href;
+            var scriptDirectory = "";
+            function locateFile(path) { if (Module["locateFile"]) {
+                return Module["locateFile"](path, scriptDirectory);
+            } return scriptDirectory + path; }
+            var readAsync, readBinary;
+            if (ENVIRONMENT_IS_NODE) {
+                var fs = require$1("node:fs");
+                if (_scriptName.startsWith("file:")) {
+                    scriptDirectory = require$1("node:path").dirname(require$1("node:url").fileURLToPath(_scriptName)) + "/";
+                }
+                readBinary = filename => { filename = isFileURI(filename) ? new URL(filename) : filename; var ret = fs.readFileSync(filename); return ret; };
+                readAsync = (filename_1, ...args_1) => tslib_es6.__awaiter(this, [filename_1, ...args_1], void 0, function* (filename, binary = true) { filename = isFileURI(filename) ? new URL(filename) : filename; var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); return ret; });
+                if (process.argv.length > 1) {
+                    process.argv[1].replace(/\\/g, "/");
+                }
+                process.argv.slice(2);
+            }
+            else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+                try {
+                    scriptDirectory = new URL(".", _scriptName).href;
+                }
+                catch (_d) { }
+                {
+                    if (ENVIRONMENT_IS_WORKER) {
+                        readBinary = url => { var xhr = new XMLHttpRequest; xhr.open("GET", url, false); xhr.responseType = "arraybuffer"; xhr.send(null); return new Uint8Array(xhr.response); };
+                    }
+                    readAsync = (url) => tslib_es6.__awaiter(this, void 0, void 0, function* () { if (isFileURI(url)) {
+                        return new Promise((resolve, reject) => { var xhr = new XMLHttpRequest; xhr.open("GET", url, true); xhr.responseType = "arraybuffer"; xhr.onload = () => { if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+                            resolve(xhr.response);
+                            return;
+                        } reject(xhr.status); }; xhr.onerror = reject; xhr.send(null); });
+                    } var response = yield fetch(url, { credentials: "same-origin" }); if (response.ok) {
+                        return response.arrayBuffer();
+                    } throw new Error(response.status + " : " + response.url); });
+                }
+            }
+            else ;
+            var out = console.log.bind(console);
+            var err = console.error.bind(console);
+            var wasmBinary;
+            var ABORT = false;
+            var isFileURI = filename => filename.startsWith("file://");
+            var readyPromiseResolve, readyPromiseReject;
+            var HEAP8, HEAPU8, HEAP32, HEAPU32;
+            var HEAP64;
+            var runtimeInitialized = false;
+            function updateMemoryViews() { var b = wasmMemory.buffer; HEAP8 = new Int8Array(b); Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); HEAP32 = new Int32Array(b); Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); HEAP64 = new BigInt64Array(b); new BigUint64Array(b); }
+            function preRun() { if (Module["preRun"]) {
+                if (typeof Module["preRun"] == "function")
+                    Module["preRun"] = [Module["preRun"]];
+                while (Module["preRun"].length) {
+                    addOnPreRun(Module["preRun"].shift());
+                }
+            } callRuntimeCallbacks(onPreRuns); }
+            function initRuntime() { runtimeInitialized = true; if (!Module["noFSInit"] && !FS.initialized)
+                FS.init(); wasmExports["f"](); FS.ignorePermissions = false; }
+            function postRun() { if (Module["postRun"]) {
+                if (typeof Module["postRun"] == "function")
+                    Module["postRun"] = [Module["postRun"]];
+                while (Module["postRun"].length) {
+                    addOnPostRun(Module["postRun"].shift());
+                }
+            } callRuntimeCallbacks(onPostRuns); }
+            function abort(what) { var _a; (_a = Module["onAbort"]) === null || _a === void 0 ? void 0 : _a.call(Module, what); what = "Aborted(" + what + ")"; err(what); ABORT = true; what += ". Build with -sASSERTIONS for more info."; var e = new WebAssembly.RuntimeError(what); readyPromiseReject === null || readyPromiseReject === void 0 ? void 0 : readyPromiseReject(e); throw e; }
+            var wasmBinaryFile;
+            function findWasmBinary() { if (Module["locateFile"]) {
+                return locateFile("crypto_haetae.wasm");
+            } return new URL("crypto_haetae.wasm", new URL(module.uri, document.baseURI).href).href; }
+            function getBinarySync(file) { if (file == wasmBinaryFile && wasmBinary) {
+                return new Uint8Array(wasmBinary);
+            } if (readBinary) {
+                return readBinary(file);
+            } throw "both async and sync fetching of the wasm failed"; }
+            function getWasmBinary(binaryFile) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { if (!wasmBinary) {
+                    try {
+                        var response = yield readAsync(binaryFile);
+                        return new Uint8Array(response);
+                    }
+                    catch (_a) { }
+                } return getBinarySync(binaryFile); });
+            }
+            function instantiateArrayBuffer(binaryFile, imports) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { try {
+                    var binary = yield getWasmBinary(binaryFile);
+                    var instance = yield WebAssembly.instantiate(binary, imports);
+                    return instance;
+                }
+                catch (reason) {
+                    err(`failed to asynchronously prepare wasm: ${reason}`);
+                    abort(reason);
+                } });
+            }
+            function instantiateAsync(binary, binaryFile, imports) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
+                    try {
+                        var response = fetch(binaryFile, { credentials: "same-origin" });
+                        var instantiationResult = yield WebAssembly.instantiateStreaming(response, imports);
+                        return instantiationResult;
+                    }
+                    catch (reason) {
+                        err(`wasm streaming compile failed: ${reason}`);
+                        err("falling back to ArrayBuffer instantiation");
+                    }
+                } return instantiateArrayBuffer(binaryFile, imports); });
+            }
+            function getWasmImports() { var imports = { a: wasmImports }; return imports; }
+            function createWasm() {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { function receiveInstance(instance, module) { wasmExports = instance.exports; assignWasmExports(wasmExports); updateMemoryViews(); return wasmExports; } function receiveInstantiationResult(result) { return receiveInstance(result["instance"]); } var info = getWasmImports(); if (Module["instantiateWasm"]) {
+                    return new Promise((resolve, reject) => { Module["instantiateWasm"](info, (inst, mod) => { resolve(receiveInstance(inst)); }); });
+                } wasmBinaryFile !== null && wasmBinaryFile !== void 0 ? wasmBinaryFile : (wasmBinaryFile = findWasmBinary()); var result = yield instantiateAsync(wasmBinary, wasmBinaryFile, info); var exports$1 = receiveInstantiationResult(result); return exports$1; });
+            }
+            var callRuntimeCallbacks = callbacks => { while (callbacks.length > 0) {
+                callbacks.shift()(Module);
+            } };
+            var onPostRuns = [];
+            var addOnPostRun = cb => onPostRuns.push(cb);
+            var onPreRuns = [];
+            var addOnPreRun = cb => onPreRuns.push(cb);
+            var stackRestore = val => __emscripten_stack_restore(val);
+            var stackSave = () => _emscripten_stack_get_current();
+            var syscallGetVarargI = () => { var ret = HEAP32[+SYSCALLS.varargs >> 2]; SYSCALLS.varargs += 4; return ret; };
+            var PATH = { isAbs: path => path.charAt(0) === "/", splitPath: filename => { var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; return splitPathRe.exec(filename).slice(1); }, normalizeArray: (parts, allowAboveRoot) => { var up = 0; for (var i = parts.length - 1; i >= 0; i--) {
+                    var last = parts[i];
+                    if (last === ".") {
+                        parts.splice(i, 1);
+                    }
+                    else if (last === "..") {
+                        parts.splice(i, 1);
+                        up++;
+                    }
+                    else if (up) {
+                        parts.splice(i, 1);
+                        up--;
+                    }
+                } if (allowAboveRoot) {
+                    for (; up; up--) {
+                        parts.unshift("..");
+                    }
+                } return parts; }, normalize: path => { var isAbsolute = PATH.isAbs(path), trailingSlash = path.slice(-1) === "/"; path = PATH.normalizeArray(path.split("/").filter(p => !!p), !isAbsolute).join("/"); if (!path && !isAbsolute) {
+                    path = ".";
+                } if (path && trailingSlash) {
+                    path += "/";
+                } return (isAbsolute ? "/" : "") + path; }, dirname: path => { var result = PATH.splitPath(path), root = result[0], dir = result[1]; if (!root && !dir) {
+                    return ".";
+                } if (dir) {
+                    dir = dir.slice(0, -1);
+                } return root + dir; }, basename: path => path && path.match(/([^\/]+|\/)\/*$/)[1], join: (...paths) => PATH.normalize(paths.join("/")), join2: (l, r) => PATH.normalize(l + "/" + r) };
+            var initRandomFill = () => { if (ENVIRONMENT_IS_NODE) {
+                var nodeCrypto = require$1("node:crypto");
+                return view => nodeCrypto.randomFillSync(view);
+            } return view => crypto.getRandomValues(view); };
+            var randomFill = view => { (randomFill = initRandomFill())(view); };
+            var PATH_FS = { resolve: (...args) => { var resolvedPath = "", resolvedAbsolute = false; for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+                    var path = i >= 0 ? args[i] : FS.cwd();
+                    if (typeof path != "string") {
+                        throw new TypeError("Arguments to path.resolve must be strings");
+                    }
+                    else if (!path) {
+                        return "";
+                    }
+                    resolvedPath = path + "/" + resolvedPath;
+                    resolvedAbsolute = PATH.isAbs(path);
+                } resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/"); return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; }, relative: (from, to) => { from = PATH_FS.resolve(from).slice(1); to = PATH_FS.resolve(to).slice(1); function trim(arr) { var start = 0; for (; start < arr.length; start++) {
+                    if (arr[start] !== "")
+                        break;
+                } var end = arr.length - 1; for (; end >= 0; end--) {
+                    if (arr[end] !== "")
+                        break;
+                } if (start > end)
+                    return []; return arr.slice(start, end - start + 1); } var fromParts = trim(from.split("/")); var toParts = trim(to.split("/")); var length = Math.min(fromParts.length, toParts.length); var samePartsLength = length; for (var i = 0; i < length; i++) {
+                    if (fromParts[i] !== toParts[i]) {
+                        samePartsLength = i;
+                        break;
+                    }
+                } var outputParts = []; for (var i = samePartsLength; i < fromParts.length; i++) {
+                    outputParts.push("..");
+                } outputParts = outputParts.concat(toParts.slice(samePartsLength)); return outputParts.join("/"); } };
+            var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
+            var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { var maxIdx = idx + maxBytesToRead; while (heapOrArray[idx] && !(idx >= maxIdx))
+                ++idx; return idx; };
+            var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead); if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+            } var str = ""; while (idx < endPtr) {
+                var u0 = heapOrArray[idx++];
+                if (!(u0 & 128)) {
+                    str += String.fromCharCode(u0);
+                    continue;
+                }
+                var u1 = heapOrArray[idx++] & 63;
+                if ((u0 & 224) == 192) {
+                    str += String.fromCharCode((u0 & 31) << 6 | u1);
+                    continue;
+                }
+                var u2 = heapOrArray[idx++] & 63;
+                if ((u0 & 240) == 224) {
+                    u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+                }
+                else {
+                    u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+                }
+                if (u0 < 65536) {
+                    str += String.fromCharCode(u0);
+                }
+                else {
+                    var ch = u0 - 65536;
+                    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+                }
+            } return str; };
+            var FS_stdin_getChar_buffer = [];
+            var lengthBytesUTF8 = str => { var len = 0; for (var i = 0; i < str.length; ++i) {
+                var c = str.charCodeAt(i);
+                if (c <= 127) {
+                    len++;
+                }
+                else if (c <= 2047) {
+                    len += 2;
+                }
+                else if (c >= 55296 && c <= 57343) {
+                    len += 4;
+                    ++i;
+                }
+                else {
+                    len += 3;
+                }
+            } return len; };
+            var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { if (!(maxBytesToWrite > 0))
+                return 0; var startIdx = outIdx; var endIdx = outIdx + maxBytesToWrite - 1; for (var i = 0; i < str.length; ++i) {
+                var u = str.codePointAt(i);
+                if (u <= 127) {
+                    if (outIdx >= endIdx)
+                        break;
+                    heap[outIdx++] = u;
+                }
+                else if (u <= 2047) {
+                    if (outIdx + 1 >= endIdx)
+                        break;
+                    heap[outIdx++] = 192 | u >> 6;
+                    heap[outIdx++] = 128 | u & 63;
+                }
+                else if (u <= 65535) {
+                    if (outIdx + 2 >= endIdx)
+                        break;
+                    heap[outIdx++] = 224 | u >> 12;
+                    heap[outIdx++] = 128 | u >> 6 & 63;
+                    heap[outIdx++] = 128 | u & 63;
+                }
+                else {
+                    if (outIdx + 3 >= endIdx)
+                        break;
+                    heap[outIdx++] = 240 | u >> 18;
+                    heap[outIdx++] = 128 | u >> 12 & 63;
+                    heap[outIdx++] = 128 | u >> 6 & 63;
+                    heap[outIdx++] = 128 | u & 63;
+                    i++;
+                }
+            } heap[outIdx] = 0; return outIdx - startIdx; };
+            var intArrayFromString = (stringy, dontAddNull, length) => { var len = lengthBytesUTF8(stringy) + 1; var u8array = new Array(len); var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); u8array.length = numBytesWritten; return u8array; };
+            var FS_stdin_getChar = () => { var _a; if (!FS_stdin_getChar_buffer.length) {
+                var result = null;
+                if (ENVIRONMENT_IS_NODE) {
+                    var BUFSIZE = 256;
+                    var buf = Buffer.alloc(BUFSIZE);
+                    var bytesRead = 0;
+                    var fd = process.stdin.fd;
+                    try {
+                        bytesRead = fs.readSync(fd, buf, 0, BUFSIZE);
+                    }
+                    catch (e) {
+                        if (e.toString().includes("EOF"))
+                            bytesRead = 0;
+                        else
+                            throw e;
+                    }
+                    if (bytesRead > 0) {
+                        result = buf.slice(0, bytesRead).toString("utf-8");
+                    }
+                }
+                else if ((_a = globalThis.window) === null || _a === void 0 ? void 0 : _a.prompt) {
+                    result = window.prompt("Input: ");
+                    if (result !== null) {
+                        result += "\n";
+                    }
+                }
+                else ;
+                if (!result) {
+                    return null;
+                }
+                FS_stdin_getChar_buffer = intArrayFromString(result);
+            } return FS_stdin_getChar_buffer.shift(); };
+            var TTY = { ttys: [], init() { }, shutdown() { }, register(dev, ops) { TTY.ttys[dev] = { input: [], output: [], ops }; FS.registerDevice(dev, TTY.stream_ops); }, stream_ops: { open(stream) { var tty = TTY.ttys[stream.node.rdev]; if (!tty) {
+                        throw new FS.ErrnoError(43);
+                    } stream.tty = tty; stream.seekable = false; }, close(stream) { stream.tty.ops.fsync(stream.tty); }, fsync(stream) { stream.tty.ops.fsync(stream.tty); }, read(stream, buffer, offset, length, pos) { if (!stream.tty || !stream.tty.ops.get_char) {
+                        throw new FS.ErrnoError(60);
+                    } var bytesRead = 0; for (var i = 0; i < length; i++) {
+                        var result;
+                        try {
+                            result = stream.tty.ops.get_char(stream.tty);
+                        }
+                        catch (e) {
+                            throw new FS.ErrnoError(29);
+                        }
+                        if (result === undefined && bytesRead === 0) {
+                            throw new FS.ErrnoError(6);
+                        }
+                        if (result === null || result === undefined)
+                            break;
+                        bytesRead++;
+                        buffer[offset + i] = result;
+                    } if (bytesRead) {
+                        stream.node.atime = Date.now();
+                    } return bytesRead; }, write(stream, buffer, offset, length, pos) { if (!stream.tty || !stream.tty.ops.put_char) {
+                        throw new FS.ErrnoError(60);
+                    } try {
+                        for (var i = 0; i < length; i++) {
+                            stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+                        }
+                    }
+                    catch (e) {
+                        throw new FS.ErrnoError(29);
+                    } if (length) {
+                        stream.node.mtime = stream.node.ctime = Date.now();
+                    } return i; } }, default_tty_ops: { get_char(tty) { return FS_stdin_getChar(); }, put_char(tty, val) { if (val === null || val === 10) {
+                        out(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    }
+                    else {
+                        if (val != 0)
+                            tty.output.push(val);
+                    } }, fsync(tty) { var _a; if (((_a = tty.output) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                        out(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    } }, ioctl_tcgets(tty) { return { c_iflag: 25856, c_oflag: 5, c_cflag: 191, c_lflag: 35387, c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }; }, ioctl_tcsets(tty, optional_actions, data) { return 0; }, ioctl_tiocgwinsz(tty) { return [24, 80]; } }, default_tty1_ops: { put_char(tty, val) { if (val === null || val === 10) {
+                        err(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    }
+                    else {
+                        if (val != 0)
+                            tty.output.push(val);
+                    } }, fsync(tty) { var _a; if (((_a = tty.output) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                        err(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    } } } };
+            var mmapAlloc = size => { abort(); };
+            var MEMFS = { ops_table: null, mount(mount) { return MEMFS.createNode(null, "/", 16895, 0); }, createNode(parent, name, mode, dev) { var _a; if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+                    throw new FS.ErrnoError(63);
+                } MEMFS.ops_table || (MEMFS.ops_table = { dir: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, lookup: MEMFS.node_ops.lookup, mknod: MEMFS.node_ops.mknod, rename: MEMFS.node_ops.rename, unlink: MEMFS.node_ops.unlink, rmdir: MEMFS.node_ops.rmdir, readdir: MEMFS.node_ops.readdir, symlink: MEMFS.node_ops.symlink }, stream: { llseek: MEMFS.stream_ops.llseek } }, file: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: { llseek: MEMFS.stream_ops.llseek, read: MEMFS.stream_ops.read, write: MEMFS.stream_ops.write, mmap: MEMFS.stream_ops.mmap, msync: MEMFS.stream_ops.msync } }, link: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, readlink: MEMFS.node_ops.readlink }, stream: {} }, chrdev: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: FS.chrdev_stream_ops } }); var node = FS.createNode(parent, name, mode, dev); if (FS.isDir(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.dir.node;
+                    node.stream_ops = MEMFS.ops_table.dir.stream;
+                    node.contents = {};
+                }
+                else if (FS.isFile(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.file.node;
+                    node.stream_ops = MEMFS.ops_table.file.stream;
+                    node.usedBytes = 0;
+                    node.contents = (_a = MEMFS.emptyFileContents) !== null && _a !== void 0 ? _a : (MEMFS.emptyFileContents = new Uint8Array(0));
+                }
+                else if (FS.isLink(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.link.node;
+                    node.stream_ops = MEMFS.ops_table.link.stream;
+                }
+                else if (FS.isChrdev(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.chrdev.node;
+                    node.stream_ops = MEMFS.ops_table.chrdev.stream;
+                } node.atime = node.mtime = node.ctime = Date.now(); if (parent) {
+                    parent.contents[name] = node;
+                    parent.atime = parent.mtime = parent.ctime = node.atime;
+                } return node; }, getFileDataAsTypedArray(node) { return node.contents.subarray(0, node.usedBytes); }, expandFileStorage(node, newCapacity) { var prevCapacity = node.contents.length; if (prevCapacity >= newCapacity)
+                    return; var CAPACITY_DOUBLING_MAX = 1024 * 1024; newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0); if (prevCapacity)
+                    newCapacity = Math.max(newCapacity, 256); var oldContents = MEMFS.getFileDataAsTypedArray(node); node.contents = new Uint8Array(newCapacity); node.contents.set(oldContents); }, resizeFileStorage(node, newSize) { if (node.usedBytes == newSize)
+                    return; var oldContents = node.contents; node.contents = new Uint8Array(newSize); node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); node.usedBytes = newSize; }, node_ops: { getattr(node) { var attr = {}; attr.dev = FS.isChrdev(node.mode) ? node.id : 1; attr.ino = node.id; attr.mode = node.mode; attr.nlink = 1; attr.uid = 0; attr.gid = 0; attr.rdev = node.rdev; if (FS.isDir(node.mode)) {
+                        attr.size = 4096;
+                    }
+                    else if (FS.isFile(node.mode)) {
+                        attr.size = node.usedBytes;
+                    }
+                    else if (FS.isLink(node.mode)) {
+                        attr.size = node.link.length;
+                    }
+                    else {
+                        attr.size = 0;
+                    } attr.atime = new Date(node.atime); attr.mtime = new Date(node.mtime); attr.ctime = new Date(node.ctime); attr.blksize = 4096; attr.blocks = Math.ceil(attr.size / attr.blksize); return attr; }, setattr(node, attr) { for (const key of ["mode", "atime", "mtime", "ctime"]) {
+                        if (attr[key] != null) {
+                            node[key] = attr[key];
+                        }
+                    } if (attr.size !== undefined) {
+                        MEMFS.resizeFileStorage(node, attr.size);
+                    } }, lookup(parent, name) { if (!MEMFS.doesNotExistError) {
+                        MEMFS.doesNotExistError = new FS.ErrnoError(44);
+                        MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+                    } throw MEMFS.doesNotExistError; }, mknod(parent, name, mode, dev) { return MEMFS.createNode(parent, name, mode, dev); }, rename(old_node, new_dir, new_name) { var new_node; try {
+                        new_node = FS.lookupNode(new_dir, new_name);
+                    }
+                    catch (e) { } if (new_node) {
+                        if (FS.isDir(old_node.mode)) {
+                            for (var i in new_node.contents) {
+                                throw new FS.ErrnoError(55);
+                            }
+                        }
+                        FS.hashRemoveNode(new_node);
+                    } delete old_node.parent.contents[old_node.name]; new_dir.contents[new_name] = old_node; old_node.name = new_name; new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now(); }, unlink(parent, name) { delete parent.contents[name]; parent.ctime = parent.mtime = Date.now(); }, rmdir(parent, name) { var node = FS.lookupNode(parent, name); for (var i in node.contents) {
+                        throw new FS.ErrnoError(55);
+                    } delete parent.contents[name]; parent.ctime = parent.mtime = Date.now(); }, readdir(node) { return [".", "..", ...Object.keys(node.contents)]; }, symlink(parent, newname, oldpath) { var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); node.link = oldpath; return node; }, readlink(node) { if (!FS.isLink(node.mode)) {
+                        throw new FS.ErrnoError(28);
+                    } return node.link; } }, stream_ops: { read(stream, buffer, offset, length, position) { var contents = stream.node.contents; if (position >= stream.node.usedBytes)
+                        return 0; var size = Math.min(stream.node.usedBytes - position, length); buffer.set(contents.subarray(position, position + size), offset); return size; }, write(stream, buffer, offset, length, position, canOwn) { if (buffer.buffer === HEAP8.buffer) {
+                        canOwn = false;
+                    } if (!length)
+                        return 0; var node = stream.node; node.mtime = node.ctime = Date.now(); if (canOwn) {
+                        node.contents = buffer.subarray(offset, offset + length);
+                        node.usedBytes = length;
+                    }
+                    else if (node.usedBytes === 0 && position === 0) {
+                        node.contents = buffer.slice(offset, offset + length);
+                        node.usedBytes = length;
+                    }
+                    else {
+                        MEMFS.expandFileStorage(node, position + length);
+                        node.contents.set(buffer.subarray(offset, offset + length), position);
+                        node.usedBytes = Math.max(node.usedBytes, position + length);
+                    } return length; }, llseek(stream, offset, whence) { var position = offset; if (whence === 1) {
+                        position += stream.position;
+                    }
+                    else if (whence === 2) {
+                        if (FS.isFile(stream.node.mode)) {
+                            position += stream.node.usedBytes;
+                        }
+                    } if (position < 0) {
+                        throw new FS.ErrnoError(28);
+                    } return position; }, mmap(stream, length, position, prot, flags) { if (!FS.isFile(stream.node.mode)) {
+                        throw new FS.ErrnoError(43);
+                    } var ptr; var allocated; var contents = stream.node.contents; if (!(flags & 2) && contents.buffer === HEAP8.buffer) {
+                        allocated = false;
+                        ptr = contents.byteOffset;
+                    }
+                    else {
+                        allocated = true;
+                        ptr = mmapAlloc();
+                        if (!ptr) {
+                            throw new FS.ErrnoError(48);
+                        }
+                        if (contents) {
+                            if (position > 0 || position + length < contents.length) {
+                                if (contents.subarray) {
+                                    contents = contents.subarray(position, position + length);
+                                }
+                                else {
+                                    contents = Array.prototype.slice.call(contents, position, position + length);
+                                }
+                            }
+                            HEAP8.set(contents, ptr);
+                        }
+                    } return { ptr, allocated }; }, msync(stream, buffer, offset, length, mmapFlags) { MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); return 0; } } };
+            var FS_modeStringToFlags = str => { if (typeof str != "string")
+                return str; var flagModes = { r: 0, "r+": 2, w: 512 | 64 | 1, "w+": 512 | 64 | 2, a: 1024 | 64 | 1, "a+": 1024 | 64 | 2 }; var flags = flagModes[str]; if (typeof flags == "undefined") {
+                throw new Error(`Unknown file open mode: ${str}`);
+            } return flags; };
+            var FS_fileDataToTypedArray = data => { if (typeof data == "string") {
+                data = intArrayFromString(data);
+            } if (!data.subarray) {
+                data = new Uint8Array(data);
+            } return data; };
+            var FS_getMode = (canRead, canWrite) => { var mode = 0; if (canRead)
+                mode |= 292 | 73; if (canWrite)
+                mode |= 146; return mode; };
+            var asyncLoad = (url) => tslib_es6.__awaiter(this, void 0, void 0, function* () { var arrayBuffer = yield readAsync(url); return new Uint8Array(arrayBuffer); });
+            var FS_createDataFile = (...args) => FS.createDataFile(...args);
+            var runDependencies = 0;
+            var dependenciesFulfilled = null;
+            var removeRunDependency = id => { var _a; runDependencies--; (_a = Module["monitorRunDependencies"]) === null || _a === void 0 ? void 0 : _a.call(Module, runDependencies); if (runDependencies == 0) {
+                if (dependenciesFulfilled) {
+                    var callback = dependenciesFulfilled;
+                    dependenciesFulfilled = null;
+                    callback();
+                }
+            } };
+            var addRunDependency = id => { var _a; runDependencies++; (_a = Module["monitorRunDependencies"]) === null || _a === void 0 ? void 0 : _a.call(Module, runDependencies); };
+            var preloadPlugins = [];
+            var FS_handledByPreloadPlugin = (byteArray, fullname) => tslib_es6.__awaiter(this, void 0, void 0, function* () { if (typeof Browser != "undefined")
+                Browser.init(); for (var plugin of preloadPlugins) {
+                if (plugin["canHandle"](fullname)) {
+                    return plugin["handle"](byteArray, fullname);
+                }
+            } return byteArray; });
+            var FS_preloadFile = (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => tslib_es6.__awaiter(this, void 0, void 0, function* () { var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; addRunDependency(); try {
+                var byteArray = url;
+                if (typeof url == "string") {
+                    byteArray = yield asyncLoad(url);
+                }
+                byteArray = yield FS_handledByPreloadPlugin(byteArray, fullname);
+                preFinish === null || preFinish === void 0 ? void 0 : preFinish();
+                if (!dontCreateFile) {
+                    FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+                }
+            }
+            finally {
+                removeRunDependency();
+            } });
+            var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish).then(onload).catch(onerror); };
+            var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, ErrnoError: class {
+                    constructor(errno) {
+                        this.name = "ErrnoError";
+                        this.errno = errno;
+                    }
+                }, FSStream: class {
+                    constructor() {
+                        this.shared = {};
+                    }
+                    get object() { return this.node; }
+                    set object(val) { this.node = val; }
+                    get isRead() { return (this.flags & 2097155) !== 1; }
+                    get isWrite() { return (this.flags & 2097155) !== 0; }
+                    get isAppend() { return this.flags & 1024; }
+                    get flags() { return this.shared.flags; }
+                    set flags(val) { this.shared.flags = val; }
+                    get position() { return this.shared.position; }
+                    set position(val) { this.shared.position = val; }
+                }, FSNode: class {
+                    constructor(parent, name, mode, rdev) {
+                        this.node_ops = {};
+                        this.stream_ops = {};
+                        this.readMode = 292 | 73;
+                        this.writeMode = 146;
+                        this.mounted = null;
+                        if (!parent) {
+                            parent = this;
+                        }
+                        this.parent = parent;
+                        this.mount = parent.mount;
+                        this.id = FS.nextInode++;
+                        this.name = name;
+                        this.mode = mode;
+                        this.rdev = rdev;
+                        this.atime = this.mtime = this.ctime = Date.now();
+                    }
+                    get read() { return (this.mode & this.readMode) === this.readMode; }
+                    set read(val) { val ? this.mode |= this.readMode : this.mode &= ~this.readMode; }
+                    get write() { return (this.mode & this.writeMode) === this.writeMode; }
+                    set write(val) { val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode; }
+                    get isFolder() { return FS.isDir(this.mode); }
+                    get isDevice() { return FS.isChrdev(this.mode); }
+                }, lookupPath(path, opts = {}) { var _a; if (!path) {
+                    throw new FS.ErrnoError(44);
+                } (_a = opts.follow_mount) !== null && _a !== void 0 ? _a : (opts.follow_mount = true); if (!PATH.isAbs(path)) {
+                    path = FS.cwd() + "/" + path;
+                } linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
+                    var parts = path.split("/").filter(p => !!p);
+                    var current = FS.root;
+                    var current_path = "/";
+                    for (var i = 0; i < parts.length; i++) {
+                        var islast = i === parts.length - 1;
+                        if (islast && opts.parent) {
+                            break;
+                        }
+                        if (parts[i] === ".") {
+                            continue;
+                        }
+                        if (parts[i] === "..") {
+                            current_path = PATH.dirname(current_path);
+                            if (FS.isRoot(current)) {
+                                path = current_path + "/" + parts.slice(i + 1).join("/");
+                                nlinks--;
+                                continue linkloop;
+                            }
+                            else {
+                                current = current.parent;
+                            }
+                            continue;
+                        }
+                        current_path = PATH.join2(current_path, parts[i]);
+                        try {
+                            current = FS.lookupNode(current, parts[i]);
+                        }
+                        catch (e) {
+                            if ((e === null || e === void 0 ? void 0 : e.errno) === 44 && islast && opts.noent_okay) {
+                                return { path: current_path };
+                            }
+                            throw e;
+                        }
+                        if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
+                            current = current.mounted.root;
+                        }
+                        if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+                            if (!current.node_ops.readlink) {
+                                throw new FS.ErrnoError(52);
+                            }
+                            var link = current.node_ops.readlink(current);
+                            if (!PATH.isAbs(link)) {
+                                link = PATH.dirname(current_path) + "/" + link;
+                            }
+                            path = link + "/" + parts.slice(i + 1).join("/");
+                            continue linkloop;
+                        }
+                    }
+                    return { path: current_path, node: current };
+                } throw new FS.ErrnoError(32); }, getPath(node) { var path; while (true) {
+                    if (FS.isRoot(node)) {
+                        var mount = node.mount.mountpoint;
+                        if (!path)
+                            return mount;
+                        return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
+                    }
+                    path = path ? `${node.name}/${path}` : node.name;
+                    node = node.parent;
+                } }, hashName(parentid, name) { var hash = 0; for (var i = 0; i < name.length; i++) {
+                    hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+                } return (parentid + hash >>> 0) % FS.nameTable.length; }, hashAddNode(node) { var hash = FS.hashName(node.parent.id, node.name); node.name_next = FS.nameTable[hash]; FS.nameTable[hash] = node; }, hashRemoveNode(node) { var hash = FS.hashName(node.parent.id, node.name); if (FS.nameTable[hash] === node) {
+                    FS.nameTable[hash] = node.name_next;
+                }
+                else {
+                    var current = FS.nameTable[hash];
+                    while (current) {
+                        if (current.name_next === node) {
+                            current.name_next = node.name_next;
+                            break;
+                        }
+                        current = current.name_next;
+                    }
+                } }, lookupNode(parent, name) { var errCode = FS.mayLookup(parent); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } var hash = FS.hashName(parent.id, name); for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+                    var nodeName = node.name;
+                    if (node.parent.id === parent.id && nodeName === name) {
+                        return node;
+                    }
+                } return FS.lookup(parent, name); }, createNode(parent, name, mode, rdev) { var node = new FS.FSNode(parent, name, mode, rdev); FS.hashAddNode(node); return node; }, destroyNode(node) { FS.hashRemoveNode(node); }, isRoot(node) { return node === node.parent; }, isMountpoint(node) { return !!node.mounted; }, isFile(mode) { return (mode & 61440) === 32768; }, isDir(mode) { return (mode & 61440) === 16384; }, isLink(mode) { return (mode & 61440) === 40960; }, isChrdev(mode) { return (mode & 61440) === 8192; }, isBlkdev(mode) { return (mode & 61440) === 24576; }, isFIFO(mode) { return (mode & 61440) === 4096; }, isSocket(mode) { return (mode & 49152) === 49152; }, flagsToPermissionString(flag) { var perms = ["r", "w", "rw"][flag & 3]; if (flag & 512) {
+                    perms += "w";
+                } return perms; }, nodePermissions(node, perms) { if (FS.ignorePermissions) {
+                    return 0;
+                } if (perms.includes("r") && !(node.mode & 292)) {
+                    return 2;
+                } if (perms.includes("w") && !(node.mode & 146)) {
+                    return 2;
+                } if (perms.includes("x") && !(node.mode & 73)) {
+                    return 2;
+                } return 0; }, mayLookup(dir) { if (!FS.isDir(dir.mode))
+                    return 54; var errCode = FS.nodePermissions(dir, "x"); if (errCode)
+                    return errCode; if (!dir.node_ops.lookup)
+                    return 2; return 0; }, mayCreate(dir, name) { if (!FS.isDir(dir.mode)) {
+                    return 54;
+                } try {
+                    var node = FS.lookupNode(dir, name);
+                    return 20;
+                }
+                catch (e) { } return FS.nodePermissions(dir, "wx"); }, mayDelete(dir, name, isdir) { var node; try {
+                    node = FS.lookupNode(dir, name);
+                }
+                catch (e) {
+                    return e.errno;
+                } var errCode = FS.nodePermissions(dir, "wx"); if (errCode) {
+                    return errCode;
+                } if (isdir) {
+                    if (!FS.isDir(node.mode)) {
+                        return 54;
+                    }
+                    if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+                        return 10;
+                    }
+                }
+                else if (FS.isDir(node.mode)) {
+                    return 31;
+                } return 0; }, mayOpen(node, flags) { if (!node) {
+                    return 44;
+                } if (FS.isLink(node.mode)) {
+                    return 32;
+                } var mode = FS.flagsToPermissionString(flags); if (FS.isDir(node.mode)) {
+                    if (mode !== "r" || flags & (512 | 64)) {
+                        return 31;
+                    }
+                } return FS.nodePermissions(node, mode); }, checkOpExists(op, err) { if (!op) {
+                    throw new FS.ErrnoError(err);
+                } return op; }, MAX_OPEN_FDS: 4096, nextfd() { for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
+                    if (!FS.streams[fd]) {
+                        return fd;
+                    }
+                } throw new FS.ErrnoError(33); }, getStreamChecked(fd) { var stream = FS.getStream(fd); if (!stream) {
+                    throw new FS.ErrnoError(8);
+                } return stream; }, getStream: fd => FS.streams[fd], createStream(stream, fd = -1) { stream = Object.assign(new FS.FSStream, stream); if (fd == -1) {
+                    fd = FS.nextfd();
+                } stream.fd = fd; FS.streams[fd] = stream; return stream; }, closeStream(fd) { FS.streams[fd] = null; }, dupStream(origStream, fd = -1) { var _a, _b; var stream = FS.createStream(origStream, fd); (_b = (_a = stream.stream_ops) === null || _a === void 0 ? void 0 : _a.dup) === null || _b === void 0 ? void 0 : _b.call(_a, stream); return stream; }, doSetAttr(stream, node, attr) { var setattr = stream === null || stream === void 0 ? void 0 : stream.stream_ops.setattr; var arg = setattr ? stream : node; setattr !== null && setattr !== void 0 ? setattr : (setattr = node.node_ops.setattr); FS.checkOpExists(setattr, 63); setattr(arg, attr); }, chrdev_stream_ops: { open(stream) { var _a, _b; var device = FS.getDevice(stream.node.rdev); stream.stream_ops = device.stream_ops; (_b = (_a = stream.stream_ops).open) === null || _b === void 0 ? void 0 : _b.call(_a, stream); }, llseek() { throw new FS.ErrnoError(70); } }, major: dev => dev >> 8, minor: dev => dev & 255, makedev: (ma, mi) => ma << 8 | mi, registerDevice(dev, ops) { FS.devices[dev] = { stream_ops: ops }; }, getDevice: dev => FS.devices[dev], getMounts(mount) { var mounts = []; var check = [mount]; while (check.length) {
+                    var m = check.pop();
+                    mounts.push(m);
+                    check.push(...m.mounts);
+                } return mounts; }, syncfs(populate, callback) { if (typeof populate == "function") {
+                    callback = populate;
+                    populate = false;
+                } FS.syncFSRequests++; if (FS.syncFSRequests > 1) {
+                    err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
+                } var mounts = FS.getMounts(FS.root.mount); var completed = 0; function doCallback(errCode) { FS.syncFSRequests--; return callback(errCode); } function done(errCode) { if (errCode) {
+                    if (!done.errored) {
+                        done.errored = true;
+                        return doCallback(errCode);
+                    }
+                    return;
+                } if (++completed >= mounts.length) {
+                    doCallback(null);
+                } } for (var mount of mounts) {
+                    if (mount.type.syncfs) {
+                        mount.type.syncfs(mount, populate, done);
+                    }
+                    else {
+                        done(null);
+                    }
+                } }, mount(type, opts, mountpoint) { var root = mountpoint === "/"; var pseudo = !mountpoint; var node; if (root && FS.root) {
+                    throw new FS.ErrnoError(10);
+                }
+                else if (!root && !pseudo) {
+                    var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+                    mountpoint = lookup.path;
+                    node = lookup.node;
+                    if (FS.isMountpoint(node)) {
+                        throw new FS.ErrnoError(10);
+                    }
+                    if (!FS.isDir(node.mode)) {
+                        throw new FS.ErrnoError(54);
+                    }
+                } var mount = { type, opts, mountpoint, mounts: [] }; var mountRoot = type.mount(mount); mountRoot.mount = mount; mount.root = mountRoot; if (root) {
+                    FS.root = mountRoot;
+                }
+                else if (node) {
+                    node.mounted = mount;
+                    if (node.mount) {
+                        node.mount.mounts.push(mount);
+                    }
+                } return mountRoot; }, unmount(mountpoint) { var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); if (!FS.isMountpoint(lookup.node)) {
+                    throw new FS.ErrnoError(28);
+                } var node = lookup.node; var mount = node.mounted; var mounts = FS.getMounts(mount); for (var [hash, current] of Object.entries(FS.nameTable)) {
+                    while (current) {
+                        var next = current.name_next;
+                        if (mounts.includes(current.mount)) {
+                            FS.destroyNode(current);
+                        }
+                        current = next;
+                    }
+                } node.mounted = null; var idx = node.mount.mounts.indexOf(mount); node.mount.mounts.splice(idx, 1); }, lookup(parent, name) { return parent.node_ops.lookup(parent, name); }, mknod(path, mode, dev) { var lookup = FS.lookupPath(path, { parent: true }); var parent = lookup.node; var name = PATH.basename(path); if (!name) {
+                    throw new FS.ErrnoError(28);
+                } if (name === "." || name === "..") {
+                    throw new FS.ErrnoError(20);
+                } var errCode = FS.mayCreate(parent, name); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.mknod) {
+                    throw new FS.ErrnoError(63);
+                } return parent.node_ops.mknod(parent, name, mode, dev); }, statfs(path) { return FS.statfsNode(FS.lookupPath(path, { follow: true }).node); }, statfsStream(stream) { return FS.statfsNode(stream.node); }, statfsNode(node) { var rtn = { bsize: 4096, frsize: 4096, blocks: 1e6, bfree: 5e5, bavail: 5e5, files: FS.nextInode, ffree: FS.nextInode - 1, fsid: 42, flags: 2, namelen: 255 }; if (node.node_ops.statfs) {
+                    Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
+                } return rtn; }, create(path, mode = 438) { mode &= 4095; mode |= 32768; return FS.mknod(path, mode, 0); }, mkdir(path, mode = 511) { mode &= 511 | 512; mode |= 16384; return FS.mknod(path, mode, 0); }, mkdirTree(path, mode) { var dirs = path.split("/"); var d = ""; for (var dir of dirs) {
+                    if (!dir)
+                        continue;
+                    if (d || PATH.isAbs(path))
+                        d += "/";
+                    d += dir;
+                    try {
+                        FS.mkdir(d, mode);
+                    }
+                    catch (e) {
+                        if (e.errno != 20)
+                            throw e;
+                    }
+                } }, mkdev(path, mode, dev) { if (typeof dev == "undefined") {
+                    dev = mode;
+                    mode = 438;
+                } mode |= 8192; return FS.mknod(path, mode, dev); }, symlink(oldpath, newpath) { if (!PATH_FS.resolve(oldpath)) {
+                    throw new FS.ErrnoError(44);
+                } var lookup = FS.lookupPath(newpath, { parent: true }); var parent = lookup.node; if (!parent) {
+                    throw new FS.ErrnoError(44);
+                } var newname = PATH.basename(newpath); var errCode = FS.mayCreate(parent, newname); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.symlink) {
+                    throw new FS.ErrnoError(63);
+                } return parent.node_ops.symlink(parent, newname, oldpath); }, rename(old_path, new_path) { var old_dirname = PATH.dirname(old_path); var new_dirname = PATH.dirname(new_path); var old_name = PATH.basename(old_path); var new_name = PATH.basename(new_path); var lookup, old_dir, new_dir; lookup = FS.lookupPath(old_path, { parent: true }); old_dir = lookup.node; lookup = FS.lookupPath(new_path, { parent: true }); new_dir = lookup.node; if (!old_dir || !new_dir)
+                    throw new FS.ErrnoError(44); if (old_dir.mount !== new_dir.mount) {
+                    throw new FS.ErrnoError(75);
+                } var old_node = FS.lookupNode(old_dir, old_name); var relative = PATH_FS.relative(old_path, new_dirname); if (relative.charAt(0) !== ".") {
+                    throw new FS.ErrnoError(28);
+                } relative = PATH_FS.relative(new_path, old_dirname); if (relative.charAt(0) !== ".") {
+                    throw new FS.ErrnoError(55);
+                } var new_node; try {
+                    new_node = FS.lookupNode(new_dir, new_name);
+                }
+                catch (e) { } if (old_node === new_node) {
+                    return;
+                } var isdir = FS.isDir(old_node.mode); var errCode = FS.mayDelete(old_dir, old_name, isdir); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!old_dir.node_ops.rename) {
+                    throw new FS.ErrnoError(63);
+                } if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
+                    throw new FS.ErrnoError(10);
+                } if (new_dir !== old_dir) {
+                    errCode = FS.nodePermissions(old_dir, "w");
+                    if (errCode) {
+                        throw new FS.ErrnoError(errCode);
+                    }
+                } FS.hashRemoveNode(old_node); try {
+                    old_dir.node_ops.rename(old_node, new_dir, new_name);
+                    old_node.parent = new_dir;
+                }
+                catch (e) {
+                    throw e;
+                }
+                finally {
+                    FS.hashAddNode(old_node);
+                } }, rmdir(path) { var lookup = FS.lookupPath(path, { parent: true }); var parent = lookup.node; var name = PATH.basename(path); var node = FS.lookupNode(parent, name); var errCode = FS.mayDelete(parent, name, true); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.rmdir) {
+                    throw new FS.ErrnoError(63);
+                } if (FS.isMountpoint(node)) {
+                    throw new FS.ErrnoError(10);
+                } parent.node_ops.rmdir(parent, name); FS.destroyNode(node); }, readdir(path) { var lookup = FS.lookupPath(path, { follow: true }); var node = lookup.node; var readdir = FS.checkOpExists(node.node_ops.readdir, 54); return readdir(node); }, unlink(path) { var lookup = FS.lookupPath(path, { parent: true }); var parent = lookup.node; if (!parent) {
+                    throw new FS.ErrnoError(44);
+                } var name = PATH.basename(path); var node = FS.lookupNode(parent, name); var errCode = FS.mayDelete(parent, name, false); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.unlink) {
+                    throw new FS.ErrnoError(63);
+                } if (FS.isMountpoint(node)) {
+                    throw new FS.ErrnoError(10);
+                } parent.node_ops.unlink(parent, name); FS.destroyNode(node); }, readlink(path) { var lookup = FS.lookupPath(path); var link = lookup.node; if (!link) {
+                    throw new FS.ErrnoError(44);
+                } if (!link.node_ops.readlink) {
+                    throw new FS.ErrnoError(28);
+                } return link.node_ops.readlink(link); }, stat(path, dontFollow) { var lookup = FS.lookupPath(path, { follow: !dontFollow }); var node = lookup.node; var getattr = FS.checkOpExists(node.node_ops.getattr, 63); return getattr(node); }, fstat(fd) { var stream = FS.getStreamChecked(fd); var node = stream.node; var getattr = stream.stream_ops.getattr; var arg = getattr ? stream : node; getattr !== null && getattr !== void 0 ? getattr : (getattr = node.node_ops.getattr); FS.checkOpExists(getattr, 63); return getattr(arg); }, lstat(path) { return FS.stat(path, true); }, doChmod(stream, node, mode, dontFollow) { FS.doSetAttr(stream, node, { mode: mode & 4095 | node.mode & -4096, ctime: Date.now(), dontFollow }); }, chmod(path, mode, dontFollow) { var node; if (typeof path == "string") {
+                    var lookup = FS.lookupPath(path, { follow: !dontFollow });
+                    node = lookup.node;
+                }
+                else {
+                    node = path;
+                } FS.doChmod(null, node, mode, dontFollow); }, lchmod(path, mode) { FS.chmod(path, mode, true); }, fchmod(fd, mode) { var stream = FS.getStreamChecked(fd); FS.doChmod(stream, stream.node, mode, false); }, doChown(stream, node, dontFollow) { FS.doSetAttr(stream, node, { timestamp: Date.now(), dontFollow }); }, chown(path, uid, gid, dontFollow) { var node; if (typeof path == "string") {
+                    var lookup = FS.lookupPath(path, { follow: !dontFollow });
+                    node = lookup.node;
+                }
+                else {
+                    node = path;
+                } FS.doChown(null, node, dontFollow); }, lchown(path, uid, gid) { FS.chown(path, uid, gid, true); }, fchown(fd, uid, gid) { var stream = FS.getStreamChecked(fd); FS.doChown(stream, stream.node, false); }, doTruncate(stream, node, len) { if (FS.isDir(node.mode)) {
+                    throw new FS.ErrnoError(31);
+                } if (!FS.isFile(node.mode)) {
+                    throw new FS.ErrnoError(28);
+                } var errCode = FS.nodePermissions(node, "w"); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } FS.doSetAttr(stream, node, { size: len, timestamp: Date.now() }); }, truncate(path, len) { if (len < 0) {
+                    throw new FS.ErrnoError(28);
+                } var node; if (typeof path == "string") {
+                    var lookup = FS.lookupPath(path, { follow: true });
+                    node = lookup.node;
+                }
+                else {
+                    node = path;
+                } FS.doTruncate(null, node, len); }, ftruncate(fd, len) { var stream = FS.getStreamChecked(fd); if (len < 0 || (stream.flags & 2097155) === 0) {
+                    throw new FS.ErrnoError(28);
+                } FS.doTruncate(stream, stream.node, len); }, utime(path, atime, mtime) { var lookup = FS.lookupPath(path, { follow: true }); var node = lookup.node; var setattr = FS.checkOpExists(node.node_ops.setattr, 63); setattr(node, { atime, mtime }); }, open(path, flags, mode = 438) { if (path === "") {
+                    throw new FS.ErrnoError(44);
+                } flags = FS_modeStringToFlags(flags); if (flags & 64) {
+                    mode = mode & 4095 | 32768;
+                }
+                else {
+                    mode = 0;
+                } var node; var isDirPath; if (typeof path == "object") {
+                    node = path;
+                }
+                else {
+                    isDirPath = path.endsWith("/");
+                    var lookup = FS.lookupPath(path, { follow: !(flags & 131072), noent_okay: true });
+                    node = lookup.node;
+                    path = lookup.path;
+                } var created = false; if (flags & 64) {
+                    if (node) {
+                        if (flags & 128) {
+                            throw new FS.ErrnoError(20);
+                        }
+                    }
+                    else if (isDirPath) {
+                        throw new FS.ErrnoError(31);
+                    }
+                    else {
+                        node = FS.mknod(path, mode | 511, 0);
+                        created = true;
+                    }
+                } if (!node) {
+                    throw new FS.ErrnoError(44);
+                } if (FS.isChrdev(node.mode)) {
+                    flags &= -513;
+                } if (flags & 65536 && !FS.isDir(node.mode)) {
+                    throw new FS.ErrnoError(54);
+                } if (!created) {
+                    var errCode = FS.mayOpen(node, flags);
+                    if (errCode) {
+                        throw new FS.ErrnoError(errCode);
+                    }
+                } if (flags & 512 && !created) {
+                    FS.truncate(node, 0);
+                } flags &= -131713; var stream = FS.createStream({ node, path: FS.getPath(node), flags, seekable: true, position: 0, stream_ops: node.stream_ops, ungotten: [], error: false }); if (stream.stream_ops.open) {
+                    stream.stream_ops.open(stream);
+                } if (created) {
+                    FS.chmod(node, mode & 511);
+                } return stream; }, close(stream) { if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if (stream.getdents)
+                    stream.getdents = null; try {
+                    if (stream.stream_ops.close) {
+                        stream.stream_ops.close(stream);
+                    }
+                }
+                catch (e) {
+                    throw e;
+                }
+                finally {
+                    FS.closeStream(stream.fd);
+                } stream.fd = null; }, isClosed(stream) { return stream.fd === null; }, llseek(stream, offset, whence) { if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if (!stream.seekable || !stream.stream_ops.llseek) {
+                    throw new FS.ErrnoError(70);
+                } if (whence != 0 && whence != 1 && whence != 2) {
+                    throw new FS.ErrnoError(28);
+                } stream.position = stream.stream_ops.llseek(stream, offset, whence); stream.ungotten = []; return stream.position; }, read(stream, buffer, offset, length, position) { if (length < 0 || position < 0) {
+                    throw new FS.ErrnoError(28);
+                } if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if ((stream.flags & 2097155) === 1) {
+                    throw new FS.ErrnoError(8);
+                } if (FS.isDir(stream.node.mode)) {
+                    throw new FS.ErrnoError(31);
+                } if (!stream.stream_ops.read) {
+                    throw new FS.ErrnoError(28);
+                } var seeking = typeof position != "undefined"; if (!seeking) {
+                    position = stream.position;
+                }
+                else if (!stream.seekable) {
+                    throw new FS.ErrnoError(70);
+                } var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); if (!seeking)
+                    stream.position += bytesRead; return bytesRead; }, write(stream, buffer, offset, length, position, canOwn) { if (length < 0 || position < 0) {
+                    throw new FS.ErrnoError(28);
+                } if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if ((stream.flags & 2097155) === 0) {
+                    throw new FS.ErrnoError(8);
+                } if (FS.isDir(stream.node.mode)) {
+                    throw new FS.ErrnoError(31);
+                } if (!stream.stream_ops.write) {
+                    throw new FS.ErrnoError(28);
+                } if (stream.seekable && stream.flags & 1024) {
+                    FS.llseek(stream, 0, 2);
+                } var seeking = typeof position != "undefined"; if (!seeking) {
+                    position = stream.position;
+                }
+                else if (!stream.seekable) {
+                    throw new FS.ErrnoError(70);
+                } var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); if (!seeking)
+                    stream.position += bytesWritten; return bytesWritten; }, mmap(stream, length, position, prot, flags) { if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
+                    throw new FS.ErrnoError(2);
+                } if ((stream.flags & 2097155) === 1) {
+                    throw new FS.ErrnoError(2);
+                } if (!stream.stream_ops.mmap) {
+                    throw new FS.ErrnoError(43);
+                } if (!length) {
+                    throw new FS.ErrnoError(28);
+                } return stream.stream_ops.mmap(stream, length, position, prot, flags); }, msync(stream, buffer, offset, length, mmapFlags) { if (!stream.stream_ops.msync) {
+                    return 0;
+                } return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); }, ioctl(stream, cmd, arg) { if (!stream.stream_ops.ioctl) {
+                    throw new FS.ErrnoError(59);
+                } return stream.stream_ops.ioctl(stream, cmd, arg); }, readFile(path, opts = {}) { opts.flags = opts.flags || 0; opts.encoding = opts.encoding || "binary"; if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
+                    abort(`Invalid encoding type "${opts.encoding}"`);
+                } var stream = FS.open(path, opts.flags); var stat = FS.stat(path); var length = stat.size; var buf = new Uint8Array(length); FS.read(stream, buf, 0, length, 0); if (opts.encoding === "utf8") {
+                    buf = UTF8ArrayToString(buf);
+                } FS.close(stream); return buf; }, writeFile(path, data, opts = {}) { opts.flags = opts.flags || 577; var stream = FS.open(path, opts.flags, opts.mode); data = FS_fileDataToTypedArray(data); FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); FS.close(stream); }, cwd: () => FS.currentPath, chdir(path) { var lookup = FS.lookupPath(path, { follow: true }); if (lookup.node === null) {
+                    throw new FS.ErrnoError(44);
+                } if (!FS.isDir(lookup.node.mode)) {
+                    throw new FS.ErrnoError(54);
+                } var errCode = FS.nodePermissions(lookup.node, "x"); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } FS.currentPath = lookup.path; }, createDefaultDirectories() { FS.mkdir("/tmp"); FS.mkdir("/home"); FS.mkdir("/home/web_user"); }, createDefaultDevices() { FS.mkdir("/dev"); FS.registerDevice(FS.makedev(1, 3), { read: () => 0, write: (stream, buffer, offset, length, pos) => length, llseek: () => 0 }); FS.mkdev("/dev/null", FS.makedev(1, 3)); TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); FS.mkdev("/dev/tty", FS.makedev(5, 0)); FS.mkdev("/dev/tty1", FS.makedev(6, 0)); var randomBuffer = new Uint8Array(1024), randomLeft = 0; var randomByte = () => { if (randomLeft === 0) {
+                    randomFill(randomBuffer);
+                    randomLeft = randomBuffer.byteLength;
+                } return randomBuffer[--randomLeft]; }; FS.createDevice("/dev", "random", randomByte); FS.createDevice("/dev", "urandom", randomByte); FS.mkdir("/dev/shm"); FS.mkdir("/dev/shm/tmp"); }, createSpecialDirectories() { FS.mkdir("/proc"); var proc_self = FS.mkdir("/proc/self"); FS.mkdir("/proc/self/fd"); FS.mount({ mount() { var node = FS.createNode(proc_self, "fd", 16895, 73); node.stream_ops = { llseek: MEMFS.stream_ops.llseek }; node.node_ops = { lookup(parent, name) { var fd = +name; var stream = FS.getStreamChecked(fd); var ret = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => stream.path }, id: fd + 1 }; ret.parent = ret; return ret; }, readdir() { return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString()); } }; return node; } }, {}, "/proc/self/fd"); }, createStandardStreams(input, output, error) { if (input) {
+                    FS.createDevice("/dev", "stdin", input);
+                }
+                else {
+                    FS.symlink("/dev/tty", "/dev/stdin");
+                } if (output) {
+                    FS.createDevice("/dev", "stdout", null, output);
+                }
+                else {
+                    FS.symlink("/dev/tty", "/dev/stdout");
+                } if (error) {
+                    FS.createDevice("/dev", "stderr", null, error);
+                }
+                else {
+                    FS.symlink("/dev/tty1", "/dev/stderr");
+                } FS.open("/dev/stdin", 0); FS.open("/dev/stdout", 1); FS.open("/dev/stderr", 1); }, staticInit() { FS.nameTable = new Array(4096); FS.mount(MEMFS, {}, "/"); FS.createDefaultDirectories(); FS.createDefaultDevices(); FS.createSpecialDirectories(); FS.filesystems = { MEMFS }; }, init(input, output, error) { FS.initialized = true; input !== null && input !== void 0 ? input : (input = Module["stdin"]); output !== null && output !== void 0 ? output : (output = Module["stdout"]); error !== null && error !== void 0 ? error : (error = Module["stderr"]); FS.createStandardStreams(input, output, error); }, quit() { FS.initialized = false; for (var stream of FS.streams) {
+                    if (stream) {
+                        FS.close(stream);
+                    }
+                } }, findObject(path, dontResolveLastLink) { var ret = FS.analyzePath(path, dontResolveLastLink); if (!ret.exists) {
+                    return null;
+                } return ret.object; }, analyzePath(path, dontResolveLastLink) { try {
+                    var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+                    path = lookup.path;
+                }
+                catch (e) { } var ret = { isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null }; try {
+                    var lookup = FS.lookupPath(path, { parent: true });
+                    ret.parentExists = true;
+                    ret.parentPath = lookup.path;
+                    ret.parentObject = lookup.node;
+                    ret.name = PATH.basename(path);
+                    lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+                    ret.exists = true;
+                    ret.path = lookup.path;
+                    ret.object = lookup.node;
+                    ret.name = lookup.node.name;
+                    ret.isRoot = lookup.path === "/";
+                }
+                catch (e) {
+                    ret.error = e.errno;
+                } return ret; }, createPath(parent, path, canRead, canWrite) { parent = typeof parent == "string" ? parent : FS.getPath(parent); var parts = path.split("/").reverse(); while (parts.length) {
+                    var part = parts.pop();
+                    if (!part)
+                        continue;
+                    var current = PATH.join2(parent, part);
+                    try {
+                        FS.mkdir(current);
+                    }
+                    catch (e) {
+                        if (e.errno != 20)
+                            throw e;
+                    }
+                    parent = current;
+                } return current; }, createFile(parent, name, properties, canRead, canWrite) { var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); var mode = FS_getMode(canRead, canWrite); return FS.create(path, mode); }, createDataFile(parent, name, data, canRead, canWrite, canOwn) { var path = name; if (parent) {
+                    parent = typeof parent == "string" ? parent : FS.getPath(parent);
+                    path = name ? PATH.join2(parent, name) : parent;
+                } var mode = FS_getMode(canRead, canWrite); var node = FS.create(path, mode); if (data) {
+                    data = FS_fileDataToTypedArray(data);
+                    FS.chmod(node, mode | 146);
+                    var stream = FS.open(node, 577);
+                    FS.write(stream, data, 0, data.length, 0, canOwn);
+                    FS.close(stream);
+                    FS.chmod(node, mode);
+                } }, createDevice(parent, name, input, output) { var _a; var _b; var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); var mode = FS_getMode(!!input, !!output); (_a = (_b = FS.createDevice).major) !== null && _a !== void 0 ? _a : (_b.major = 64); var dev = FS.makedev(FS.createDevice.major++, 0); FS.registerDevice(dev, { open(stream) { stream.seekable = false; }, close(stream) { var _a; if ((_a = output === null || output === void 0 ? void 0 : output.buffer) === null || _a === void 0 ? void 0 : _a.length) {
+                        output(10);
+                    } }, read(stream, buffer, offset, length, pos) { var bytesRead = 0; for (var i = 0; i < length; i++) {
+                        var result;
+                        try {
+                            result = input();
+                        }
+                        catch (e) {
+                            throw new FS.ErrnoError(29);
+                        }
+                        if (result === undefined && bytesRead === 0) {
+                            throw new FS.ErrnoError(6);
+                        }
+                        if (result === null || result === undefined)
+                            break;
+                        bytesRead++;
+                        buffer[offset + i] = result;
+                    } if (bytesRead) {
+                        stream.node.atime = Date.now();
+                    } return bytesRead; }, write(stream, buffer, offset, length, pos) { for (var i = 0; i < length; i++) {
+                        try {
+                            output(buffer[offset + i]);
+                        }
+                        catch (e) {
+                            throw new FS.ErrnoError(29);
+                        }
+                    } if (length) {
+                        stream.node.mtime = stream.node.ctime = Date.now();
+                    } return i; } }); return FS.mkdev(path, mode, dev); }, forceLoadFile(obj) { if (obj.isDevice || obj.isFolder || obj.link || obj.contents)
+                    return true; if (globalThis.XMLHttpRequest) {
+                    abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+                }
+                else {
+                    try {
+                        obj.contents = readBinary(obj.url);
+                    }
+                    catch (e) {
+                        throw new FS.ErrnoError(29);
+                    }
+                } }, createLazyFile(parent, name, url, canRead, canWrite) { class LazyUint8Array {
+                    constructor() {
+                        this.lengthKnown = false;
+                        this.chunks = [];
+                    }
+                    get(idx) { if (idx > this.length - 1 || idx < 0) {
+                        return undefined;
+                    } var chunkOffset = idx % this.chunkSize; var chunkNum = idx / this.chunkSize | 0; return this.getter(chunkNum)[chunkOffset]; }
+                    setDataGetter(getter) { this.getter = getter; }
+                    cacheLength() { var xhr = new XMLHttpRequest; xhr.open("HEAD", url, false); xhr.send(null); if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
+                        abort("Couldn't load " + url + ". Status: " + xhr.status); var datalength = Number(xhr.getResponseHeader("Content-length")); var header; var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; var chunkSize = 1024 * 1024; if (!hasByteServing)
+                        chunkSize = datalength; var doXHR = (from, to) => { if (from > to)
+                        abort("invalid range (" + from + ", " + to + ") or no bytes requested!"); if (to > datalength - 1)
+                        abort("only " + datalength + " bytes available! programmer error!"); var xhr = new XMLHttpRequest; xhr.open("GET", url, false); if (datalength !== chunkSize)
+                        xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); xhr.responseType = "arraybuffer"; if (xhr.overrideMimeType) {
+                        xhr.overrideMimeType("text/plain; charset=x-user-defined");
+                    } xhr.send(null); if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
+                        abort("Couldn't load " + url + ". Status: " + xhr.status); if (xhr.response !== undefined) {
+                        return new Uint8Array(xhr.response || []);
+                    } return intArrayFromString(xhr.responseText || ""); }; var lazyArray = this; lazyArray.setDataGetter(chunkNum => { var start = chunkNum * chunkSize; var end = (chunkNum + 1) * chunkSize - 1; end = Math.min(end, datalength - 1); if (typeof lazyArray.chunks[chunkNum] == "undefined") {
+                        lazyArray.chunks[chunkNum] = doXHR(start, end);
+                    } if (typeof lazyArray.chunks[chunkNum] == "undefined")
+                        abort("doXHR failed!"); return lazyArray.chunks[chunkNum]; }); if (usesGzip || !datalength) {
+                        chunkSize = datalength = 1;
+                        datalength = this.getter(0).length;
+                        chunkSize = datalength;
+                        out("LazyFiles on gzip forces download of the whole file when length is accessed");
+                    } this._length = datalength; this._chunkSize = chunkSize; this.lengthKnown = true; }
+                    get length() { if (!this.lengthKnown) {
+                        this.cacheLength();
+                    } return this._length; }
+                    get chunkSize() { if (!this.lengthKnown) {
+                        this.cacheLength();
+                    } return this._chunkSize; }
+                } if (globalThis.XMLHttpRequest) {
+                    if (!ENVIRONMENT_IS_WORKER)
+                        abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");
+                    var lazyArray = new LazyUint8Array;
+                    var properties = { isDevice: false, contents: lazyArray };
+                }
+                else {
+                    var properties = { isDevice: false, url };
+                } var node = FS.createFile(parent, name, properties, canRead, canWrite); if (properties.contents) {
+                    node.contents = properties.contents;
+                }
+                else if (properties.url) {
+                    node.contents = null;
+                    node.url = properties.url;
+                } Object.defineProperties(node, { usedBytes: { get: function () { return this.contents.length; } } }); var stream_ops = {}; for (const [key, fn] of Object.entries(node.stream_ops)) {
+                    stream_ops[key] = (...args) => { FS.forceLoadFile(node); return fn(...args); };
+                } function writeChunks(stream, buffer, offset, length, position) { var contents = stream.node.contents; if (position >= contents.length)
+                    return 0; var size = Math.min(contents.length - position, length); if (contents.slice) {
+                    for (var i = 0; i < size; i++) {
+                        buffer[offset + i] = contents[position + i];
+                    }
+                }
+                else {
+                    for (var i = 0; i < size; i++) {
+                        buffer[offset + i] = contents.get(position + i);
+                    }
+                } return size; } stream_ops.read = (stream, buffer, offset, length, position) => { FS.forceLoadFile(node); return writeChunks(stream, buffer, offset, length, position); }; stream_ops.mmap = (stream, length, position, prot, flags) => { FS.forceLoadFile(node); var ptr = mmapAlloc(); if (!ptr) {
+                    throw new FS.ErrnoError(48);
+                } writeChunks(stream, HEAP8, ptr, length, position); return { ptr, allocated: true }; }; node.stream_ops = stream_ops; return node; } };
+            var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+            var SYSCALLS = { calculateAt(dirfd, path, allowEmpty) { if (PATH.isAbs(path)) {
+                    return path;
+                } var dir; if (dirfd === -100) {
+                    dir = FS.cwd();
+                }
+                else {
+                    var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+                    dir = dirstream.path;
+                } if (path.length == 0) {
+                    if (!allowEmpty) {
+                        throw new FS.ErrnoError(44);
+                    }
+                    return dir;
+                } return dir + "/" + path; }, writeStat(buf, stat) { HEAPU32[buf >> 2] = stat.dev; HEAPU32[buf + 4 >> 2] = stat.mode; HEAPU32[buf + 8 >> 2] = stat.nlink; HEAPU32[buf + 12 >> 2] = stat.uid; HEAPU32[buf + 16 >> 2] = stat.gid; HEAPU32[buf + 20 >> 2] = stat.rdev; HEAP64[buf + 24 >> 3] = BigInt(stat.size); HEAP32[buf + 32 >> 2] = 4096; HEAP32[buf + 36 >> 2] = stat.blocks; var atime = stat.atime.getTime(); var mtime = stat.mtime.getTime(); var ctime = stat.ctime.getTime(); HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3)); HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3; HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3)); HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3; HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3)); HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3; HEAP64[buf + 88 >> 3] = BigInt(stat.ino); return 0; }, writeStatFs(buf, stats) { HEAPU32[buf + 4 >> 2] = stats.bsize; HEAPU32[buf + 60 >> 2] = stats.bsize; HEAP64[buf + 8 >> 3] = BigInt(stats.blocks); HEAP64[buf + 16 >> 3] = BigInt(stats.bfree); HEAP64[buf + 24 >> 3] = BigInt(stats.bavail); HEAP64[buf + 32 >> 3] = BigInt(stats.files); HEAP64[buf + 40 >> 3] = BigInt(stats.ffree); HEAPU32[buf + 48 >> 2] = stats.fsid; HEAPU32[buf + 64 >> 2] = stats.flags; HEAPU32[buf + 56 >> 2] = stats.namelen; }, doMsync(addr, stream, len, flags, offset) { if (!FS.isFile(stream.node.mode)) {
+                    throw new FS.ErrnoError(43);
+                } if (flags & 2) {
+                    return 0;
+                } var buffer = HEAPU8.slice(addr, addr + len); FS.msync(stream, buffer, offset, len, flags); }, getStreamFromFD(fd) { var stream = FS.getStreamChecked(fd); return stream; }, varargs: undefined, getStr(ptr) { var ret = UTF8ToString(ptr); return ret; } };
+            function ___syscall_openat(dirfd, path, flags, varargs) { SYSCALLS.varargs = varargs; try {
+                path = SYSCALLS.getStr(path);
+                path = SYSCALLS.calculateAt(dirfd, path);
+                var mode = varargs ? syscallGetVarargI() : 0;
+                return FS.open(path, flags, mode).fd;
+            }
+            catch (e) {
+                if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+                    throw e;
+                return -e.errno;
+            } }
+            var __abort_js = () => abort("");
+            var getHeapMax = () => 2147483648;
+            var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+            var growMemory = size => { var oldHeapSize = wasmMemory.buffer.byteLength; var pages = (size - oldHeapSize + 65535) / 65536 | 0; try {
+                wasmMemory.grow(pages);
+                updateMemoryViews();
+                return 1;
+            }
+            catch (e) { } };
+            var _emscripten_resize_heap = requestedSize => { var oldSize = HEAPU8.length; requestedSize >>>= 0; var maxHeapSize = getHeapMax(); if (requestedSize > maxHeapSize) {
+                return false;
+            } for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = growMemory(newSize);
+                if (replacement) {
+                    return true;
+                }
+            } return false; };
+            var doReadv = (stream, iov, iovcnt, offset) => { var ret = 0; for (var i = 0; i < iovcnt; i++) {
+                var ptr = HEAPU32[iov >> 2];
+                var len = HEAPU32[iov + 4 >> 2];
+                iov += 8;
+                var curr = FS.read(stream, HEAP8, ptr, len, offset);
+                if (curr < 0)
+                    return -1;
+                ret += curr;
+                if (curr < len)
+                    break;
+            } return ret; };
+            function _fd_read(fd, iov, iovcnt, pnum) { try {
+                var stream = SYSCALLS.getStreamFromFD(fd);
+                var num = doReadv(stream, iov, iovcnt);
+                HEAPU32[pnum >> 2] = num;
+                return 0;
+            }
+            catch (e) {
+                if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+                    throw e;
+                return e.errno;
+            } }
+            var getCFunc = ident => { var func = Module["_" + ident]; return func; };
+            var writeArrayToMemory = (array, buffer) => { HEAP8.set(array, buffer); };
+            var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+            var stackAlloc = sz => __emscripten_stack_alloc(sz);
+            var stringToUTF8OnStack = str => { var size = lengthBytesUTF8(str) + 1; var ret = stackAlloc(size); stringToUTF8(str, ret, size); return ret; };
+            var ccall = (ident, returnType, argTypes, args, opts) => { var toC = { string: str => { var ret = 0; if (str !== null && str !== undefined && str !== 0) {
+                    ret = stringToUTF8OnStack(str);
+                } return ret; }, array: arr => { var ret = stackAlloc(arr.length); writeArrayToMemory(arr, ret); return ret; } }; function convertReturnValue(ret) { if (returnType === "string") {
+                return UTF8ToString(ret);
+            } if (returnType === "boolean")
+                return Boolean(ret); return ret; } var func = getCFunc(ident); var cArgs = []; var stack = 0; if (args) {
+                for (var i = 0; i < args.length; i++) {
+                    var converter = toC[argTypes[i]];
+                    if (converter) {
+                        if (stack === 0)
+                            stack = stackSave();
+                        cArgs[i] = converter(args[i]);
+                    }
+                    else {
+                        cArgs[i] = args[i];
+                    }
+                }
+            } var ret = func(...cArgs); function onDone(ret) { if (stack !== 0)
+                stackRestore(stack); return convertReturnValue(ret); } ret = onDone(ret); return ret; };
+            var cwrap = (ident, returnType, argTypes, opts) => { var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean"); var numericRet = returnType !== "string"; if (numericRet && numericArgs && !opts) {
+                return getCFunc(ident);
+            } return (...args) => ccall(ident, returnType, argTypes, args); };
+            FS.createPreloadedFile = FS_createPreloadedFile;
+            FS.preloadFile = FS_preloadFile;
+            FS.staticInit();
+            {
+                if (Module["noExitRuntime"])
+                    Module["noExitRuntime"];
+                if (Module["preloadPlugins"])
+                    preloadPlugins = Module["preloadPlugins"];
+                if (Module["print"])
+                    out = Module["print"];
+                if (Module["printErr"])
+                    err = Module["printErr"];
+                if (Module["wasmBinary"])
+                    wasmBinary = Module["wasmBinary"];
+                if (Module["arguments"])
+                    Module["arguments"];
+                if (Module["thisProgram"])
+                    Module["thisProgram"];
+                if (Module["preInit"]) {
+                    if (typeof Module["preInit"] == "function")
+                        Module["preInit"] = [Module["preInit"]];
+                    while (Module["preInit"].length > 0) {
+                        Module["preInit"].shift()();
+                    }
+                }
+            }
+            Module["ccall"] = ccall;
+            Module["cwrap"] = cwrap;
+            var __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, wasmMemory;
+            function assignWasmExports(wasmExports) { Module["_wasm_haetae_keypair"] = wasmExports["g"]; Module["_wasm_haetae_sign"] = wasmExports["h"]; Module["_wasm_haetae_verify"] = wasmExports["i"]; Module["_malloc"] = wasmExports["j"]; Module["_free"] = wasmExports["k"]; __emscripten_stack_restore = wasmExports["l"]; __emscripten_stack_alloc = wasmExports["m"]; _emscripten_stack_get_current = wasmExports["n"]; wasmMemory = wasmExports["e"]; wasmExports["__indirect_function_table"]; }
+            var wasmImports = { c: ___syscall_openat, d: __abort_js, a: _emscripten_resize_heap, b: _fd_read };
+            function run() { if (runDependencies > 0) {
+                dependenciesFulfilled = run;
+                return;
+            } preRun(); if (runDependencies > 0) {
+                dependenciesFulfilled = run;
+                return;
+            } function doRun() { var _a; Module["calledRun"] = true; if (ABORT)
+                return; initRuntime(); readyPromiseResolve === null || readyPromiseResolve === void 0 ? void 0 : readyPromiseResolve(Module); (_a = Module["onRuntimeInitialized"]) === null || _a === void 0 ? void 0 : _a.call(Module); postRun(); } if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(() => { setTimeout(() => Module["setStatus"](""), 1); doRun(); }, 1);
+            }
+            else {
+                doRun();
+            } }
+            var wasmExports;
+            wasmExports = yield (createWasm());
+            run();
+            if (runtimeInitialized) {
+                moduleRtn = Module;
+            }
+            else {
+                moduleRtn = new Promise((resolve, reject) => { readyPromiseResolve = resolve; readyPromiseReject = reject; });
+            }
+            return moduleRtn;
+        });
+    }
+
+    function SmaugtModule() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (moduleArg = {}) {
+            var _a, _b, _c;
+            var moduleRtn;
+            var Module = moduleArg;
+            var ENVIRONMENT_IS_WEB = !!globalThis.window;
+            var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+            var ENVIRONMENT_IS_NODE = ((_b = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.versions) === null || _b === void 0 ? void 0 : _b.node) && ((_c = globalThis.process) === null || _c === void 0 ? void 0 : _c.type) != "renderer";
+            if (ENVIRONMENT_IS_NODE) {
+                const { createRequire } = yield ((m)=>(function (t) { return new Promise(function (resolve, reject) { require([t], function (m) { resolve(/*#__PURE__*/_interopNamespaceDefault(m)); }, reject); }); })(/* @vite-ignore */ /* webpackIgnore: true */ m))("node:module");
+                var require$1 = createRequire(new URL(module.uri, document.baseURI).href);
+            }
+            var _scriptName = new URL(module.uri, document.baseURI).href;
+            var scriptDirectory = "";
+            function locateFile(path) { if (Module["locateFile"]) {
+                return Module["locateFile"](path, scriptDirectory);
+            } return scriptDirectory + path; }
+            var readAsync, readBinary;
+            if (ENVIRONMENT_IS_NODE) {
+                var fs = require$1("node:fs");
+                if (_scriptName.startsWith("file:")) {
+                    scriptDirectory = require$1("node:path").dirname(require$1("node:url").fileURLToPath(_scriptName)) + "/";
+                }
+                readBinary = filename => { filename = isFileURI(filename) ? new URL(filename) : filename; var ret = fs.readFileSync(filename); return ret; };
+                readAsync = (filename_1, ...args_1) => tslib_es6.__awaiter(this, [filename_1, ...args_1], void 0, function* (filename, binary = true) { filename = isFileURI(filename) ? new URL(filename) : filename; var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); return ret; });
+                if (process.argv.length > 1) {
+                    process.argv[1].replace(/\\/g, "/");
+                }
+                process.argv.slice(2);
+            }
+            else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+                try {
+                    scriptDirectory = new URL(".", _scriptName).href;
+                }
+                catch (_d) { }
+                {
+                    if (ENVIRONMENT_IS_WORKER) {
+                        readBinary = url => { var xhr = new XMLHttpRequest; xhr.open("GET", url, false); xhr.responseType = "arraybuffer"; xhr.send(null); return new Uint8Array(xhr.response); };
+                    }
+                    readAsync = (url) => tslib_es6.__awaiter(this, void 0, void 0, function* () { if (isFileURI(url)) {
+                        return new Promise((resolve, reject) => { var xhr = new XMLHttpRequest; xhr.open("GET", url, true); xhr.responseType = "arraybuffer"; xhr.onload = () => { if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+                            resolve(xhr.response);
+                            return;
+                        } reject(xhr.status); }; xhr.onerror = reject; xhr.send(null); });
+                    } var response = yield fetch(url, { credentials: "same-origin" }); if (response.ok) {
+                        return response.arrayBuffer();
+                    } throw new Error(response.status + " : " + response.url); });
+                }
+            }
+            else ;
+            var out = console.log.bind(console);
+            var err = console.error.bind(console);
+            var wasmBinary;
+            var ABORT = false;
+            var isFileURI = filename => filename.startsWith("file://");
+            var readyPromiseResolve, readyPromiseReject;
+            var HEAP8, HEAPU8, HEAP32, HEAPU32;
+            var HEAP64;
+            var runtimeInitialized = false;
+            function updateMemoryViews() { var b = wasmMemory.buffer; HEAP8 = new Int8Array(b); Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); HEAP32 = new Int32Array(b); Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); HEAP64 = new BigInt64Array(b); new BigUint64Array(b); }
+            function preRun() { if (Module["preRun"]) {
+                if (typeof Module["preRun"] == "function")
+                    Module["preRun"] = [Module["preRun"]];
+                while (Module["preRun"].length) {
+                    addOnPreRun(Module["preRun"].shift());
+                }
+            } callRuntimeCallbacks(onPreRuns); }
+            function initRuntime() { runtimeInitialized = true; if (!Module["noFSInit"] && !FS.initialized)
+                FS.init(); wasmExports["f"](); FS.ignorePermissions = false; }
+            function postRun() { if (Module["postRun"]) {
+                if (typeof Module["postRun"] == "function")
+                    Module["postRun"] = [Module["postRun"]];
+                while (Module["postRun"].length) {
+                    addOnPostRun(Module["postRun"].shift());
+                }
+            } callRuntimeCallbacks(onPostRuns); }
+            function abort(what) { var _a; (_a = Module["onAbort"]) === null || _a === void 0 ? void 0 : _a.call(Module, what); what = "Aborted(" + what + ")"; err(what); ABORT = true; what += ". Build with -sASSERTIONS for more info."; var e = new WebAssembly.RuntimeError(what); readyPromiseReject === null || readyPromiseReject === void 0 ? void 0 : readyPromiseReject(e); throw e; }
+            var wasmBinaryFile;
+            function findWasmBinary() { if (Module["locateFile"]) {
+                return locateFile("crypto_smaugt.wasm");
+            } return new URL("crypto_smaugt.wasm", new URL(module.uri, document.baseURI).href).href; }
+            function getBinarySync(file) { if (file == wasmBinaryFile && wasmBinary) {
+                return new Uint8Array(wasmBinary);
+            } if (readBinary) {
+                return readBinary(file);
+            } throw "both async and sync fetching of the wasm failed"; }
+            function getWasmBinary(binaryFile) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { if (!wasmBinary) {
+                    try {
+                        var response = yield readAsync(binaryFile);
+                        return new Uint8Array(response);
+                    }
+                    catch (_a) { }
+                } return getBinarySync(binaryFile); });
+            }
+            function instantiateArrayBuffer(binaryFile, imports) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { try {
+                    var binary = yield getWasmBinary(binaryFile);
+                    var instance = yield WebAssembly.instantiate(binary, imports);
+                    return instance;
+                }
+                catch (reason) {
+                    err(`failed to asynchronously prepare wasm: ${reason}`);
+                    abort(reason);
+                } });
+            }
+            function instantiateAsync(binary, binaryFile, imports) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
+                    try {
+                        var response = fetch(binaryFile, { credentials: "same-origin" });
+                        var instantiationResult = yield WebAssembly.instantiateStreaming(response, imports);
+                        return instantiationResult;
+                    }
+                    catch (reason) {
+                        err(`wasm streaming compile failed: ${reason}`);
+                        err("falling back to ArrayBuffer instantiation");
+                    }
+                } return instantiateArrayBuffer(binaryFile, imports); });
+            }
+            function getWasmImports() { var imports = { a: wasmImports }; return imports; }
+            function createWasm() {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () { function receiveInstance(instance, module) { wasmExports = instance.exports; assignWasmExports(wasmExports); updateMemoryViews(); return wasmExports; } function receiveInstantiationResult(result) { return receiveInstance(result["instance"]); } var info = getWasmImports(); if (Module["instantiateWasm"]) {
+                    return new Promise((resolve, reject) => { Module["instantiateWasm"](info, (inst, mod) => { resolve(receiveInstance(inst)); }); });
+                } wasmBinaryFile !== null && wasmBinaryFile !== void 0 ? wasmBinaryFile : (wasmBinaryFile = findWasmBinary()); var result = yield instantiateAsync(wasmBinary, wasmBinaryFile, info); var exports$1 = receiveInstantiationResult(result); return exports$1; });
+            }
+            var callRuntimeCallbacks = callbacks => { while (callbacks.length > 0) {
+                callbacks.shift()(Module);
+            } };
+            var onPostRuns = [];
+            var addOnPostRun = cb => onPostRuns.push(cb);
+            var onPreRuns = [];
+            var addOnPreRun = cb => onPreRuns.push(cb);
+            var stackRestore = val => __emscripten_stack_restore(val);
+            var stackSave = () => _emscripten_stack_get_current();
+            var syscallGetVarargI = () => { var ret = HEAP32[+SYSCALLS.varargs >> 2]; SYSCALLS.varargs += 4; return ret; };
+            var PATH = { isAbs: path => path.charAt(0) === "/", splitPath: filename => { var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; return splitPathRe.exec(filename).slice(1); }, normalizeArray: (parts, allowAboveRoot) => { var up = 0; for (var i = parts.length - 1; i >= 0; i--) {
+                    var last = parts[i];
+                    if (last === ".") {
+                        parts.splice(i, 1);
+                    }
+                    else if (last === "..") {
+                        parts.splice(i, 1);
+                        up++;
+                    }
+                    else if (up) {
+                        parts.splice(i, 1);
+                        up--;
+                    }
+                } if (allowAboveRoot) {
+                    for (; up; up--) {
+                        parts.unshift("..");
+                    }
+                } return parts; }, normalize: path => { var isAbsolute = PATH.isAbs(path), trailingSlash = path.slice(-1) === "/"; path = PATH.normalizeArray(path.split("/").filter(p => !!p), !isAbsolute).join("/"); if (!path && !isAbsolute) {
+                    path = ".";
+                } if (path && trailingSlash) {
+                    path += "/";
+                } return (isAbsolute ? "/" : "") + path; }, dirname: path => { var result = PATH.splitPath(path), root = result[0], dir = result[1]; if (!root && !dir) {
+                    return ".";
+                } if (dir) {
+                    dir = dir.slice(0, -1);
+                } return root + dir; }, basename: path => path && path.match(/([^\/]+|\/)\/*$/)[1], join: (...paths) => PATH.normalize(paths.join("/")), join2: (l, r) => PATH.normalize(l + "/" + r) };
+            var initRandomFill = () => { if (ENVIRONMENT_IS_NODE) {
+                var nodeCrypto = require$1("node:crypto");
+                return view => nodeCrypto.randomFillSync(view);
+            } return view => crypto.getRandomValues(view); };
+            var randomFill = view => { (randomFill = initRandomFill())(view); };
+            var PATH_FS = { resolve: (...args) => { var resolvedPath = "", resolvedAbsolute = false; for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+                    var path = i >= 0 ? args[i] : FS.cwd();
+                    if (typeof path != "string") {
+                        throw new TypeError("Arguments to path.resolve must be strings");
+                    }
+                    else if (!path) {
+                        return "";
+                    }
+                    resolvedPath = path + "/" + resolvedPath;
+                    resolvedAbsolute = PATH.isAbs(path);
+                } resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/"); return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; }, relative: (from, to) => { from = PATH_FS.resolve(from).slice(1); to = PATH_FS.resolve(to).slice(1); function trim(arr) { var start = 0; for (; start < arr.length; start++) {
+                    if (arr[start] !== "")
+                        break;
+                } var end = arr.length - 1; for (; end >= 0; end--) {
+                    if (arr[end] !== "")
+                        break;
+                } if (start > end)
+                    return []; return arr.slice(start, end - start + 1); } var fromParts = trim(from.split("/")); var toParts = trim(to.split("/")); var length = Math.min(fromParts.length, toParts.length); var samePartsLength = length; for (var i = 0; i < length; i++) {
+                    if (fromParts[i] !== toParts[i]) {
+                        samePartsLength = i;
+                        break;
+                    }
+                } var outputParts = []; for (var i = samePartsLength; i < fromParts.length; i++) {
+                    outputParts.push("..");
+                } outputParts = outputParts.concat(toParts.slice(samePartsLength)); return outputParts.join("/"); } };
+            var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
+            var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { var maxIdx = idx + maxBytesToRead; while (heapOrArray[idx] && !(idx >= maxIdx))
+                ++idx; return idx; };
+            var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead); if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+            } var str = ""; while (idx < endPtr) {
+                var u0 = heapOrArray[idx++];
+                if (!(u0 & 128)) {
+                    str += String.fromCharCode(u0);
+                    continue;
+                }
+                var u1 = heapOrArray[idx++] & 63;
+                if ((u0 & 224) == 192) {
+                    str += String.fromCharCode((u0 & 31) << 6 | u1);
+                    continue;
+                }
+                var u2 = heapOrArray[idx++] & 63;
+                if ((u0 & 240) == 224) {
+                    u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+                }
+                else {
+                    u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+                }
+                if (u0 < 65536) {
+                    str += String.fromCharCode(u0);
+                }
+                else {
+                    var ch = u0 - 65536;
+                    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+                }
+            } return str; };
+            var FS_stdin_getChar_buffer = [];
+            var lengthBytesUTF8 = str => { var len = 0; for (var i = 0; i < str.length; ++i) {
+                var c = str.charCodeAt(i);
+                if (c <= 127) {
+                    len++;
+                }
+                else if (c <= 2047) {
+                    len += 2;
+                }
+                else if (c >= 55296 && c <= 57343) {
+                    len += 4;
+                    ++i;
+                }
+                else {
+                    len += 3;
+                }
+            } return len; };
+            var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { if (!(maxBytesToWrite > 0))
+                return 0; var startIdx = outIdx; var endIdx = outIdx + maxBytesToWrite - 1; for (var i = 0; i < str.length; ++i) {
+                var u = str.codePointAt(i);
+                if (u <= 127) {
+                    if (outIdx >= endIdx)
+                        break;
+                    heap[outIdx++] = u;
+                }
+                else if (u <= 2047) {
+                    if (outIdx + 1 >= endIdx)
+                        break;
+                    heap[outIdx++] = 192 | u >> 6;
+                    heap[outIdx++] = 128 | u & 63;
+                }
+                else if (u <= 65535) {
+                    if (outIdx + 2 >= endIdx)
+                        break;
+                    heap[outIdx++] = 224 | u >> 12;
+                    heap[outIdx++] = 128 | u >> 6 & 63;
+                    heap[outIdx++] = 128 | u & 63;
+                }
+                else {
+                    if (outIdx + 3 >= endIdx)
+                        break;
+                    heap[outIdx++] = 240 | u >> 18;
+                    heap[outIdx++] = 128 | u >> 12 & 63;
+                    heap[outIdx++] = 128 | u >> 6 & 63;
+                    heap[outIdx++] = 128 | u & 63;
+                    i++;
+                }
+            } heap[outIdx] = 0; return outIdx - startIdx; };
+            var intArrayFromString = (stringy, dontAddNull, length) => { var len = lengthBytesUTF8(stringy) + 1; var u8array = new Array(len); var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); u8array.length = numBytesWritten; return u8array; };
+            var FS_stdin_getChar = () => { var _a; if (!FS_stdin_getChar_buffer.length) {
+                var result = null;
+                if (ENVIRONMENT_IS_NODE) {
+                    var BUFSIZE = 256;
+                    var buf = Buffer.alloc(BUFSIZE);
+                    var bytesRead = 0;
+                    var fd = process.stdin.fd;
+                    try {
+                        bytesRead = fs.readSync(fd, buf, 0, BUFSIZE);
+                    }
+                    catch (e) {
+                        if (e.toString().includes("EOF"))
+                            bytesRead = 0;
+                        else
+                            throw e;
+                    }
+                    if (bytesRead > 0) {
+                        result = buf.slice(0, bytesRead).toString("utf-8");
+                    }
+                }
+                else if ((_a = globalThis.window) === null || _a === void 0 ? void 0 : _a.prompt) {
+                    result = window.prompt("Input: ");
+                    if (result !== null) {
+                        result += "\n";
+                    }
+                }
+                else ;
+                if (!result) {
+                    return null;
+                }
+                FS_stdin_getChar_buffer = intArrayFromString(result);
+            } return FS_stdin_getChar_buffer.shift(); };
+            var TTY = { ttys: [], init() { }, shutdown() { }, register(dev, ops) { TTY.ttys[dev] = { input: [], output: [], ops }; FS.registerDevice(dev, TTY.stream_ops); }, stream_ops: { open(stream) { var tty = TTY.ttys[stream.node.rdev]; if (!tty) {
+                        throw new FS.ErrnoError(43);
+                    } stream.tty = tty; stream.seekable = false; }, close(stream) { stream.tty.ops.fsync(stream.tty); }, fsync(stream) { stream.tty.ops.fsync(stream.tty); }, read(stream, buffer, offset, length, pos) { if (!stream.tty || !stream.tty.ops.get_char) {
+                        throw new FS.ErrnoError(60);
+                    } var bytesRead = 0; for (var i = 0; i < length; i++) {
+                        var result;
+                        try {
+                            result = stream.tty.ops.get_char(stream.tty);
+                        }
+                        catch (e) {
+                            throw new FS.ErrnoError(29);
+                        }
+                        if (result === undefined && bytesRead === 0) {
+                            throw new FS.ErrnoError(6);
+                        }
+                        if (result === null || result === undefined)
+                            break;
+                        bytesRead++;
+                        buffer[offset + i] = result;
+                    } if (bytesRead) {
+                        stream.node.atime = Date.now();
+                    } return bytesRead; }, write(stream, buffer, offset, length, pos) { if (!stream.tty || !stream.tty.ops.put_char) {
+                        throw new FS.ErrnoError(60);
+                    } try {
+                        for (var i = 0; i < length; i++) {
+                            stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+                        }
+                    }
+                    catch (e) {
+                        throw new FS.ErrnoError(29);
+                    } if (length) {
+                        stream.node.mtime = stream.node.ctime = Date.now();
+                    } return i; } }, default_tty_ops: { get_char(tty) { return FS_stdin_getChar(); }, put_char(tty, val) { if (val === null || val === 10) {
+                        out(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    }
+                    else {
+                        if (val != 0)
+                            tty.output.push(val);
+                    } }, fsync(tty) { var _a; if (((_a = tty.output) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                        out(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    } }, ioctl_tcgets(tty) { return { c_iflag: 25856, c_oflag: 5, c_cflag: 191, c_lflag: 35387, c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }; }, ioctl_tcsets(tty, optional_actions, data) { return 0; }, ioctl_tiocgwinsz(tty) { return [24, 80]; } }, default_tty1_ops: { put_char(tty, val) { if (val === null || val === 10) {
+                        err(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    }
+                    else {
+                        if (val != 0)
+                            tty.output.push(val);
+                    } }, fsync(tty) { var _a; if (((_a = tty.output) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                        err(UTF8ArrayToString(tty.output));
+                        tty.output = [];
+                    } } } };
+            var mmapAlloc = size => { abort(); };
+            var MEMFS = { ops_table: null, mount(mount) { return MEMFS.createNode(null, "/", 16895, 0); }, createNode(parent, name, mode, dev) { var _a; if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+                    throw new FS.ErrnoError(63);
+                } MEMFS.ops_table || (MEMFS.ops_table = { dir: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, lookup: MEMFS.node_ops.lookup, mknod: MEMFS.node_ops.mknod, rename: MEMFS.node_ops.rename, unlink: MEMFS.node_ops.unlink, rmdir: MEMFS.node_ops.rmdir, readdir: MEMFS.node_ops.readdir, symlink: MEMFS.node_ops.symlink }, stream: { llseek: MEMFS.stream_ops.llseek } }, file: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: { llseek: MEMFS.stream_ops.llseek, read: MEMFS.stream_ops.read, write: MEMFS.stream_ops.write, mmap: MEMFS.stream_ops.mmap, msync: MEMFS.stream_ops.msync } }, link: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, readlink: MEMFS.node_ops.readlink }, stream: {} }, chrdev: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: FS.chrdev_stream_ops } }); var node = FS.createNode(parent, name, mode, dev); if (FS.isDir(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.dir.node;
+                    node.stream_ops = MEMFS.ops_table.dir.stream;
+                    node.contents = {};
+                }
+                else if (FS.isFile(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.file.node;
+                    node.stream_ops = MEMFS.ops_table.file.stream;
+                    node.usedBytes = 0;
+                    node.contents = (_a = MEMFS.emptyFileContents) !== null && _a !== void 0 ? _a : (MEMFS.emptyFileContents = new Uint8Array(0));
+                }
+                else if (FS.isLink(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.link.node;
+                    node.stream_ops = MEMFS.ops_table.link.stream;
+                }
+                else if (FS.isChrdev(node.mode)) {
+                    node.node_ops = MEMFS.ops_table.chrdev.node;
+                    node.stream_ops = MEMFS.ops_table.chrdev.stream;
+                } node.atime = node.mtime = node.ctime = Date.now(); if (parent) {
+                    parent.contents[name] = node;
+                    parent.atime = parent.mtime = parent.ctime = node.atime;
+                } return node; }, getFileDataAsTypedArray(node) { return node.contents.subarray(0, node.usedBytes); }, expandFileStorage(node, newCapacity) { var prevCapacity = node.contents.length; if (prevCapacity >= newCapacity)
+                    return; var CAPACITY_DOUBLING_MAX = 1024 * 1024; newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0); if (prevCapacity)
+                    newCapacity = Math.max(newCapacity, 256); var oldContents = MEMFS.getFileDataAsTypedArray(node); node.contents = new Uint8Array(newCapacity); node.contents.set(oldContents); }, resizeFileStorage(node, newSize) { if (node.usedBytes == newSize)
+                    return; var oldContents = node.contents; node.contents = new Uint8Array(newSize); node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); node.usedBytes = newSize; }, node_ops: { getattr(node) { var attr = {}; attr.dev = FS.isChrdev(node.mode) ? node.id : 1; attr.ino = node.id; attr.mode = node.mode; attr.nlink = 1; attr.uid = 0; attr.gid = 0; attr.rdev = node.rdev; if (FS.isDir(node.mode)) {
+                        attr.size = 4096;
+                    }
+                    else if (FS.isFile(node.mode)) {
+                        attr.size = node.usedBytes;
+                    }
+                    else if (FS.isLink(node.mode)) {
+                        attr.size = node.link.length;
+                    }
+                    else {
+                        attr.size = 0;
+                    } attr.atime = new Date(node.atime); attr.mtime = new Date(node.mtime); attr.ctime = new Date(node.ctime); attr.blksize = 4096; attr.blocks = Math.ceil(attr.size / attr.blksize); return attr; }, setattr(node, attr) { for (const key of ["mode", "atime", "mtime", "ctime"]) {
+                        if (attr[key] != null) {
+                            node[key] = attr[key];
+                        }
+                    } if (attr.size !== undefined) {
+                        MEMFS.resizeFileStorage(node, attr.size);
+                    } }, lookup(parent, name) { if (!MEMFS.doesNotExistError) {
+                        MEMFS.doesNotExistError = new FS.ErrnoError(44);
+                        MEMFS.doesNotExistError.stack = "<generic error, no stack>";
+                    } throw MEMFS.doesNotExistError; }, mknod(parent, name, mode, dev) { return MEMFS.createNode(parent, name, mode, dev); }, rename(old_node, new_dir, new_name) { var new_node; try {
+                        new_node = FS.lookupNode(new_dir, new_name);
+                    }
+                    catch (e) { } if (new_node) {
+                        if (FS.isDir(old_node.mode)) {
+                            for (var i in new_node.contents) {
+                                throw new FS.ErrnoError(55);
+                            }
+                        }
+                        FS.hashRemoveNode(new_node);
+                    } delete old_node.parent.contents[old_node.name]; new_dir.contents[new_name] = old_node; old_node.name = new_name; new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now(); }, unlink(parent, name) { delete parent.contents[name]; parent.ctime = parent.mtime = Date.now(); }, rmdir(parent, name) { var node = FS.lookupNode(parent, name); for (var i in node.contents) {
+                        throw new FS.ErrnoError(55);
+                    } delete parent.contents[name]; parent.ctime = parent.mtime = Date.now(); }, readdir(node) { return [".", "..", ...Object.keys(node.contents)]; }, symlink(parent, newname, oldpath) { var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); node.link = oldpath; return node; }, readlink(node) { if (!FS.isLink(node.mode)) {
+                        throw new FS.ErrnoError(28);
+                    } return node.link; } }, stream_ops: { read(stream, buffer, offset, length, position) { var contents = stream.node.contents; if (position >= stream.node.usedBytes)
+                        return 0; var size = Math.min(stream.node.usedBytes - position, length); buffer.set(contents.subarray(position, position + size), offset); return size; }, write(stream, buffer, offset, length, position, canOwn) { if (buffer.buffer === HEAP8.buffer) {
+                        canOwn = false;
+                    } if (!length)
+                        return 0; var node = stream.node; node.mtime = node.ctime = Date.now(); if (canOwn) {
+                        node.contents = buffer.subarray(offset, offset + length);
+                        node.usedBytes = length;
+                    }
+                    else if (node.usedBytes === 0 && position === 0) {
+                        node.contents = buffer.slice(offset, offset + length);
+                        node.usedBytes = length;
+                    }
+                    else {
+                        MEMFS.expandFileStorage(node, position + length);
+                        node.contents.set(buffer.subarray(offset, offset + length), position);
+                        node.usedBytes = Math.max(node.usedBytes, position + length);
+                    } return length; }, llseek(stream, offset, whence) { var position = offset; if (whence === 1) {
+                        position += stream.position;
+                    }
+                    else if (whence === 2) {
+                        if (FS.isFile(stream.node.mode)) {
+                            position += stream.node.usedBytes;
+                        }
+                    } if (position < 0) {
+                        throw new FS.ErrnoError(28);
+                    } return position; }, mmap(stream, length, position, prot, flags) { if (!FS.isFile(stream.node.mode)) {
+                        throw new FS.ErrnoError(43);
+                    } var ptr; var allocated; var contents = stream.node.contents; if (!(flags & 2) && contents.buffer === HEAP8.buffer) {
+                        allocated = false;
+                        ptr = contents.byteOffset;
+                    }
+                    else {
+                        allocated = true;
+                        ptr = mmapAlloc();
+                        if (!ptr) {
+                            throw new FS.ErrnoError(48);
+                        }
+                        if (contents) {
+                            if (position > 0 || position + length < contents.length) {
+                                if (contents.subarray) {
+                                    contents = contents.subarray(position, position + length);
+                                }
+                                else {
+                                    contents = Array.prototype.slice.call(contents, position, position + length);
+                                }
+                            }
+                            HEAP8.set(contents, ptr);
+                        }
+                    } return { ptr, allocated }; }, msync(stream, buffer, offset, length, mmapFlags) { MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); return 0; } } };
+            var FS_modeStringToFlags = str => { if (typeof str != "string")
+                return str; var flagModes = { r: 0, "r+": 2, w: 512 | 64 | 1, "w+": 512 | 64 | 2, a: 1024 | 64 | 1, "a+": 1024 | 64 | 2 }; var flags = flagModes[str]; if (typeof flags == "undefined") {
+                throw new Error(`Unknown file open mode: ${str}`);
+            } return flags; };
+            var FS_fileDataToTypedArray = data => { if (typeof data == "string") {
+                data = intArrayFromString(data);
+            } if (!data.subarray) {
+                data = new Uint8Array(data);
+            } return data; };
+            var FS_getMode = (canRead, canWrite) => { var mode = 0; if (canRead)
+                mode |= 292 | 73; if (canWrite)
+                mode |= 146; return mode; };
+            var asyncLoad = (url) => tslib_es6.__awaiter(this, void 0, void 0, function* () { var arrayBuffer = yield readAsync(url); return new Uint8Array(arrayBuffer); });
+            var FS_createDataFile = (...args) => FS.createDataFile(...args);
+            var runDependencies = 0;
+            var dependenciesFulfilled = null;
+            var removeRunDependency = id => { var _a; runDependencies--; (_a = Module["monitorRunDependencies"]) === null || _a === void 0 ? void 0 : _a.call(Module, runDependencies); if (runDependencies == 0) {
+                if (dependenciesFulfilled) {
+                    var callback = dependenciesFulfilled;
+                    dependenciesFulfilled = null;
+                    callback();
+                }
+            } };
+            var addRunDependency = id => { var _a; runDependencies++; (_a = Module["monitorRunDependencies"]) === null || _a === void 0 ? void 0 : _a.call(Module, runDependencies); };
+            var preloadPlugins = [];
+            var FS_handledByPreloadPlugin = (byteArray, fullname) => tslib_es6.__awaiter(this, void 0, void 0, function* () { if (typeof Browser != "undefined")
+                Browser.init(); for (var plugin of preloadPlugins) {
+                if (plugin["canHandle"](fullname)) {
+                    return plugin["handle"](byteArray, fullname);
+                }
+            } return byteArray; });
+            var FS_preloadFile = (parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish) => tslib_es6.__awaiter(this, void 0, void 0, function* () { var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; addRunDependency(); try {
+                var byteArray = url;
+                if (typeof url == "string") {
+                    byteArray = yield asyncLoad(url);
+                }
+                byteArray = yield FS_handledByPreloadPlugin(byteArray, fullname);
+                preFinish === null || preFinish === void 0 ? void 0 : preFinish();
+                if (!dontCreateFile) {
+                    FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+                }
+            }
+            finally {
+                removeRunDependency();
+            } });
+            var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { FS_preloadFile(parent, name, url, canRead, canWrite, dontCreateFile, canOwn, preFinish).then(onload).catch(onerror); };
+            var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, ErrnoError: class {
+                    constructor(errno) {
+                        this.name = "ErrnoError";
+                        this.errno = errno;
+                    }
+                }, FSStream: class {
+                    constructor() {
+                        this.shared = {};
+                    }
+                    get object() { return this.node; }
+                    set object(val) { this.node = val; }
+                    get isRead() { return (this.flags & 2097155) !== 1; }
+                    get isWrite() { return (this.flags & 2097155) !== 0; }
+                    get isAppend() { return this.flags & 1024; }
+                    get flags() { return this.shared.flags; }
+                    set flags(val) { this.shared.flags = val; }
+                    get position() { return this.shared.position; }
+                    set position(val) { this.shared.position = val; }
+                }, FSNode: class {
+                    constructor(parent, name, mode, rdev) {
+                        this.node_ops = {};
+                        this.stream_ops = {};
+                        this.readMode = 292 | 73;
+                        this.writeMode = 146;
+                        this.mounted = null;
+                        if (!parent) {
+                            parent = this;
+                        }
+                        this.parent = parent;
+                        this.mount = parent.mount;
+                        this.id = FS.nextInode++;
+                        this.name = name;
+                        this.mode = mode;
+                        this.rdev = rdev;
+                        this.atime = this.mtime = this.ctime = Date.now();
+                    }
+                    get read() { return (this.mode & this.readMode) === this.readMode; }
+                    set read(val) { val ? this.mode |= this.readMode : this.mode &= ~this.readMode; }
+                    get write() { return (this.mode & this.writeMode) === this.writeMode; }
+                    set write(val) { val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode; }
+                    get isFolder() { return FS.isDir(this.mode); }
+                    get isDevice() { return FS.isChrdev(this.mode); }
+                }, lookupPath(path, opts = {}) { var _a; if (!path) {
+                    throw new FS.ErrnoError(44);
+                } (_a = opts.follow_mount) !== null && _a !== void 0 ? _a : (opts.follow_mount = true); if (!PATH.isAbs(path)) {
+                    path = FS.cwd() + "/" + path;
+                } linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
+                    var parts = path.split("/").filter(p => !!p);
+                    var current = FS.root;
+                    var current_path = "/";
+                    for (var i = 0; i < parts.length; i++) {
+                        var islast = i === parts.length - 1;
+                        if (islast && opts.parent) {
+                            break;
+                        }
+                        if (parts[i] === ".") {
+                            continue;
+                        }
+                        if (parts[i] === "..") {
+                            current_path = PATH.dirname(current_path);
+                            if (FS.isRoot(current)) {
+                                path = current_path + "/" + parts.slice(i + 1).join("/");
+                                nlinks--;
+                                continue linkloop;
+                            }
+                            else {
+                                current = current.parent;
+                            }
+                            continue;
+                        }
+                        current_path = PATH.join2(current_path, parts[i]);
+                        try {
+                            current = FS.lookupNode(current, parts[i]);
+                        }
+                        catch (e) {
+                            if ((e === null || e === void 0 ? void 0 : e.errno) === 44 && islast && opts.noent_okay) {
+                                return { path: current_path };
+                            }
+                            throw e;
+                        }
+                        if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
+                            current = current.mounted.root;
+                        }
+                        if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+                            if (!current.node_ops.readlink) {
+                                throw new FS.ErrnoError(52);
+                            }
+                            var link = current.node_ops.readlink(current);
+                            if (!PATH.isAbs(link)) {
+                                link = PATH.dirname(current_path) + "/" + link;
+                            }
+                            path = link + "/" + parts.slice(i + 1).join("/");
+                            continue linkloop;
+                        }
+                    }
+                    return { path: current_path, node: current };
+                } throw new FS.ErrnoError(32); }, getPath(node) { var path; while (true) {
+                    if (FS.isRoot(node)) {
+                        var mount = node.mount.mountpoint;
+                        if (!path)
+                            return mount;
+                        return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
+                    }
+                    path = path ? `${node.name}/${path}` : node.name;
+                    node = node.parent;
+                } }, hashName(parentid, name) { var hash = 0; for (var i = 0; i < name.length; i++) {
+                    hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+                } return (parentid + hash >>> 0) % FS.nameTable.length; }, hashAddNode(node) { var hash = FS.hashName(node.parent.id, node.name); node.name_next = FS.nameTable[hash]; FS.nameTable[hash] = node; }, hashRemoveNode(node) { var hash = FS.hashName(node.parent.id, node.name); if (FS.nameTable[hash] === node) {
+                    FS.nameTable[hash] = node.name_next;
+                }
+                else {
+                    var current = FS.nameTable[hash];
+                    while (current) {
+                        if (current.name_next === node) {
+                            current.name_next = node.name_next;
+                            break;
+                        }
+                        current = current.name_next;
+                    }
+                } }, lookupNode(parent, name) { var errCode = FS.mayLookup(parent); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } var hash = FS.hashName(parent.id, name); for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+                    var nodeName = node.name;
+                    if (node.parent.id === parent.id && nodeName === name) {
+                        return node;
+                    }
+                } return FS.lookup(parent, name); }, createNode(parent, name, mode, rdev) { var node = new FS.FSNode(parent, name, mode, rdev); FS.hashAddNode(node); return node; }, destroyNode(node) { FS.hashRemoveNode(node); }, isRoot(node) { return node === node.parent; }, isMountpoint(node) { return !!node.mounted; }, isFile(mode) { return (mode & 61440) === 32768; }, isDir(mode) { return (mode & 61440) === 16384; }, isLink(mode) { return (mode & 61440) === 40960; }, isChrdev(mode) { return (mode & 61440) === 8192; }, isBlkdev(mode) { return (mode & 61440) === 24576; }, isFIFO(mode) { return (mode & 61440) === 4096; }, isSocket(mode) { return (mode & 49152) === 49152; }, flagsToPermissionString(flag) { var perms = ["r", "w", "rw"][flag & 3]; if (flag & 512) {
+                    perms += "w";
+                } return perms; }, nodePermissions(node, perms) { if (FS.ignorePermissions) {
+                    return 0;
+                } if (perms.includes("r") && !(node.mode & 292)) {
+                    return 2;
+                } if (perms.includes("w") && !(node.mode & 146)) {
+                    return 2;
+                } if (perms.includes("x") && !(node.mode & 73)) {
+                    return 2;
+                } return 0; }, mayLookup(dir) { if (!FS.isDir(dir.mode))
+                    return 54; var errCode = FS.nodePermissions(dir, "x"); if (errCode)
+                    return errCode; if (!dir.node_ops.lookup)
+                    return 2; return 0; }, mayCreate(dir, name) { if (!FS.isDir(dir.mode)) {
+                    return 54;
+                } try {
+                    var node = FS.lookupNode(dir, name);
+                    return 20;
+                }
+                catch (e) { } return FS.nodePermissions(dir, "wx"); }, mayDelete(dir, name, isdir) { var node; try {
+                    node = FS.lookupNode(dir, name);
+                }
+                catch (e) {
+                    return e.errno;
+                } var errCode = FS.nodePermissions(dir, "wx"); if (errCode) {
+                    return errCode;
+                } if (isdir) {
+                    if (!FS.isDir(node.mode)) {
+                        return 54;
+                    }
+                    if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+                        return 10;
+                    }
+                }
+                else if (FS.isDir(node.mode)) {
+                    return 31;
+                } return 0; }, mayOpen(node, flags) { if (!node) {
+                    return 44;
+                } if (FS.isLink(node.mode)) {
+                    return 32;
+                } var mode = FS.flagsToPermissionString(flags); if (FS.isDir(node.mode)) {
+                    if (mode !== "r" || flags & (512 | 64)) {
+                        return 31;
+                    }
+                } return FS.nodePermissions(node, mode); }, checkOpExists(op, err) { if (!op) {
+                    throw new FS.ErrnoError(err);
+                } return op; }, MAX_OPEN_FDS: 4096, nextfd() { for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
+                    if (!FS.streams[fd]) {
+                        return fd;
+                    }
+                } throw new FS.ErrnoError(33); }, getStreamChecked(fd) { var stream = FS.getStream(fd); if (!stream) {
+                    throw new FS.ErrnoError(8);
+                } return stream; }, getStream: fd => FS.streams[fd], createStream(stream, fd = -1) { stream = Object.assign(new FS.FSStream, stream); if (fd == -1) {
+                    fd = FS.nextfd();
+                } stream.fd = fd; FS.streams[fd] = stream; return stream; }, closeStream(fd) { FS.streams[fd] = null; }, dupStream(origStream, fd = -1) { var _a, _b; var stream = FS.createStream(origStream, fd); (_b = (_a = stream.stream_ops) === null || _a === void 0 ? void 0 : _a.dup) === null || _b === void 0 ? void 0 : _b.call(_a, stream); return stream; }, doSetAttr(stream, node, attr) { var setattr = stream === null || stream === void 0 ? void 0 : stream.stream_ops.setattr; var arg = setattr ? stream : node; setattr !== null && setattr !== void 0 ? setattr : (setattr = node.node_ops.setattr); FS.checkOpExists(setattr, 63); setattr(arg, attr); }, chrdev_stream_ops: { open(stream) { var _a, _b; var device = FS.getDevice(stream.node.rdev); stream.stream_ops = device.stream_ops; (_b = (_a = stream.stream_ops).open) === null || _b === void 0 ? void 0 : _b.call(_a, stream); }, llseek() { throw new FS.ErrnoError(70); } }, major: dev => dev >> 8, minor: dev => dev & 255, makedev: (ma, mi) => ma << 8 | mi, registerDevice(dev, ops) { FS.devices[dev] = { stream_ops: ops }; }, getDevice: dev => FS.devices[dev], getMounts(mount) { var mounts = []; var check = [mount]; while (check.length) {
+                    var m = check.pop();
+                    mounts.push(m);
+                    check.push(...m.mounts);
+                } return mounts; }, syncfs(populate, callback) { if (typeof populate == "function") {
+                    callback = populate;
+                    populate = false;
+                } FS.syncFSRequests++; if (FS.syncFSRequests > 1) {
+                    err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
+                } var mounts = FS.getMounts(FS.root.mount); var completed = 0; function doCallback(errCode) { FS.syncFSRequests--; return callback(errCode); } function done(errCode) { if (errCode) {
+                    if (!done.errored) {
+                        done.errored = true;
+                        return doCallback(errCode);
+                    }
+                    return;
+                } if (++completed >= mounts.length) {
+                    doCallback(null);
+                } } for (var mount of mounts) {
+                    if (mount.type.syncfs) {
+                        mount.type.syncfs(mount, populate, done);
+                    }
+                    else {
+                        done(null);
+                    }
+                } }, mount(type, opts, mountpoint) { var root = mountpoint === "/"; var pseudo = !mountpoint; var node; if (root && FS.root) {
+                    throw new FS.ErrnoError(10);
+                }
+                else if (!root && !pseudo) {
+                    var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+                    mountpoint = lookup.path;
+                    node = lookup.node;
+                    if (FS.isMountpoint(node)) {
+                        throw new FS.ErrnoError(10);
+                    }
+                    if (!FS.isDir(node.mode)) {
+                        throw new FS.ErrnoError(54);
+                    }
+                } var mount = { type, opts, mountpoint, mounts: [] }; var mountRoot = type.mount(mount); mountRoot.mount = mount; mount.root = mountRoot; if (root) {
+                    FS.root = mountRoot;
+                }
+                else if (node) {
+                    node.mounted = mount;
+                    if (node.mount) {
+                        node.mount.mounts.push(mount);
+                    }
+                } return mountRoot; }, unmount(mountpoint) { var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); if (!FS.isMountpoint(lookup.node)) {
+                    throw new FS.ErrnoError(28);
+                } var node = lookup.node; var mount = node.mounted; var mounts = FS.getMounts(mount); for (var [hash, current] of Object.entries(FS.nameTable)) {
+                    while (current) {
+                        var next = current.name_next;
+                        if (mounts.includes(current.mount)) {
+                            FS.destroyNode(current);
+                        }
+                        current = next;
+                    }
+                } node.mounted = null; var idx = node.mount.mounts.indexOf(mount); node.mount.mounts.splice(idx, 1); }, lookup(parent, name) { return parent.node_ops.lookup(parent, name); }, mknod(path, mode, dev) { var lookup = FS.lookupPath(path, { parent: true }); var parent = lookup.node; var name = PATH.basename(path); if (!name) {
+                    throw new FS.ErrnoError(28);
+                } if (name === "." || name === "..") {
+                    throw new FS.ErrnoError(20);
+                } var errCode = FS.mayCreate(parent, name); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.mknod) {
+                    throw new FS.ErrnoError(63);
+                } return parent.node_ops.mknod(parent, name, mode, dev); }, statfs(path) { return FS.statfsNode(FS.lookupPath(path, { follow: true }).node); }, statfsStream(stream) { return FS.statfsNode(stream.node); }, statfsNode(node) { var rtn = { bsize: 4096, frsize: 4096, blocks: 1e6, bfree: 5e5, bavail: 5e5, files: FS.nextInode, ffree: FS.nextInode - 1, fsid: 42, flags: 2, namelen: 255 }; if (node.node_ops.statfs) {
+                    Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
+                } return rtn; }, create(path, mode = 438) { mode &= 4095; mode |= 32768; return FS.mknod(path, mode, 0); }, mkdir(path, mode = 511) { mode &= 511 | 512; mode |= 16384; return FS.mknod(path, mode, 0); }, mkdirTree(path, mode) { var dirs = path.split("/"); var d = ""; for (var dir of dirs) {
+                    if (!dir)
+                        continue;
+                    if (d || PATH.isAbs(path))
+                        d += "/";
+                    d += dir;
+                    try {
+                        FS.mkdir(d, mode);
+                    }
+                    catch (e) {
+                        if (e.errno != 20)
+                            throw e;
+                    }
+                } }, mkdev(path, mode, dev) { if (typeof dev == "undefined") {
+                    dev = mode;
+                    mode = 438;
+                } mode |= 8192; return FS.mknod(path, mode, dev); }, symlink(oldpath, newpath) { if (!PATH_FS.resolve(oldpath)) {
+                    throw new FS.ErrnoError(44);
+                } var lookup = FS.lookupPath(newpath, { parent: true }); var parent = lookup.node; if (!parent) {
+                    throw new FS.ErrnoError(44);
+                } var newname = PATH.basename(newpath); var errCode = FS.mayCreate(parent, newname); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.symlink) {
+                    throw new FS.ErrnoError(63);
+                } return parent.node_ops.symlink(parent, newname, oldpath); }, rename(old_path, new_path) { var old_dirname = PATH.dirname(old_path); var new_dirname = PATH.dirname(new_path); var old_name = PATH.basename(old_path); var new_name = PATH.basename(new_path); var lookup, old_dir, new_dir; lookup = FS.lookupPath(old_path, { parent: true }); old_dir = lookup.node; lookup = FS.lookupPath(new_path, { parent: true }); new_dir = lookup.node; if (!old_dir || !new_dir)
+                    throw new FS.ErrnoError(44); if (old_dir.mount !== new_dir.mount) {
+                    throw new FS.ErrnoError(75);
+                } var old_node = FS.lookupNode(old_dir, old_name); var relative = PATH_FS.relative(old_path, new_dirname); if (relative.charAt(0) !== ".") {
+                    throw new FS.ErrnoError(28);
+                } relative = PATH_FS.relative(new_path, old_dirname); if (relative.charAt(0) !== ".") {
+                    throw new FS.ErrnoError(55);
+                } var new_node; try {
+                    new_node = FS.lookupNode(new_dir, new_name);
+                }
+                catch (e) { } if (old_node === new_node) {
+                    return;
+                } var isdir = FS.isDir(old_node.mode); var errCode = FS.mayDelete(old_dir, old_name, isdir); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!old_dir.node_ops.rename) {
+                    throw new FS.ErrnoError(63);
+                } if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
+                    throw new FS.ErrnoError(10);
+                } if (new_dir !== old_dir) {
+                    errCode = FS.nodePermissions(old_dir, "w");
+                    if (errCode) {
+                        throw new FS.ErrnoError(errCode);
+                    }
+                } FS.hashRemoveNode(old_node); try {
+                    old_dir.node_ops.rename(old_node, new_dir, new_name);
+                    old_node.parent = new_dir;
+                }
+                catch (e) {
+                    throw e;
+                }
+                finally {
+                    FS.hashAddNode(old_node);
+                } }, rmdir(path) { var lookup = FS.lookupPath(path, { parent: true }); var parent = lookup.node; var name = PATH.basename(path); var node = FS.lookupNode(parent, name); var errCode = FS.mayDelete(parent, name, true); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.rmdir) {
+                    throw new FS.ErrnoError(63);
+                } if (FS.isMountpoint(node)) {
+                    throw new FS.ErrnoError(10);
+                } parent.node_ops.rmdir(parent, name); FS.destroyNode(node); }, readdir(path) { var lookup = FS.lookupPath(path, { follow: true }); var node = lookup.node; var readdir = FS.checkOpExists(node.node_ops.readdir, 54); return readdir(node); }, unlink(path) { var lookup = FS.lookupPath(path, { parent: true }); var parent = lookup.node; if (!parent) {
+                    throw new FS.ErrnoError(44);
+                } var name = PATH.basename(path); var node = FS.lookupNode(parent, name); var errCode = FS.mayDelete(parent, name, false); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } if (!parent.node_ops.unlink) {
+                    throw new FS.ErrnoError(63);
+                } if (FS.isMountpoint(node)) {
+                    throw new FS.ErrnoError(10);
+                } parent.node_ops.unlink(parent, name); FS.destroyNode(node); }, readlink(path) { var lookup = FS.lookupPath(path); var link = lookup.node; if (!link) {
+                    throw new FS.ErrnoError(44);
+                } if (!link.node_ops.readlink) {
+                    throw new FS.ErrnoError(28);
+                } return link.node_ops.readlink(link); }, stat(path, dontFollow) { var lookup = FS.lookupPath(path, { follow: !dontFollow }); var node = lookup.node; var getattr = FS.checkOpExists(node.node_ops.getattr, 63); return getattr(node); }, fstat(fd) { var stream = FS.getStreamChecked(fd); var node = stream.node; var getattr = stream.stream_ops.getattr; var arg = getattr ? stream : node; getattr !== null && getattr !== void 0 ? getattr : (getattr = node.node_ops.getattr); FS.checkOpExists(getattr, 63); return getattr(arg); }, lstat(path) { return FS.stat(path, true); }, doChmod(stream, node, mode, dontFollow) { FS.doSetAttr(stream, node, { mode: mode & 4095 | node.mode & -4096, ctime: Date.now(), dontFollow }); }, chmod(path, mode, dontFollow) { var node; if (typeof path == "string") {
+                    var lookup = FS.lookupPath(path, { follow: !dontFollow });
+                    node = lookup.node;
+                }
+                else {
+                    node = path;
+                } FS.doChmod(null, node, mode, dontFollow); }, lchmod(path, mode) { FS.chmod(path, mode, true); }, fchmod(fd, mode) { var stream = FS.getStreamChecked(fd); FS.doChmod(stream, stream.node, mode, false); }, doChown(stream, node, dontFollow) { FS.doSetAttr(stream, node, { timestamp: Date.now(), dontFollow }); }, chown(path, uid, gid, dontFollow) { var node; if (typeof path == "string") {
+                    var lookup = FS.lookupPath(path, { follow: !dontFollow });
+                    node = lookup.node;
+                }
+                else {
+                    node = path;
+                } FS.doChown(null, node, dontFollow); }, lchown(path, uid, gid) { FS.chown(path, uid, gid, true); }, fchown(fd, uid, gid) { var stream = FS.getStreamChecked(fd); FS.doChown(stream, stream.node, false); }, doTruncate(stream, node, len) { if (FS.isDir(node.mode)) {
+                    throw new FS.ErrnoError(31);
+                } if (!FS.isFile(node.mode)) {
+                    throw new FS.ErrnoError(28);
+                } var errCode = FS.nodePermissions(node, "w"); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } FS.doSetAttr(stream, node, { size: len, timestamp: Date.now() }); }, truncate(path, len) { if (len < 0) {
+                    throw new FS.ErrnoError(28);
+                } var node; if (typeof path == "string") {
+                    var lookup = FS.lookupPath(path, { follow: true });
+                    node = lookup.node;
+                }
+                else {
+                    node = path;
+                } FS.doTruncate(null, node, len); }, ftruncate(fd, len) { var stream = FS.getStreamChecked(fd); if (len < 0 || (stream.flags & 2097155) === 0) {
+                    throw new FS.ErrnoError(28);
+                } FS.doTruncate(stream, stream.node, len); }, utime(path, atime, mtime) { var lookup = FS.lookupPath(path, { follow: true }); var node = lookup.node; var setattr = FS.checkOpExists(node.node_ops.setattr, 63); setattr(node, { atime, mtime }); }, open(path, flags, mode = 438) { if (path === "") {
+                    throw new FS.ErrnoError(44);
+                } flags = FS_modeStringToFlags(flags); if (flags & 64) {
+                    mode = mode & 4095 | 32768;
+                }
+                else {
+                    mode = 0;
+                } var node; var isDirPath; if (typeof path == "object") {
+                    node = path;
+                }
+                else {
+                    isDirPath = path.endsWith("/");
+                    var lookup = FS.lookupPath(path, { follow: !(flags & 131072), noent_okay: true });
+                    node = lookup.node;
+                    path = lookup.path;
+                } var created = false; if (flags & 64) {
+                    if (node) {
+                        if (flags & 128) {
+                            throw new FS.ErrnoError(20);
+                        }
+                    }
+                    else if (isDirPath) {
+                        throw new FS.ErrnoError(31);
+                    }
+                    else {
+                        node = FS.mknod(path, mode | 511, 0);
+                        created = true;
+                    }
+                } if (!node) {
+                    throw new FS.ErrnoError(44);
+                } if (FS.isChrdev(node.mode)) {
+                    flags &= -513;
+                } if (flags & 65536 && !FS.isDir(node.mode)) {
+                    throw new FS.ErrnoError(54);
+                } if (!created) {
+                    var errCode = FS.mayOpen(node, flags);
+                    if (errCode) {
+                        throw new FS.ErrnoError(errCode);
+                    }
+                } if (flags & 512 && !created) {
+                    FS.truncate(node, 0);
+                } flags &= -131713; var stream = FS.createStream({ node, path: FS.getPath(node), flags, seekable: true, position: 0, stream_ops: node.stream_ops, ungotten: [], error: false }); if (stream.stream_ops.open) {
+                    stream.stream_ops.open(stream);
+                } if (created) {
+                    FS.chmod(node, mode & 511);
+                } return stream; }, close(stream) { if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if (stream.getdents)
+                    stream.getdents = null; try {
+                    if (stream.stream_ops.close) {
+                        stream.stream_ops.close(stream);
+                    }
+                }
+                catch (e) {
+                    throw e;
+                }
+                finally {
+                    FS.closeStream(stream.fd);
+                } stream.fd = null; }, isClosed(stream) { return stream.fd === null; }, llseek(stream, offset, whence) { if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if (!stream.seekable || !stream.stream_ops.llseek) {
+                    throw new FS.ErrnoError(70);
+                } if (whence != 0 && whence != 1 && whence != 2) {
+                    throw new FS.ErrnoError(28);
+                } stream.position = stream.stream_ops.llseek(stream, offset, whence); stream.ungotten = []; return stream.position; }, read(stream, buffer, offset, length, position) { if (length < 0 || position < 0) {
+                    throw new FS.ErrnoError(28);
+                } if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if ((stream.flags & 2097155) === 1) {
+                    throw new FS.ErrnoError(8);
+                } if (FS.isDir(stream.node.mode)) {
+                    throw new FS.ErrnoError(31);
+                } if (!stream.stream_ops.read) {
+                    throw new FS.ErrnoError(28);
+                } var seeking = typeof position != "undefined"; if (!seeking) {
+                    position = stream.position;
+                }
+                else if (!stream.seekable) {
+                    throw new FS.ErrnoError(70);
+                } var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); if (!seeking)
+                    stream.position += bytesRead; return bytesRead; }, write(stream, buffer, offset, length, position, canOwn) { if (length < 0 || position < 0) {
+                    throw new FS.ErrnoError(28);
+                } if (FS.isClosed(stream)) {
+                    throw new FS.ErrnoError(8);
+                } if ((stream.flags & 2097155) === 0) {
+                    throw new FS.ErrnoError(8);
+                } if (FS.isDir(stream.node.mode)) {
+                    throw new FS.ErrnoError(31);
+                } if (!stream.stream_ops.write) {
+                    throw new FS.ErrnoError(28);
+                } if (stream.seekable && stream.flags & 1024) {
+                    FS.llseek(stream, 0, 2);
+                } var seeking = typeof position != "undefined"; if (!seeking) {
+                    position = stream.position;
+                }
+                else if (!stream.seekable) {
+                    throw new FS.ErrnoError(70);
+                } var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); if (!seeking)
+                    stream.position += bytesWritten; return bytesWritten; }, mmap(stream, length, position, prot, flags) { if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
+                    throw new FS.ErrnoError(2);
+                } if ((stream.flags & 2097155) === 1) {
+                    throw new FS.ErrnoError(2);
+                } if (!stream.stream_ops.mmap) {
+                    throw new FS.ErrnoError(43);
+                } if (!length) {
+                    throw new FS.ErrnoError(28);
+                } return stream.stream_ops.mmap(stream, length, position, prot, flags); }, msync(stream, buffer, offset, length, mmapFlags) { if (!stream.stream_ops.msync) {
+                    return 0;
+                } return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); }, ioctl(stream, cmd, arg) { if (!stream.stream_ops.ioctl) {
+                    throw new FS.ErrnoError(59);
+                } return stream.stream_ops.ioctl(stream, cmd, arg); }, readFile(path, opts = {}) { opts.flags = opts.flags || 0; opts.encoding = opts.encoding || "binary"; if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
+                    abort(`Invalid encoding type "${opts.encoding}"`);
+                } var stream = FS.open(path, opts.flags); var stat = FS.stat(path); var length = stat.size; var buf = new Uint8Array(length); FS.read(stream, buf, 0, length, 0); if (opts.encoding === "utf8") {
+                    buf = UTF8ArrayToString(buf);
+                } FS.close(stream); return buf; }, writeFile(path, data, opts = {}) { opts.flags = opts.flags || 577; var stream = FS.open(path, opts.flags, opts.mode); data = FS_fileDataToTypedArray(data); FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); FS.close(stream); }, cwd: () => FS.currentPath, chdir(path) { var lookup = FS.lookupPath(path, { follow: true }); if (lookup.node === null) {
+                    throw new FS.ErrnoError(44);
+                } if (!FS.isDir(lookup.node.mode)) {
+                    throw new FS.ErrnoError(54);
+                } var errCode = FS.nodePermissions(lookup.node, "x"); if (errCode) {
+                    throw new FS.ErrnoError(errCode);
+                } FS.currentPath = lookup.path; }, createDefaultDirectories() { FS.mkdir("/tmp"); FS.mkdir("/home"); FS.mkdir("/home/web_user"); }, createDefaultDevices() { FS.mkdir("/dev"); FS.registerDevice(FS.makedev(1, 3), { read: () => 0, write: (stream, buffer, offset, length, pos) => length, llseek: () => 0 }); FS.mkdev("/dev/null", FS.makedev(1, 3)); TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); FS.mkdev("/dev/tty", FS.makedev(5, 0)); FS.mkdev("/dev/tty1", FS.makedev(6, 0)); var randomBuffer = new Uint8Array(1024), randomLeft = 0; var randomByte = () => { if (randomLeft === 0) {
+                    randomFill(randomBuffer);
+                    randomLeft = randomBuffer.byteLength;
+                } return randomBuffer[--randomLeft]; }; FS.createDevice("/dev", "random", randomByte); FS.createDevice("/dev", "urandom", randomByte); FS.mkdir("/dev/shm"); FS.mkdir("/dev/shm/tmp"); }, createSpecialDirectories() { FS.mkdir("/proc"); var proc_self = FS.mkdir("/proc/self"); FS.mkdir("/proc/self/fd"); FS.mount({ mount() { var node = FS.createNode(proc_self, "fd", 16895, 73); node.stream_ops = { llseek: MEMFS.stream_ops.llseek }; node.node_ops = { lookup(parent, name) { var fd = +name; var stream = FS.getStreamChecked(fd); var ret = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => stream.path }, id: fd + 1 }; ret.parent = ret; return ret; }, readdir() { return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString()); } }; return node; } }, {}, "/proc/self/fd"); }, createStandardStreams(input, output, error) { if (input) {
+                    FS.createDevice("/dev", "stdin", input);
+                }
+                else {
+                    FS.symlink("/dev/tty", "/dev/stdin");
+                } if (output) {
+                    FS.createDevice("/dev", "stdout", null, output);
+                }
+                else {
+                    FS.symlink("/dev/tty", "/dev/stdout");
+                } if (error) {
+                    FS.createDevice("/dev", "stderr", null, error);
+                }
+                else {
+                    FS.symlink("/dev/tty1", "/dev/stderr");
+                } FS.open("/dev/stdin", 0); FS.open("/dev/stdout", 1); FS.open("/dev/stderr", 1); }, staticInit() { FS.nameTable = new Array(4096); FS.mount(MEMFS, {}, "/"); FS.createDefaultDirectories(); FS.createDefaultDevices(); FS.createSpecialDirectories(); FS.filesystems = { MEMFS }; }, init(input, output, error) { FS.initialized = true; input !== null && input !== void 0 ? input : (input = Module["stdin"]); output !== null && output !== void 0 ? output : (output = Module["stdout"]); error !== null && error !== void 0 ? error : (error = Module["stderr"]); FS.createStandardStreams(input, output, error); }, quit() { FS.initialized = false; for (var stream of FS.streams) {
+                    if (stream) {
+                        FS.close(stream);
+                    }
+                } }, findObject(path, dontResolveLastLink) { var ret = FS.analyzePath(path, dontResolveLastLink); if (!ret.exists) {
+                    return null;
+                } return ret.object; }, analyzePath(path, dontResolveLastLink) { try {
+                    var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+                    path = lookup.path;
+                }
+                catch (e) { } var ret = { isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null }; try {
+                    var lookup = FS.lookupPath(path, { parent: true });
+                    ret.parentExists = true;
+                    ret.parentPath = lookup.path;
+                    ret.parentObject = lookup.node;
+                    ret.name = PATH.basename(path);
+                    lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+                    ret.exists = true;
+                    ret.path = lookup.path;
+                    ret.object = lookup.node;
+                    ret.name = lookup.node.name;
+                    ret.isRoot = lookup.path === "/";
+                }
+                catch (e) {
+                    ret.error = e.errno;
+                } return ret; }, createPath(parent, path, canRead, canWrite) { parent = typeof parent == "string" ? parent : FS.getPath(parent); var parts = path.split("/").reverse(); while (parts.length) {
+                    var part = parts.pop();
+                    if (!part)
+                        continue;
+                    var current = PATH.join2(parent, part);
+                    try {
+                        FS.mkdir(current);
+                    }
+                    catch (e) {
+                        if (e.errno != 20)
+                            throw e;
+                    }
+                    parent = current;
+                } return current; }, createFile(parent, name, properties, canRead, canWrite) { var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); var mode = FS_getMode(canRead, canWrite); return FS.create(path, mode); }, createDataFile(parent, name, data, canRead, canWrite, canOwn) { var path = name; if (parent) {
+                    parent = typeof parent == "string" ? parent : FS.getPath(parent);
+                    path = name ? PATH.join2(parent, name) : parent;
+                } var mode = FS_getMode(canRead, canWrite); var node = FS.create(path, mode); if (data) {
+                    data = FS_fileDataToTypedArray(data);
+                    FS.chmod(node, mode | 146);
+                    var stream = FS.open(node, 577);
+                    FS.write(stream, data, 0, data.length, 0, canOwn);
+                    FS.close(stream);
+                    FS.chmod(node, mode);
+                } }, createDevice(parent, name, input, output) { var _a; var _b; var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); var mode = FS_getMode(!!input, !!output); (_a = (_b = FS.createDevice).major) !== null && _a !== void 0 ? _a : (_b.major = 64); var dev = FS.makedev(FS.createDevice.major++, 0); FS.registerDevice(dev, { open(stream) { stream.seekable = false; }, close(stream) { var _a; if ((_a = output === null || output === void 0 ? void 0 : output.buffer) === null || _a === void 0 ? void 0 : _a.length) {
+                        output(10);
+                    } }, read(stream, buffer, offset, length, pos) { var bytesRead = 0; for (var i = 0; i < length; i++) {
+                        var result;
+                        try {
+                            result = input();
+                        }
+                        catch (e) {
+                            throw new FS.ErrnoError(29);
+                        }
+                        if (result === undefined && bytesRead === 0) {
+                            throw new FS.ErrnoError(6);
+                        }
+                        if (result === null || result === undefined)
+                            break;
+                        bytesRead++;
+                        buffer[offset + i] = result;
+                    } if (bytesRead) {
+                        stream.node.atime = Date.now();
+                    } return bytesRead; }, write(stream, buffer, offset, length, pos) { for (var i = 0; i < length; i++) {
+                        try {
+                            output(buffer[offset + i]);
+                        }
+                        catch (e) {
+                            throw new FS.ErrnoError(29);
+                        }
+                    } if (length) {
+                        stream.node.mtime = stream.node.ctime = Date.now();
+                    } return i; } }); return FS.mkdev(path, mode, dev); }, forceLoadFile(obj) { if (obj.isDevice || obj.isFolder || obj.link || obj.contents)
+                    return true; if (globalThis.XMLHttpRequest) {
+                    abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+                }
+                else {
+                    try {
+                        obj.contents = readBinary(obj.url);
+                    }
+                    catch (e) {
+                        throw new FS.ErrnoError(29);
+                    }
+                } }, createLazyFile(parent, name, url, canRead, canWrite) { class LazyUint8Array {
+                    constructor() {
+                        this.lengthKnown = false;
+                        this.chunks = [];
+                    }
+                    get(idx) { if (idx > this.length - 1 || idx < 0) {
+                        return undefined;
+                    } var chunkOffset = idx % this.chunkSize; var chunkNum = idx / this.chunkSize | 0; return this.getter(chunkNum)[chunkOffset]; }
+                    setDataGetter(getter) { this.getter = getter; }
+                    cacheLength() { var xhr = new XMLHttpRequest; xhr.open("HEAD", url, false); xhr.send(null); if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
+                        abort("Couldn't load " + url + ". Status: " + xhr.status); var datalength = Number(xhr.getResponseHeader("Content-length")); var header; var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; var chunkSize = 1024 * 1024; if (!hasByteServing)
+                        chunkSize = datalength; var doXHR = (from, to) => { if (from > to)
+                        abort("invalid range (" + from + ", " + to + ") or no bytes requested!"); if (to > datalength - 1)
+                        abort("only " + datalength + " bytes available! programmer error!"); var xhr = new XMLHttpRequest; xhr.open("GET", url, false); if (datalength !== chunkSize)
+                        xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); xhr.responseType = "arraybuffer"; if (xhr.overrideMimeType) {
+                        xhr.overrideMimeType("text/plain; charset=x-user-defined");
+                    } xhr.send(null); if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
+                        abort("Couldn't load " + url + ". Status: " + xhr.status); if (xhr.response !== undefined) {
+                        return new Uint8Array(xhr.response || []);
+                    } return intArrayFromString(xhr.responseText || ""); }; var lazyArray = this; lazyArray.setDataGetter(chunkNum => { var start = chunkNum * chunkSize; var end = (chunkNum + 1) * chunkSize - 1; end = Math.min(end, datalength - 1); if (typeof lazyArray.chunks[chunkNum] == "undefined") {
+                        lazyArray.chunks[chunkNum] = doXHR(start, end);
+                    } if (typeof lazyArray.chunks[chunkNum] == "undefined")
+                        abort("doXHR failed!"); return lazyArray.chunks[chunkNum]; }); if (usesGzip || !datalength) {
+                        chunkSize = datalength = 1;
+                        datalength = this.getter(0).length;
+                        chunkSize = datalength;
+                        out("LazyFiles on gzip forces download of the whole file when length is accessed");
+                    } this._length = datalength; this._chunkSize = chunkSize; this.lengthKnown = true; }
+                    get length() { if (!this.lengthKnown) {
+                        this.cacheLength();
+                    } return this._length; }
+                    get chunkSize() { if (!this.lengthKnown) {
+                        this.cacheLength();
+                    } return this._chunkSize; }
+                } if (globalThis.XMLHttpRequest) {
+                    if (!ENVIRONMENT_IS_WORKER)
+                        abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");
+                    var lazyArray = new LazyUint8Array;
+                    var properties = { isDevice: false, contents: lazyArray };
+                }
+                else {
+                    var properties = { isDevice: false, url };
+                } var node = FS.createFile(parent, name, properties, canRead, canWrite); if (properties.contents) {
+                    node.contents = properties.contents;
+                }
+                else if (properties.url) {
+                    node.contents = null;
+                    node.url = properties.url;
+                } Object.defineProperties(node, { usedBytes: { get: function () { return this.contents.length; } } }); var stream_ops = {}; for (const [key, fn] of Object.entries(node.stream_ops)) {
+                    stream_ops[key] = (...args) => { FS.forceLoadFile(node); return fn(...args); };
+                } function writeChunks(stream, buffer, offset, length, position) { var contents = stream.node.contents; if (position >= contents.length)
+                    return 0; var size = Math.min(contents.length - position, length); if (contents.slice) {
+                    for (var i = 0; i < size; i++) {
+                        buffer[offset + i] = contents[position + i];
+                    }
+                }
+                else {
+                    for (var i = 0; i < size; i++) {
+                        buffer[offset + i] = contents.get(position + i);
+                    }
+                } return size; } stream_ops.read = (stream, buffer, offset, length, position) => { FS.forceLoadFile(node); return writeChunks(stream, buffer, offset, length, position); }; stream_ops.mmap = (stream, length, position, prot, flags) => { FS.forceLoadFile(node); var ptr = mmapAlloc(); if (!ptr) {
+                    throw new FS.ErrnoError(48);
+                } writeChunks(stream, HEAP8, ptr, length, position); return { ptr, allocated: true }; }; node.stream_ops = stream_ops; return node; } };
+            var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+            var SYSCALLS = { calculateAt(dirfd, path, allowEmpty) { if (PATH.isAbs(path)) {
+                    return path;
+                } var dir; if (dirfd === -100) {
+                    dir = FS.cwd();
+                }
+                else {
+                    var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+                    dir = dirstream.path;
+                } if (path.length == 0) {
+                    if (!allowEmpty) {
+                        throw new FS.ErrnoError(44);
+                    }
+                    return dir;
+                } return dir + "/" + path; }, writeStat(buf, stat) { HEAPU32[buf >> 2] = stat.dev; HEAPU32[buf + 4 >> 2] = stat.mode; HEAPU32[buf + 8 >> 2] = stat.nlink; HEAPU32[buf + 12 >> 2] = stat.uid; HEAPU32[buf + 16 >> 2] = stat.gid; HEAPU32[buf + 20 >> 2] = stat.rdev; HEAP64[buf + 24 >> 3] = BigInt(stat.size); HEAP32[buf + 32 >> 2] = 4096; HEAP32[buf + 36 >> 2] = stat.blocks; var atime = stat.atime.getTime(); var mtime = stat.mtime.getTime(); var ctime = stat.ctime.getTime(); HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3)); HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3; HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3)); HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3; HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3)); HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3; HEAP64[buf + 88 >> 3] = BigInt(stat.ino); return 0; }, writeStatFs(buf, stats) { HEAPU32[buf + 4 >> 2] = stats.bsize; HEAPU32[buf + 60 >> 2] = stats.bsize; HEAP64[buf + 8 >> 3] = BigInt(stats.blocks); HEAP64[buf + 16 >> 3] = BigInt(stats.bfree); HEAP64[buf + 24 >> 3] = BigInt(stats.bavail); HEAP64[buf + 32 >> 3] = BigInt(stats.files); HEAP64[buf + 40 >> 3] = BigInt(stats.ffree); HEAPU32[buf + 48 >> 2] = stats.fsid; HEAPU32[buf + 64 >> 2] = stats.flags; HEAPU32[buf + 56 >> 2] = stats.namelen; }, doMsync(addr, stream, len, flags, offset) { if (!FS.isFile(stream.node.mode)) {
+                    throw new FS.ErrnoError(43);
+                } if (flags & 2) {
+                    return 0;
+                } var buffer = HEAPU8.slice(addr, addr + len); FS.msync(stream, buffer, offset, len, flags); }, getStreamFromFD(fd) { var stream = FS.getStreamChecked(fd); return stream; }, varargs: undefined, getStr(ptr) { var ret = UTF8ToString(ptr); return ret; } };
+            function ___syscall_openat(dirfd, path, flags, varargs) { SYSCALLS.varargs = varargs; try {
+                path = SYSCALLS.getStr(path);
+                path = SYSCALLS.calculateAt(dirfd, path);
+                var mode = varargs ? syscallGetVarargI() : 0;
+                return FS.open(path, flags, mode).fd;
+            }
+            catch (e) {
+                if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+                    throw e;
+                return -e.errno;
+            } }
+            var __abort_js = () => abort("");
+            var getHeapMax = () => 2147483648;
+            var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+            var growMemory = size => { var oldHeapSize = wasmMemory.buffer.byteLength; var pages = (size - oldHeapSize + 65535) / 65536 | 0; try {
+                wasmMemory.grow(pages);
+                updateMemoryViews();
+                return 1;
+            }
+            catch (e) { } };
+            var _emscripten_resize_heap = requestedSize => { var oldSize = HEAPU8.length; requestedSize >>>= 0; var maxHeapSize = getHeapMax(); if (requestedSize > maxHeapSize) {
+                return false;
+            } for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = growMemory(newSize);
+                if (replacement) {
+                    return true;
+                }
+            } return false; };
+            var doReadv = (stream, iov, iovcnt, offset) => { var ret = 0; for (var i = 0; i < iovcnt; i++) {
+                var ptr = HEAPU32[iov >> 2];
+                var len = HEAPU32[iov + 4 >> 2];
+                iov += 8;
+                var curr = FS.read(stream, HEAP8, ptr, len, offset);
+                if (curr < 0)
+                    return -1;
+                ret += curr;
+                if (curr < len)
+                    break;
+            } return ret; };
+            function _fd_read(fd, iov, iovcnt, pnum) { try {
+                var stream = SYSCALLS.getStreamFromFD(fd);
+                var num = doReadv(stream, iov, iovcnt);
+                HEAPU32[pnum >> 2] = num;
+                return 0;
+            }
+            catch (e) {
+                if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
+                    throw e;
+                return e.errno;
+            } }
+            var getCFunc = ident => { var func = Module["_" + ident]; return func; };
+            var writeArrayToMemory = (array, buffer) => { HEAP8.set(array, buffer); };
+            var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+            var stackAlloc = sz => __emscripten_stack_alloc(sz);
+            var stringToUTF8OnStack = str => { var size = lengthBytesUTF8(str) + 1; var ret = stackAlloc(size); stringToUTF8(str, ret, size); return ret; };
+            var ccall = (ident, returnType, argTypes, args, opts) => { var toC = { string: str => { var ret = 0; if (str !== null && str !== undefined && str !== 0) {
+                    ret = stringToUTF8OnStack(str);
+                } return ret; }, array: arr => { var ret = stackAlloc(arr.length); writeArrayToMemory(arr, ret); return ret; } }; function convertReturnValue(ret) { if (returnType === "string") {
+                return UTF8ToString(ret);
+            } if (returnType === "boolean")
+                return Boolean(ret); return ret; } var func = getCFunc(ident); var cArgs = []; var stack = 0; if (args) {
+                for (var i = 0; i < args.length; i++) {
+                    var converter = toC[argTypes[i]];
+                    if (converter) {
+                        if (stack === 0)
+                            stack = stackSave();
+                        cArgs[i] = converter(args[i]);
+                    }
+                    else {
+                        cArgs[i] = args[i];
+                    }
+                }
+            } var ret = func(...cArgs); function onDone(ret) { if (stack !== 0)
+                stackRestore(stack); return convertReturnValue(ret); } ret = onDone(ret); return ret; };
+            var cwrap = (ident, returnType, argTypes, opts) => { var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean"); var numericRet = returnType !== "string"; if (numericRet && numericArgs && !opts) {
+                return getCFunc(ident);
+            } return (...args) => ccall(ident, returnType, argTypes, args); };
+            FS.createPreloadedFile = FS_createPreloadedFile;
+            FS.preloadFile = FS_preloadFile;
+            FS.staticInit();
+            {
+                if (Module["noExitRuntime"])
+                    Module["noExitRuntime"];
+                if (Module["preloadPlugins"])
+                    preloadPlugins = Module["preloadPlugins"];
+                if (Module["print"])
+                    out = Module["print"];
+                if (Module["printErr"])
+                    err = Module["printErr"];
+                if (Module["wasmBinary"])
+                    wasmBinary = Module["wasmBinary"];
+                if (Module["arguments"])
+                    Module["arguments"];
+                if (Module["thisProgram"])
+                    Module["thisProgram"];
+                if (Module["preInit"]) {
+                    if (typeof Module["preInit"] == "function")
+                        Module["preInit"] = [Module["preInit"]];
+                    while (Module["preInit"].length > 0) {
+                        Module["preInit"].shift()();
+                    }
+                }
+            }
+            Module["ccall"] = ccall;
+            Module["cwrap"] = cwrap;
+            var __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, wasmMemory;
+            function assignWasmExports(wasmExports) { Module["_wasm_smaugt_keypair"] = wasmExports["g"]; Module["_wasm_smaugt_encapsulate"] = wasmExports["h"]; Module["_wasm_smaugt_decapsulate"] = wasmExports["i"]; Module["_malloc"] = wasmExports["j"]; Module["_free"] = wasmExports["k"]; __emscripten_stack_restore = wasmExports["l"]; __emscripten_stack_alloc = wasmExports["m"]; _emscripten_stack_get_current = wasmExports["n"]; wasmMemory = wasmExports["e"]; wasmExports["__indirect_function_table"]; }
+            var wasmImports = { c: ___syscall_openat, d: __abort_js, a: _emscripten_resize_heap, b: _fd_read };
+            function run() { if (runDependencies > 0) {
+                dependenciesFulfilled = run;
+                return;
+            } preRun(); if (runDependencies > 0) {
+                dependenciesFulfilled = run;
+                return;
+            } function doRun() { var _a; Module["calledRun"] = true; if (ABORT)
+                return; initRuntime(); readyPromiseResolve === null || readyPromiseResolve === void 0 ? void 0 : readyPromiseResolve(Module); (_a = Module["onRuntimeInitialized"]) === null || _a === void 0 ? void 0 : _a.call(Module); postRun(); } if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(() => { setTimeout(() => Module["setStatus"](""), 1); doRun(); }, 1);
+            }
+            else {
+                doRun();
+            } }
+            var wasmExports;
+            wasmExports = yield (createWasm());
+            run();
+            if (runtimeInitialized) {
+                moduleRtn = Module;
+            }
+            else {
+                moduleRtn = new Promise((resolve, reject) => { readyPromiseResolve = resolve; readyPromiseReject = reject; });
+            }
+            return moduleRtn;
+        });
+    }
+
+    // 환경(브라우저/Node)에 따라 .wasm 바이너리를 가져오는 헬퍼.
+    //
+    // - 브라우저/Worker: fetch() 사용. http(s):/blob:/data: URL 모두 처리.
+    // - Node.js: file:// URL 이면 fs 로 직접 읽고, 그 외엔 글로벌 fetch (Node 18+ 내장) 사용.
+    //
+    // 사용자는 보통 직접 호출할 일이 없고, loadLocusWasm 에 fetcher 옵션을 주입할 때만
+    // 이 함수의 시그니처 (url: URL) => Promise<Uint8Array> 와 동일하면 된다.
+    var _a, _b;
+    const isNode = !!((_b = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.versions) === null || _b === void 0 ? void 0 : _b.node);
+    // node:* 모듈을 동적으로 로드할 때 import 인자를 변수로 우회한다.
+    // 리터럴 dynamic import (`import('node:fs/promises')`) 는 Vite/Rollup 의
+    // 정적 분석에 잡혀 browser 빌드에서 "Module 'node:*' has been externalized
+    // for browser compatibility" 경고를 띄운다. 변수로 인자를 감싸면 정적
+    // 분석을 회피하고, Node 런타임에서는 그대로 동적 import 가 된다.
+    // 이 함수의 isNode 가드 안에서만 호출되므로 browser 런타임에서는 도달하지 않는다.
+    const _dynImport = (m) => (function (t) { return new Promise(function (resolve, reject) { require([t], function (m) { resolve(/*#__PURE__*/_interopNamespaceDefault(m)); }, reject); }); })(/* @vite-ignore */ /* webpackIgnore: true */ m);
+    /**
+     * .wasm 바이너리를 Uint8Array 로 가져온다.
+     * @param {URL | string} input
+     * @returns {Promise<Uint8Array>}
+     */
+    function fetchWasmBytes(input) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const url = input instanceof URL ? input : new URL(input);
+            // Node 에서 패키지 동봉 파일 (file://) 은 fs 로 직접 읽는 게 가장 빠르고 의존성도 없다.
+            if (isNode && url.protocol === 'file:') {
+                const [{ readFile }, { fileURLToPath }] = yield Promise.all([
+                    _dynImport('node:fs/promises'),
+                    _dynImport('node:url'),
+                ]);
+                const buf = yield readFile(fileURLToPath(url));
+                return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+            }
+            if (typeof fetch !== 'function') {
+                throw new Error('fetchWasmBytes: globalThis.fetch is not available in this environment');
+            }
+            const res = yield fetch(url);
+            if (!res.ok) {
+                throw new Error(`fetchWasmBytes: failed to fetch ${url} — ${res.status} ${res.statusText}`);
+            }
+            const ab = yield res.arrayBuffer();
+            return new Uint8Array(ab);
+        });
+    }
+
+    let aimerC;
+    let smaugtC;
+    let haetaeC;
+    // 2. 키 생성 브릿지
+    // Go 측 aimer_wasm.go 는 (pkSize, skSize, jsSeed) 로 호출한다. seedBuf 를
+    // C 메모리로 복사해서 _wasm_aimer_keypair(pkPtr, skPtr, seedPtr) 에 넘겨야
+    // AIMER 의 NIST AES-CTR-DRBG (rng.c) 가 시드되어 결정적이지 않은 키를 생성한다.
+    globalThis.js_aimer_generate_keypair = function (pkSize, skSize, seedBuf) {
+        const pkPtr = aimerC._malloc(pkSize);
+        const skPtr = aimerC._malloc(skSize);
+        const seedPtr = aimerC._malloc(seedBuf.length);
+        aimerC.HEAPU8.set(seedBuf, seedPtr);
+        const ret = aimerC._wasm_aimer_keypair(pkPtr, skPtr, seedPtr);
+        let pkBytes = null, skBytes = null;
+        if (ret === 0) {
+            pkBytes = new Uint8Array(aimerC.HEAPU8.buffer, pkPtr, pkSize).slice();
+            skBytes = new Uint8Array(aimerC.HEAPU8.buffer, skPtr, skSize).slice();
+        }
+        aimerC._free(pkPtr);
+        aimerC._free(skPtr);
+        aimerC._free(seedPtr);
+        return { ret: ret, pk: pkBytes, sk: skBytes };
+    };
+    // 3. 서명 브릿지
+    globalThis.js_aimer_sign = function (msgBuf, skBuf, maxSigLen) {
+        const msgPtr = aimerC._malloc(msgBuf.length);
+        const skPtr = aimerC._malloc(skBuf.length);
+        const sigPtr = aimerC._malloc(maxSigLen);
+        const sigLenPtr = aimerC._malloc(4);
+        aimerC.HEAPU8.set(msgBuf, msgPtr);
+        aimerC.HEAPU8.set(skBuf, skPtr);
+        // 💡 [핵심 해결] 중간에 0, 0 (ctx, ctxlen) 파라미터를 추가해서 총 7개를 넘깁니다!
+        const ret = aimerC._wasm_aimer_sign(sigPtr, sigLenPtr, msgPtr, msgBuf.length, 0, 0, skPtr);
+        const actualLen = aimerC.HEAPU32[sigLenPtr / 4];
+        const exactSigBuf = new Uint8Array(aimerC.HEAPU8.buffer, sigPtr, actualLen).slice();
+        aimerC._free(msgPtr);
+        aimerC._free(skPtr);
+        aimerC._free(sigPtr);
+        aimerC._free(sigLenPtr);
+        return { ret: ret, signature: exactSigBuf };
+    };
+    // 4. 검증 브릿지
+    globalThis.js_aimer_verify = function (sigBuf, msgBuf, pkBuf) {
+        // 💡 [완벽 해결 1] AIMer 128s의 정확한 서명 길이는 5904 바이트입니다.
+        // Go 언어(LocusChain)가 6000 바이트로 0을 채워서 보내더라도, 정확히 5904 바이트만 잘라냅니다.
+        let exactSigLen = 4160;
+        if (sigBuf.length < exactSigLen) {
+            exactSigLen = sigBuf.length;
+        }
+        const sigPtr = aimerC._malloc(exactSigLen);
+        const msgPtr = aimerC._malloc(msgBuf.length);
+        const pkPtr = aimerC._malloc(pkBuf.length);
+        // 딱 5904 바이트만 C 메모리에 복사합니다.
+        aimerC.HEAPU8.set(sigBuf.subarray(0, exactSigLen), sigPtr);
+        aimerC.HEAPU8.set(msgBuf, msgPtr);
+        aimerC.HEAPU8.set(pkBuf, pkPtr);
+        // 💡 [완벽 해결 2] 파라미터 7개 (0, 0 포함)와 정확한 길이(exactSigLen)를 넘깁니다!
+        const ret = aimerC._wasm_aimer_verify(sigPtr, exactSigLen, msgPtr, msgBuf.length, 0, 0, pkPtr);
+        aimerC._free(sigPtr);
+        aimerC._free(msgPtr);
+        aimerC._free(pkPtr);
+        return { ret: ret };
+    };
+    // ==========================================
+    // [SMAUGT JS Bridge (KEM)]
+    // ==========================================
+    // 2. 키 쌍 생성 브릿지
+    globalThis.js_smaugt_generate_keypair = function (pkSize, skSize) {
+        const pkPtr = smaugtC._malloc(pkSize);
+        const skPtr = smaugtC._malloc(skSize);
+        const ret = smaugtC._wasm_smaugt_keypair(pkPtr, skPtr);
+        let pkBytes = null, skBytes = null;
+        if (ret === 0) {
+            pkBytes = new Uint8Array(smaugtC.HEAPU8.buffer, pkPtr, pkSize).slice();
+            skBytes = new Uint8Array(smaugtC.HEAPU8.buffer, skPtr, skSize).slice();
+        }
+        smaugtC._free(pkPtr);
+        smaugtC._free(skPtr);
+        return { ret: ret, pk: pkBytes, sk: skBytes };
+    };
+    // 3. 캡슐화 (Encapsulate) 브릿지
+    globalThis.js_smaugt_encapsulate = function (pkBuf, ctSize, ssSize) {
+        const pkPtr = smaugtC._malloc(pkBuf.length);
+        const ctPtr = smaugtC._malloc(ctSize);
+        const ssPtr = smaugtC._malloc(ssSize);
+        // Go에서 받은 공개키(pk)를 C 메모리에 복사
+        smaugtC.HEAPU8.set(pkBuf, pkPtr);
+        const ret = smaugtC._wasm_smaugt_encapsulate(ctPtr, ssPtr, pkPtr);
+        let ctBytes = null, ssBytes = null;
+        if (ret === 0) {
+            // 암호문과 공유 비밀키를 C 메모리에서 빼옴
+            ctBytes = new Uint8Array(smaugtC.HEAPU8.buffer, ctPtr, ctSize).slice();
+            ssBytes = new Uint8Array(smaugtC.HEAPU8.buffer, ssPtr, ssSize).slice();
+        }
+        smaugtC._free(pkPtr);
+        smaugtC._free(ctPtr);
+        smaugtC._free(ssPtr);
+        return { ret: ret, ciphertext: ctBytes, sharedSecret: ssBytes };
+    };
+    // 4. 디캡슐화 (Decapsulate) 브릿지
+    globalThis.js_smaugt_decapsulate = function (ctBuf, skBuf, ssSize) {
+        const ctPtr = smaugtC._malloc(ctBuf.length);
+        const skPtr = smaugtC._malloc(skBuf.length);
+        const ssPtr = smaugtC._malloc(ssSize);
+        // Go에서 받은 암호문(ct)과 비밀키(sk)를 C 메모리에 복사
+        smaugtC.HEAPU8.set(ctBuf, ctPtr);
+        smaugtC.HEAPU8.set(skBuf, skPtr);
+        const ret = smaugtC._wasm_smaugt_decapsulate(ssPtr, ctPtr, skPtr);
+        let ssBytes = null;
+        if (ret === 0) {
+            ssBytes = new Uint8Array(smaugtC.HEAPU8.buffer, ssPtr, ssSize).slice();
+        }
+        smaugtC._free(ctPtr);
+        smaugtC._free(skPtr);
+        smaugtC._free(ssPtr);
+        return { ret: ret, sharedSecret: ssBytes };
+    };
+    // ==========================================
+    // [HAETAE JS Bridge (Signature)]
+    // ==========================================
+    // 2. 키 쌍 생성 브릿지
+    // Go 측 haetae_wasm.go 도 (pkSize, skSize, jsSeed) 로 호출한다. AIMER 와
+    // 동일하게 seedBuf 를 C 메모리로 복사해서 _wasm_haetae_keypair 의 3번째
+    // 인자로 전달해야 HAETAE 의 randombytes 가 시드된다.
+    globalThis.js_haetae_generate_keypair = function (pkSize, skSize, seedBuf) {
+        const pkPtr = haetaeC._malloc(pkSize);
+        const skPtr = haetaeC._malloc(skSize);
+        const seedPtr = haetaeC._malloc(seedBuf.length);
+        haetaeC.HEAPU8.set(seedBuf, seedPtr);
+        const ret = haetaeC._wasm_haetae_keypair(pkPtr, skPtr, seedPtr);
+        let pkBytes = null, skBytes = null;
+        if (ret === 0) {
+            pkBytes = new Uint8Array(haetaeC.HEAPU8.buffer, pkPtr, pkSize).slice();
+            skBytes = new Uint8Array(haetaeC.HEAPU8.buffer, skPtr, skSize).slice();
+        }
+        haetaeC._free(pkPtr);
+        haetaeC._free(skPtr);
+        haetaeC._free(seedPtr);
+        return { ret: ret, pk: pkBytes, sk: skBytes };
+    };
+    // 3. 서명 생성 브릿지
+    globalThis.js_haetae_sign = function (msgBuf, skBuf, maxSigSize) {
+        const sigPtr = haetaeC._malloc(maxSigSize);
+        const sigLenPtr = haetaeC._malloc(4); // size_t
+        const msgPtr = haetaeC._malloc(msgBuf.length);
+        const skPtr = haetaeC._malloc(skBuf.length);
+        haetaeC.HEAPU8.set(msgBuf, msgPtr);
+        haetaeC.HEAPU8.set(skBuf, skPtr);
+        // C 래퍼에서 ctx 인자를 제거했으므로 5개의 인자만 넘깁니다.
+        const ret = haetaeC._wasm_haetae_sign(sigPtr, sigLenPtr, msgPtr, msgBuf.length, skPtr);
+        let sigBytes = null;
+        if (ret === 0) {
+            const actualSigLen = haetaeC.HEAPU32[sigLenPtr / 4];
+            sigBytes = new Uint8Array(haetaeC.HEAPU8.buffer, sigPtr, actualSigLen).slice();
+        }
+        haetaeC._free(sigPtr);
+        haetaeC._free(sigLenPtr);
+        haetaeC._free(msgPtr);
+        haetaeC._free(skPtr);
+        return { ret: ret, signature: sigBytes };
+    };
+    // 4. 서명 검증 브릿지
+    globalThis.js_haetae_verify = function (sigBuf, msgBuf, pkBuf) {
+        const sigPtr = haetaeC._malloc(sigBuf.length);
+        const msgPtr = haetaeC._malloc(msgBuf.length);
+        const pkPtr = haetaeC._malloc(pkBuf.length);
+        haetaeC.HEAPU8.set(sigBuf, sigPtr);
+        haetaeC.HEAPU8.set(msgBuf, msgPtr);
+        haetaeC.HEAPU8.set(pkBuf, pkPtr);
+        const ret = haetaeC._wasm_haetae_verify(sigPtr, sigBuf.length, msgPtr, msgBuf.length, pkPtr);
+        haetaeC._free(sigPtr);
+        haetaeC._free(msgPtr);
+        haetaeC._free(pkPtr);
+        return { ret: ret };
+    };
+    // 정적 리터럴 URL — Vite/Rollup/Webpack5 가 `new URL(<리터럴>, import.meta.url)` 패턴을
+    // 정적 분석해서 사용자 빌드의 자산 그래프에 wasm 을 자동 등록할 수 있도록 모듈 최상위에서 선언.
+    // override (baseUrl/urls) 가 없을 때만 사용된다.
+    const DEFAULT_AIMER_URL = new URL('../autogen/wasm/crypto_aimer.wasm', new URL(module.uri, document.baseURI).href);
+    const DEFAULT_SMAUGT_URL = new URL('../autogen/wasm/crypto_smaugt.wasm', new URL(module.uri, document.baseURI).href);
+    const DEFAULT_HAETAE_URL = new URL('../autogen/wasm/crypto_haetae.wasm', new URL(module.uri, document.baseURI).href);
+    // AIMER / SMAUGT / HAETAE 의 .wasm 바이너리를 외부에서 받아와 Emscripten 모듈에 주입한다.
+    // Module({ wasmBinary }) 가 주어지면 글루는 자체 fetch 를 건너뛰고 그 바이트를 사용한다.
+    //
+    // opts:
+    //   baseUrl?: URL | string  — 기본은 이 파일이 위치한 디렉토리(=dist/utils/...) 기준 ./autogen/wasm/.
+    //   urls?: { aimer, smaugt, haetae }  — 개별 파일 override
+    //   fetcher?: (url: URL) => Promise<Uint8Array>  — 완전 커스텀 (CDN/캐시/모킹)
+    function loadCryptoWasm() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (opts = {}) {
+            var _a, _b, _c, _d;
+            const get = (_a = opts.fetcher) !== null && _a !== void 0 ? _a : fetchWasmBytes;
+            // 우선순위: opts.urls.* > opts.baseUrl > 정적 리터럴
+            const pick = (override, defaultUrl, name) => {
+                if (override) {
+                    const base = opts.baseUrl
+                        ? (opts.baseUrl instanceof URL ? opts.baseUrl : new URL(opts.baseUrl))
+                        : new URL('../autogen/wasm/', new URL(module.uri, document.baseURI).href);
+                    return override instanceof URL ? override : new URL(override, base);
+                }
+                if (opts.baseUrl) {
+                    const base = opts.baseUrl instanceof URL ? opts.baseUrl : new URL(opts.baseUrl);
+                    return new URL(name, base);
+                }
+                return defaultUrl;
+            };
+            const [aimerBin, smaugtBin, haetaeBin] = yield Promise.all([
+                get(pick((_b = opts.urls) === null || _b === void 0 ? void 0 : _b.aimer, DEFAULT_AIMER_URL, 'crypto_aimer.wasm')),
+                get(pick((_c = opts.urls) === null || _c === void 0 ? void 0 : _c.smaugt, DEFAULT_SMAUGT_URL, 'crypto_smaugt.wasm')),
+                get(pick((_d = opts.urls) === null || _d === void 0 ? void 0 : _d.haetae, DEFAULT_HAETAE_URL, 'crypto_haetae.wasm')),
+            ]);
+            aimerC = yield AimerModule({ wasmBinary: aimerBin });
+            smaugtC = yield SmaugtModule({ wasmBinary: smaugtBin });
+            haetaeC = yield HaetaeModule({ wasmBinary: haetaeBin });
+        });
+    }
+
+    /* eslint-disable */
+    (() => {
+        const enosys = () => {
+            const err = new Error('not implemented');
+            err.code = 'ENOSYS';
+            return err;
+        };
+        if (!globalThis.fs) {
+            let outputBuf = '';
+            globalThis.fs = {
+                constants: {
+                    O_WRONLY: -1,
+                    O_RDWR: -1,
+                    O_CREAT: -1,
+                    O_TRUNC: -1,
+                    O_APPEND: -1,
+                    O_EXCL: -1
+                }, // unused
+                writeSync(fd, buf) {
+                    outputBuf += decoder.decode(buf);
+                    const nl = outputBuf.lastIndexOf('\n');
+                    if (nl != -1) {
+                        console.log(outputBuf.substring(0, nl));
+                        outputBuf = outputBuf.substring(nl + 1);
+                    }
+                    return buf.length;
+                },
+                write(fd, buf, offset, length, position, callback) {
+                    if (offset !== 0 || length !== buf.length || position !== null) {
+                        callback(enosys());
+                        return;
+                    }
+                    const n = this.writeSync(fd, buf);
+                    callback(null, n);
+                },
+                chmod(path, mode, callback) {
+                    callback(enosys());
+                },
+                chown(path, uid, gid, callback) {
+                    callback(enosys());
+                },
+                close(fd, callback) {
+                    callback(enosys());
+                },
+                fchmod(fd, mode, callback) {
+                    callback(enosys());
+                },
+                fchown(fd, uid, gid, callback) {
+                    callback(enosys());
+                },
+                fstat(fd, callback) {
+                    callback(enosys());
+                },
+                fsync(fd, callback) {
+                    callback(null);
+                },
+                ftruncate(fd, length, callback) {
+                    callback(enosys());
+                },
+                lchown(path, uid, gid, callback) {
+                    callback(enosys());
+                },
+                link(path, link, callback) {
+                    callback(enosys());
+                },
+                lstat(path, callback) {
+                    callback(enosys());
+                },
+                mkdir(path, perm, callback) {
+                    callback(enosys());
+                },
+                open(path, flags, mode, callback) {
+                    callback(enosys());
+                },
+                read(fd, buffer, offset, length, position, callback) {
+                    callback(enosys());
+                },
+                readdir(path, callback) {
+                    callback(enosys());
+                },
+                readlink(path, callback) {
+                    callback(enosys());
+                },
+                rename(from, to, callback) {
+                    callback(enosys());
+                },
+                rmdir(path, callback) {
+                    callback(enosys());
+                },
+                stat(path, callback) {
+                    callback(enosys());
+                },
+                symlink(path, link, callback) {
+                    callback(enosys());
+                },
+                truncate(path, length, callback) {
+                    callback(enosys());
+                },
+                unlink(path, callback) {
+                    callback(enosys());
+                },
+                utimes(path, atime, mtime, callback) {
+                    callback(enosys());
+                }
+            };
+        }
+        // if (!globalThis.process) {
+        //   globalThis.process = {
+        //     getuid() {
+        //       return -1;
+        //     },
+        //     getgid() {
+        //       return -1;
+        //     },
+        //     geteuid() {
+        //       return -1;
+        //     },
+        //     getegid() {
+        //       return -1;
+        //     },
+        //     getgroups() {
+        //       throw enosys();
+        //     },
+        //     pid: -1,
+        //     ppid: -1,
+        //     umask() {
+        //       throw enosys();
+        //     },
+        //     cwd() {
+        //       throw enosys();
+        //     },
+        //     chdir() {
+        //       throw enosys();
+        //     }
+        //   };
+        // }
+        if (!globalThis.crypto) {
+            throw new Error('globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)');
+        }
+        if (!globalThis.performance) {
+            throw new Error('globalThis.performance is not available, polyfill required (performance.now only)');
+        }
+        if (!globalThis.TextEncoder) {
+            throw new Error('globalThis.TextEncoder is not available, polyfill required');
+        }
+        if (!globalThis.TextDecoder) {
+            throw new Error('globalThis.TextDecoder is not available, polyfill required');
+        }
+        const encoder = new TextEncoder('utf-8');
+        const decoder = new TextDecoder('utf-8');
+        globalThis.Go = class {
+            constructor() {
+                this.argv = ['js'];
+                this.env = {};
+                this.exit = code => {
+                    if (code !== 0) {
+                        console.warn('exit code:', code);
+                    }
+                };
+                this._exitPromise = new Promise(resolve => {
+                    this._resolveExitPromise = resolve;
+                });
+                this._pendingEvent = null;
+                this._scheduledTimeouts = new Map();
+                this._nextCallbackTimeoutID = 1;
+                const setInt64 = (addr, v) => {
+                    this.mem.setUint32(addr + 0, v, true);
+                    this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+                };
+                const getInt64 = addr => {
+                    const low = this.mem.getUint32(addr + 0, true);
+                    const high = this.mem.getInt32(addr + 4, true);
+                    return low + high * 4294967296;
+                };
+                const loadValue = addr => {
+                    const f = this.mem.getFloat64(addr, true);
+                    if (f === 0) {
+                        return undefined;
+                    }
+                    if (!isNaN(f)) {
+                        return f;
+                    }
+                    const id = this.mem.getUint32(addr, true);
+                    return this._values[id];
+                };
+                const storeValue = (addr, v) => {
+                    const nanHead = 0x7ff80000;
+                    if (typeof v === 'number' && v !== 0) {
+                        if (isNaN(v)) {
+                            this.mem.setUint32(addr + 4, nanHead, true);
+                            this.mem.setUint32(addr, 0, true);
+                            return;
+                        }
+                        this.mem.setFloat64(addr, v, true);
+                        return;
+                    }
+                    if (v === undefined) {
+                        this.mem.setFloat64(addr, 0, true);
+                        return;
+                    }
+                    let id = this._ids.get(v);
+                    if (id === undefined) {
+                        id = this._idPool.pop();
+                        if (id === undefined) {
+                            id = this._values.length;
+                        }
+                        this._values[id] = v;
+                        this._goRefCounts[id] = 0;
+                        this._ids.set(v, id);
+                    }
+                    this._goRefCounts[id]++;
+                    let typeFlag = 0;
+                    switch (typeof v) {
+                        case 'object':
+                            if (v !== null) {
+                                typeFlag = 1;
+                            }
+                            break;
+                        case 'string':
+                            typeFlag = 2;
+                            break;
+                        case 'symbol':
+                            typeFlag = 3;
+                            break;
+                        case 'function':
+                            typeFlag = 4;
+                            break;
+                    }
+                    this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+                    this.mem.setUint32(addr, id, true);
+                };
+                const loadSlice = addr => {
+                    const array = getInt64(addr + 0);
+                    const len = getInt64(addr + 8);
+                    return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+                };
+                const loadSliceOfValues = addr => {
+                    const array = getInt64(addr + 0);
+                    const len = getInt64(addr + 8);
+                    const a = new Array(len);
+                    for (let i = 0; i < len; i++) {
+                        a[i] = loadValue(array + i * 8);
+                    }
+                    return a;
+                };
+                const loadString = addr => {
+                    const saddr = getInt64(addr + 0);
+                    const len = getInt64(addr + 8);
+                    return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
+                };
+                const timeOrigin = Date.now() - performance.now();
+                this.importObject = {
+                    _gotest: {
+                        add: (a, b) => a + b
+                    },
+                    gojs: {
+                        // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+                        // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+                        // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+                        // This changes the SP, thus we have to update the SP used by the imported function.
+                        // func wasmExit(code int32)
+                        'runtime.wasmExit': sp => {
+                            sp >>>= 0;
+                            const code = this.mem.getInt32(sp + 8, true);
+                            this.exited = true;
+                            delete this._inst;
+                            delete this._values;
+                            delete this._goRefCounts;
+                            delete this._ids;
+                            delete this._idPool;
+                            this.exit(code);
+                        },
+                        // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+                        'runtime.wasmWrite': sp => {
+                            sp >>>= 0;
+                            const fd = getInt64(sp + 8);
+                            const p = getInt64(sp + 16);
+                            const n = this.mem.getInt32(sp + 24, true);
+                            fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
+                        },
+                        // func resetMemoryDataView()
+                        'runtime.resetMemoryDataView': sp => {
+                            this.mem = new DataView(this._inst.exports.mem.buffer);
+                        },
+                        // func nanotime1() int64
+                        'runtime.nanotime1': sp => {
+                            sp >>>= 0;
+                            setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
+                        },
+                        // func walltime() (sec int64, nsec int32)
+                        'runtime.walltime': sp => {
+                            sp >>>= 0;
+                            const msec = new Date().getTime();
+                            setInt64(sp + 8, msec / 1000);
+                            this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
+                        },
+                        // func scheduleTimeoutEvent(delay int64) int32
+                        'runtime.scheduleTimeoutEvent': sp => {
+                            sp >>>= 0;
+                            const id = this._nextCallbackTimeoutID;
+                            this._nextCallbackTimeoutID++;
+                            this._scheduledTimeouts.set(id, setTimeout(() => {
+                                this._resume();
+                                while (this._scheduledTimeouts.has(id)) {
+                                    // for some reason Go failed to register the timeout event, log and try again
+                                    // (temporary workaround for https://github.com/golang/go/issues/28975)
+                                    console.warn('scheduleTimeoutEvent: missed timeout event');
+                                    this._resume();
+                                }
+                            }, getInt64(sp + 8)));
+                            this.mem.setInt32(sp + 16, id, true);
+                        },
+                        // func clearTimeoutEvent(id int32)
+                        'runtime.clearTimeoutEvent': sp => {
+                            sp >>>= 0;
+                            const id = this.mem.getInt32(sp + 8, true);
+                            clearTimeout(this._scheduledTimeouts.get(id));
+                            this._scheduledTimeouts.delete(id);
+                        },
+                        // func getRandomData(r []byte)
+                        'runtime.getRandomData': sp => {
+                            sp >>>= 0;
+                            crypto.getRandomValues(loadSlice(sp + 8));
+                        },
+                        // func finalizeRef(v ref)
+                        'syscall/js.finalizeRef': sp => {
+                            sp >>>= 0;
+                            const id = this.mem.getUint32(sp + 8, true);
+                            this._goRefCounts[id]--;
+                            if (this._goRefCounts[id] === 0) {
+                                const v = this._values[id];
+                                this._values[id] = null;
+                                this._ids.delete(v);
+                                this._idPool.push(id);
+                            }
+                        },
+                        // func stringVal(value string) ref
+                        'syscall/js.stringVal': sp => {
+                            sp >>>= 0;
+                            storeValue(sp + 24, loadString(sp + 8));
+                        },
+                        // func valueGet(v ref, p string) ref
+                        'syscall/js.valueGet': sp => {
+                            sp >>>= 0;
+                            const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+                            sp = this._inst.exports.getsp() >>> 0; // see comment above
+                            storeValue(sp + 32, result);
+                        },
+                        // func valueSet(v ref, p string, x ref)
+                        'syscall/js.valueSet': sp => {
+                            sp >>>= 0;
+                            Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
+                        },
+                        // func valueDelete(v ref, p string)
+                        'syscall/js.valueDelete': sp => {
+                            sp >>>= 0;
+                            Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+                        },
+                        // func valueIndex(v ref, i int) ref
+                        'syscall/js.valueIndex': sp => {
+                            sp >>>= 0;
+                            storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
+                        },
+                        // valueSetIndex(v ref, i int, x ref)
+                        'syscall/js.valueSetIndex': sp => {
+                            sp >>>= 0;
+                            Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
+                        },
+                        // func valueCall(v ref, m string, args []ref) (ref, bool)
+                        'syscall/js.valueCall': sp => {
+                            sp >>>= 0;
+                            try {
+                                const v = loadValue(sp + 8);
+                                const m = Reflect.get(v, loadString(sp + 16));
+                                const args = loadSliceOfValues(sp + 32);
+                                const result = Reflect.apply(m, v, args);
+                                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                                storeValue(sp + 56, result);
+                                this.mem.setUint8(sp + 64, 1);
+                            }
+                            catch (err) {
+                                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                                storeValue(sp + 56, err);
+                                this.mem.setUint8(sp + 64, 0);
+                            }
+                        },
+                        // func valueInvoke(v ref, args []ref) (ref, bool)
+                        'syscall/js.valueInvoke': sp => {
+                            sp >>>= 0;
+                            try {
+                                const v = loadValue(sp + 8);
+                                const args = loadSliceOfValues(sp + 16);
+                                const result = Reflect.apply(v, undefined, args);
+                                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                                storeValue(sp + 40, result);
+                                this.mem.setUint8(sp + 48, 1);
+                            }
+                            catch (err) {
+                                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                                storeValue(sp + 40, err);
+                                this.mem.setUint8(sp + 48, 0);
+                            }
+                        },
+                        // func valueNew(v ref, args []ref) (ref, bool)
+                        'syscall/js.valueNew': sp => {
+                            sp >>>= 0;
+                            try {
+                                const v = loadValue(sp + 8);
+                                const args = loadSliceOfValues(sp + 16);
+                                const result = Reflect.construct(v, args);
+                                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                                storeValue(sp + 40, result);
+                                this.mem.setUint8(sp + 48, 1);
+                            }
+                            catch (err) {
+                                sp = this._inst.exports.getsp() >>> 0; // see comment above
+                                storeValue(sp + 40, err);
+                                this.mem.setUint8(sp + 48, 0);
+                            }
+                        },
+                        // func valueLength(v ref) int
+                        'syscall/js.valueLength': sp => {
+                            sp >>>= 0;
+                            setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+                        },
+                        // valuePrepareString(v ref) (ref, int)
+                        'syscall/js.valuePrepareString': sp => {
+                            sp >>>= 0;
+                            const str = encoder.encode(String(loadValue(sp + 8)));
+                            storeValue(sp + 16, str);
+                            setInt64(sp + 24, str.length);
+                        },
+                        // valueLoadString(v ref, b []byte)
+                        'syscall/js.valueLoadString': sp => {
+                            sp >>>= 0;
+                            const str = loadValue(sp + 8);
+                            loadSlice(sp + 16).set(str);
+                        },
+                        // func valueInstanceOf(v ref, t ref) bool
+                        'syscall/js.valueInstanceOf': sp => {
+                            sp >>>= 0;
+                            this.mem.setUint8(sp + 24, loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0);
+                        },
+                        // func copyBytesToGo(dst []byte, src ref) (int, bool)
+                        'syscall/js.copyBytesToGo': sp => {
+                            sp >>>= 0;
+                            const dst = loadSlice(sp + 8);
+                            const src = loadValue(sp + 32);
+                            if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+                                this.mem.setUint8(sp + 48, 0);
+                                return;
+                            }
+                            const toCopy = src.subarray(0, dst.length);
+                            dst.set(toCopy);
+                            setInt64(sp + 40, toCopy.length);
+                            this.mem.setUint8(sp + 48, 1);
+                        },
+                        // func copyBytesToJS(dst ref, src []byte) (int, bool)
+                        'syscall/js.copyBytesToJS': sp => {
+                            sp >>>= 0;
+                            const dst = loadValue(sp + 8);
+                            const src = loadSlice(sp + 16);
+                            if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+                                this.mem.setUint8(sp + 48, 0);
+                                return;
+                            }
+                            const toCopy = src.subarray(0, dst.length);
+                            dst.set(toCopy);
+                            setInt64(sp + 40, toCopy.length);
+                            this.mem.setUint8(sp + 48, 1);
+                        },
+                        debug: value => {
+                            console.log(value);
+                        }
+                    }
+                };
+            }
+            run(instance) {
+                return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+                    if (!(instance instanceof WebAssembly.Instance)) {
+                        throw new Error('Go.run: WebAssembly.Instance expected');
+                    }
+                    this._inst = instance;
+                    this.mem = new DataView(this._inst.exports.mem.buffer);
+                    this._values = [
+                        // JS values that Go currently has references to, indexed by reference id
+                        NaN,
+                        0,
+                        null,
+                        true,
+                        false,
+                        globalThis,
+                        this
+                    ];
+                    this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
+                    this._ids = new Map([
+                        // mapping from JS values to reference ids
+                        [0, 1],
+                        [null, 2],
+                        [true, 3],
+                        [false, 4],
+                        [globalThis, 5],
+                        [this, 6]
+                    ]);
+                    this._idPool = []; // unused ids that have been garbage collected
+                    this.exited = false; // whether the Go program has exited
+                    // Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
+                    let offset = 4096;
+                    const strPtr = str => {
+                        const ptr = offset;
+                        const bytes = encoder.encode(str + '\0');
+                        new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+                        offset += bytes.length;
+                        if (offset % 8 !== 0) {
+                            offset += 8 - (offset % 8);
+                        }
+                        return ptr;
+                    };
+                    const argc = this.argv.length;
+                    const argvPtrs = [];
+                    this.argv.forEach(arg => {
+                        argvPtrs.push(strPtr(arg));
+                    });
+                    argvPtrs.push(0);
+                    const keys = Object.keys(this.env).sort();
+                    keys.forEach(key => {
+                        argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+                    });
+                    argvPtrs.push(0);
+                    const argv = offset;
+                    argvPtrs.forEach(ptr => {
+                        this.mem.setUint32(offset, ptr, true);
+                        this.mem.setUint32(offset + 4, 0, true);
+                        offset += 8;
+                    });
+                    // The linker guarantees global data starts from at least wasmMinDataAddr.
+                    // Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
+                    const wasmMinDataAddr = 4096 + 8192;
+                    if (offset >= wasmMinDataAddr) {
+                        throw new Error('total length of command line and environment variables exceeds limit');
+                    }
+                    this._inst.exports.run(argc, argv);
+                    if (this.exited) {
+                        this._resolveExitPromise();
+                    }
+                    yield this._exitPromise;
+                });
+            }
+            _resume() {
+                if (this.exited) {
+                    throw new Error('Go program has already exited');
+                }
+                this._inst.exports.resume();
+                if (this.exited) {
+                    this._resolveExitPromise();
+                }
+            }
+            _makeFuncWrapper(id) {
+                const go = this;
+                return function () {
+                    const event = { id: id, this: this, args: arguments };
+                    go._pendingEvent = event;
+                    go._resume();
+                    return event.result;
+                };
+            }
+        };
+    })();
+    ((function () {
+        try {
+            if (typeof WebAssembly === 'object' && typeof WebAssembly.instantiate === 'function') {
+                const module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
+                if (module instanceof WebAssembly.Module) {
+                    return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
+                }
+            }
+        }
+        catch (e) { }
+        return false;
+    }))();
+    const go = new globalThis.Go();
+    const LCLIB_SEQ_KEY = '__LCLIB_WASM_SEQ__';
+    if (globalThis[LCLIB_SEQ_KEY] === undefined) {
+        globalThis[LCLIB_SEQ_KEY] = 0;
+    }
+    globalThis[LCLIB_SEQ_KEY] += 1;
+    const namespace = `wallet_${globalThis[LCLIB_SEQ_KEY]}`;
+    const lclibWasmConfig = { namespace };
+    // 정적 리터럴 URL — Vite/Rollup/Webpack5 가 `new URL(<리터럴>, import.meta.url)` 패턴을
+    // 정적 분석해서 사용자 빌드의 자산 그래프에 wasm 을 자동 등록할 수 있도록 모듈 최상위에서 선언.
+    // override (baseUrl/urls) 가 없을 때만 사용된다.
+    const DEFAULT_LCLIB_URL = new URL('../autogen/wasm/lclib.wasm', new URL(module.uri, document.baseURI).href);
+    // .wasm 바이너리 4 개(lclib + AIMER/SMAUGT/HAETAE) 를 외부 파일에서 fetch 해서 로드한다.
+    //
+    // opts:
+    //   baseUrl?: URL | string  — wasm 파일들이 놓인 베이스. 기본은 이 모듈 기준 ../autogen/wasm/.
+    //   urls?: { lclib, aimer, smaugt, haetae }  — 개별 파일 override (URL | string)
+    //   fetcher?: (url: URL) => Promise<Uint8Array>  — 완전 커스텀 (CDN/캐시/모킹/Node 정적 경로)
+    function load() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (opts = {}) {
+            var _a, _b;
+            try {
+                const get = (_a = opts.fetcher) !== null && _a !== void 0 ? _a : fetchWasmBytes;
+                // 우선순위: opts.urls.lclib > opts.baseUrl > 정적 리터럴
+                let lclibUrl;
+                if ((_b = opts.urls) === null || _b === void 0 ? void 0 : _b.lclib) {
+                    const base = opts.baseUrl
+                        ? (opts.baseUrl instanceof URL ? opts.baseUrl : new URL(opts.baseUrl))
+                        : new URL('../autogen/wasm/', new URL(module.uri, document.baseURI).href);
+                    lclibUrl = opts.urls.lclib instanceof URL ? opts.urls.lclib : new URL(opts.urls.lclib, base);
+                }
+                else if (opts.baseUrl) {
+                    const base = opts.baseUrl instanceof URL ? opts.baseUrl : new URL(opts.baseUrl);
+                    lclibUrl = new URL('lclib.wasm', base);
+                }
+                else {
+                    lclibUrl = DEFAULT_LCLIB_URL;
+                }
+                // crypto WASM 3 종과 Go lclib WASM 을 병렬로 다운로드.
+                const cryptoPromise = loadCryptoWasm(opts);
+                const lclibBytesPromise = get(lclibUrl);
+                let lclibBytes;
+                try {
+                    [, lclibBytes] = yield Promise.all([cryptoPromise, lclibBytesPromise]);
+                }
+                catch (err) {
+                    // 어느 단계에서 실패했는지 컨텍스트를 남긴다.
+                    console.error('Locus Chain WASM failed to load.', err);
+                    throw err;
+                }
+                globalThis.__LCLIB_WASM_CONFIG__ = lclibWasmConfig;
+                const result = yield WebAssembly.instantiate(lclibBytes, go.importObject);
+                go.run(result.instance);
+                delete globalThis.__LCLIB_WASM_CONFIG__;
+            }
+            catch (err) {
+                console.error('Locus Chain LCLIB WASM failed to load.', err);
+                throw err;
+            }
+        });
+    }
+
+    exports.load = load;
+    exports.namespace = namespace;
+
+}));