coolprop_js_npm
Version:
I don't do Python
1,346 lines (1,345 loc) • 251 kB
JavaScript
var Module = typeof Module != "undefined" ? Module : {};
var moduleOverrides = Object.assign({}, Module);
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow
};
var ENVIRONMENT_IS_WEB = typeof window == "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
if (Module["ENVIRONMENT"]) {
throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)")
}
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory)
}
return scriptDirectory + path
}
var read_, readAsync, readBinary;
if (ENVIRONMENT_IS_NODE) {
if (typeof process == "undefined" || !process.release || process.release.name !== "node")
throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
var nodeVersion = process.versions.node;
var numericVersion = nodeVersion.split(".").slice(0, 3);
numericVersion = numericVersion[0] * 1e4 + numericVersion[1] * 100 + numericVersion[2].split("-")[0] * 1;
if (numericVersion < 16e4) {
throw new Error("This emscripten-generated code requires node v16.0.0 (detected v" + nodeVersion + ")")
}
var fs = require("fs");
var nodePath = require("path");
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = nodePath.dirname(scriptDirectory) + "/"
} else {
scriptDirectory = __dirname + "/"
}
read_ = (filename, binary) => {
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
return fs.readFileSync(filename, binary ? undefined : "utf8")
};
readBinary = filename => {
var ret = read_(filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret)
}
assert(ret.buffer);
return ret
};
readAsync = (filename, onload, onerror, binary = true) => {
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
fs.readFile(filename, binary ? undefined : "utf8", (err, data) => {
if (err)
onerror(err);
else
onload(binary ? data.buffer : data)
})
};
if (!Module["thisProgram"] && process.argv.length > 1) {
thisProgram = process.argv[1].replace(/\\/g, "/")
}
arguments_ = process.argv.slice(2);
if (typeof module != "undefined") {
module["exports"] = Module
}
process.on("uncaughtException", ex => {
if (ex !== "unwind" && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
throw ex
}
});
quit_ = (status, toThrow) => {
process.exitCode = status;
throw toThrow
};
Module["inspect"] = () => "[Emscripten Module object]"
} else if (ENVIRONMENT_IS_SHELL) {
if (typeof process == "object" && typeof require === "function" || typeof window == "object" || typeof importScripts == "function")
throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
if (typeof read != "undefined") {
read_ = read
}
readBinary = f => {
if (typeof readbuffer == "function") {
return new Uint8Array(readbuffer(f))
}
let data = read(f, "binary");
assert(typeof data == "object");
return data
};
readAsync = (f, onload, onerror) => {
setTimeout(() => onload(readBinary(f)))
};
if (typeof clearTimeout == "undefined") {
globalThis.clearTimeout = id => {}
}
if (typeof setTimeout == "undefined") {
globalThis.setTimeout = f => typeof f == "function" ? f() : abort()
}
if (typeof scriptArgs != "undefined") {
arguments_ = scriptArgs
} else if (typeof arguments != "undefined") {
arguments_ = arguments
}
if (typeof quit == "function") {
quit_ = (status, toThrow) => {
setTimeout(() => {
if (!(toThrow instanceof ExitStatus)) {
let toLog = toThrow;
if (toThrow && typeof toThrow == "object" && toThrow.stack) {
toLog = [toThrow, toThrow.stack]
}
err(`exiting due to exception: ${toLog}`)
}
quit(status)
});
throw toThrow
}
}
if (typeof print != "undefined") {
if (typeof console == "undefined")
console = {};
console.log = print;
console.warn = console.error = typeof printErr != "undefined" ? printErr : print
}
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href
} else if (typeof document != "undefined" && document.currentScript) {
scriptDirectory = document.currentScript.src
}
if (scriptDirectory.indexOf("blob:") !== 0) {
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1)
} else {
scriptDirectory = ""
}
if (!(typeof window == "object" || typeof importScripts == "function"))
throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"); {
read_ = url => {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText
};
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, onload, onerror) => {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
return
}
onerror()
};
xhr.onerror = onerror;
xhr.send(null)
}
}
} else {
throw new Error("environment detection error")
}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.error.bind(console);
Object.assign(Module, moduleOverrides);
moduleOverrides = null;
checkIncomingModuleAPI();
if (Module["arguments"])
arguments_ = Module["arguments"];
legacyModuleProp("arguments", "arguments_");
if (Module["thisProgram"])
thisProgram = Module["thisProgram"];
legacyModuleProp("thisProgram", "thisProgram");
if (Module["quit"])
quit_ = Module["quit"];
legacyModuleProp("quit", "quit_");
assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["read"] == "undefined", "Module.read option was removed (modify read_ in JS)");
assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");
assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
legacyModuleProp("asm", "wasmExports");
legacyModuleProp("read", "read_");
legacyModuleProp("readAsync", "readAsync");
legacyModuleProp("readBinary", "readBinary");
legacyModuleProp("setWindowTitle", "setWindowTitle");
assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable.");
var wasmBinary;
if (Module["wasmBinary"])
wasmBinary = Module["wasmBinary"];
legacyModuleProp("wasmBinary", "wasmBinary");
if (typeof WebAssembly != "object") {
abort("no native wasm support detected")
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed" + (text ? ": " + text : ""))
}
}
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateMemoryViews() {
var b = wasmMemory.buffer;
Module["HEAP8"] = HEAP8 = new Int8Array(b);
Module["HEAP16"] = HEAP16 = new Int16Array(b);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
Module["HEAP32"] = HEAP32 = new Int32Array(b);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
Module["HEAPF64"] = HEAPF64 = new Float64Array(b)
}
assert(!Module["STACK_SIZE"], "STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time");
assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");
assert(!Module["wasmMemory"], "Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally");
assert(!Module["INITIAL_MEMORY"], "Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically");
function writeStackCookie() {
var max = _emscripten_stack_get_end();
assert((max & 3) == 0);
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)!")
}
}
(function () {
var h16 = new Int16Array(1);
var h8 = new Int8Array(h16.buffer);
h16[0] = 25459;
if (h8[0] !== 115 || h8[1] !== 99)
throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)"
})();
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift())
}
}
callRuntimeCallbacks(__ATPRERUN__)
}
function initRuntime() {
assert(!runtimeInitialized);
runtimeInitialized = true;
checkStackCookie();
if (!Module["noFSInit"] && !FS.init.initialized)
FS.init();
FS.ignorePermissions = false;
TTY.init();
callRuntimeCallbacks(__ATINIT__)
}
function postRun() {
checkStackCookie();
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift())
}
}
callRuntimeCallbacks(__ATPOSTRUN__)
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb)
}
function addOnInit(cb) {
__ATINIT__.unshift(cb)
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb)
}
assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
var runDependencyTracking = {};
function getUniqueRunDependency(id) {
var orig = id;
while (1) {
if (!runDependencyTracking[id])
return id;
id = orig + Math.random()
}
}
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies)
}
if (id) {
assert(!runDependencyTracking[id]);
runDependencyTracking[id] = 1;
if (runDependencyWatcher === null && typeof setInterval != "undefined") {
runDependencyWatcher = setInterval(() => {
if (ABORT) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
return
}
var shown = false;
for (var dep in runDependencyTracking) {
if (!shown) {
shown = true;
err("still waiting on run dependencies:")
}
err(`dependency: ${dep}`)
}
if (shown) {
err("(end of list)")
}
}, 1e4)
}
} else {
err("warning: run dependency added without ID")
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies)
}
if (id) {
assert(runDependencyTracking[id]);
delete runDependencyTracking[id]
} else {
err("warning: run dependency removed without ID")
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback()
}
}
}
function abort(what) {
if (Module["onAbort"]) {
Module["onAbort"](what)
}
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
EXITSTATUS = 1;
var e = new WebAssembly.RuntimeError(what);
throw e
}
var dataURIPrefix = "data:application/octet-stream;base64,";
var isDataURI = filename => filename.startsWith(dataURIPrefix);
var isFileURI = filename => filename.startsWith("file://");
function createExportWrapper(name) {
return function () {
assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
var f = wasmExports[name];
assert(f, `exported native function \`${name}\` not found`);
return f.apply(null, arguments)
}
}
class EmscriptenEH extends Error {}
class EmscriptenSjLj extends EmscriptenEH {}
class CppException extends EmscriptenEH {
constructor(excPtr) {
super(excPtr);
this.excPtr = excPtr;
const excInfo = getExceptionMessage(excPtr);
this.name = excInfo[0];
this.message = excInfo[1]
}
}
var wasmBinaryFile;
wasmBinaryFile = "coolprop.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile)
}
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 getBinaryPromise(binaryFile) {
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
if (typeof fetch == "function" && !isFileURI(binaryFile)) {
return fetch(binaryFile, {
credentials: "same-origin"
}).then(response => {
if (!response["ok"]) {
throw "failed to load wasm binary file at '" + binaryFile + "'"
}
return response["arrayBuffer"]()
}).catch(() => getBinarySync(binaryFile))
} else if (readAsync) {
return new Promise((resolve, reject) => {
readAsync(binaryFile, response => resolve(new Uint8Array(response)), reject)
})
}
}
return Promise.resolve().then(() => getBinarySync(binaryFile))
}
function instantiateArrayBuffer(binaryFile, imports, receiver) {
return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(instance => instance).then(receiver, reason => {
err(`failed to asynchronously prepare wasm: ${reason}`);
if (isFileURI(wasmBinaryFile)) {
err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`)
}
abort(reason)
})
}
function instantiateAsync(binary, binaryFile, imports, callback) {
if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
return fetch(binaryFile, {
credentials: "same-origin"
}).then(response => {
var result = WebAssembly.instantiateStreaming(response, imports);
return result.then(callback, function (reason) {
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(binaryFile, imports, callback)
})
})
}
return instantiateArrayBuffer(binaryFile, imports, callback)
}
function createWasm() {
var info = {
"env": wasmImports,
"wasi_snapshot_preview1": wasmImports
};
function receiveInstance(instance, module) {
wasmExports = instance.exports;
wasmMemory = wasmExports["memory"];
assert(wasmMemory, "memory not found in wasm exports");
updateMemoryViews();
wasmTable = wasmExports["__indirect_function_table"];
assert(wasmTable, "table not found in wasm exports");
addOnInit(wasmExports["__wasm_call_ctors"]);
removeRunDependency("wasm-instantiate");
return wasmExports
}
addRunDependency("wasm-instantiate");
var trueModule = Module;
function receiveInstantiationResult(result) {
assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
trueModule = null;
receiveInstance(result["instance"])
}
if (Module["instantiateWasm"]) {
try {
return Module["instantiateWasm"](info, receiveInstance)
} catch (e) {
err(`Module.instantiateWasm callback failed with error: ${e}`);
return false
}
}
instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
return {}
}
var tempDouble;
var tempI64;
function legacyModuleProp(prop, newName, incomming = true) {
if (!Object.getOwnPropertyDescriptor(Module, prop)) {
Object.defineProperty(Module, prop, {
configurable: true,
get() {
let extra = incomming ? " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)" : "";
abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra)
}
})
}
}
function ignoredModuleProp(prop) {
if (Object.getOwnPropertyDescriptor(Module, prop)) {
abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`)
}
}
function isExportedByForceFilesystem(name) {
return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency"
}
function missingGlobal(sym, msg) {
if (typeof globalThis !== "undefined") {
Object.defineProperty(globalThis, sym, {
configurable: true,
get() {
warnOnce("`" + sym + "` is not longer defined by emscripten. " + msg);
return undefined
}
})
}
}
missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");
missingGlobal("asm", "Please use wasmExports instead");
function missingLibrarySymbol(sym) {
if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
Object.defineProperty(globalThis, sym, {
configurable: true,
get() {
var msg = "`" + sym + "` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line";
var librarySymbol = sym;
if (!librarySymbol.startsWith("_")) {
librarySymbol = "$" + sym
}
msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='" + librarySymbol + "')";
if (isExportedByForceFilesystem(sym)) {
msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"
}
warnOnce(msg);
return undefined
}
})
}
unexportedRuntimeSymbol(sym)
}
function unexportedRuntimeSymbol(sym) {
if (!Object.getOwnPropertyDescriptor(Module, sym)) {
Object.defineProperty(Module, sym, {
configurable: true,
get() {
var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)";
if (isExportedByForceFilesystem(sym)) {
msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"
}
abort(msg)
}
})
}
}
function ExitStatus(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 withStackSave = f => {
var stack = stackSave();
var ret = f();
stackRestore(stack);
return ret
};
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (heapOrArray[endPtr] && !(endPtr >= endIdx))
++endPtr;
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 {
if ((u0 & 248) != 240)
warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
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) => {
assert(typeof ptr == "number");
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
};
var getExceptionMessageCommon = ptr => withStackSave(() => {
var type_addr_addr = stackAlloc(4);
var message_addr_addr = stackAlloc(4);
___get_exception_message(ptr, type_addr_addr, message_addr_addr);
var type_addr = HEAPU32[type_addr_addr >> 2];
var message_addr = HEAPU32[message_addr_addr >> 2];
var type = UTF8ToString(type_addr);
_free(type_addr);
var message;
if (message_addr) {
message = UTF8ToString(message_addr);
_free(message_addr)
}
return [type, message]
});
var getExceptionMessage = ptr => getExceptionMessageCommon(ptr);
Module["getExceptionMessage"] = getExceptionMessage;
var noExitRuntime = Module["noExitRuntime"] || true;
var ptrToString = ptr => {
assert(typeof ptr === "number");
ptr >>>= 0;
return "0x" + ptr.toString(16).padStart(8, "0")
};
var warnOnce = text => {
if (!warnOnce.shown)
warnOnce.shown = {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
if (ENVIRONMENT_IS_NODE)
text = "warning: " + text;
err(text)
}
};
var ___assert_fail = (condition, filename, line, func) => {
abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"])
};
var exceptionCaught = [];
var uncaughtExceptionCount = 0;
var ___cxa_begin_catch = ptr => {
var info = new ExceptionInfo(ptr);
if (!info.get_caught()) {
info.set_caught(true);
uncaughtExceptionCount--
}
info.set_rethrown(false);
exceptionCaught.push(info);
___cxa_increment_exception_refcount(info.excPtr);
return info.get_exception_ptr()
};
var ___cxa_call_unexpected = exception => abort("Unexpected exception thrown, this is not properly supported - aborting");
var exceptionLast = 0;
var ___cxa_end_catch = () => {
_setThrew(0, 0);
assert(exceptionCaught.length > 0);
var info = exceptionCaught.pop();
___cxa_decrement_exception_refcount(info.excPtr);
exceptionLast = 0
};
function ExceptionInfo(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
this.set_type = function (type) {
HEAPU32[this.ptr + 4 >> 2] = type
};
this.get_type = function () {
return HEAPU32[this.ptr + 4 >> 2]
};
this.set_destructor = function (destructor) {
HEAPU32[this.ptr + 8 >> 2] = destructor
};
this.get_destructor = function () {
return HEAPU32[this.ptr + 8 >> 2]
};
this.set_caught = function (caught) {
caught = caught ? 1 : 0;
HEAP8[this.ptr + 12 >> 0] = caught
};
this.get_caught = function () {
return HEAP8[this.ptr + 12 >> 0] != 0
};
this.set_rethrown = function (rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[this.ptr + 13 >> 0] = rethrown
};
this.get_rethrown = function () {
return HEAP8[this.ptr + 13 >> 0] != 0
};
this.init = function (type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor)
};
this.set_adjusted_ptr = function (adjustedPtr) {
HEAPU32[this.ptr + 16 >> 2] = adjustedPtr
};
this.get_adjusted_ptr = function () {
return HEAPU32[this.ptr + 16 >> 2]
};
this.get_exception_ptr = function () {
var isPointer = ___cxa_is_pointer_type(this.get_type());
if (isPointer) {
return HEAPU32[this.excPtr >> 2]
}
var adjusted = this.get_adjusted_ptr();
if (adjusted !== 0)
return adjusted;
return this.excPtr
}
}
var ___resumeException = ptr => {
if (!exceptionLast) {
exceptionLast = new CppException(ptr)
}
throw exceptionLast
};
var findMatchingCatch = args => {
var thrown = exceptionLast && exceptionLast.excPtr;
if (!thrown) {
setTempRet0(0);
return 0
}
var info = new ExceptionInfo(thrown);
info.set_adjusted_ptr(thrown);
var thrownType = info.get_type();
if (!thrownType) {
setTempRet0(0);
return thrown
}
for (var arg in args) {
var caughtType = args[arg];
if (caughtType === 0 || caughtType === thrownType) {
break
}
var adjusted_ptr_addr = info.ptr + 16;
if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
setTempRet0(caughtType);
return thrown
}
}
setTempRet0(thrownType);
return thrown
};
var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
var ___cxa_find_matching_catch_3 = arg0 => findMatchingCatch([arg0]);
var ___cxa_find_matching_catch_4 = (arg0, arg1) => findMatchingCatch([arg0, arg1]);
var ___cxa_get_exception_ptr = ptr => {
var rtn = new ExceptionInfo(ptr).get_exception_ptr();
return rtn
};
var ___cxa_rethrow = () => {
var info = exceptionCaught.pop();
if (!info) {
abort("no exception to throw")
}
var ptr = info.excPtr;
if (!info.get_rethrown()) {
exceptionCaught.push(info);
info.set_rethrown(true);
info.set_caught(false);
uncaughtExceptionCount++
}
exceptionLast = new CppException(ptr);
throw exceptionLast
};
var ___cxa_throw = (ptr, type, destructor) => {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = new CppException(ptr);
uncaughtExceptionCount++;
throw exceptionLast
};
var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
var setErrNo = value => {
HEAP32[___errno_location() >> 2] = value;
return value
};
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.substr(-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.substr(0, dir.length - 1)
}
return root + dir
},
basename: path => {
if (path === "/")
return "/";
path = PATH.normalize(path);
path = path.replace(/\/$/, "");
var lastSlash = path.lastIndexOf("/");
if (lastSlash === -1)
return path;
return path.substr(lastSlash + 1)
},
join: function () {
var paths = Array.prototype.slice.call(arguments);
return PATH.normalize(paths.join("/"))
},
join2: (l, r) => PATH.normalize(l + "/" + r)
};
var initRandomFill = () => {
if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
return view => crypto.getRandomValues(view)
} else if (ENVIRONMENT_IS_NODE) {
try {
var crypto_module = require("crypto");
var randomFillSync = crypto_module["randomFillSync"];
if (randomFillSync) {
return view => crypto_module["randomFillSync"](view)
}
var randomBytes = crypto_module["randomBytes"];
return view => (view.set(randomBytes(view.byteLength)), view)
} catch (e) {}
}
abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: (array) => { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };")
};
var randomFill = view => (randomFill = initRandomFill())(view);
var PATH_FS = {
resolve: function () {
var resolvedPath = "",
resolvedAbsolute = false;
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path = i >= 0 ? arguments[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).substr(1);
to = PATH_FS.resolve(to).substr(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 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) => {
assert(typeof str === "string");
if (!(maxBytesToWrite > 0))
return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = 65536 + ((u & 1023) << 10) | u1 & 1023
}
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;
if (u > 1114111)
warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
heap[outIdx++] = 240 | u >> 18;
heap[outIdx++] = 128 | u >> 12 & 63;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63
}
}
heap[outIdx] = 0;
return outIdx - startIdx
};
function 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 (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)
} catch (e) {
if (e.toString().includes("EOF"))
bytesRead = 0;
else
throw e
}
if (bytesRead > 0) {
result = buf.slice(0, bytesRead).toString("utf-8")
} else {
result = null
}
} else if (typeof window != "undefined" && typeof window.prompt == "function") {
result = window.prompt("Input: ");
if (result !== null) {
result += "\n"
}
} else if (typeof readline == "function") {
result = readline();
if (result !== null) {
result += "\n"
}
}
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: 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.timestamp = 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.timestamp = 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, 0));
tty.output = []
} else {
if (val != 0)
tty.output.push(val)
}
},
fsync(tty) {
if (tty.output && tty.output.length > 0) {
out(UTF8ArrayToString(tty.output, 0));
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, 0));
tty.output = []
} else {
if (val != 0)
tty.output.push(val)
}
},
fsync(tty) {
if (tty.output && tty.output.length > 0) {
err(UTF8ArrayToString(tty.output, 0));
tty.output = []
}
}
}
};
var mmapAlloc = size => {
abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported")
};
var MEMFS = {
ops_table: null,
mount(mount) {
return MEMFS.createNode(null, "/", 16384 | 511, 0)
},
createNode(parent, name, mode, dev) {
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
throw new FS.ErrnoError(63)
}
if (!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,
allocate: MEMFS.stream_ops.allocate,
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.timestamp = Date.now();
if (parent) {
parent.contents[name] = node;
parent.timestamp = node.timestamp
}
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.timestamp);
attr.mtime = new Date(node.timestamp);
attr.ctime = new Date(node.timestamp);
attr.blksize = 4096;
attr.blocks = Math.ceil(attr.size / attr.blksize);
return attr
},
setattr(node, attr) {
if (attr.mode !== undefined) {
node.mode = attr.mode
}
if (attr.timestamp !== undefined) {
node.timestamp = attr.timestamp
}
if (attr.size !== undefined) {
MEMFS.resizeFileStorage(node, attr.size)
}
},
lookup(parent, name) {
throw FS.genericErrors[44]
},
mknod(parent, name, mode, dev) {
return MEMFS.createNode(parent, name, mode, dev)
},
rename(old_node, new_dir, new_name) {
if (FS.isDir(old_node.mode)) {
var new_node;
try {
new_node = FS.lookupNode(new_dir, new_name)
} catch (e) {}
if (new_node) {
for (var i in new_node.contents) {
throw new FS.ErrnoError(55)
}
}