xash3d-fwgs
Version:
Xash3D-FWGS emscripten port
790 lines • 741 kB
JavaScript
var Xash3D = (() => {
var _scriptName = typeof document != "undefined" ? document.currentScript?.src : undefined;
return async function (moduleArg = {}) {
var moduleRtn;
var Module = moduleArg;
var ENVIRONMENT_IS_WEB = true;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => { throw toThrow; };
var scriptDirectory = "";
function locateFile(path) { if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
} return scriptDirectory + path; }
var readAsync, readBinary;
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
try {
scriptDirectory = new URL(".", _scriptName).href;
}
catch { }
{
readAsync = async (url) => { var response = await 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 dynamicLibraries = [];
var wasmBinary;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) { if (!condition) {
abort(text);
} }
var isFileURI = filename => filename.startsWith("file://");
function writeStackCookie() { var max = _emscripten_stack_get_end(); if (max == 0) {
max += 4;
} HEAPU32[max >> 2] = 34821223; HEAPU32[max + 4 >> 2] = 2310721022; HEAPU32[0 >> 2] = 1668509029; }
function checkStackCookie() { if (ABORT)
return; var max = _emscripten_stack_get_end(); if (max == 0) {
max += 4;
} var cookie1 = HEAPU32[max >> 2]; var cookie2 = HEAPU32[max + 4 >> 2]; if (cookie1 != 34821223 || cookie2 != 2310721022) {
abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
} if (HEAPU32[0 >> 2] != 1668509029) {
abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
} }
var readyPromiseResolve, readyPromiseReject;
var wasmMemory;
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var HEAP64, HEAPU64;
var runtimeInitialized = false;
function updateMemoryViews() { var b = wasmMemory.buffer; HEAP8 = new Int8Array(b); HEAP16 = new Int16Array(b); HEAPU8 = new Uint8Array(b); HEAPU16 = new Uint16Array(b); HEAP32 = new Int32Array(b); HEAPU32 = new Uint32Array(b); HEAPF32 = new Float32Array(b); HEAPF64 = new Float64Array(b); HEAP64 = new BigInt64Array(b); HEAPU64 = new BigUint64Array(b); }
function initMemory() { if (Module["wasmMemory"]) {
wasmMemory = Module["wasmMemory"];
}
else {
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 134217728;
wasmMemory = new WebAssembly.Memory({ initial: INITIAL_MEMORY / 65536, maximum: 32768 });
} updateMemoryViews(); }
var __RELOC_FUNCS__ = [];
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; checkStackCookie(); callRuntimeCallbacks(__RELOC_FUNCS__); callRuntimeCallbacks(onInits); if (!Module["noFSInit"] && !FS.initialized)
FS.init(); TTY.init(); SOCKFS.root = FS.mount(SOCKFS, {}, null); PIPEFS.root = FS.mount(PIPEFS, {}, null); wasmExports["__wasm_call_ctors"](); callRuntimeCallbacks(onPostCtors); FS.ignorePermissions = false; }
function preMain() { checkStackCookie(); callRuntimeCallbacks(onMains); }
function postRun() { checkStackCookie(); if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
} callRuntimeCallbacks(onPostRuns); }
var runDependencies = 0;
var dependenciesFulfilled = null;
function addRunDependency(id) { runDependencies++; Module["monitorRunDependencies"]?.(runDependencies); }
function removeRunDependency(id) { runDependencies--; Module["monitorRunDependencies"]?.(runDependencies); if (runDependencies == 0) {
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
} }
function abort(what) { Module["onAbort"]?.(what); what = "Aborted(" + what + ")"; err(what); ABORT = true; what += ". Build with -sASSERTIONS for more info."; var e = new WebAssembly.RuntimeError(what); readyPromiseReject?.(e); throw e; }
var wasmBinaryFile;
function findWasmBinary() { return locateFile("xash.wasm"); }
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"; }
async function getWasmBinary(binaryFile) { if (!wasmBinary) {
try {
var response = await readAsync(binaryFile);
return new Uint8Array(response);
}
catch { }
} return getBinarySync(binaryFile); }
async function instantiateArrayBuffer(binaryFile, imports) { try {
var binary = await getWasmBinary(binaryFile);
var instance = await WebAssembly.instantiate(binary, imports);
return instance;
}
catch (reason) {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
} }
async function instantiateAsync(binary, binaryFile, imports) { if (!binary && typeof WebAssembly.instantiateStreaming == "function") {
try {
var response = fetch(binaryFile, { credentials: "same-origin" });
var instantiationResult = await 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() { return { env: wasmImports, wasi_snapshot_preview1: wasmImports, "GOT.mem": new Proxy(wasmImports, GOTHandler), "GOT.func": new Proxy(wasmImports, GOTHandler) }; }
async function createWasm() { function receiveInstance(instance, module) { wasmExports = instance.exports; wasmExports = relocateExports(wasmExports, 1024); var metadata = getDylinkMetadata(module); if (metadata.neededDynlibs) {
dynamicLibraries = metadata.neededDynlibs.concat(dynamicLibraries);
} mergeLibSymbols(wasmExports, "main"); LDSO.init(); loadDylibs(); __RELOC_FUNCS__.push(wasmExports["__wasm_apply_data_relocs"]); assignWasmExports(wasmExports); removeRunDependency("wasm-instantiate"); return wasmExports; } addRunDependency("wasm-instantiate"); function receiveInstantiationResult(result) { return receiveInstance(result["instance"], result["module"]); } var info = getWasmImports(); if (Module["instantiateWasm"]) {
return new Promise((resolve, reject) => { Module["instantiateWasm"](info, (mod, inst) => { resolve(receiveInstance(mod, inst)); }); });
} wasmBinaryFile ?? (wasmBinaryFile = findWasmBinary()); var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info); var exports = receiveInstantiationResult(result); return exports; }
class ExitStatus {
constructor(status) {
this.name = "ExitStatus";
this.message = `Program terminated with exit(${status})`;
this.status = status;
}
}
var GOT = {};
var currentModuleWeakSymbols = new Set(["__start___llvm_prf_data", "__stop___llvm_prf_data", "__start___llvm_prf_names", "__stop___llvm_prf_names", "__start___llvm_prf_vns", "__stop___llvm_prf_vns", "__start___llvm_prf_vtab", "__stop___llvm_prf_vtab", "__start___llvm_prf_cnts", "__stop___llvm_prf_cnts", "__start___llvm_prf_bits", "__stop___llvm_prf_bits", "__start___llvm_prf_vnds", "__stop___llvm_prf_vnds"]);
var GOTHandler = { get(obj, symName) { var rtn = GOT[symName]; if (!rtn) {
rtn = GOT[symName] = new WebAssembly.Global({ value: "i32", mutable: true });
} if (!currentModuleWeakSymbols.has(symName)) {
rtn.required = true;
} return rtn; } };
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 UTF8Decoder = new TextDecoder;
var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { var maxIdx = idx + maxBytesToRead; if (ignoreNul)
return maxIdx; while (heapOrArray[idx] && !(idx >= maxIdx))
++idx; return idx; };
var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul); return UTF8Decoder.decode(heapOrArray.buffer ? heapOrArray.subarray(idx, endPtr) : new Uint8Array(heapOrArray.slice(idx, endPtr))); };
var getDylinkMetadata = binary => { var offset = 0; var end = 0; function getU8() { return binary[offset++]; } function getLEB() { var ret = 0; var mul = 1; while (1) {
var byte = binary[offset++];
ret += (byte & 127) * mul;
mul *= 128;
if (!(byte & 128))
break;
} return ret; } function getString() { var len = getLEB(); offset += len; return UTF8ArrayToString(binary, offset - len, len); } function getStringList() { var count = getLEB(); var rtn = []; while (count--)
rtn.push(getString()); return rtn; } function failIf(condition, message) { if (condition)
throw new Error(message); } if (binary instanceof WebAssembly.Module) {
var dylinkSection = WebAssembly.Module.customSections(binary, "dylink.0");
failIf(dylinkSection.length === 0, "need dylink section");
binary = new Uint8Array(dylinkSection[0]);
end = binary.length;
}
else {
var int32View = new Uint32Array(new Uint8Array(binary.subarray(0, 24)).buffer);
var magicNumberFound = int32View[0] == 1836278016;
failIf(!magicNumberFound, "need to see wasm magic number");
failIf(binary[8] !== 0, "need the dylink section to be first");
offset = 9;
var section_size = getLEB();
end = offset + section_size;
var name = getString();
failIf(name !== "dylink.0");
} var customSection = { neededDynlibs: [], tlsExports: new Set, weakImports: new Set, runtimePaths: [] }; var WASM_DYLINK_MEM_INFO = 1; var WASM_DYLINK_NEEDED = 2; var WASM_DYLINK_EXPORT_INFO = 3; var WASM_DYLINK_IMPORT_INFO = 4; var WASM_DYLINK_RUNTIME_PATH = 5; var WASM_SYMBOL_TLS = 256; var WASM_SYMBOL_BINDING_MASK = 3; var WASM_SYMBOL_BINDING_WEAK = 1; while (offset < end) {
var subsectionType = getU8();
var subsectionSize = getLEB();
if (subsectionType === WASM_DYLINK_MEM_INFO) {
customSection.memorySize = getLEB();
customSection.memoryAlign = getLEB();
customSection.tableSize = getLEB();
customSection.tableAlign = getLEB();
}
else if (subsectionType === WASM_DYLINK_NEEDED) {
customSection.neededDynlibs = getStringList();
}
else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
var count = getLEB();
while (count--) {
var symname = getString();
var flags = getLEB();
if (flags & WASM_SYMBOL_TLS) {
customSection.tlsExports.add(symname);
}
}
}
else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {
var count = getLEB();
while (count--) {
var modname = getString();
var symname = getString();
var flags = getLEB();
if ((flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
customSection.weakImports.add(symname);
}
}
}
else if (subsectionType === WASM_DYLINK_RUNTIME_PATH) {
customSection.runtimePaths = getStringList();
}
else {
offset += subsectionSize;
}
} return customSection; };
function getValue(ptr, type = "i8") { if (type.endsWith("*"))
type = "*"; switch (type) {
case "i1": return HEAP8[ptr];
case "i8": return HEAP8[ptr];
case "i16": return HEAP16[ptr >> 1];
case "i32": return HEAP32[ptr >> 2];
case "i64": return HEAP64[ptr >> 3];
case "float": return HEAPF32[ptr >> 2];
case "double": return HEAPF64[ptr >> 3];
case "*": return HEAPU32[ptr >> 2];
default: abort(`invalid type for getValue: ${type}`);
} }
var newDSO = (name, handle, syms) => { var dso = { refcount: Infinity, name, exports: syms, global: true }; LDSO.loadedLibsByName[name] = dso; if (handle != undefined) {
LDSO.loadedLibsByHandle[handle] = dso;
} return dso; };
var LDSO = { loadedLibsByName: {}, loadedLibsByHandle: {}, init() { newDSO("__main__", 0, wasmImports); } };
var ___heap_base = 33286528;
var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
var getMemory = size => { if (runtimeInitialized) {
return _calloc(size, 1);
} var ret = ___heap_base; var end = ret + alignMemory(size, 16); ___heap_base = end; GOT["__heap_base"].value = end; return ret; };
var isInternalSym = symName => ["__cpp_exception", "__c_longjmp", "__wasm_apply_data_relocs", "__dso_handle", "__tls_size", "__tls_align", "__set_stack_limits", "_emscripten_tls_init", "__wasm_init_tls", "__wasm_call_ctors", "__start_em_asm", "__stop_em_asm", "__start_em_js", "__stop_em_js"].includes(symName) || symName.startsWith("__em_js__");
var uleb128EncodeWithLen = arr => { const n = arr.length; return [n % 128 | 128, n >> 7, ...arr]; };
var wasmTypeCodes = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
var generateTypePack = types => uleb128EncodeWithLen(Array.from(types, type => { var code = wasmTypeCodes[type]; return code; }));
var convertJsFunctionToWasm = (func, sig) => { var bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...uleb128EncodeWithLen([1, 96, ...generateTypePack(sig.slice(1)), ...generateTypePack(sig[0] === "v" ? "" : sig[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0); var module = new WebAssembly.Module(bytes); var instance = new WebAssembly.Instance(module, { e: { f: func } }); var wrappedFunc = instance.exports["f"]; return wrappedFunc; };
var wasmTable = new WebAssembly.Table({ initial: 2727, element: "anyfunc" });
var getWasmTableEntry = funcPtr => wasmTable.get(funcPtr);
var updateTableMap = (offset, count) => { if (functionsInTableMap) {
for (var i = offset; i < offset + count; i++) {
var item = getWasmTableEntry(i);
if (item) {
functionsInTableMap.set(item, i);
}
}
} };
var functionsInTableMap;
var getFunctionAddress = func => { if (!functionsInTableMap) {
functionsInTableMap = new WeakMap;
updateTableMap(0, wasmTable.length);
} return functionsInTableMap.get(func) || 0; };
var freeTableIndexes = [];
var getEmptyTableSlot = () => { if (freeTableIndexes.length) {
return freeTableIndexes.pop();
} return wasmTable["grow"](1); };
var setWasmTableEntry = (idx, func) => wasmTable.set(idx, func);
var addFunction = (func, sig) => { var rtn = getFunctionAddress(func); if (rtn) {
return rtn;
} var ret = getEmptyTableSlot(); try {
setWasmTableEntry(ret, func);
}
catch (err) {
if (!(err instanceof TypeError)) {
throw err;
}
var wrapped = convertJsFunctionToWasm(func, sig);
setWasmTableEntry(ret, wrapped);
} functionsInTableMap.set(func, ret); return ret; };
var updateGOT = (exports, replace) => { for (var symName in exports) {
if (isInternalSym(symName)) {
continue;
}
var value = exports[symName];
GOT[symName] || (GOT[symName] = new WebAssembly.Global({ value: "i32", mutable: true }));
if (replace || GOT[symName].value == 0) {
if (typeof value == "function") {
GOT[symName].value = addFunction(value);
}
else if (typeof value == "number") {
GOT[symName].value = value;
}
else {
err(`unhandled export type for '${symName}': ${typeof value}`);
}
}
} };
var relocateExports = (exports, memoryBase, replace) => { var relocated = {}; for (var e in exports) {
var value = exports[e];
if (typeof value == "object") {
value = value.value;
}
if (typeof value == "number") {
value += memoryBase;
}
relocated[e] = value;
} updateGOT(relocated, replace); return relocated; };
var isSymbolDefined = symName => { var existing = wasmImports[symName]; if (!existing || existing.stub) {
return false;
} return true; };
var dynCall = (sig, ptr, args = [], promising = false) => { var func = getWasmTableEntry(ptr); var rtn = func(...args); function convert(rtn) { return rtn; } return convert(rtn); };
var stackSave = () => _emscripten_stack_get_current();
var stackRestore = val => __emscripten_stack_restore(val);
var createInvokeFunction = sig => (ptr, ...args) => { var sp = stackSave(); try {
return dynCall(sig, ptr, args);
}
catch (e) {
stackRestore(sp);
if (e !== e + 0)
throw e;
_setThrew(1, 0);
if (sig[0] == "j")
return 0n;
} };
var resolveGlobalSymbol = (symName, direct = false) => { var sym; if (isSymbolDefined(symName)) {
sym = wasmImports[symName];
}
else if (symName.startsWith("invoke_")) {
sym = wasmImports[symName] = createInvokeFunction(symName.split("_")[1]);
} return { sym, name: symName }; };
var onPostCtors = [];
var addOnPostCtor = cb => onPostCtors.push(cb);
var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => { if (!ptr)
return ""; var end = findStringEnd(HEAPU8, ptr, maxBytesToRead, ignoreNul); return UTF8Decoder.decode(HEAPU8.subarray(ptr, end)); };
var loadWebAssemblyModule = (binary, flags, libName, localScope, handle) => { var metadata = getDylinkMetadata(binary); currentModuleWeakSymbols = metadata.weakImports; function loadModule() { var memAlign = Math.pow(2, metadata.memoryAlign); var memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0; var tableBase = metadata.tableSize ? wasmTable.length : 0; if (handle) {
HEAP8[handle + 8] = 1;
HEAPU32[handle + 12 >> 2] = memoryBase;
HEAP32[handle + 16 >> 2] = metadata.memorySize;
HEAPU32[handle + 20 >> 2] = tableBase;
HEAP32[handle + 24 >> 2] = metadata.tableSize;
} if (metadata.tableSize) {
wasmTable.grow(metadata.tableSize);
} var moduleExports; function resolveSymbol(sym) { var resolved = resolveGlobalSymbol(sym).sym; if (!resolved && localScope) {
resolved = localScope[sym];
} if (!resolved) {
resolved = moduleExports[sym];
} return resolved; } var proxyHandler = { get(stubs, prop) { switch (prop) {
case "__memory_base": return memoryBase;
case "__table_base": return tableBase;
} if (prop in wasmImports && !wasmImports[prop].stub) {
var res = wasmImports[prop];
return res;
} if (!(prop in stubs)) {
var resolved;
stubs[prop] = (...args) => { resolved || (resolved = resolveSymbol(prop)); return resolved(...args); };
} return stubs[prop]; } }; var proxy = new Proxy({}, proxyHandler); var info = { "GOT.mem": new Proxy({}, GOTHandler), "GOT.func": new Proxy({}, GOTHandler), env: proxy, wasi_snapshot_preview1: proxy }; function postInstantiation(module, instance) { updateTableMap(tableBase, metadata.tableSize); moduleExports = relocateExports(instance.exports, memoryBase); if (!flags.allowUndefined) {
reportUndefinedSymbols();
} function addEmAsm(addr, body) { var args = []; var arity = 0; for (; arity < 16; arity++) {
if (body.indexOf("$" + arity) != -1) {
args.push("$" + arity);
}
else {
break;
}
} args = args.join(","); var func = `(${args}) => { ${body} };`; ASM_CONSTS[start] = eval(func); } if ("__start_em_asm" in moduleExports) {
var start = moduleExports["__start_em_asm"];
var stop = moduleExports["__stop_em_asm"];
while (start < stop) {
var jsString = UTF8ToString(start);
addEmAsm(start, jsString);
start = HEAPU8.indexOf(0, start) + 1;
}
} function addEmJs(name, cSig, body) { var jsArgs = []; cSig = cSig.slice(1, -1); if (cSig != "void") {
cSig = cSig.split(",");
for (var i in cSig) {
var jsArg = cSig[i].split(" ").pop();
jsArgs.push(jsArg.replace("*", ""));
}
} var func = `(${jsArgs}) => ${body};`; moduleExports[name] = eval(func); } for (var name in moduleExports) {
if (name.startsWith("__em_js__")) {
var start = moduleExports[name];
var jsString = UTF8ToString(start);
var parts = jsString.split("<::>");
addEmJs(name.replace("__em_js__", ""), parts[0], parts[1]);
delete moduleExports[name];
}
} var applyRelocs = moduleExports["__wasm_apply_data_relocs"]; if (applyRelocs) {
if (runtimeInitialized) {
applyRelocs();
}
else {
__RELOC_FUNCS__.push(applyRelocs);
}
} var init = moduleExports["__wasm_call_ctors"]; if (init) {
if (runtimeInitialized) {
init();
}
else {
addOnPostCtor(init);
}
} return moduleExports; } if (flags.loadAsync) {
return (async () => { var instance; if (binary instanceof WebAssembly.Module) {
instance = new WebAssembly.Instance(binary, info);
}
else {
({ module: binary, instance } = await WebAssembly.instantiate(binary, info));
} return postInstantiation(binary, instance); })();
} var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary); var instance = new WebAssembly.Instance(module, info); return postInstantiation(module, instance); } flags = { ...flags, rpath: { parentLibPath: libName, paths: metadata.runtimePaths } }; if (flags.loadAsync) {
return metadata.neededDynlibs.reduce((chain, dynNeeded) => chain.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);
} metadata.neededDynlibs.forEach(needed => loadDynamicLibrary(needed, flags, localScope)); return loadModule(); };
var mergeLibSymbols = (exports, libName) => { for (var [sym, exp] of Object.entries(exports)) {
const setImport = target => { if (!isSymbolDefined(target)) {
wasmImports[target] = exp;
} };
setImport(sym);
const main_alias = "__main_argc_argv";
if (sym == "main") {
setImport(main_alias);
}
if (sym == main_alias) {
setImport("main");
}
} };
var asyncLoad = async (url) => { var arrayBuffer = await readAsync(url); return new Uint8Array(arrayBuffer); };
var preloadPlugins = [];
var registerWasmPlugin = () => { var wasmPlugin = { promiseChainEnd: Promise.resolve(), canHandle: name => !Module["noWasmDecoding"] && name.endsWith(".so"), handle: (byteArray, name, onload, onerror) => { wasmPlugin["promiseChainEnd"] = wasmPlugin["promiseChainEnd"].then(() => loadWebAssemblyModule(byteArray, { loadAsync: true, nodelete: true }, name, {})).then(exports => { preloadedWasm[name] = exports; onload(byteArray); }, error => { err(`failed to instantiate wasm: ${name}: ${error}`); onerror(); }); } }; preloadPlugins.push(wasmPlugin); };
var preloadedWasm = {};
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 replaceORIGIN = (parentLibName, rpath) => { if (rpath.startsWith("$ORIGIN")) {
var origin = PATH.dirname(parentLibName);
return rpath.replace("$ORIGIN", origin);
} return rpath; };
var withStackSave = f => { var stack = stackSave(); var ret = f(); stackRestore(stack); return ret; };
var stackAlloc = sz => __emscripten_stack_alloc(sz);
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 stringToUTF8OnStack = str => { var size = lengthBytesUTF8(str) + 1; var ret = stackAlloc(size); stringToUTF8(str, ret, size); return ret; };
var initRandomFill = () => 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 FS_stdin_getChar_buffer = [];
var intArrayFromString = (stringy, dontAddNull, length) => { var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; var u8array = new Array(len); var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); if (dontAddNull)
u8array.length = numBytesWritten; return u8array; };
var FS_stdin_getChar = () => { if (!FS_stdin_getChar_buffer.length) {
var result = null;
if (typeof window != "undefined" && typeof window.prompt == "function") {
result = window.prompt("Input: ");
if (result !== null) {
result += "\n";
}
}
else { }
if (!result) {
return null;
}
FS_stdin_getChar_buffer = intArrayFromString(result, true);
} 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) { if (tty.output?.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) { if (tty.output?.length > 0) {
err(UTF8ArrayToString(tty.output));
tty.output = [];
} } } };
var zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
var mmapAlloc = size => { size = alignMemory(size, 65536); var ptr = _emscripten_builtin_memalign(65536, size); if (ptr)
zeroMemory(ptr, size); return ptr; };
var MEMFS = { ops_table: null, mount(mount) { return MEMFS.createNode(null, "/", 16895, 0); }, createNode(parent, name, mode, dev) { 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 = null;
}
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) { if (!node.contents)
return new Uint8Array(0); if (node.contents.subarray)
return node.contents.subarray(0, node.usedBytes); return new Uint8Array(node.contents); }, expandFileStorage(node, newCapacity) { var prevCapacity = node.contents ? node.contents.length : 0; 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 != 0)
newCapacity = Math.max(newCapacity, 256); var oldContents = node.contents; node.contents = new Uint8Array(newCapacity); if (node.usedBytes > 0)
node.contents.set(oldContents.subarray(0, node.usedBytes), 0); }, resizeFileStorage(node, newSize) { if (node.usedBytes == newSize)
return; if (newSize == 0) {
node.contents = null;
node.usedBytes = 0;
}
else {
var oldContents = node.contents;
node.contents = new Uint8Array(newSize);
if (oldContents) {
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); if (size > 8 && contents.subarray) {
buffer.set(contents.subarray(position, position + size), offset);
}
else {
for (var i = 0; i < size; i++)
buffer[offset + i] = contents[position + i];
} 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 (buffer.subarray && (!node.contents || node.contents.subarray)) {
if (canOwn) {
node.contents = buffer.subarray(offset, offset + length);
node.usedBytes = length;
return length;
}
else if (node.usedBytes === 0 && position === 0) {
node.contents = buffer.slice(offset, offset + length);
node.usedBytes = length;
return length;
}
else if (position + length <= node.usedBytes) {
node.contents.set(buffer.subarray(offset, offset + length), position);
return length;
}
} MEMFS.expandFileStorage(node, position + length); if (node.contents.subarray && buffer.subarray) {
node.contents.set(buffer.subarray(offset, offset + length), position);
}
else {
for (var i = 0; i < length; i++) {
node.contents[position + i] = buffer[offset + i];
}
} 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 && contents.buffer === HEAP8.buffer) {
allocated = false;
ptr = contents.byteOffset;
}
else {
allocated = true;
ptr = mmapAlloc(length);
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_createDataFile = (...args) => FS.createDataFile(...args);
var getUniqueRunDependency = id => id;
var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => { if (typeof Browser != "undefined")
Browser.init(); var handled = false; preloadPlugins.forEach(plugin => { if (handled)
return; if (plugin["canHandle"](fullname)) {
plugin["handle"](byteArray, fullname, finish, onerror);
handled = true;
} }); return handled; };
var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; var dep = getUniqueRunDependency(`cp ${fullname}`); function processData(byteArray) { function finish(byteArray) { preFinish?.(); if (!dontCreateFile) {
FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
} onload?.(); removeRunDependency(dep); } if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => { onerror?.(); removeRunDependency(dep); })) {
return;
} finish(byteArray); } addRunDependency(dep); if (typeof url == "string") {
asyncLoad(url).then(processData, onerror);
}
else {
processData(url);
} };
var FS_modeStringToFlags = 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_getMode = (canRead, canWrite) => { var mode = 0; if (canRead)
mode |= 292 | 73; if (canWrite)
mode |= 146; return mode; };
var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, readFiles: {}, 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