mirror of
https://gitee.com/myxzgzs/boyue_jnpf.git
synced 2025-08-14 02:02:42 +08:00
5181 lines
4.6 MiB
JavaScript
5181 lines
4.6 MiB
JavaScript
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||
|
|
var __commonJS = (cb, mod) => function __require() {
|
||
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||
|
|
};
|
||
|
|
|
||
|
|
// postject.js
|
||
|
|
var require_postject = __commonJS({
|
||
|
|
"postject.js"(exports2, module2) {
|
||
|
|
var Module = (() => {
|
||
|
|
var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0;
|
||
|
|
if (typeof '' !== "undefined")
|
||
|
|
_scriptDir = _scriptDir || '';
|
||
|
|
return function(Module2) {
|
||
|
|
Module2 = Module2 || {};
|
||
|
|
var Module2 = typeof Module2 != "undefined" ? Module2 : {};
|
||
|
|
var readyPromiseResolve, readyPromiseReject;
|
||
|
|
Module2["ready"] = new Promise(function(resolve, reject) {
|
||
|
|
readyPromiseResolve = resolve;
|
||
|
|
readyPromiseReject = reject;
|
||
|
|
});
|
||
|
|
var moduleOverrides = Object.assign({}, Module2);
|
||
|
|
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 scriptDirectory = "";
|
||
|
|
function locateFile(path2) {
|
||
|
|
if (Module2["locateFile"]) {
|
||
|
|
return Module2["locateFile"](path2, scriptDirectory);
|
||
|
|
}
|
||
|
|
return scriptDirectory + path2;
|
||
|
|
}
|
||
|
|
var read_, readAsync, readBinary, setWindowTitle;
|
||
|
|
function logExceptionOnExit(e) {
|
||
|
|
if (e instanceof ExitStatus)
|
||
|
|
return;
|
||
|
|
let toLog = e;
|
||
|
|
err("exiting due to exception: " + toLog);
|
||
|
|
}
|
||
|
|
if (ENVIRONMENT_IS_NODE) {
|
||
|
|
if (ENVIRONMENT_IS_WORKER) {
|
||
|
|
scriptDirectory = require("path").dirname(scriptDirectory) + "/";
|
||
|
|
} else {
|
||
|
|
scriptDirectory = '' + "/";
|
||
|
|
}
|
||
|
|
var fs2, nodePath;
|
||
|
|
if (typeof require === "function") {
|
||
|
|
fs2 = require("fs");
|
||
|
|
nodePath = require("path");
|
||
|
|
}
|
||
|
|
read_ = (filename, binary) => {
|
||
|
|
var ret = tryParseAsDataURI(filename);
|
||
|
|
if (ret) {
|
||
|
|
return binary ? ret : ret.toString();
|
||
|
|
}
|
||
|
|
filename = nodePath["normalize"](filename);
|
||
|
|
return fs2.readFileSync(filename, binary ? void 0 : "utf8");
|
||
|
|
};
|
||
|
|
readBinary = (filename) => {
|
||
|
|
var ret = read_(filename, true);
|
||
|
|
if (!ret.buffer) {
|
||
|
|
ret = new Uint8Array(ret);
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
readAsync = (filename, onload, onerror) => {
|
||
|
|
var ret = tryParseAsDataURI(filename);
|
||
|
|
if (ret) {
|
||
|
|
onload(ret);
|
||
|
|
}
|
||
|
|
filename = nodePath["normalize"](filename);
|
||
|
|
fs2.readFile(filename, function(err2, data) {
|
||
|
|
if (err2)
|
||
|
|
onerror(err2);
|
||
|
|
else
|
||
|
|
onload(data.buffer);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
if (process["argv"].length > 1) {
|
||
|
|
thisProgram = process["argv"][1].replace(/\\/g, "/");
|
||
|
|
}
|
||
|
|
arguments_ = process["argv"].slice(2);
|
||
|
|
process["on"]("uncaughtException", function(ex) {
|
||
|
|
if (!(ex instanceof ExitStatus)) {
|
||
|
|
throw ex;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
process["on"]("unhandledRejection", function(reason) {
|
||
|
|
throw reason;
|
||
|
|
});
|
||
|
|
quit_ = (status, toThrow) => {
|
||
|
|
if (keepRuntimeAlive()) {
|
||
|
|
process["exitCode"] = status;
|
||
|
|
throw toThrow;
|
||
|
|
}
|
||
|
|
logExceptionOnExit(toThrow);
|
||
|
|
process["exit"](status);
|
||
|
|
};
|
||
|
|
Module2["inspect"] = function() {
|
||
|
|
return "[Emscripten Module object]";
|
||
|
|
};
|
||
|
|
} 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 (_scriptDir) {
|
||
|
|
scriptDirectory = _scriptDir;
|
||
|
|
}
|
||
|
|
if (scriptDirectory.indexOf("blob:") !== 0) {
|
||
|
|
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
|
||
|
|
} else {
|
||
|
|
scriptDirectory = "";
|
||
|
|
}
|
||
|
|
{
|
||
|
|
read_ = (url) => {
|
||
|
|
try {
|
||
|
|
var xhr = new XMLHttpRequest();
|
||
|
|
xhr.open("GET", url, false);
|
||
|
|
xhr.send(null);
|
||
|
|
return xhr.responseText;
|
||
|
|
} catch (err2) {
|
||
|
|
var data = tryParseAsDataURI(url);
|
||
|
|
if (data) {
|
||
|
|
return intArrayToString(data);
|
||
|
|
}
|
||
|
|
throw err2;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
if (ENVIRONMENT_IS_WORKER) {
|
||
|
|
readBinary = (url) => {
|
||
|
|
try {
|
||
|
|
var xhr = new XMLHttpRequest();
|
||
|
|
xhr.open("GET", url, false);
|
||
|
|
xhr.responseType = "arraybuffer";
|
||
|
|
xhr.send(null);
|
||
|
|
return new Uint8Array(xhr.response);
|
||
|
|
} catch (err2) {
|
||
|
|
var data = tryParseAsDataURI(url);
|
||
|
|
if (data) {
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
throw err2;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
var data = tryParseAsDataURI(url);
|
||
|
|
if (data) {
|
||
|
|
onload(data.buffer);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
onerror();
|
||
|
|
};
|
||
|
|
xhr.onerror = onerror;
|
||
|
|
xhr.send(null);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
setWindowTitle = (title) => document.title = title;
|
||
|
|
} else {
|
||
|
|
}
|
||
|
|
var out = Module2["print"] || console.log.bind(console);
|
||
|
|
var err = Module2["printErr"] || console.warn.bind(console);
|
||
|
|
Object.assign(Module2, moduleOverrides);
|
||
|
|
moduleOverrides = null;
|
||
|
|
if (Module2["arguments"])
|
||
|
|
arguments_ = Module2["arguments"];
|
||
|
|
if (Module2["thisProgram"])
|
||
|
|
thisProgram = Module2["thisProgram"];
|
||
|
|
if (Module2["quit"])
|
||
|
|
quit_ = Module2["quit"];
|
||
|
|
var POINTER_SIZE = 4;
|
||
|
|
var wasmBinary;
|
||
|
|
if (Module2["wasmBinary"])
|
||
|
|
wasmBinary = Module2["wasmBinary"];
|
||
|
|
var noExitRuntime = Module2["noExitRuntime"] || true;
|
||
|
|
if (typeof WebAssembly != "object") {
|
||
|
|
abort("no native wasm support detected");
|
||
|
|
}
|
||
|
|
var wasmMemory;
|
||
|
|
var ABORT = false;
|
||
|
|
var EXITSTATUS;
|
||
|
|
function assert(condition, text) {
|
||
|
|
if (!condition) {
|
||
|
|
abort(text);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
|
||
|
|
function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
|
||
|
|
idx >>>= 0;
|
||
|
|
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 {
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
function UTF8ToString(ptr, maxBytesToRead) {
|
||
|
|
ptr >>>= 0;
|
||
|
|
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
|
||
|
|
}
|
||
|
|
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
|
||
|
|
outIdx >>>= 0;
|
||
|
|
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++ >>> 0] = u;
|
||
|
|
} else if (u <= 2047) {
|
||
|
|
if (outIdx + 1 >= endIdx)
|
||
|
|
break;
|
||
|
|
heap[outIdx++ >>> 0] = 192 | u >> 6;
|
||
|
|
heap[outIdx++ >>> 0] = 128 | u & 63;
|
||
|
|
} else if (u <= 65535) {
|
||
|
|
if (outIdx + 2 >= endIdx)
|
||
|
|
break;
|
||
|
|
heap[outIdx++ >>> 0] = 224 | u >> 12;
|
||
|
|
heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
|
||
|
|
heap[outIdx++ >>> 0] = 128 | u & 63;
|
||
|
|
} else {
|
||
|
|
if (outIdx + 3 >= endIdx)
|
||
|
|
break;
|
||
|
|
heap[outIdx++ >>> 0] = 240 | u >> 18;
|
||
|
|
heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
|
||
|
|
heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
|
||
|
|
heap[outIdx++ >>> 0] = 128 | u & 63;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
heap[outIdx >>> 0] = 0;
|
||
|
|
return outIdx - startIdx;
|
||
|
|
}
|
||
|
|
function stringToUTF8(str, outPtr, maxBytesToWrite) {
|
||
|
|
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
|
||
|
|
}
|
||
|
|
function 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 buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
|
||
|
|
function updateGlobalBufferAndViews(buf) {
|
||
|
|
buffer = buf;
|
||
|
|
Module2["HEAP8"] = HEAP8 = new Int8Array(buf);
|
||
|
|
Module2["HEAP16"] = HEAP16 = new Int16Array(buf);
|
||
|
|
Module2["HEAP32"] = HEAP32 = new Int32Array(buf);
|
||
|
|
Module2["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
|
||
|
|
Module2["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
|
||
|
|
Module2["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
|
||
|
|
Module2["HEAPF32"] = HEAPF32 = new Float32Array(buf);
|
||
|
|
Module2["HEAPF64"] = HEAPF64 = new Float64Array(buf);
|
||
|
|
}
|
||
|
|
var INITIAL_MEMORY = Module2["INITIAL_MEMORY"] || 268435456;
|
||
|
|
var wasmTable;
|
||
|
|
var __ATPRERUN__ = [];
|
||
|
|
var __ATINIT__ = [];
|
||
|
|
var __ATPOSTRUN__ = [];
|
||
|
|
var runtimeInitialized = false;
|
||
|
|
function keepRuntimeAlive() {
|
||
|
|
return noExitRuntime;
|
||
|
|
}
|
||
|
|
function preRun() {
|
||
|
|
if (Module2["preRun"]) {
|
||
|
|
if (typeof Module2["preRun"] == "function")
|
||
|
|
Module2["preRun"] = [Module2["preRun"]];
|
||
|
|
while (Module2["preRun"].length) {
|
||
|
|
addOnPreRun(Module2["preRun"].shift());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
callRuntimeCallbacks(__ATPRERUN__);
|
||
|
|
}
|
||
|
|
function initRuntime() {
|
||
|
|
runtimeInitialized = true;
|
||
|
|
if (!Module2["noFSInit"] && !FS.init.initialized)
|
||
|
|
FS.init();
|
||
|
|
FS.ignorePermissions = false;
|
||
|
|
TTY.init();
|
||
|
|
callRuntimeCallbacks(__ATINIT__);
|
||
|
|
}
|
||
|
|
function postRun() {
|
||
|
|
if (Module2["postRun"]) {
|
||
|
|
if (typeof Module2["postRun"] == "function")
|
||
|
|
Module2["postRun"] = [Module2["postRun"]];
|
||
|
|
while (Module2["postRun"].length) {
|
||
|
|
addOnPostRun(Module2["postRun"].shift());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
callRuntimeCallbacks(__ATPOSTRUN__);
|
||
|
|
}
|
||
|
|
function addOnPreRun(cb) {
|
||
|
|
__ATPRERUN__.unshift(cb);
|
||
|
|
}
|
||
|
|
function addOnInit(cb) {
|
||
|
|
__ATINIT__.unshift(cb);
|
||
|
|
}
|
||
|
|
function addOnPostRun(cb) {
|
||
|
|
__ATPOSTRUN__.unshift(cb);
|
||
|
|
}
|
||
|
|
var runDependencies = 0;
|
||
|
|
var runDependencyWatcher = null;
|
||
|
|
var dependenciesFulfilled = null;
|
||
|
|
function getUniqueRunDependency(id) {
|
||
|
|
return id;
|
||
|
|
}
|
||
|
|
function addRunDependency(id) {
|
||
|
|
runDependencies++;
|
||
|
|
if (Module2["monitorRunDependencies"]) {
|
||
|
|
Module2["monitorRunDependencies"](runDependencies);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function removeRunDependency(id) {
|
||
|
|
runDependencies--;
|
||
|
|
if (Module2["monitorRunDependencies"]) {
|
||
|
|
Module2["monitorRunDependencies"](runDependencies);
|
||
|
|
}
|
||
|
|
if (runDependencies == 0) {
|
||
|
|
if (runDependencyWatcher !== null) {
|
||
|
|
clearInterval(runDependencyWatcher);
|
||
|
|
runDependencyWatcher = null;
|
||
|
|
}
|
||
|
|
if (dependenciesFulfilled) {
|
||
|
|
var callback = dependenciesFulfilled;
|
||
|
|
dependenciesFulfilled = null;
|
||
|
|
callback();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function abort(what) {
|
||
|
|
{
|
||
|
|
if (Module2["onAbort"]) {
|
||
|
|
Module2["onAbort"](what);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
what = "Aborted(" + what + ")";
|
||
|
|
err(what);
|
||
|
|
ABORT = true;
|
||
|
|
EXITSTATUS = 1;
|
||
|
|
what += ". Build with -sASSERTIONS for more info.";
|
||
|
|
var e = new WebAssembly.RuntimeError(what);
|
||
|
|
readyPromiseReject(e);
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
var dataURIPrefix = "data:application/octet-stream;base64,";
|
||
|
|
function isDataURI(filename) {
|
||
|
|
return filename.startsWith(dataURIPrefix);
|
||
|
|
}
|
||
|
|
function isFileURI(filename) {
|
||
|
|
return filename.startsWith("file://");
|
||
|
|
}
|
||
|
|
var wasmBinaryFile;
|
||
|
|
wasmBinaryFile = "data:application/octet-stream;base64,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
|
||
|
|
if (!isDataURI(wasmBinaryFile)) {
|
||
|
|
wasmBinaryFile = locateFile(wasmBinaryFile);
|
||
|
|
}
|
||
|
|
function getBinary(file) {
|
||
|
|
try {
|
||
|
|
if (file == wasmBinaryFile && wasmBinary) {
|
||
|
|
return new Uint8Array(wasmBinary);
|
||
|
|
}
|
||
|
|
var binary = tryParseAsDataURI(file);
|
||
|
|
if (binary) {
|
||
|
|
return binary;
|
||
|
|
}
|
||
|
|
if (readBinary) {
|
||
|
|
return readBinary(file);
|
||
|
|
}
|
||
|
|
throw "both async and sync fetching of the wasm failed";
|
||
|
|
} catch (err2) {
|
||
|
|
abort(err2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function getBinaryPromise() {
|
||
|
|
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
|
||
|
|
if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) {
|
||
|
|
return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
|
||
|
|
if (!response["ok"]) {
|
||
|
|
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
|
||
|
|
}
|
||
|
|
return response["arrayBuffer"]();
|
||
|
|
}).catch(function() {
|
||
|
|
return getBinary(wasmBinaryFile);
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
if (readAsync) {
|
||
|
|
return new Promise(function(resolve, reject) {
|
||
|
|
readAsync(wasmBinaryFile, function(response) {
|
||
|
|
resolve(new Uint8Array(response));
|
||
|
|
}, reject);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return Promise.resolve().then(function() {
|
||
|
|
return getBinary(wasmBinaryFile);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function createWasm() {
|
||
|
|
var info = { "a": asmLibraryArg };
|
||
|
|
function receiveInstance(instance, module3) {
|
||
|
|
var exports4 = instance.exports;
|
||
|
|
Module2["asm"] = exports4;
|
||
|
|
wasmMemory = Module2["asm"]["ab"];
|
||
|
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
||
|
|
wasmTable = Module2["asm"]["cb"];
|
||
|
|
addOnInit(Module2["asm"]["bb"]);
|
||
|
|
removeRunDependency("wasm-instantiate");
|
||
|
|
}
|
||
|
|
addRunDependency("wasm-instantiate");
|
||
|
|
function receiveInstantiationResult(result) {
|
||
|
|
receiveInstance(result["instance"]);
|
||
|
|
}
|
||
|
|
function instantiateArrayBuffer(receiver) {
|
||
|
|
return getBinaryPromise().then(function(binary) {
|
||
|
|
return WebAssembly.instantiate(binary, info);
|
||
|
|
}).then(function(instance) {
|
||
|
|
return instance;
|
||
|
|
}).then(receiver, function(reason) {
|
||
|
|
err("failed to asynchronously prepare wasm: " + reason);
|
||
|
|
abort(reason);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function instantiateAsync() {
|
||
|
|
if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
|
||
|
|
return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
|
||
|
|
var result = WebAssembly.instantiateStreaming(response, info);
|
||
|
|
return result.then(receiveInstantiationResult, function(reason) {
|
||
|
|
err("wasm streaming compile failed: " + reason);
|
||
|
|
err("falling back to ArrayBuffer instantiation");
|
||
|
|
return instantiateArrayBuffer(receiveInstantiationResult);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
return instantiateArrayBuffer(receiveInstantiationResult);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (Module2["instantiateWasm"]) {
|
||
|
|
try {
|
||
|
|
var exports3 = Module2["instantiateWasm"](info, receiveInstance);
|
||
|
|
return exports3;
|
||
|
|
} catch (e) {
|
||
|
|
err("Module.instantiateWasm callback failed with error: " + e);
|
||
|
|
readyPromiseReject(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
instantiateAsync().catch(readyPromiseReject);
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
var tempDouble;
|
||
|
|
var tempI64;
|
||
|
|
function ExitStatus(status) {
|
||
|
|
this.name = "ExitStatus";
|
||
|
|
this.message = "Program terminated with exit(" + status + ")";
|
||
|
|
this.status = status;
|
||
|
|
}
|
||
|
|
function callRuntimeCallbacks(callbacks) {
|
||
|
|
while (callbacks.length > 0) {
|
||
|
|
callbacks.shift()(Module2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function intArrayToString(array) {
|
||
|
|
var ret = [];
|
||
|
|
for (var i = 0; i < array.length; i++) {
|
||
|
|
var chr = array[i];
|
||
|
|
if (chr > 255) {
|
||
|
|
if (ASSERTIONS) {
|
||
|
|
assert(false, "Character code " + chr + " (" + String.fromCharCode(chr) + ") at offset " + i + " not in 0x00-0xFF.");
|
||
|
|
}
|
||
|
|
chr &= 255;
|
||
|
|
}
|
||
|
|
ret.push(String.fromCharCode(chr));
|
||
|
|
}
|
||
|
|
return ret.join("");
|
||
|
|
}
|
||
|
|
function writeArrayToMemory(array, buffer2) {
|
||
|
|
HEAP8.set(array, buffer2 >>> 0);
|
||
|
|
}
|
||
|
|
function ___cxa_allocate_exception(size) {
|
||
|
|
return _malloc(size + 24) + 24;
|
||
|
|
}
|
||
|
|
var exceptionCaught = [];
|
||
|
|
function exception_addRef(info) {
|
||
|
|
info.add_ref();
|
||
|
|
}
|
||
|
|
var uncaughtExceptionCount = 0;
|
||
|
|
function ___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);
|
||
|
|
exception_addRef(info);
|
||
|
|
return info.get_exception_ptr();
|
||
|
|
}
|
||
|
|
var 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_refcount = function(refcount) {
|
||
|
|
HEAP32[this.ptr >>> 2] = refcount;
|
||
|
|
};
|
||
|
|
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_refcount(0);
|
||
|
|
this.set_caught(false);
|
||
|
|
this.set_rethrown(false);
|
||
|
|
};
|
||
|
|
this.add_ref = function() {
|
||
|
|
var value = HEAP32[this.ptr >>> 2];
|
||
|
|
HEAP32[this.ptr >>> 2] = value + 1;
|
||
|
|
};
|
||
|
|
this.release_ref = function() {
|
||
|
|
var prev = HEAP32[this.ptr >>> 2];
|
||
|
|
HEAP32[this.ptr >>> 2] = prev - 1;
|
||
|
|
return prev === 1;
|
||
|
|
};
|
||
|
|
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;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function ___cxa_free_exception(ptr) {
|
||
|
|
return _free(new ExceptionInfo(ptr).ptr);
|
||
|
|
}
|
||
|
|
var wasmTableMirror = [];
|
||
|
|
function getWasmTableEntry(funcPtr) {
|
||
|
|
var func = wasmTableMirror[funcPtr];
|
||
|
|
if (!func) {
|
||
|
|
if (funcPtr >= wasmTableMirror.length)
|
||
|
|
wasmTableMirror.length = funcPtr + 1;
|
||
|
|
wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
|
||
|
|
}
|
||
|
|
return func;
|
||
|
|
}
|
||
|
|
function exception_decRef(info) {
|
||
|
|
if (info.release_ref() && !info.get_rethrown()) {
|
||
|
|
var destructor = info.get_destructor();
|
||
|
|
if (destructor) {
|
||
|
|
getWasmTableEntry(destructor)(info.excPtr);
|
||
|
|
}
|
||
|
|
___cxa_free_exception(info.excPtr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function ___cxa_end_catch() {
|
||
|
|
_setThrew(0);
|
||
|
|
var info = exceptionCaught.pop();
|
||
|
|
exception_decRef(info);
|
||
|
|
exceptionLast = 0;
|
||
|
|
}
|
||
|
|
function ___resumeException(ptr) {
|
||
|
|
if (!exceptionLast) {
|
||
|
|
exceptionLast = ptr;
|
||
|
|
}
|
||
|
|
throw ptr;
|
||
|
|
}
|
||
|
|
function ___cxa_find_matching_catch_2() {
|
||
|
|
var thrown = exceptionLast;
|
||
|
|
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 i = 0; i < arguments.length; i++) {
|
||
|
|
var caughtType = arguments[i];
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
function ___cxa_find_matching_catch_3() {
|
||
|
|
var thrown = exceptionLast;
|
||
|
|
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 i = 0; i < arguments.length; i++) {
|
||
|
|
var caughtType = arguments[i];
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
function ___cxa_find_matching_catch_4() {
|
||
|
|
var thrown = exceptionLast;
|
||
|
|
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 i = 0; i < arguments.length; i++) {
|
||
|
|
var caughtType = arguments[i];
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
function ___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 = ptr;
|
||
|
|
throw ptr;
|
||
|
|
}
|
||
|
|
function ___cxa_throw(ptr, type, destructor) {
|
||
|
|
var info = new ExceptionInfo(ptr);
|
||
|
|
info.init(type, destructor);
|
||
|
|
exceptionLast = ptr;
|
||
|
|
uncaughtExceptionCount++;
|
||
|
|
throw ptr;
|
||
|
|
}
|
||
|
|
function setErrNo(value) {
|
||
|
|
HEAP32[___errno_location() >>> 2] = value;
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
var PATH = { isAbs: (path2) => path2.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: (path2) => {
|
||
|
|
var isAbsolute = PATH.isAbs(path2), trailingSlash = path2.substr(-1) === "/";
|
||
|
|
path2 = PATH.normalizeArray(path2.split("/").filter((p) => !!p), !isAbsolute).join("/");
|
||
|
|
if (!path2 && !isAbsolute) {
|
||
|
|
path2 = ".";
|
||
|
|
}
|
||
|
|
if (path2 && trailingSlash) {
|
||
|
|
path2 += "/";
|
||
|
|
}
|
||
|
|
return (isAbsolute ? "/" : "") + path2;
|
||
|
|
}, dirname: (path2) => {
|
||
|
|
var result = PATH.splitPath(path2), root = result[0], dir = result[1];
|
||
|
|
if (!root && !dir) {
|
||
|
|
return ".";
|
||
|
|
}
|
||
|
|
if (dir) {
|
||
|
|
dir = dir.substr(0, dir.length - 1);
|
||
|
|
}
|
||
|
|
return root + dir;
|
||
|
|
}, basename: (path2) => {
|
||
|
|
if (path2 === "/")
|
||
|
|
return "/";
|
||
|
|
path2 = PATH.normalize(path2);
|
||
|
|
path2 = path2.replace(/\/$/, "");
|
||
|
|
var lastSlash = path2.lastIndexOf("/");
|
||
|
|
if (lastSlash === -1)
|
||
|
|
return path2;
|
||
|
|
return path2.substr(lastSlash + 1);
|
||
|
|
}, join: function() {
|
||
|
|
var paths = Array.prototype.slice.call(arguments);
|
||
|
|
return PATH.normalize(paths.join("/"));
|
||
|
|
}, join2: (l, r) => {
|
||
|
|
return PATH.normalize(l + "/" + r);
|
||
|
|
} };
|
||
|
|
function getRandomDevice() {
|
||
|
|
if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
|
||
|
|
var randomBuffer = new Uint8Array(1);
|
||
|
|
return () => {
|
||
|
|
crypto.getRandomValues(randomBuffer);
|
||
|
|
return randomBuffer[0];
|
||
|
|
};
|
||
|
|
} else if (ENVIRONMENT_IS_NODE) {
|
||
|
|
try {
|
||
|
|
var crypto_module = require("crypto");
|
||
|
|
return () => crypto_module["randomBytes"](1)[0];
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return () => abort("randomDevice");
|
||
|
|
}
|
||
|
|
var PATH_FS = { resolve: function() {
|
||
|
|
var resolvedPath = "", resolvedAbsolute = false;
|
||
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
||
|
|
var path2 = i >= 0 ? arguments[i] : FS.cwd();
|
||
|
|
if (typeof path2 != "string") {
|
||
|
|
throw new TypeError("Arguments to path.resolve must be strings");
|
||
|
|
} else if (!path2) {
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
resolvedPath = path2 + "/" + resolvedPath;
|
||
|
|
resolvedAbsolute = PATH.isAbs(path2);
|
||
|
|
}
|
||
|
|
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("/");
|
||
|
|
} };
|
||
|
|
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 TTY = { ttys: [], init: function() {
|
||
|
|
}, shutdown: function() {
|
||
|
|
}, register: function(dev, ops) {
|
||
|
|
TTY.ttys[dev] = { input: [], output: [], ops };
|
||
|
|
FS.registerDevice(dev, TTY.stream_ops);
|
||
|
|
}, stream_ops: { open: function(stream) {
|
||
|
|
var tty = TTY.ttys[stream.node.rdev];
|
||
|
|
if (!tty) {
|
||
|
|
throw new FS.ErrnoError(43);
|
||
|
|
}
|
||
|
|
stream.tty = tty;
|
||
|
|
stream.seekable = false;
|
||
|
|
}, close: function(stream) {
|
||
|
|
stream.tty.ops.fsync(stream.tty);
|
||
|
|
}, fsync: function(stream) {
|
||
|
|
stream.tty.ops.fsync(stream.tty);
|
||
|
|
}, read: function(stream, buffer2, 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 === void 0 && bytesRead === 0) {
|
||
|
|
throw new FS.ErrnoError(6);
|
||
|
|
}
|
||
|
|
if (result === null || result === void 0)
|
||
|
|
break;
|
||
|
|
bytesRead++;
|
||
|
|
buffer2[offset + i] = result;
|
||
|
|
}
|
||
|
|
if (bytesRead) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return bytesRead;
|
||
|
|
}, write: function(stream, buffer2, 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, buffer2[offset + i]);
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(29);
|
||
|
|
}
|
||
|
|
if (length) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
} }, default_tty_ops: { get_char: function(tty) {
|
||
|
|
if (!tty.input.length) {
|
||
|
|
var result = null;
|
||
|
|
if (ENVIRONMENT_IS_NODE) {
|
||
|
|
var BUFSIZE = 256;
|
||
|
|
var buf = Buffer.alloc(BUFSIZE);
|
||
|
|
var bytesRead = 0;
|
||
|
|
try {
|
||
|
|
bytesRead = fs2.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1);
|
||
|
|
} 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;
|
||
|
|
}
|
||
|
|
tty.input = intArrayFromString(result, true);
|
||
|
|
}
|
||
|
|
return tty.input.shift();
|
||
|
|
}, put_char: function(tty, val) {
|
||
|
|
if (val === null || val === 10) {
|
||
|
|
out(UTF8ArrayToString(tty.output, 0));
|
||
|
|
tty.output = [];
|
||
|
|
} else {
|
||
|
|
if (val != 0)
|
||
|
|
tty.output.push(val);
|
||
|
|
}
|
||
|
|
}, fsync: function(tty) {
|
||
|
|
if (tty.output && tty.output.length > 0) {
|
||
|
|
out(UTF8ArrayToString(tty.output, 0));
|
||
|
|
tty.output = [];
|
||
|
|
}
|
||
|
|
} }, default_tty1_ops: { put_char: function(tty, val) {
|
||
|
|
if (val === null || val === 10) {
|
||
|
|
err(UTF8ArrayToString(tty.output, 0));
|
||
|
|
tty.output = [];
|
||
|
|
} else {
|
||
|
|
if (val != 0)
|
||
|
|
tty.output.push(val);
|
||
|
|
}
|
||
|
|
}, fsync: function(tty) {
|
||
|
|
if (tty.output && tty.output.length > 0) {
|
||
|
|
err(UTF8ArrayToString(tty.output, 0));
|
||
|
|
tty.output = [];
|
||
|
|
}
|
||
|
|
} } };
|
||
|
|
function mmapAlloc(size) {
|
||
|
|
abort();
|
||
|
|
}
|
||
|
|
var MEMFS = { ops_table: null, mount: function(mount) {
|
||
|
|
return MEMFS.createNode(null, "/", 16384 | 511, 0);
|
||
|
|
}, createNode: function(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: function(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: function(node, newCapacity) {
|
||
|
|
newCapacity >>>= 0;
|
||
|
|
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: function(node, newSize) {
|
||
|
|
newSize >>>= 0;
|
||
|
|
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: function(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: function(node, attr) {
|
||
|
|
if (attr.mode !== void 0) {
|
||
|
|
node.mode = attr.mode;
|
||
|
|
}
|
||
|
|
if (attr.timestamp !== void 0) {
|
||
|
|
node.timestamp = attr.timestamp;
|
||
|
|
}
|
||
|
|
if (attr.size !== void 0) {
|
||
|
|
MEMFS.resizeFileStorage(node, attr.size);
|
||
|
|
}
|
||
|
|
}, lookup: function(parent, name) {
|
||
|
|
throw FS.genericErrors[44];
|
||
|
|
}, mknod: function(parent, name, mode, dev) {
|
||
|
|
return MEMFS.createNode(parent, name, mode, dev);
|
||
|
|
}, rename: function(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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
delete old_node.parent.contents[old_node.name];
|
||
|
|
old_node.parent.timestamp = Date.now();
|
||
|
|
old_node.name = new_name;
|
||
|
|
new_dir.contents[new_name] = old_node;
|
||
|
|
new_dir.timestamp = old_node.parent.timestamp;
|
||
|
|
old_node.parent = new_dir;
|
||
|
|
}, unlink: function(parent, name) {
|
||
|
|
delete parent.contents[name];
|
||
|
|
parent.timestamp = Date.now();
|
||
|
|
}, rmdir: function(parent, name) {
|
||
|
|
var node = FS.lookupNode(parent, name);
|
||
|
|
for (var i in node.contents) {
|
||
|
|
throw new FS.ErrnoError(55);
|
||
|
|
}
|
||
|
|
delete parent.contents[name];
|
||
|
|
parent.timestamp = Date.now();
|
||
|
|
}, readdir: function(node) {
|
||
|
|
var entries = [".", ".."];
|
||
|
|
for (var key in node.contents) {
|
||
|
|
if (!node.contents.hasOwnProperty(key)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
entries.push(key);
|
||
|
|
}
|
||
|
|
return entries;
|
||
|
|
}, symlink: function(parent, newname, oldpath) {
|
||
|
|
var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
|
||
|
|
node.link = oldpath;
|
||
|
|
return node;
|
||
|
|
}, readlink: function(node) {
|
||
|
|
if (!FS.isLink(node.mode)) {
|
||
|
|
throw new FS.ErrnoError(28);
|
||
|
|
}
|
||
|
|
return node.link;
|
||
|
|
} }, stream_ops: { read: function(stream, buffer2, 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) {
|
||
|
|
buffer2.set(contents.subarray(position, position + size), offset);
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < size; i++)
|
||
|
|
buffer2[offset + i] = contents[position + i];
|
||
|
|
}
|
||
|
|
return size;
|
||
|
|
}, write: function(stream, buffer2, offset, length, position, canOwn) {
|
||
|
|
if (buffer2.buffer === HEAP8.buffer) {
|
||
|
|
canOwn = false;
|
||
|
|
}
|
||
|
|
if (!length)
|
||
|
|
return 0;
|
||
|
|
var node = stream.node;
|
||
|
|
node.timestamp = Date.now();
|
||
|
|
if (buffer2.subarray && (!node.contents || node.contents.subarray)) {
|
||
|
|
if (canOwn) {
|
||
|
|
node.contents = buffer2.subarray(offset, offset + length);
|
||
|
|
node.usedBytes = length;
|
||
|
|
return length;
|
||
|
|
} else if (node.usedBytes === 0 && position === 0) {
|
||
|
|
node.contents = buffer2.slice(offset, offset + length);
|
||
|
|
node.usedBytes = length;
|
||
|
|
return length;
|
||
|
|
} else if (position + length <= node.usedBytes) {
|
||
|
|
node.contents.set(buffer2.subarray(offset, offset + length), position);
|
||
|
|
return length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
MEMFS.expandFileStorage(node, position + length);
|
||
|
|
if (node.contents.subarray && buffer2.subarray) {
|
||
|
|
node.contents.set(buffer2.subarray(offset, offset + length), position);
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
node.contents[position + i] = buffer2[offset + i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
node.usedBytes = Math.max(node.usedBytes, position + length);
|
||
|
|
return length;
|
||
|
|
}, llseek: function(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;
|
||
|
|
}, allocate: function(stream, offset, length) {
|
||
|
|
MEMFS.expandFileStorage(stream.node, offset + length);
|
||
|
|
stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
|
||
|
|
}, mmap: function(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 === buffer) {
|
||
|
|
allocated = false;
|
||
|
|
ptr = contents.byteOffset;
|
||
|
|
} else {
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
allocated = true;
|
||
|
|
ptr = mmapAlloc(length);
|
||
|
|
if (!ptr) {
|
||
|
|
throw new FS.ErrnoError(48);
|
||
|
|
}
|
||
|
|
ptr >>>= 0;
|
||
|
|
HEAP8.set(contents, ptr >>> 0);
|
||
|
|
}
|
||
|
|
return { ptr, allocated };
|
||
|
|
}, msync: function(stream, buffer2, offset, length, mmapFlags) {
|
||
|
|
MEMFS.stream_ops.write(stream, buffer2, 0, length, offset, false);
|
||
|
|
return 0;
|
||
|
|
} } };
|
||
|
|
function asyncLoad(url, onload, onerror, noRunDep) {
|
||
|
|
var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
|
||
|
|
readAsync(url, (arrayBuffer) => {
|
||
|
|
assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
|
||
|
|
onload(new Uint8Array(arrayBuffer));
|
||
|
|
if (dep)
|
||
|
|
removeRunDependency(dep);
|
||
|
|
}, (event) => {
|
||
|
|
if (onerror) {
|
||
|
|
onerror();
|
||
|
|
} else {
|
||
|
|
throw 'Loading data file "' + url + '" failed.';
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (dep)
|
||
|
|
addRunDependency(dep);
|
||
|
|
}
|
||
|
|
var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, ErrnoError: null, genericErrors: {}, filesystems: null, syncFSRequests: 0, lookupPath: (path2, opts = {}) => {
|
||
|
|
path2 = PATH_FS.resolve(FS.cwd(), path2);
|
||
|
|
if (!path2)
|
||
|
|
return { path: "", node: null };
|
||
|
|
var defaults = { follow_mount: true, recurse_count: 0 };
|
||
|
|
opts = Object.assign(defaults, opts);
|
||
|
|
if (opts.recurse_count > 8) {
|
||
|
|
throw new FS.ErrnoError(32);
|
||
|
|
}
|
||
|
|
var parts = PATH.normalizeArray(path2.split("/").filter((p) => !!p), false);
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
current = FS.lookupNode(current, parts[i]);
|
||
|
|
current_path = PATH.join2(current_path, parts[i]);
|
||
|
|
if (FS.isMountpoint(current)) {
|
||
|
|
if (!islast || islast && opts.follow_mount) {
|
||
|
|
current = current.mounted.root;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!islast || opts.follow) {
|
||
|
|
var count = 0;
|
||
|
|
while (FS.isLink(current.mode)) {
|
||
|
|
var link = FS.readlink(current_path);
|
||
|
|
current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
|
||
|
|
var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
|
||
|
|
current = lookup.node;
|
||
|
|
if (count++ > 40) {
|
||
|
|
throw new FS.ErrnoError(32);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return { path: current_path, node: current };
|
||
|
|
}, getPath: (node) => {
|
||
|
|
var path2;
|
||
|
|
while (true) {
|
||
|
|
if (FS.isRoot(node)) {
|
||
|
|
var mount = node.mount.mountpoint;
|
||
|
|
if (!path2)
|
||
|
|
return mount;
|
||
|
|
return mount[mount.length - 1] !== "/" ? mount + "/" + path2 : mount + path2;
|
||
|
|
}
|
||
|
|
path2 = path2 ? node.name + "/" + path2 : 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, parent);
|
||
|
|
}
|
||
|
|
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;
|
||
|
|
}, flagModes: { "r": 0, "r+": 2, "w": 577, "w+": 578, "a": 1089, "a+": 1090 }, modeStringToFlags: (str) => {
|
||
|
|
var flags = FS.flagModes[str];
|
||
|
|
if (typeof flags == "undefined") {
|
||
|
|
throw new Error("Unknown file open mode: " + str);
|
||
|
|
}
|
||
|
|
return flags;
|
||
|
|
}, 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;
|
||
|
|
} else if (perms.includes("w") && !(node.mode & 146)) {
|
||
|
|
return 2;
|
||
|
|
} else if (perms.includes("x") && !(node.mode & 73)) {
|
||
|
|
return 2;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}, mayLookup: (dir) => {
|
||
|
|
var errCode = FS.nodePermissions(dir, "x");
|
||
|
|
if (errCode)
|
||
|
|
return errCode;
|
||
|
|
if (!dir.node_ops.lookup)
|
||
|
|
return 2;
|
||
|
|
return 0;
|
||
|
|
}, mayCreate: (dir, name) => {
|
||
|
|
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;
|
||
|
|
} else if (FS.isDir(node.mode)) {
|
||
|
|
if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
|
||
|
|
return 31;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
|
||
|
|
}, MAX_OPEN_FDS: 4096, nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => {
|
||
|
|
for (var fd = fd_start; fd <= fd_end; fd++) {
|
||
|
|
if (!FS.streams[fd]) {
|
||
|
|
return fd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw new FS.ErrnoError(33);
|
||
|
|
}, getStream: (fd) => FS.streams[fd], createStream: (stream, fd_start, fd_end) => {
|
||
|
|
if (!FS.FSStream) {
|
||
|
|
FS.FSStream = function() {
|
||
|
|
this.shared = {};
|
||
|
|
};
|
||
|
|
FS.FSStream.prototype = {};
|
||
|
|
Object.defineProperties(FS.FSStream.prototype, { object: { get: function() {
|
||
|
|
return this.node;
|
||
|
|
}, set: function(val) {
|
||
|
|
this.node = val;
|
||
|
|
} }, isRead: { get: function() {
|
||
|
|
return (this.flags & 2097155) !== 1;
|
||
|
|
} }, isWrite: { get: function() {
|
||
|
|
return (this.flags & 2097155) !== 0;
|
||
|
|
} }, isAppend: { get: function() {
|
||
|
|
return this.flags & 1024;
|
||
|
|
} }, flags: { get: function() {
|
||
|
|
return this.shared.flags;
|
||
|
|
}, set: function(val) {
|
||
|
|
this.shared.flags = val;
|
||
|
|
} }, position: { get: function() {
|
||
|
|
return this.shared.position;
|
||
|
|
}, set: function(val) {
|
||
|
|
this.shared.position = val;
|
||
|
|
} } });
|
||
|
|
}
|
||
|
|
stream = Object.assign(new FS.FSStream(), stream);
|
||
|
|
var fd = FS.nextfd(fd_start, fd_end);
|
||
|
|
stream.fd = fd;
|
||
|
|
FS.streams[fd] = stream;
|
||
|
|
return stream;
|
||
|
|
}, closeStream: (fd) => {
|
||
|
|
FS.streams[fd] = null;
|
||
|
|
}, chrdev_stream_ops: { open: (stream) => {
|
||
|
|
var device = FS.getDevice(stream.node.rdev);
|
||
|
|
stream.stream_ops = device.stream_ops;
|
||
|
|
if (stream.stream_ops.open) {
|
||
|
|
stream.stream_ops.open(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.apply(check, 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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mounts.forEach((mount) => {
|
||
|
|
if (!mount.type.syncfs) {
|
||
|
|
return done(null);
|
||
|
|
}
|
||
|
|
mount.type.syncfs(mount, populate, done);
|
||
|
|
});
|
||
|
|
}, 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);
|
||
|
|
Object.keys(FS.nameTable).forEach((hash) => {
|
||
|
|
var current = FS.nameTable[hash];
|
||
|
|
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: (path2, mode, dev) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
var name = PATH.basename(path2);
|
||
|
|
if (!name || name === "." || name === "..") {
|
||
|
|
throw new FS.ErrnoError(28);
|
||
|
|
}
|
||
|
|
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);
|
||
|
|
}, create: (path2, mode) => {
|
||
|
|
mode = mode !== void 0 ? mode : 438;
|
||
|
|
mode &= 4095;
|
||
|
|
mode |= 32768;
|
||
|
|
return FS.mknod(path2, mode, 0);
|
||
|
|
}, mkdir: (path2, mode) => {
|
||
|
|
mode = mode !== void 0 ? mode : 511;
|
||
|
|
mode &= 511 | 512;
|
||
|
|
mode |= 16384;
|
||
|
|
return FS.mknod(path2, mode, 0);
|
||
|
|
}, mkdirTree: (path2, mode) => {
|
||
|
|
var dirs = path2.split("/");
|
||
|
|
var d = "";
|
||
|
|
for (var i = 0; i < dirs.length; ++i) {
|
||
|
|
if (!dirs[i])
|
||
|
|
continue;
|
||
|
|
d += "/" + dirs[i];
|
||
|
|
try {
|
||
|
|
FS.mkdir(d, mode);
|
||
|
|
} catch (e) {
|
||
|
|
if (e.errno != 20)
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, mkdev: (path2, mode, dev) => {
|
||
|
|
if (typeof dev == "undefined") {
|
||
|
|
dev = mode;
|
||
|
|
mode = 438;
|
||
|
|
}
|
||
|
|
mode |= 8192;
|
||
|
|
return FS.mknod(path2, 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);
|
||
|
|
} catch (e) {
|
||
|
|
throw e;
|
||
|
|
} finally {
|
||
|
|
FS.hashAddNode(old_node);
|
||
|
|
}
|
||
|
|
}, rmdir: (path2) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
var name = PATH.basename(path2);
|
||
|
|
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: (path2) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: true });
|
||
|
|
var node = lookup.node;
|
||
|
|
if (!node.node_ops.readdir) {
|
||
|
|
throw new FS.ErrnoError(54);
|
||
|
|
}
|
||
|
|
return node.node_ops.readdir(node);
|
||
|
|
}, unlink: (path2) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { parent: true });
|
||
|
|
var parent = lookup.node;
|
||
|
|
if (!parent) {
|
||
|
|
throw new FS.ErrnoError(44);
|
||
|
|
}
|
||
|
|
var name = PATH.basename(path2);
|
||
|
|
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: (path2) => {
|
||
|
|
var lookup = FS.lookupPath(path2);
|
||
|
|
var link = lookup.node;
|
||
|
|
if (!link) {
|
||
|
|
throw new FS.ErrnoError(44);
|
||
|
|
}
|
||
|
|
if (!link.node_ops.readlink) {
|
||
|
|
throw new FS.ErrnoError(28);
|
||
|
|
}
|
||
|
|
return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
|
||
|
|
}, stat: (path2, dontFollow) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: !dontFollow });
|
||
|
|
var node = lookup.node;
|
||
|
|
if (!node) {
|
||
|
|
throw new FS.ErrnoError(44);
|
||
|
|
}
|
||
|
|
if (!node.node_ops.getattr) {
|
||
|
|
throw new FS.ErrnoError(63);
|
||
|
|
}
|
||
|
|
return node.node_ops.getattr(node);
|
||
|
|
}, lstat: (path2) => {
|
||
|
|
return FS.stat(path2, true);
|
||
|
|
}, chmod: (path2, mode, dontFollow) => {
|
||
|
|
var node;
|
||
|
|
if (typeof path2 == "string") {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: !dontFollow });
|
||
|
|
node = lookup.node;
|
||
|
|
} else {
|
||
|
|
node = path2;
|
||
|
|
}
|
||
|
|
if (!node.node_ops.setattr) {
|
||
|
|
throw new FS.ErrnoError(63);
|
||
|
|
}
|
||
|
|
node.node_ops.setattr(node, { mode: mode & 4095 | node.mode & ~4095, timestamp: Date.now() });
|
||
|
|
}, lchmod: (path2, mode) => {
|
||
|
|
FS.chmod(path2, mode, true);
|
||
|
|
}, fchmod: (fd, mode) => {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream) {
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
}
|
||
|
|
FS.chmod(stream.node, mode);
|
||
|
|
}, chown: (path2, uid, gid, dontFollow) => {
|
||
|
|
var node;
|
||
|
|
if (typeof path2 == "string") {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: !dontFollow });
|
||
|
|
node = lookup.node;
|
||
|
|
} else {
|
||
|
|
node = path2;
|
||
|
|
}
|
||
|
|
if (!node.node_ops.setattr) {
|
||
|
|
throw new FS.ErrnoError(63);
|
||
|
|
}
|
||
|
|
node.node_ops.setattr(node, { timestamp: Date.now() });
|
||
|
|
}, lchown: (path2, uid, gid) => {
|
||
|
|
FS.chown(path2, uid, gid, true);
|
||
|
|
}, fchown: (fd, uid, gid) => {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream) {
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
}
|
||
|
|
FS.chown(stream.node, uid, gid);
|
||
|
|
}, truncate: (path2, len) => {
|
||
|
|
if (len < 0) {
|
||
|
|
throw new FS.ErrnoError(28);
|
||
|
|
}
|
||
|
|
var node;
|
||
|
|
if (typeof path2 == "string") {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: true });
|
||
|
|
node = lookup.node;
|
||
|
|
} else {
|
||
|
|
node = path2;
|
||
|
|
}
|
||
|
|
if (!node.node_ops.setattr) {
|
||
|
|
throw new FS.ErrnoError(63);
|
||
|
|
}
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
node.node_ops.setattr(node, { size: len, timestamp: Date.now() });
|
||
|
|
}, ftruncate: (fd, len) => {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream) {
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
}
|
||
|
|
if ((stream.flags & 2097155) === 0) {
|
||
|
|
throw new FS.ErrnoError(28);
|
||
|
|
}
|
||
|
|
FS.truncate(stream.node, len);
|
||
|
|
}, utime: (path2, atime, mtime) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: true });
|
||
|
|
var node = lookup.node;
|
||
|
|
node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) });
|
||
|
|
}, open: (path2, flags, mode) => {
|
||
|
|
if (path2 === "") {
|
||
|
|
throw new FS.ErrnoError(44);
|
||
|
|
}
|
||
|
|
flags = typeof flags == "string" ? FS.modeStringToFlags(flags) : flags;
|
||
|
|
mode = typeof mode == "undefined" ? 438 : mode;
|
||
|
|
if (flags & 64) {
|
||
|
|
mode = mode & 4095 | 32768;
|
||
|
|
} else {
|
||
|
|
mode = 0;
|
||
|
|
}
|
||
|
|
var node;
|
||
|
|
if (typeof path2 == "object") {
|
||
|
|
node = path2;
|
||
|
|
} else {
|
||
|
|
path2 = PATH.normalize(path2);
|
||
|
|
try {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: !(flags & 131072) });
|
||
|
|
node = lookup.node;
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var created = false;
|
||
|
|
if (flags & 64) {
|
||
|
|
if (node) {
|
||
|
|
if (flags & 128) {
|
||
|
|
throw new FS.ErrnoError(20);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
node = FS.mknod(path2, mode, 0);
|
||
|
|
created = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!node) {
|
||
|
|
throw new FS.ErrnoError(44);
|
||
|
|
}
|
||
|
|
if (FS.isChrdev(node.mode)) {
|
||
|
|
flags &= ~512;
|
||
|
|
}
|
||
|
|
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 &= ~(128 | 512 | 131072);
|
||
|
|
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 (Module2["logReadFiles"] && !(flags & 1)) {
|
||
|
|
if (!FS.readFiles)
|
||
|
|
FS.readFiles = {};
|
||
|
|
if (!(path2 in FS.readFiles)) {
|
||
|
|
FS.readFiles[path2] = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
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, buffer2, offset, length, position) => {
|
||
|
|
offset >>>= 0;
|
||
|
|
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, buffer2, offset, length, position);
|
||
|
|
if (!seeking)
|
||
|
|
stream.position += bytesRead;
|
||
|
|
return bytesRead;
|
||
|
|
}, write: (stream, buffer2, offset, length, position, canOwn) => {
|
||
|
|
offset >>>= 0;
|
||
|
|
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, buffer2, offset, length, position, canOwn);
|
||
|
|
if (!seeking)
|
||
|
|
stream.position += bytesWritten;
|
||
|
|
return bytesWritten;
|
||
|
|
}, allocate: (stream, offset, length) => {
|
||
|
|
if (FS.isClosed(stream)) {
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
}
|
||
|
|
if (offset < 0 || length <= 0) {
|
||
|
|
throw new FS.ErrnoError(28);
|
||
|
|
}
|
||
|
|
if ((stream.flags & 2097155) === 0) {
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
}
|
||
|
|
if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
|
||
|
|
throw new FS.ErrnoError(43);
|
||
|
|
}
|
||
|
|
if (!stream.stream_ops.allocate) {
|
||
|
|
throw new FS.ErrnoError(138);
|
||
|
|
}
|
||
|
|
stream.stream_ops.allocate(stream, offset, length);
|
||
|
|
}, 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);
|
||
|
|
}
|
||
|
|
return stream.stream_ops.mmap(stream, length, position, prot, flags);
|
||
|
|
}, msync: (stream, buffer2, offset, length, mmapFlags) => {
|
||
|
|
offset >>>= 0;
|
||
|
|
if (!stream.stream_ops.msync) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
return stream.stream_ops.msync(stream, buffer2, offset, length, mmapFlags);
|
||
|
|
}, munmap: (stream) => 0, ioctl: (stream, cmd, arg) => {
|
||
|
|
if (!stream.stream_ops.ioctl) {
|
||
|
|
throw new FS.ErrnoError(59);
|
||
|
|
}
|
||
|
|
return stream.stream_ops.ioctl(stream, cmd, arg);
|
||
|
|
}, readFile: (path2, opts = {}) => {
|
||
|
|
opts.flags = opts.flags || 0;
|
||
|
|
opts.encoding = opts.encoding || "binary";
|
||
|
|
if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
|
||
|
|
throw new Error('Invalid encoding type "' + opts.encoding + '"');
|
||
|
|
}
|
||
|
|
var ret;
|
||
|
|
var stream = FS.open(path2, opts.flags);
|
||
|
|
var stat = FS.stat(path2);
|
||
|
|
var length = stat.size;
|
||
|
|
var buf = new Uint8Array(length);
|
||
|
|
FS.read(stream, buf, 0, length, 0);
|
||
|
|
if (opts.encoding === "utf8") {
|
||
|
|
ret = UTF8ArrayToString(buf, 0);
|
||
|
|
} else if (opts.encoding === "binary") {
|
||
|
|
ret = buf;
|
||
|
|
}
|
||
|
|
FS.close(stream);
|
||
|
|
return ret;
|
||
|
|
}, writeFile: (path2, data, opts = {}) => {
|
||
|
|
opts.flags = opts.flags || 577;
|
||
|
|
var stream = FS.open(path2, opts.flags, opts.mode);
|
||
|
|
if (typeof data == "string") {
|
||
|
|
var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
|
||
|
|
var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
|
||
|
|
FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn);
|
||
|
|
} else if (ArrayBuffer.isView(data)) {
|
||
|
|
FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
|
||
|
|
} else {
|
||
|
|
throw new Error("Unsupported data type");
|
||
|
|
}
|
||
|
|
FS.close(stream);
|
||
|
|
}, cwd: () => FS.currentPath, chdir: (path2) => {
|
||
|
|
var lookup = FS.lookupPath(path2, { 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, buffer2, offset, length, pos) => length });
|
||
|
|
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 random_device = getRandomDevice();
|
||
|
|
FS.createDevice("/dev", "random", random_device);
|
||
|
|
FS.createDevice("/dev", "urandom", random_device);
|
||
|
|
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", 16384 | 511, 73);
|
||
|
|
node.node_ops = { lookup: (parent, name) => {
|
||
|
|
var fd = +name;
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream)
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
var ret = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => stream.path } };
|
||
|
|
ret.parent = ret;
|
||
|
|
return ret;
|
||
|
|
} };
|
||
|
|
return node;
|
||
|
|
} }, {}, "/proc/self/fd");
|
||
|
|
}, createStandardStreams: () => {
|
||
|
|
if (Module2["stdin"]) {
|
||
|
|
FS.createDevice("/dev", "stdin", Module2["stdin"]);
|
||
|
|
} else {
|
||
|
|
FS.symlink("/dev/tty", "/dev/stdin");
|
||
|
|
}
|
||
|
|
if (Module2["stdout"]) {
|
||
|
|
FS.createDevice("/dev", "stdout", null, Module2["stdout"]);
|
||
|
|
} else {
|
||
|
|
FS.symlink("/dev/tty", "/dev/stdout");
|
||
|
|
}
|
||
|
|
if (Module2["stderr"]) {
|
||
|
|
FS.createDevice("/dev", "stderr", null, Module2["stderr"]);
|
||
|
|
} else {
|
||
|
|
FS.symlink("/dev/tty1", "/dev/stderr");
|
||
|
|
}
|
||
|
|
var stdin = FS.open("/dev/stdin", 0);
|
||
|
|
var stdout = FS.open("/dev/stdout", 1);
|
||
|
|
var stderr = FS.open("/dev/stderr", 1);
|
||
|
|
}, ensureErrnoError: () => {
|
||
|
|
if (FS.ErrnoError)
|
||
|
|
return;
|
||
|
|
FS.ErrnoError = function ErrnoError(errno, node) {
|
||
|
|
this.node = node;
|
||
|
|
this.setErrno = function(errno2) {
|
||
|
|
this.errno = errno2;
|
||
|
|
};
|
||
|
|
this.setErrno(errno);
|
||
|
|
this.message = "FS error";
|
||
|
|
};
|
||
|
|
FS.ErrnoError.prototype = new Error();
|
||
|
|
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
|
||
|
|
[44].forEach((code) => {
|
||
|
|
FS.genericErrors[code] = new FS.ErrnoError(code);
|
||
|
|
FS.genericErrors[code].stack = "<generic error, no stack>";
|
||
|
|
});
|
||
|
|
}, staticInit: () => {
|
||
|
|
FS.ensureErrnoError();
|
||
|
|
FS.nameTable = new Array(4096);
|
||
|
|
FS.mount(MEMFS, {}, "/");
|
||
|
|
FS.createDefaultDirectories();
|
||
|
|
FS.createDefaultDevices();
|
||
|
|
FS.createSpecialDirectories();
|
||
|
|
FS.filesystems = { "MEMFS": MEMFS };
|
||
|
|
}, init: (input, output, error) => {
|
||
|
|
FS.init.initialized = true;
|
||
|
|
FS.ensureErrnoError();
|
||
|
|
Module2["stdin"] = input || Module2["stdin"];
|
||
|
|
Module2["stdout"] = output || Module2["stdout"];
|
||
|
|
Module2["stderr"] = error || Module2["stderr"];
|
||
|
|
FS.createStandardStreams();
|
||
|
|
}, quit: () => {
|
||
|
|
FS.init.initialized = false;
|
||
|
|
for (var i = 0; i < FS.streams.length; i++) {
|
||
|
|
var stream = FS.streams[i];
|
||
|
|
if (!stream) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
FS.close(stream);
|
||
|
|
}
|
||
|
|
}, getMode: (canRead, canWrite) => {
|
||
|
|
var mode = 0;
|
||
|
|
if (canRead)
|
||
|
|
mode |= 292 | 73;
|
||
|
|
if (canWrite)
|
||
|
|
mode |= 146;
|
||
|
|
return mode;
|
||
|
|
}, findObject: (path2, dontResolveLastLink) => {
|
||
|
|
var ret = FS.analyzePath(path2, dontResolveLastLink);
|
||
|
|
if (!ret.exists) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return ret.object;
|
||
|
|
}, analyzePath: (path2, dontResolveLastLink) => {
|
||
|
|
try {
|
||
|
|
var lookup = FS.lookupPath(path2, { follow: !dontResolveLastLink });
|
||
|
|
path2 = 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(path2, { parent: true });
|
||
|
|
ret.parentExists = true;
|
||
|
|
ret.parentPath = lookup.path;
|
||
|
|
ret.parentObject = lookup.node;
|
||
|
|
ret.name = PATH.basename(path2);
|
||
|
|
lookup = FS.lookupPath(path2, { 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, path2, canRead, canWrite) => {
|
||
|
|
parent = typeof parent == "string" ? parent : FS.getPath(parent);
|
||
|
|
var parts = path2.split("/").reverse();
|
||
|
|
while (parts.length) {
|
||
|
|
var part = parts.pop();
|
||
|
|
if (!part)
|
||
|
|
continue;
|
||
|
|
var current = PATH.join2(parent, part);
|
||
|
|
try {
|
||
|
|
FS.mkdir(current);
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
parent = current;
|
||
|
|
}
|
||
|
|
return current;
|
||
|
|
}, createFile: (parent, name, properties, canRead, canWrite) => {
|
||
|
|
var path2 = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
|
||
|
|
var mode = FS.getMode(canRead, canWrite);
|
||
|
|
return FS.create(path2, mode);
|
||
|
|
}, createDataFile: (parent, name, data, canRead, canWrite, canOwn) => {
|
||
|
|
var path2 = name;
|
||
|
|
if (parent) {
|
||
|
|
parent = typeof parent == "string" ? parent : FS.getPath(parent);
|
||
|
|
path2 = name ? PATH.join2(parent, name) : parent;
|
||
|
|
}
|
||
|
|
var mode = FS.getMode(canRead, canWrite);
|
||
|
|
var node = FS.create(path2, mode);
|
||
|
|
if (data) {
|
||
|
|
if (typeof data == "string") {
|
||
|
|
var arr = new Array(data.length);
|
||
|
|
for (var i = 0, len = data.length; i < len; ++i)
|
||
|
|
arr[i] = data.charCodeAt(i);
|
||
|
|
data = arr;
|
||
|
|
}
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
}, createDevice: (parent, name, input, output) => {
|
||
|
|
var path2 = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
|
||
|
|
var mode = FS.getMode(!!input, !!output);
|
||
|
|
if (!FS.createDevice.major)
|
||
|
|
FS.createDevice.major = 64;
|
||
|
|
var dev = FS.makedev(FS.createDevice.major++, 0);
|
||
|
|
FS.registerDevice(dev, { open: (stream) => {
|
||
|
|
stream.seekable = false;
|
||
|
|
}, close: (stream) => {
|
||
|
|
if (output && output.buffer && output.buffer.length) {
|
||
|
|
output(10);
|
||
|
|
}
|
||
|
|
}, read: (stream, buffer2, 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 === void 0 && bytesRead === 0) {
|
||
|
|
throw new FS.ErrnoError(6);
|
||
|
|
}
|
||
|
|
if (result === null || result === void 0)
|
||
|
|
break;
|
||
|
|
bytesRead++;
|
||
|
|
buffer2[offset + i] = result;
|
||
|
|
}
|
||
|
|
if (bytesRead) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return bytesRead;
|
||
|
|
}, write: (stream, buffer2, offset, length, pos) => {
|
||
|
|
for (var i = 0; i < length; i++) {
|
||
|
|
try {
|
||
|
|
output(buffer2[offset + i]);
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(29);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (length) {
|
||
|
|
stream.node.timestamp = Date.now();
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
} });
|
||
|
|
return FS.mkdev(path2, mode, dev);
|
||
|
|
}, forceLoadFile: (obj) => {
|
||
|
|
if (obj.isDevice || obj.isFolder || obj.link || obj.contents)
|
||
|
|
return true;
|
||
|
|
if (typeof XMLHttpRequest != "undefined") {
|
||
|
|
throw new Error("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 if (read_) {
|
||
|
|
try {
|
||
|
|
obj.contents = intArrayFromString(read_(obj.url), true);
|
||
|
|
obj.usedBytes = obj.contents.length;
|
||
|
|
} catch (e) {
|
||
|
|
throw new FS.ErrnoError(29);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
throw new Error("Cannot load without read() or XMLHttpRequest.");
|
||
|
|
}
|
||
|
|
}, createLazyFile: (parent, name, url, canRead, canWrite) => {
|
||
|
|
function LazyUint8Array() {
|
||
|
|
this.lengthKnown = false;
|
||
|
|
this.chunks = [];
|
||
|
|
}
|
||
|
|
LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
|
||
|
|
if (idx > this.length - 1 || idx < 0) {
|
||
|
|
return void 0;
|
||
|
|
}
|
||
|
|
var chunkOffset = idx % this.chunkSize;
|
||
|
|
var chunkNum = idx / this.chunkSize | 0;
|
||
|
|
return this.getter(chunkNum)[chunkOffset];
|
||
|
|
};
|
||
|
|
LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
|
||
|
|
this.getter = getter;
|
||
|
|
};
|
||
|
|
LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
|
||
|
|
var xhr = new XMLHttpRequest();
|
||
|
|
xhr.open("HEAD", url, false);
|
||
|
|
xhr.send(null);
|
||
|
|
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
|
||
|
|
throw new Error("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)
|
||
|
|
throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
|
||
|
|
if (to > datalength - 1)
|
||
|
|
throw new Error("only " + datalength + " bytes available! programmer error!");
|
||
|
|
var xhr2 = new XMLHttpRequest();
|
||
|
|
xhr2.open("GET", url, false);
|
||
|
|
if (datalength !== chunkSize)
|
||
|
|
xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to);
|
||
|
|
xhr2.responseType = "arraybuffer";
|
||
|
|
if (xhr2.overrideMimeType) {
|
||
|
|
xhr2.overrideMimeType("text/plain; charset=x-user-defined");
|
||
|
|
}
|
||
|
|
xhr2.send(null);
|
||
|
|
if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304))
|
||
|
|
throw new Error("Couldn't load " + url + ". Status: " + xhr2.status);
|
||
|
|
if (xhr2.response !== void 0) {
|
||
|
|
return new Uint8Array(xhr2.response || []);
|
||
|
|
}
|
||
|
|
return intArrayFromString(xhr2.responseText || "", true);
|
||
|
|
};
|
||
|
|
var lazyArray2 = this;
|
||
|
|
lazyArray2.setDataGetter((chunkNum) => {
|
||
|
|
var start = chunkNum * chunkSize;
|
||
|
|
var end = (chunkNum + 1) * chunkSize - 1;
|
||
|
|
end = Math.min(end, datalength - 1);
|
||
|
|
if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
|
||
|
|
lazyArray2.chunks[chunkNum] = doXHR(start, end);
|
||
|
|
}
|
||
|
|
if (typeof lazyArray2.chunks[chunkNum] == "undefined")
|
||
|
|
throw new Error("doXHR failed!");
|
||
|
|
return lazyArray2.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;
|
||
|
|
};
|
||
|
|
if (typeof XMLHttpRequest != "undefined") {
|
||
|
|
if (!ENVIRONMENT_IS_WORKER)
|
||
|
|
throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
|
||
|
|
var lazyArray = new LazyUint8Array();
|
||
|
|
Object.defineProperties(lazyArray, { length: { get: function() {
|
||
|
|
if (!this.lengthKnown) {
|
||
|
|
this.cacheLength();
|
||
|
|
}
|
||
|
|
return this._length;
|
||
|
|
} }, chunkSize: { get: function() {
|
||
|
|
if (!this.lengthKnown) {
|
||
|
|
this.cacheLength();
|
||
|
|
}
|
||
|
|
return this._chunkSize;
|
||
|
|
} } });
|
||
|
|
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 = {};
|
||
|
|
var keys = Object.keys(node.stream_ops);
|
||
|
|
keys.forEach((key) => {
|
||
|
|
var fn = node.stream_ops[key];
|
||
|
|
stream_ops[key] = function forceLoadLazyFile() {
|
||
|
|
FS.forceLoadFile(node);
|
||
|
|
return fn.apply(null, arguments);
|
||
|
|
};
|
||
|
|
});
|
||
|
|
function writeChunks(stream, buffer2, 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++) {
|
||
|
|
buffer2[offset + i] = contents[position + i];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < size; i++) {
|
||
|
|
buffer2[offset + i] = contents.get(position + i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return size;
|
||
|
|
}
|
||
|
|
stream_ops.read = (stream, buffer2, offset, length, position) => {
|
||
|
|
FS.forceLoadFile(node);
|
||
|
|
return writeChunks(stream, buffer2, offset, length, position);
|
||
|
|
};
|
||
|
|
stream_ops.mmap = (stream, length, position, prot, flags) => {
|
||
|
|
FS.forceLoadFile(node);
|
||
|
|
var ptr = mmapAlloc(length);
|
||
|
|
if (!ptr) {
|
||
|
|
throw new FS.ErrnoError(48);
|
||
|
|
}
|
||
|
|
writeChunks(stream, HEAP8, ptr, length, position);
|
||
|
|
return { ptr, allocated: true };
|
||
|
|
};
|
||
|
|
node.stream_ops = stream_ops;
|
||
|
|
return node;
|
||
|
|
}, 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(byteArray2) {
|
||
|
|
if (preFinish)
|
||
|
|
preFinish();
|
||
|
|
if (!dontCreateFile) {
|
||
|
|
FS.createDataFile(parent, name, byteArray2, canRead, canWrite, canOwn);
|
||
|
|
}
|
||
|
|
if (onload)
|
||
|
|
onload();
|
||
|
|
removeRunDependency(dep);
|
||
|
|
}
|
||
|
|
if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => {
|
||
|
|
if (onerror)
|
||
|
|
onerror();
|
||
|
|
removeRunDependency(dep);
|
||
|
|
})) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
finish(byteArray);
|
||
|
|
}
|
||
|
|
addRunDependency(dep);
|
||
|
|
if (typeof url == "string") {
|
||
|
|
asyncLoad(url, (byteArray) => processData(byteArray), onerror);
|
||
|
|
} else {
|
||
|
|
processData(url);
|
||
|
|
}
|
||
|
|
}, indexedDB: () => {
|
||
|
|
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
||
|
|
}, DB_NAME: () => {
|
||
|
|
return "EM_FS_" + window.location.pathname;
|
||
|
|
}, DB_VERSION: 20, DB_STORE_NAME: "FILE_DATA", saveFilesToDB: (paths, onload, onerror) => {
|
||
|
|
onload = onload || (() => {
|
||
|
|
});
|
||
|
|
onerror = onerror || (() => {
|
||
|
|
});
|
||
|
|
var indexedDB = FS.indexedDB();
|
||
|
|
try {
|
||
|
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
||
|
|
} catch (e) {
|
||
|
|
return onerror(e);
|
||
|
|
}
|
||
|
|
openRequest.onupgradeneeded = () => {
|
||
|
|
out("creating db");
|
||
|
|
var db = openRequest.result;
|
||
|
|
db.createObjectStore(FS.DB_STORE_NAME);
|
||
|
|
};
|
||
|
|
openRequest.onsuccess = () => {
|
||
|
|
var db = openRequest.result;
|
||
|
|
var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite");
|
||
|
|
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
||
|
|
var ok = 0, fail = 0, total = paths.length;
|
||
|
|
function finish() {
|
||
|
|
if (fail == 0)
|
||
|
|
onload();
|
||
|
|
else
|
||
|
|
onerror();
|
||
|
|
}
|
||
|
|
paths.forEach((path2) => {
|
||
|
|
var putRequest = files.put(FS.analyzePath(path2).object.contents, path2);
|
||
|
|
putRequest.onsuccess = () => {
|
||
|
|
ok++;
|
||
|
|
if (ok + fail == total)
|
||
|
|
finish();
|
||
|
|
};
|
||
|
|
putRequest.onerror = () => {
|
||
|
|
fail++;
|
||
|
|
if (ok + fail == total)
|
||
|
|
finish();
|
||
|
|
};
|
||
|
|
});
|
||
|
|
transaction.onerror = onerror;
|
||
|
|
};
|
||
|
|
openRequest.onerror = onerror;
|
||
|
|
}, loadFilesFromDB: (paths, onload, onerror) => {
|
||
|
|
onload = onload || (() => {
|
||
|
|
});
|
||
|
|
onerror = onerror || (() => {
|
||
|
|
});
|
||
|
|
var indexedDB = FS.indexedDB();
|
||
|
|
try {
|
||
|
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
||
|
|
} catch (e) {
|
||
|
|
return onerror(e);
|
||
|
|
}
|
||
|
|
openRequest.onupgradeneeded = onerror;
|
||
|
|
openRequest.onsuccess = () => {
|
||
|
|
var db = openRequest.result;
|
||
|
|
try {
|
||
|
|
var transaction = db.transaction([FS.DB_STORE_NAME], "readonly");
|
||
|
|
} catch (e) {
|
||
|
|
onerror(e);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
||
|
|
var ok = 0, fail = 0, total = paths.length;
|
||
|
|
function finish() {
|
||
|
|
if (fail == 0)
|
||
|
|
onload();
|
||
|
|
else
|
||
|
|
onerror();
|
||
|
|
}
|
||
|
|
paths.forEach((path2) => {
|
||
|
|
var getRequest = files.get(path2);
|
||
|
|
getRequest.onsuccess = () => {
|
||
|
|
if (FS.analyzePath(path2).exists) {
|
||
|
|
FS.unlink(path2);
|
||
|
|
}
|
||
|
|
FS.createDataFile(PATH.dirname(path2), PATH.basename(path2), getRequest.result, true, true, true);
|
||
|
|
ok++;
|
||
|
|
if (ok + fail == total)
|
||
|
|
finish();
|
||
|
|
};
|
||
|
|
getRequest.onerror = () => {
|
||
|
|
fail++;
|
||
|
|
if (ok + fail == total)
|
||
|
|
finish();
|
||
|
|
};
|
||
|
|
});
|
||
|
|
transaction.onerror = onerror;
|
||
|
|
};
|
||
|
|
openRequest.onerror = onerror;
|
||
|
|
} };
|
||
|
|
var SYSCALLS = { DEFAULT_POLLMASK: 5, calculateAt: function(dirfd, path2, allowEmpty) {
|
||
|
|
if (PATH.isAbs(path2)) {
|
||
|
|
return path2;
|
||
|
|
}
|
||
|
|
var dir;
|
||
|
|
if (dirfd === -100) {
|
||
|
|
dir = FS.cwd();
|
||
|
|
} else {
|
||
|
|
var dirstream = SYSCALLS.getStreamFromFD(dirfd);
|
||
|
|
dir = dirstream.path;
|
||
|
|
}
|
||
|
|
if (path2.length == 0) {
|
||
|
|
if (!allowEmpty) {
|
||
|
|
throw new FS.ErrnoError(44);
|
||
|
|
}
|
||
|
|
return dir;
|
||
|
|
}
|
||
|
|
return PATH.join2(dir, path2);
|
||
|
|
}, doStat: function(func, path2, buf) {
|
||
|
|
try {
|
||
|
|
var stat = func(path2);
|
||
|
|
} catch (e) {
|
||
|
|
if (e && e.node && PATH.normalize(path2) !== PATH.normalize(FS.getPath(e.node))) {
|
||
|
|
return -54;
|
||
|
|
}
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
HEAP32[buf >>> 2] = stat.dev;
|
||
|
|
HEAP32[buf + 8 >>> 2] = stat.ino;
|
||
|
|
HEAP32[buf + 12 >>> 2] = stat.mode;
|
||
|
|
HEAPU32[buf + 16 >>> 2] = stat.nlink;
|
||
|
|
HEAP32[buf + 20 >>> 2] = stat.uid;
|
||
|
|
HEAP32[buf + 24 >>> 2] = stat.gid;
|
||
|
|
HEAP32[buf + 28 >>> 2] = stat.rdev;
|
||
|
|
tempI64 = [stat.size >>> 0, (tempDouble = stat.size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 40 >>> 2] = tempI64[0], HEAP32[buf + 44 >>> 2] = tempI64[1];
|
||
|
|
HEAP32[buf + 48 >>> 2] = 4096;
|
||
|
|
HEAP32[buf + 52 >>> 2] = stat.blocks;
|
||
|
|
tempI64 = [Math.floor(stat.atime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.atime.getTime() / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 56 >>> 2] = tempI64[0], HEAP32[buf + 60 >>> 2] = tempI64[1];
|
||
|
|
HEAPU32[buf + 64 >>> 2] = 0;
|
||
|
|
tempI64 = [Math.floor(stat.mtime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.mtime.getTime() / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 72 >>> 2] = tempI64[0], HEAP32[buf + 76 >>> 2] = tempI64[1];
|
||
|
|
HEAPU32[buf + 80 >>> 2] = 0;
|
||
|
|
tempI64 = [Math.floor(stat.ctime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.ctime.getTime() / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 88 >>> 2] = tempI64[0], HEAP32[buf + 92 >>> 2] = tempI64[1];
|
||
|
|
HEAPU32[buf + 96 >>> 2] = 0;
|
||
|
|
tempI64 = [stat.ino >>> 0, (tempDouble = stat.ino, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 104 >>> 2] = tempI64[0], HEAP32[buf + 108 >>> 2] = tempI64[1];
|
||
|
|
return 0;
|
||
|
|
}, doMsync: function(addr, stream, len, flags, offset) {
|
||
|
|
if (!FS.isFile(stream.node.mode)) {
|
||
|
|
throw new FS.ErrnoError(43);
|
||
|
|
}
|
||
|
|
if (flags & 2) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
addr >>>= 0;
|
||
|
|
var buffer2 = HEAPU8.slice(addr, addr + len);
|
||
|
|
FS.msync(stream, buffer2, offset, len, flags);
|
||
|
|
}, varargs: void 0, get: function() {
|
||
|
|
SYSCALLS.varargs += 4;
|
||
|
|
var ret = HEAP32[SYSCALLS.varargs - 4 >>> 2];
|
||
|
|
return ret;
|
||
|
|
}, getStr: function(ptr) {
|
||
|
|
var ret = UTF8ToString(ptr);
|
||
|
|
return ret;
|
||
|
|
}, getStreamFromFD: function(fd) {
|
||
|
|
var stream = FS.getStream(fd);
|
||
|
|
if (!stream)
|
||
|
|
throw new FS.ErrnoError(8);
|
||
|
|
return stream;
|
||
|
|
} };
|
||
|
|
function ___syscall_fcntl64(fd, cmd, varargs) {
|
||
|
|
SYSCALLS.varargs = varargs;
|
||
|
|
try {
|
||
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
|
|
switch (cmd) {
|
||
|
|
case 0: {
|
||
|
|
var arg = SYSCALLS.get();
|
||
|
|
if (arg < 0) {
|
||
|
|
return -28;
|
||
|
|
}
|
||
|
|
var newStream;
|
||
|
|
newStream = FS.createStream(stream, arg);
|
||
|
|
return newStream.fd;
|
||
|
|
}
|
||
|
|
case 1:
|
||
|
|
case 2:
|
||
|
|
return 0;
|
||
|
|
case 3:
|
||
|
|
return stream.flags;
|
||
|
|
case 4: {
|
||
|
|
var arg = SYSCALLS.get();
|
||
|
|
stream.flags |= arg;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
case 5: {
|
||
|
|
var arg = SYSCALLS.get();
|
||
|
|
var offset = 0;
|
||
|
|
HEAP16[arg + offset >>> 1] = 2;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
case 6:
|
||
|
|
case 7:
|
||
|
|
return 0;
|
||
|
|
case 16:
|
||
|
|
case 8:
|
||
|
|
return -28;
|
||
|
|
case 9:
|
||
|
|
setErrNo(28);
|
||
|
|
return -1;
|
||
|
|
default: {
|
||
|
|
return -28;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return -e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function ___syscall_ioctl(fd, op, varargs) {
|
||
|
|
SYSCALLS.varargs = varargs;
|
||
|
|
try {
|
||
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
|
|
switch (op) {
|
||
|
|
case 21509:
|
||
|
|
case 21505: {
|
||
|
|
if (!stream.tty)
|
||
|
|
return -59;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
case 21510:
|
||
|
|
case 21511:
|
||
|
|
case 21512:
|
||
|
|
case 21506:
|
||
|
|
case 21507:
|
||
|
|
case 21508: {
|
||
|
|
if (!stream.tty)
|
||
|
|
return -59;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
case 21519: {
|
||
|
|
if (!stream.tty)
|
||
|
|
return -59;
|
||
|
|
var argp = SYSCALLS.get();
|
||
|
|
HEAP32[argp >>> 2] = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
case 21520: {
|
||
|
|
if (!stream.tty)
|
||
|
|
return -59;
|
||
|
|
return -28;
|
||
|
|
}
|
||
|
|
case 21531: {
|
||
|
|
var argp = SYSCALLS.get();
|
||
|
|
return FS.ioctl(stream, op, argp);
|
||
|
|
}
|
||
|
|
case 21523: {
|
||
|
|
if (!stream.tty)
|
||
|
|
return -59;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
case 21524: {
|
||
|
|
if (!stream.tty)
|
||
|
|
return -59;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return -28;
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return -e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function ___syscall_openat(dirfd, path2, flags, varargs) {
|
||
|
|
SYSCALLS.varargs = varargs;
|
||
|
|
try {
|
||
|
|
path2 = SYSCALLS.getStr(path2);
|
||
|
|
path2 = SYSCALLS.calculateAt(dirfd, path2);
|
||
|
|
var mode = varargs ? SYSCALLS.get() : 0;
|
||
|
|
return FS.open(path2, flags, mode).fd;
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return -e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {
|
||
|
|
}
|
||
|
|
function getShiftFromSize(size) {
|
||
|
|
switch (size) {
|
||
|
|
case 1:
|
||
|
|
return 0;
|
||
|
|
case 2:
|
||
|
|
return 1;
|
||
|
|
case 4:
|
||
|
|
return 2;
|
||
|
|
case 8:
|
||
|
|
return 3;
|
||
|
|
default:
|
||
|
|
throw new TypeError("Unknown type size: " + size);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function embind_init_charCodes() {
|
||
|
|
var codes = new Array(256);
|
||
|
|
for (var i = 0; i < 256; ++i) {
|
||
|
|
codes[i] = String.fromCharCode(i);
|
||
|
|
}
|
||
|
|
embind_charCodes = codes;
|
||
|
|
}
|
||
|
|
var embind_charCodes = void 0;
|
||
|
|
function readLatin1String(ptr) {
|
||
|
|
var ret = "";
|
||
|
|
var c = ptr;
|
||
|
|
while (HEAPU8[c >>> 0]) {
|
||
|
|
ret += embind_charCodes[HEAPU8[c++ >>> 0]];
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
var awaitingDependencies = {};
|
||
|
|
var registeredTypes = {};
|
||
|
|
var typeDependencies = {};
|
||
|
|
var char_0 = 48;
|
||
|
|
var char_9 = 57;
|
||
|
|
function makeLegalFunctionName(name) {
|
||
|
|
if (void 0 === name) {
|
||
|
|
return "_unknown";
|
||
|
|
}
|
||
|
|
name = name.replace(/[^a-zA-Z0-9_]/g, "$");
|
||
|
|
var f = name.charCodeAt(0);
|
||
|
|
if (f >= char_0 && f <= char_9) {
|
||
|
|
return "_" + name;
|
||
|
|
}
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
function createNamedFunction(name, body) {
|
||
|
|
name = makeLegalFunctionName(name);
|
||
|
|
return new Function("body", "return function " + name + '() {\n "use strict"; return body.apply(this, arguments);\n};\n')(body);
|
||
|
|
}
|
||
|
|
function extendError(baseErrorType, errorName) {
|
||
|
|
var errorClass = createNamedFunction(errorName, function(message) {
|
||
|
|
this.name = errorName;
|
||
|
|
this.message = message;
|
||
|
|
var stack = new Error(message).stack;
|
||
|
|
if (stack !== void 0) {
|
||
|
|
this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
errorClass.prototype = Object.create(baseErrorType.prototype);
|
||
|
|
errorClass.prototype.constructor = errorClass;
|
||
|
|
errorClass.prototype.toString = function() {
|
||
|
|
if (this.message === void 0) {
|
||
|
|
return this.name;
|
||
|
|
} else {
|
||
|
|
return this.name + ": " + this.message;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return errorClass;
|
||
|
|
}
|
||
|
|
var BindingError = void 0;
|
||
|
|
function throwBindingError(message) {
|
||
|
|
throw new BindingError(message);
|
||
|
|
}
|
||
|
|
var InternalError = void 0;
|
||
|
|
function throwInternalError(message) {
|
||
|
|
throw new InternalError(message);
|
||
|
|
}
|
||
|
|
function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
|
||
|
|
myTypes.forEach(function(type) {
|
||
|
|
typeDependencies[type] = dependentTypes;
|
||
|
|
});
|
||
|
|
function onComplete(typeConverters2) {
|
||
|
|
var myTypeConverters = getTypeConverters(typeConverters2);
|
||
|
|
if (myTypeConverters.length !== myTypes.length) {
|
||
|
|
throwInternalError("Mismatched type converter count");
|
||
|
|
}
|
||
|
|
for (var i = 0; i < myTypes.length; ++i) {
|
||
|
|
registerType(myTypes[i], myTypeConverters[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var typeConverters = new Array(dependentTypes.length);
|
||
|
|
var unregisteredTypes = [];
|
||
|
|
var registered = 0;
|
||
|
|
dependentTypes.forEach((dt, i) => {
|
||
|
|
if (registeredTypes.hasOwnProperty(dt)) {
|
||
|
|
typeConverters[i] = registeredTypes[dt];
|
||
|
|
} else {
|
||
|
|
unregisteredTypes.push(dt);
|
||
|
|
if (!awaitingDependencies.hasOwnProperty(dt)) {
|
||
|
|
awaitingDependencies[dt] = [];
|
||
|
|
}
|
||
|
|
awaitingDependencies[dt].push(() => {
|
||
|
|
typeConverters[i] = registeredTypes[dt];
|
||
|
|
++registered;
|
||
|
|
if (registered === unregisteredTypes.length) {
|
||
|
|
onComplete(typeConverters);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (0 === unregisteredTypes.length) {
|
||
|
|
onComplete(typeConverters);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function registerType(rawType, registeredInstance, options = {}) {
|
||
|
|
if (!("argPackAdvance" in registeredInstance)) {
|
||
|
|
throw new TypeError("registerType registeredInstance requires argPackAdvance");
|
||
|
|
}
|
||
|
|
var name = registeredInstance.name;
|
||
|
|
if (!rawType) {
|
||
|
|
throwBindingError('type "' + name + '" must have a positive integer typeid pointer');
|
||
|
|
}
|
||
|
|
if (registeredTypes.hasOwnProperty(rawType)) {
|
||
|
|
if (options.ignoreDuplicateRegistrations) {
|
||
|
|
return;
|
||
|
|
} else {
|
||
|
|
throwBindingError("Cannot register type '" + name + "' twice");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
registeredTypes[rawType] = registeredInstance;
|
||
|
|
delete typeDependencies[rawType];
|
||
|
|
if (awaitingDependencies.hasOwnProperty(rawType)) {
|
||
|
|
var callbacks = awaitingDependencies[rawType];
|
||
|
|
delete awaitingDependencies[rawType];
|
||
|
|
callbacks.forEach((cb) => cb());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
|
||
|
|
var shift = getShiftFromSize(size);
|
||
|
|
name = readLatin1String(name);
|
||
|
|
registerType(rawType, { name, "fromWireType": function(wt) {
|
||
|
|
return !!wt;
|
||
|
|
}, "toWireType": function(destructors, o) {
|
||
|
|
return o ? trueValue : falseValue;
|
||
|
|
}, "argPackAdvance": 8, "readValueFromPointer": function(pointer) {
|
||
|
|
var heap;
|
||
|
|
if (size === 1) {
|
||
|
|
heap = HEAP8;
|
||
|
|
} else if (size === 2) {
|
||
|
|
heap = HEAP16;
|
||
|
|
} else if (size === 4) {
|
||
|
|
heap = HEAP32;
|
||
|
|
} else {
|
||
|
|
throw new TypeError("Unknown boolean type size: " + name);
|
||
|
|
}
|
||
|
|
return this["fromWireType"](heap[pointer >>> shift]);
|
||
|
|
}, destructorFunction: null });
|
||
|
|
}
|
||
|
|
var emval_free_list = [];
|
||
|
|
var emval_handle_array = [{}, { value: void 0 }, { value: null }, { value: true }, { value: false }];
|
||
|
|
function __emval_decref(handle) {
|
||
|
|
if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
|
||
|
|
emval_handle_array[handle] = void 0;
|
||
|
|
emval_free_list.push(handle);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function count_emval_handles() {
|
||
|
|
var count = 0;
|
||
|
|
for (var i = 5; i < emval_handle_array.length; ++i) {
|
||
|
|
if (emval_handle_array[i] !== void 0) {
|
||
|
|
++count;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return count;
|
||
|
|
}
|
||
|
|
function get_first_emval() {
|
||
|
|
for (var i = 5; i < emval_handle_array.length; ++i) {
|
||
|
|
if (emval_handle_array[i] !== void 0) {
|
||
|
|
return emval_handle_array[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
function init_emval() {
|
||
|
|
Module2["count_emval_handles"] = count_emval_handles;
|
||
|
|
Module2["get_first_emval"] = get_first_emval;
|
||
|
|
}
|
||
|
|
var Emval = { toValue: (handle) => {
|
||
|
|
if (!handle) {
|
||
|
|
throwBindingError("Cannot use deleted val. handle = " + handle);
|
||
|
|
}
|
||
|
|
return emval_handle_array[handle].value;
|
||
|
|
}, toHandle: (value) => {
|
||
|
|
switch (value) {
|
||
|
|
case void 0:
|
||
|
|
return 1;
|
||
|
|
case null:
|
||
|
|
return 2;
|
||
|
|
case true:
|
||
|
|
return 3;
|
||
|
|
case false:
|
||
|
|
return 4;
|
||
|
|
default: {
|
||
|
|
var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
|
||
|
|
emval_handle_array[handle] = { refcount: 1, value };
|
||
|
|
return handle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} };
|
||
|
|
function simpleReadValueFromPointer(pointer) {
|
||
|
|
return this["fromWireType"](HEAP32[pointer >>> 2]);
|
||
|
|
}
|
||
|
|
function __embind_register_emval(rawType, name) {
|
||
|
|
name = readLatin1String(name);
|
||
|
|
registerType(rawType, { name, "fromWireType": function(handle) {
|
||
|
|
var rv = Emval.toValue(handle);
|
||
|
|
__emval_decref(handle);
|
||
|
|
return rv;
|
||
|
|
}, "toWireType": function(destructors, value) {
|
||
|
|
return Emval.toHandle(value);
|
||
|
|
}, "argPackAdvance": 8, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: null });
|
||
|
|
}
|
||
|
|
function ensureOverloadTable(proto, methodName, humanName) {
|
||
|
|
if (void 0 === proto[methodName].overloadTable) {
|
||
|
|
var prevFunc = proto[methodName];
|
||
|
|
proto[methodName] = function() {
|
||
|
|
if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
|
||
|
|
throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
|
||
|
|
}
|
||
|
|
return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
|
||
|
|
};
|
||
|
|
proto[methodName].overloadTable = [];
|
||
|
|
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function exposePublicSymbol(name, value, numArguments) {
|
||
|
|
if (Module2.hasOwnProperty(name)) {
|
||
|
|
if (void 0 === numArguments || void 0 !== Module2[name].overloadTable && void 0 !== Module2[name].overloadTable[numArguments]) {
|
||
|
|
throwBindingError("Cannot register public name '" + name + "' twice");
|
||
|
|
}
|
||
|
|
ensureOverloadTable(Module2, name, name);
|
||
|
|
if (Module2.hasOwnProperty(numArguments)) {
|
||
|
|
throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
|
||
|
|
}
|
||
|
|
Module2[name].overloadTable[numArguments] = value;
|
||
|
|
} else {
|
||
|
|
Module2[name] = value;
|
||
|
|
if (void 0 !== numArguments) {
|
||
|
|
Module2[name].numArguments = numArguments;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function enumReadValueFromPointer(name, shift, signed) {
|
||
|
|
switch (shift) {
|
||
|
|
case 0:
|
||
|
|
return function(pointer) {
|
||
|
|
var heap = signed ? HEAP8 : HEAPU8;
|
||
|
|
return this["fromWireType"](heap[pointer >>> 0]);
|
||
|
|
};
|
||
|
|
case 1:
|
||
|
|
return function(pointer) {
|
||
|
|
var heap = signed ? HEAP16 : HEAPU16;
|
||
|
|
return this["fromWireType"](heap[pointer >>> 1]);
|
||
|
|
};
|
||
|
|
case 2:
|
||
|
|
return function(pointer) {
|
||
|
|
var heap = signed ? HEAP32 : HEAPU32;
|
||
|
|
return this["fromWireType"](heap[pointer >>> 2]);
|
||
|
|
};
|
||
|
|
default:
|
||
|
|
throw new TypeError("Unknown integer type: " + name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function __embind_register_enum(rawType, name, size, isSigned) {
|
||
|
|
var shift = getShiftFromSize(size);
|
||
|
|
name = readLatin1String(name);
|
||
|
|
function ctor() {
|
||
|
|
}
|
||
|
|
ctor.values = {};
|
||
|
|
registerType(rawType, { name, constructor: ctor, "fromWireType": function(c) {
|
||
|
|
return this.constructor.values[c];
|
||
|
|
}, "toWireType": function(destructors, c) {
|
||
|
|
return c.value;
|
||
|
|
}, "argPackAdvance": 8, "readValueFromPointer": enumReadValueFromPointer(name, shift, isSigned), destructorFunction: null });
|
||
|
|
exposePublicSymbol(name, ctor);
|
||
|
|
}
|
||
|
|
function getTypeName(type) {
|
||
|
|
var ptr = ___getTypeName(type);
|
||
|
|
var rv = readLatin1String(ptr);
|
||
|
|
_free(ptr);
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
function requireRegisteredType(rawType, humanName) {
|
||
|
|
var impl = registeredTypes[rawType];
|
||
|
|
if (void 0 === impl) {
|
||
|
|
throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
|
||
|
|
}
|
||
|
|
return impl;
|
||
|
|
}
|
||
|
|
function __embind_register_enum_value(rawEnumType, name, enumValue) {
|
||
|
|
var enumType = requireRegisteredType(rawEnumType, "enum");
|
||
|
|
name = readLatin1String(name);
|
||
|
|
var Enum = enumType.constructor;
|
||
|
|
var Value = Object.create(enumType.constructor.prototype, { value: { value: enumValue }, constructor: { value: createNamedFunction(enumType.name + "_" + name, function() {
|
||
|
|
}) } });
|
||
|
|
Enum.values[enumValue] = Value;
|
||
|
|
Enum[name] = Value;
|
||
|
|
}
|
||
|
|
function floatReadValueFromPointer(name, shift) {
|
||
|
|
switch (shift) {
|
||
|
|
case 2:
|
||
|
|
return function(pointer) {
|
||
|
|
return this["fromWireType"](HEAPF32[pointer >>> 2]);
|
||
|
|
};
|
||
|
|
case 3:
|
||
|
|
return function(pointer) {
|
||
|
|
return this["fromWireType"](HEAPF64[pointer >>> 3]);
|
||
|
|
};
|
||
|
|
default:
|
||
|
|
throw new TypeError("Unknown float type: " + name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function __embind_register_float(rawType, name, size) {
|
||
|
|
var shift = getShiftFromSize(size);
|
||
|
|
name = readLatin1String(name);
|
||
|
|
registerType(rawType, { name, "fromWireType": function(value) {
|
||
|
|
return value;
|
||
|
|
}, "toWireType": function(destructors, value) {
|
||
|
|
return value;
|
||
|
|
}, "argPackAdvance": 8, "readValueFromPointer": floatReadValueFromPointer(name, shift), destructorFunction: null });
|
||
|
|
}
|
||
|
|
function new_(constructor, argumentList) {
|
||
|
|
if (!(constructor instanceof Function)) {
|
||
|
|
throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function");
|
||
|
|
}
|
||
|
|
var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {
|
||
|
|
});
|
||
|
|
dummy.prototype = constructor.prototype;
|
||
|
|
var obj = new dummy();
|
||
|
|
var r = constructor.apply(obj, argumentList);
|
||
|
|
return r instanceof Object ? r : obj;
|
||
|
|
}
|
||
|
|
function runDestructors(destructors) {
|
||
|
|
while (destructors.length) {
|
||
|
|
var ptr = destructors.pop();
|
||
|
|
var del = destructors.pop();
|
||
|
|
del(ptr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
|
||
|
|
var argCount = argTypes.length;
|
||
|
|
if (argCount < 2) {
|
||
|
|
throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
|
||
|
|
}
|
||
|
|
var isClassMethodFunc = argTypes[1] !== null && classType !== null;
|
||
|
|
var needsDestructorStack = false;
|
||
|
|
for (var i = 1; i < argTypes.length; ++i) {
|
||
|
|
if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) {
|
||
|
|
needsDestructorStack = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var returns = argTypes[0].name !== "void";
|
||
|
|
var argsList = "";
|
||
|
|
var argsListWired = "";
|
||
|
|
for (var i = 0; i < argCount - 2; ++i) {
|
||
|
|
argsList += (i !== 0 ? ", " : "") + "arg" + i;
|
||
|
|
argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
|
||
|
|
}
|
||
|
|
var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\nif (arguments.length !== " + (argCount - 2) + ") {\nthrowBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n}\n";
|
||
|
|
if (needsDestructorStack) {
|
||
|
|
invokerFnBody += "var destructors = [];\n";
|
||
|
|
}
|
||
|
|
var dtorStack = needsDestructorStack ? "destructors" : "null";
|
||
|
|
var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
|
||
|
|
var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
|
||
|
|
if (isClassMethodFunc) {
|
||
|
|
invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
|
||
|
|
}
|
||
|
|
for (var i = 0; i < argCount - 2; ++i) {
|
||
|
|
invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
|
||
|
|
args1.push("argType" + i);
|
||
|
|
args2.push(argTypes[i + 2]);
|
||
|
|
}
|
||
|
|
if (isClassMethodFunc) {
|
||
|
|
argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
|
||
|
|
}
|
||
|
|
invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
|
||
|
|
if (needsDestructorStack) {
|
||
|
|
invokerFnBody += "runDestructors(destructors);\n";
|
||
|
|
} else {
|
||
|
|
for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
|
||
|
|
var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
|
||
|
|
if (argTypes[i].destructorFunction !== null) {
|
||
|
|
invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
|
||
|
|
args1.push(paramName + "_dtor");
|
||
|
|
args2.push(argTypes[i].destructorFunction);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (returns) {
|
||
|
|
invokerFnBody += "var ret = retType.fromWireType(rv);\nreturn ret;\n";
|
||
|
|
} else {
|
||
|
|
}
|
||
|
|
invokerFnBody += "}\n";
|
||
|
|
args1.push(invokerFnBody);
|
||
|
|
var invokerFunction = new_(Function, args1).apply(null, args2);
|
||
|
|
return invokerFunction;
|
||
|
|
}
|
||
|
|
function heap32VectorToArray(count, firstElement) {
|
||
|
|
var array = [];
|
||
|
|
for (var i = 0; i < count; i++) {
|
||
|
|
array.push(HEAPU32[firstElement + i * 4 >>> 2]);
|
||
|
|
}
|
||
|
|
return array;
|
||
|
|
}
|
||
|
|
function replacePublicSymbol(name, value, numArguments) {
|
||
|
|
if (!Module2.hasOwnProperty(name)) {
|
||
|
|
throwInternalError("Replacing nonexistant public symbol");
|
||
|
|
}
|
||
|
|
if (void 0 !== Module2[name].overloadTable && void 0 !== numArguments) {
|
||
|
|
Module2[name].overloadTable[numArguments] = value;
|
||
|
|
} else {
|
||
|
|
Module2[name] = value;
|
||
|
|
Module2[name].argCount = numArguments;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function dynCallLegacy(sig, ptr, args) {
|
||
|
|
var f = Module2["dynCall_" + sig];
|
||
|
|
return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
|
||
|
|
}
|
||
|
|
function dynCall(sig, ptr, args) {
|
||
|
|
if (sig.includes("j")) {
|
||
|
|
return dynCallLegacy(sig, ptr, args);
|
||
|
|
}
|
||
|
|
var rtn = getWasmTableEntry(ptr).apply(null, args);
|
||
|
|
return rtn;
|
||
|
|
}
|
||
|
|
function getDynCaller(sig, ptr) {
|
||
|
|
var argCache = [];
|
||
|
|
return function() {
|
||
|
|
argCache.length = 0;
|
||
|
|
Object.assign(argCache, arguments);
|
||
|
|
return dynCall(sig, ptr, argCache);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function embind__requireFunction(signature, rawFunction) {
|
||
|
|
signature = readLatin1String(signature);
|
||
|
|
function makeDynCaller() {
|
||
|
|
if (signature.includes("j")) {
|
||
|
|
return getDynCaller(signature, rawFunction);
|
||
|
|
}
|
||
|
|
return getWasmTableEntry(rawFunction);
|
||
|
|
}
|
||
|
|
var fp = makeDynCaller();
|
||
|
|
if (typeof fp != "function") {
|
||
|
|
throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
|
||
|
|
}
|
||
|
|
return fp;
|
||
|
|
}
|
||
|
|
var UnboundTypeError = void 0;
|
||
|
|
function throwUnboundTypeError(message, types) {
|
||
|
|
var unboundTypes = [];
|
||
|
|
var seen = {};
|
||
|
|
function visit(type) {
|
||
|
|
if (seen[type]) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (registeredTypes[type]) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (typeDependencies[type]) {
|
||
|
|
typeDependencies[type].forEach(visit);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
unboundTypes.push(type);
|
||
|
|
seen[type] = true;
|
||
|
|
}
|
||
|
|
types.forEach(visit);
|
||
|
|
throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "]));
|
||
|
|
}
|
||
|
|
function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
|
||
|
|
var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
|
||
|
|
name = readLatin1String(name);
|
||
|
|
rawInvoker = embind__requireFunction(signature, rawInvoker);
|
||
|
|
exposePublicSymbol(name, function() {
|
||
|
|
throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes);
|
||
|
|
}, argCount - 1);
|
||
|
|
whenDependentTypesAreResolved([], argTypes, function(argTypes2) {
|
||
|
|
var invokerArgsArray = [argTypes2[0], null].concat(argTypes2.slice(1));
|
||
|
|
replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1);
|
||
|
|
return [];
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function integerReadValueFromPointer(name, shift, signed) {
|
||
|
|
switch (shift) {
|
||
|
|
case 0:
|
||
|
|
return signed ? function readS8FromPointer(pointer) {
|
||
|
|
return HEAP8[pointer >>> 0];
|
||
|
|
} : function readU8FromPointer(pointer) {
|
||
|
|
return HEAPU8[pointer >>> 0];
|
||
|
|
};
|
||
|
|
case 1:
|
||
|
|
return signed ? function readS16FromPointer(pointer) {
|
||
|
|
return HEAP16[pointer >>> 1];
|
||
|
|
} : function readU16FromPointer(pointer) {
|
||
|
|
return HEAPU16[pointer >>> 1];
|
||
|
|
};
|
||
|
|
case 2:
|
||
|
|
return signed ? function readS32FromPointer(pointer) {
|
||
|
|
return HEAP32[pointer >>> 2];
|
||
|
|
} : function readU32FromPointer(pointer) {
|
||
|
|
return HEAPU32[pointer >>> 2];
|
||
|
|
};
|
||
|
|
default:
|
||
|
|
throw new TypeError("Unknown integer type: " + name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
|
||
|
|
name = readLatin1String(name);
|
||
|
|
if (maxRange === -1) {
|
||
|
|
maxRange = 4294967295;
|
||
|
|
}
|
||
|
|
var shift = getShiftFromSize(size);
|
||
|
|
var fromWireType = (value) => value;
|
||
|
|
if (minRange === 0) {
|
||
|
|
var bitshift = 32 - 8 * size;
|
||
|
|
fromWireType = (value) => value << bitshift >>> bitshift;
|
||
|
|
}
|
||
|
|
var isUnsignedType = name.includes("unsigned");
|
||
|
|
var checkAssertions = (value, toTypeName) => {
|
||
|
|
};
|
||
|
|
var toWireType;
|
||
|
|
if (isUnsignedType) {
|
||
|
|
toWireType = function(destructors, value) {
|
||
|
|
checkAssertions(value, this.name);
|
||
|
|
return value >>> 0;
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
toWireType = function(destructors, value) {
|
||
|
|
checkAssertions(value, this.name);
|
||
|
|
return value;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
registerType(primitiveType, { name, "fromWireType": fromWireType, "toWireType": toWireType, "argPackAdvance": 8, "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0), destructorFunction: null });
|
||
|
|
}
|
||
|
|
function __embind_register_memory_view(rawType, dataTypeIndex, name) {
|
||
|
|
var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
|
||
|
|
var TA = typeMapping[dataTypeIndex];
|
||
|
|
function decodeMemoryView(handle) {
|
||
|
|
handle = handle >> 2;
|
||
|
|
var heap = HEAPU32;
|
||
|
|
var size = heap[handle >>> 0];
|
||
|
|
var data = heap[handle + 1 >>> 0];
|
||
|
|
return new TA(buffer, data, size);
|
||
|
|
}
|
||
|
|
name = readLatin1String(name);
|
||
|
|
registerType(rawType, { name, "fromWireType": decodeMemoryView, "argPackAdvance": 8, "readValueFromPointer": decodeMemoryView }, { ignoreDuplicateRegistrations: true });
|
||
|
|
}
|
||
|
|
function __embind_register_std_string(rawType, name) {
|
||
|
|
name = readLatin1String(name);
|
||
|
|
var stdStringIsUTF8 = name === "std::string";
|
||
|
|
registerType(rawType, { name, "fromWireType": function(value) {
|
||
|
|
var length = HEAPU32[value >>> 2];
|
||
|
|
var payload = value + 4;
|
||
|
|
var str;
|
||
|
|
if (stdStringIsUTF8) {
|
||
|
|
var decodeStartPtr = payload;
|
||
|
|
for (var i = 0; i <= length; ++i) {
|
||
|
|
var currentBytePtr = payload + i;
|
||
|
|
if (i == length || HEAPU8[currentBytePtr >>> 0] == 0) {
|
||
|
|
var maxRead = currentBytePtr - decodeStartPtr;
|
||
|
|
var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
|
||
|
|
if (str === void 0) {
|
||
|
|
str = stringSegment;
|
||
|
|
} else {
|
||
|
|
str += String.fromCharCode(0);
|
||
|
|
str += stringSegment;
|
||
|
|
}
|
||
|
|
decodeStartPtr = currentBytePtr + 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var a = new Array(length);
|
||
|
|
for (var i = 0; i < length; ++i) {
|
||
|
|
a[i] = String.fromCharCode(HEAPU8[payload + i >>> 0]);
|
||
|
|
}
|
||
|
|
str = a.join("");
|
||
|
|
}
|
||
|
|
_free(value);
|
||
|
|
return str;
|
||
|
|
}, "toWireType": function(destructors, value) {
|
||
|
|
if (value instanceof ArrayBuffer) {
|
||
|
|
value = new Uint8Array(value);
|
||
|
|
}
|
||
|
|
var length;
|
||
|
|
var valueIsOfTypeString = typeof value == "string";
|
||
|
|
if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
|
||
|
|
throwBindingError("Cannot pass non-string to std::string");
|
||
|
|
}
|
||
|
|
if (stdStringIsUTF8 && valueIsOfTypeString) {
|
||
|
|
length = lengthBytesUTF8(value);
|
||
|
|
} else {
|
||
|
|
length = value.length;
|
||
|
|
}
|
||
|
|
var base = _malloc(4 + length + 1);
|
||
|
|
var ptr = base + 4;
|
||
|
|
ptr >>>= 0;
|
||
|
|
HEAPU32[base >>> 2] = length;
|
||
|
|
if (stdStringIsUTF8 && valueIsOfTypeString) {
|
||
|
|
stringToUTF8(value, ptr, length + 1);
|
||
|
|
} else {
|
||
|
|
if (valueIsOfTypeString) {
|
||
|
|
for (var i = 0; i < length; ++i) {
|
||
|
|
var charCode = value.charCodeAt(i);
|
||
|
|
if (charCode > 255) {
|
||
|
|
_free(ptr);
|
||
|
|
throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
|
||
|
|
}
|
||
|
|
HEAPU8[ptr + i >>> 0] = charCode;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (var i = 0; i < length; ++i) {
|
||
|
|
HEAPU8[ptr + i >>> 0] = value[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (destructors !== null) {
|
||
|
|
destructors.push(_free, base);
|
||
|
|
}
|
||
|
|
return base;
|
||
|
|
}, "argPackAdvance": 8, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: function(ptr) {
|
||
|
|
_free(ptr);
|
||
|
|
} });
|
||
|
|
}
|
||
|
|
var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
|
||
|
|
function UTF16ToString(ptr, maxBytesToRead) {
|
||
|
|
var endPtr = ptr;
|
||
|
|
var idx = endPtr >> 1;
|
||
|
|
var maxIdx = idx + maxBytesToRead / 2;
|
||
|
|
while (!(idx >= maxIdx) && HEAPU16[idx >>> 0])
|
||
|
|
++idx;
|
||
|
|
endPtr = idx << 1;
|
||
|
|
if (endPtr - ptr > 32 && UTF16Decoder)
|
||
|
|
return UTF16Decoder.decode(HEAPU8.subarray(ptr >>> 0, endPtr >>> 0));
|
||
|
|
var str = "";
|
||
|
|
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
|
||
|
|
var codeUnit = HEAP16[ptr + i * 2 >>> 1];
|
||
|
|
if (codeUnit == 0)
|
||
|
|
break;
|
||
|
|
str += String.fromCharCode(codeUnit);
|
||
|
|
}
|
||
|
|
return str;
|
||
|
|
}
|
||
|
|
function stringToUTF16(str, outPtr, maxBytesToWrite) {
|
||
|
|
if (maxBytesToWrite === void 0) {
|
||
|
|
maxBytesToWrite = 2147483647;
|
||
|
|
}
|
||
|
|
if (maxBytesToWrite < 2)
|
||
|
|
return 0;
|
||
|
|
maxBytesToWrite -= 2;
|
||
|
|
var startPtr = outPtr;
|
||
|
|
var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
|
||
|
|
for (var i = 0; i < numCharsToWrite; ++i) {
|
||
|
|
var codeUnit = str.charCodeAt(i);
|
||
|
|
HEAP16[outPtr >>> 1] = codeUnit;
|
||
|
|
outPtr += 2;
|
||
|
|
}
|
||
|
|
HEAP16[outPtr >>> 1] = 0;
|
||
|
|
return outPtr - startPtr;
|
||
|
|
}
|
||
|
|
function lengthBytesUTF16(str) {
|
||
|
|
return str.length * 2;
|
||
|
|
}
|
||
|
|
function UTF32ToString(ptr, maxBytesToRead) {
|
||
|
|
var i = 0;
|
||
|
|
var str = "";
|
||
|
|
while (!(i >= maxBytesToRead / 4)) {
|
||
|
|
var utf32 = HEAP32[ptr + i * 4 >>> 2];
|
||
|
|
if (utf32 == 0)
|
||
|
|
break;
|
||
|
|
++i;
|
||
|
|
if (utf32 >= 65536) {
|
||
|
|
var ch = utf32 - 65536;
|
||
|
|
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
|
||
|
|
} else {
|
||
|
|
str += String.fromCharCode(utf32);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return str;
|
||
|
|
}
|
||
|
|
function stringToUTF32(str, outPtr, maxBytesToWrite) {
|
||
|
|
outPtr >>>= 0;
|
||
|
|
if (maxBytesToWrite === void 0) {
|
||
|
|
maxBytesToWrite = 2147483647;
|
||
|
|
}
|
||
|
|
if (maxBytesToWrite < 4)
|
||
|
|
return 0;
|
||
|
|
var startPtr = outPtr;
|
||
|
|
var endPtr = startPtr + maxBytesToWrite - 4;
|
||
|
|
for (var i = 0; i < str.length; ++i) {
|
||
|
|
var codeUnit = str.charCodeAt(i);
|
||
|
|
if (codeUnit >= 55296 && codeUnit <= 57343) {
|
||
|
|
var trailSurrogate = str.charCodeAt(++i);
|
||
|
|
codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
|
||
|
|
}
|
||
|
|
HEAP32[outPtr >>> 2] = codeUnit;
|
||
|
|
outPtr += 4;
|
||
|
|
if (outPtr + 4 > endPtr)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
HEAP32[outPtr >>> 2] = 0;
|
||
|
|
return outPtr - startPtr;
|
||
|
|
}
|
||
|
|
function lengthBytesUTF32(str) {
|
||
|
|
var len = 0;
|
||
|
|
for (var i = 0; i < str.length; ++i) {
|
||
|
|
var codeUnit = str.charCodeAt(i);
|
||
|
|
if (codeUnit >= 55296 && codeUnit <= 57343)
|
||
|
|
++i;
|
||
|
|
len += 4;
|
||
|
|
}
|
||
|
|
return len;
|
||
|
|
}
|
||
|
|
function __embind_register_std_wstring(rawType, charSize, name) {
|
||
|
|
name = readLatin1String(name);
|
||
|
|
var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
|
||
|
|
if (charSize === 2) {
|
||
|
|
decodeString = UTF16ToString;
|
||
|
|
encodeString = stringToUTF16;
|
||
|
|
lengthBytesUTF = lengthBytesUTF16;
|
||
|
|
getHeap = () => HEAPU16;
|
||
|
|
shift = 1;
|
||
|
|
} else if (charSize === 4) {
|
||
|
|
decodeString = UTF32ToString;
|
||
|
|
encodeString = stringToUTF32;
|
||
|
|
lengthBytesUTF = lengthBytesUTF32;
|
||
|
|
getHeap = () => HEAPU32;
|
||
|
|
shift = 2;
|
||
|
|
}
|
||
|
|
registerType(rawType, { name, "fromWireType": function(value) {
|
||
|
|
var length = HEAPU32[value >>> 2];
|
||
|
|
var HEAP = getHeap();
|
||
|
|
var str;
|
||
|
|
var decodeStartPtr = value + 4;
|
||
|
|
for (var i = 0; i <= length; ++i) {
|
||
|
|
var currentBytePtr = value + 4 + i * charSize;
|
||
|
|
if (i == length || HEAP[currentBytePtr >>> shift] == 0) {
|
||
|
|
var maxReadBytes = currentBytePtr - decodeStartPtr;
|
||
|
|
var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
|
||
|
|
if (str === void 0) {
|
||
|
|
str = stringSegment;
|
||
|
|
} else {
|
||
|
|
str += String.fromCharCode(0);
|
||
|
|
str += stringSegment;
|
||
|
|
}
|
||
|
|
decodeStartPtr = currentBytePtr + charSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_free(value);
|
||
|
|
return str;
|
||
|
|
}, "toWireType": function(destructors, value) {
|
||
|
|
if (!(typeof value == "string")) {
|
||
|
|
throwBindingError("Cannot pass non-string to C++ string type " + name);
|
||
|
|
}
|
||
|
|
var length = lengthBytesUTF(value);
|
||
|
|
var ptr = _malloc(4 + length + charSize);
|
||
|
|
ptr >>>= 0;
|
||
|
|
HEAPU32[ptr >>> 2] = length >> shift;
|
||
|
|
encodeString(value, ptr + 4, length + charSize);
|
||
|
|
if (destructors !== null) {
|
||
|
|
destructors.push(_free, ptr);
|
||
|
|
}
|
||
|
|
return ptr;
|
||
|
|
}, "argPackAdvance": 8, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: function(ptr) {
|
||
|
|
_free(ptr);
|
||
|
|
} });
|
||
|
|
}
|
||
|
|
function __embind_register_void(rawType, name) {
|
||
|
|
name = readLatin1String(name);
|
||
|
|
registerType(rawType, { isVoid: true, name, "argPackAdvance": 0, "fromWireType": function() {
|
||
|
|
return void 0;
|
||
|
|
}, "toWireType": function(destructors, o) {
|
||
|
|
return void 0;
|
||
|
|
} });
|
||
|
|
}
|
||
|
|
var nowIsMonotonic = true;
|
||
|
|
function __emscripten_get_now_is_monotonic() {
|
||
|
|
return nowIsMonotonic;
|
||
|
|
}
|
||
|
|
function __emval_as(handle, returnType, destructorsRef) {
|
||
|
|
handle = Emval.toValue(handle);
|
||
|
|
returnType = requireRegisteredType(returnType, "emval::as");
|
||
|
|
var destructors = [];
|
||
|
|
var rd = Emval.toHandle(destructors);
|
||
|
|
HEAPU32[destructorsRef >>> 2] = rd;
|
||
|
|
return returnType["toWireType"](destructors, handle);
|
||
|
|
}
|
||
|
|
var emval_symbols = {};
|
||
|
|
function getStringOrSymbol(address) {
|
||
|
|
var symbol = emval_symbols[address];
|
||
|
|
if (symbol === void 0) {
|
||
|
|
return readLatin1String(address);
|
||
|
|
}
|
||
|
|
return symbol;
|
||
|
|
}
|
||
|
|
var emval_methodCallers = [];
|
||
|
|
function __emval_call_void_method(caller, handle, methodName, args) {
|
||
|
|
caller = emval_methodCallers[caller];
|
||
|
|
handle = Emval.toValue(handle);
|
||
|
|
methodName = getStringOrSymbol(methodName);
|
||
|
|
caller(handle, methodName, null, args);
|
||
|
|
}
|
||
|
|
function emval_get_global() {
|
||
|
|
if (typeof globalThis == "object") {
|
||
|
|
return globalThis;
|
||
|
|
}
|
||
|
|
return function() {
|
||
|
|
return Function;
|
||
|
|
}()("return this")();
|
||
|
|
}
|
||
|
|
function __emval_get_global(name) {
|
||
|
|
if (name === 0) {
|
||
|
|
return Emval.toHandle(emval_get_global());
|
||
|
|
} else {
|
||
|
|
name = getStringOrSymbol(name);
|
||
|
|
return Emval.toHandle(emval_get_global()[name]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function emval_addMethodCaller(caller) {
|
||
|
|
var id = emval_methodCallers.length;
|
||
|
|
emval_methodCallers.push(caller);
|
||
|
|
return id;
|
||
|
|
}
|
||
|
|
function emval_lookupTypes(argCount, argTypes) {
|
||
|
|
var a = new Array(argCount);
|
||
|
|
for (var i = 0; i < argCount; ++i) {
|
||
|
|
a[i] = requireRegisteredType(HEAPU32[argTypes + i * POINTER_SIZE >>> 2], "parameter " + i);
|
||
|
|
}
|
||
|
|
return a;
|
||
|
|
}
|
||
|
|
var emval_registeredMethods = [];
|
||
|
|
function __emval_get_method_caller(argCount, argTypes) {
|
||
|
|
var types = emval_lookupTypes(argCount, argTypes);
|
||
|
|
var retType = types[0];
|
||
|
|
var signatureName = retType.name + "_$" + types.slice(1).map(function(t) {
|
||
|
|
return t.name;
|
||
|
|
}).join("_") + "$";
|
||
|
|
var returnId = emval_registeredMethods[signatureName];
|
||
|
|
if (returnId !== void 0) {
|
||
|
|
return returnId;
|
||
|
|
}
|
||
|
|
var params = ["retType"];
|
||
|
|
var args = [retType];
|
||
|
|
var argsList = "";
|
||
|
|
for (var i = 0; i < argCount - 1; ++i) {
|
||
|
|
argsList += (i !== 0 ? ", " : "") + "arg" + i;
|
||
|
|
params.push("argType" + i);
|
||
|
|
args.push(types[1 + i]);
|
||
|
|
}
|
||
|
|
var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
|
||
|
|
var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n";
|
||
|
|
var offset = 0;
|
||
|
|
for (var i = 0; i < argCount - 1; ++i) {
|
||
|
|
functionBody += " var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? "+" + offset : "") + ");\n";
|
||
|
|
offset += types[i + 1]["argPackAdvance"];
|
||
|
|
}
|
||
|
|
functionBody += " var rv = handle[name](" + argsList + ");\n";
|
||
|
|
for (var i = 0; i < argCount - 1; ++i) {
|
||
|
|
if (types[i + 1]["deleteObject"]) {
|
||
|
|
functionBody += " argType" + i + ".deleteObject(arg" + i + ");\n";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!retType.isVoid) {
|
||
|
|
functionBody += " return retType.toWireType(destructors, rv);\n";
|
||
|
|
}
|
||
|
|
functionBody += "};\n";
|
||
|
|
params.push(functionBody);
|
||
|
|
var invokerFunction = new_(Function, params).apply(null, args);
|
||
|
|
returnId = emval_addMethodCaller(invokerFunction);
|
||
|
|
emval_registeredMethods[signatureName] = returnId;
|
||
|
|
return returnId;
|
||
|
|
}
|
||
|
|
function __emval_get_property(handle, key) {
|
||
|
|
handle = Emval.toValue(handle);
|
||
|
|
key = Emval.toValue(key);
|
||
|
|
return Emval.toHandle(handle[key]);
|
||
|
|
}
|
||
|
|
function __emval_incref(handle) {
|
||
|
|
if (handle > 4) {
|
||
|
|
emval_handle_array[handle].refcount += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function craftEmvalAllocator(argCount) {
|
||
|
|
var argsList = "";
|
||
|
|
for (var i = 0; i < argCount; ++i) {
|
||
|
|
argsList += (i !== 0 ? ", " : "") + "arg" + i;
|
||
|
|
}
|
||
|
|
var getMemory = () => HEAPU32;
|
||
|
|
var functionBody = "return function emval_allocator_" + argCount + "(constructor, argTypes, args) {\n var HEAPU32 = getMemory();\n";
|
||
|
|
for (var i = 0; i < argCount; ++i) {
|
||
|
|
functionBody += "var argType" + i + " = requireRegisteredType(HEAPU32[((argTypes)>>2)], 'parameter " + i + "');\nvar arg" + i + " = argType" + i + ".readValueFromPointer(args);\nargs += argType" + i + "['argPackAdvance'];\nargTypes += 4;\n";
|
||
|
|
}
|
||
|
|
functionBody += "var obj = new constructor(" + argsList + ");\nreturn valueToHandle(obj);\n}\n";
|
||
|
|
return new Function("requireRegisteredType", "Module", "valueToHandle", "getMemory", functionBody)(requireRegisteredType, Module2, Emval.toHandle, getMemory);
|
||
|
|
}
|
||
|
|
var emval_newers = {};
|
||
|
|
function __emval_new(handle, argCount, argTypes, args) {
|
||
|
|
handle = Emval.toValue(handle);
|
||
|
|
var newer = emval_newers[argCount];
|
||
|
|
if (!newer) {
|
||
|
|
newer = craftEmvalAllocator(argCount);
|
||
|
|
emval_newers[argCount] = newer;
|
||
|
|
}
|
||
|
|
return newer(handle, argTypes, args);
|
||
|
|
}
|
||
|
|
function __emval_new_cstring(v) {
|
||
|
|
return Emval.toHandle(getStringOrSymbol(v));
|
||
|
|
}
|
||
|
|
function __emval_new_object() {
|
||
|
|
return Emval.toHandle({});
|
||
|
|
}
|
||
|
|
function __emval_run_destructors(handle) {
|
||
|
|
var destructors = Emval.toValue(handle);
|
||
|
|
runDestructors(destructors);
|
||
|
|
__emval_decref(handle);
|
||
|
|
}
|
||
|
|
function __emval_set_property(handle, key, value) {
|
||
|
|
handle = Emval.toValue(handle);
|
||
|
|
key = Emval.toValue(key);
|
||
|
|
value = Emval.toValue(value);
|
||
|
|
handle[key] = value;
|
||
|
|
}
|
||
|
|
function __emval_take_value(type, arg) {
|
||
|
|
type = requireRegisteredType(type, "_emval_take_value");
|
||
|
|
var v = type["readValueFromPointer"](arg);
|
||
|
|
return Emval.toHandle(v);
|
||
|
|
}
|
||
|
|
function readI53FromI64(ptr) {
|
||
|
|
return HEAPU32[ptr >>> 2] + HEAP32[ptr + 4 >>> 2] * 4294967296;
|
||
|
|
}
|
||
|
|
function __gmtime_js(time, tmPtr) {
|
||
|
|
var date = new Date(readI53FromI64(time) * 1e3);
|
||
|
|
HEAP32[tmPtr >>> 2] = date.getUTCSeconds();
|
||
|
|
HEAP32[tmPtr + 4 >>> 2] = date.getUTCMinutes();
|
||
|
|
HEAP32[tmPtr + 8 >>> 2] = date.getUTCHours();
|
||
|
|
HEAP32[tmPtr + 12 >>> 2] = date.getUTCDate();
|
||
|
|
HEAP32[tmPtr + 16 >>> 2] = date.getUTCMonth();
|
||
|
|
HEAP32[tmPtr + 20 >>> 2] = date.getUTCFullYear() - 1900;
|
||
|
|
HEAP32[tmPtr + 24 >>> 2] = date.getUTCDay();
|
||
|
|
var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
|
||
|
|
var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
|
||
|
|
HEAP32[tmPtr + 28 >>> 2] = yday;
|
||
|
|
}
|
||
|
|
function __localtime_js(time, tmPtr) {
|
||
|
|
var date = new Date(readI53FromI64(time) * 1e3);
|
||
|
|
HEAP32[tmPtr >>> 2] = date.getSeconds();
|
||
|
|
HEAP32[tmPtr + 4 >>> 2] = date.getMinutes();
|
||
|
|
HEAP32[tmPtr + 8 >>> 2] = date.getHours();
|
||
|
|
HEAP32[tmPtr + 12 >>> 2] = date.getDate();
|
||
|
|
HEAP32[tmPtr + 16 >>> 2] = date.getMonth();
|
||
|
|
HEAP32[tmPtr + 20 >>> 2] = date.getFullYear() - 1900;
|
||
|
|
HEAP32[tmPtr + 24 >>> 2] = date.getDay();
|
||
|
|
var start = new Date(date.getFullYear(), 0, 1);
|
||
|
|
var yday = (date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24) | 0;
|
||
|
|
HEAP32[tmPtr + 28 >>> 2] = yday;
|
||
|
|
HEAP32[tmPtr + 36 >>> 2] = -(date.getTimezoneOffset() * 60);
|
||
|
|
var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
|
||
|
|
var winterOffset = start.getTimezoneOffset();
|
||
|
|
var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
|
||
|
|
HEAP32[tmPtr + 32 >>> 2] = dst;
|
||
|
|
}
|
||
|
|
function allocateUTF8(str) {
|
||
|
|
var size = lengthBytesUTF8(str) + 1;
|
||
|
|
var ret = _malloc(size);
|
||
|
|
if (ret)
|
||
|
|
stringToUTF8Array(str, HEAP8, ret, size);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
function _tzset_impl(timezone, daylight, tzname) {
|
||
|
|
var currentYear = new Date().getFullYear();
|
||
|
|
var winter = new Date(currentYear, 0, 1);
|
||
|
|
var summer = new Date(currentYear, 6, 1);
|
||
|
|
var winterOffset = winter.getTimezoneOffset();
|
||
|
|
var summerOffset = summer.getTimezoneOffset();
|
||
|
|
var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
|
||
|
|
HEAP32[timezone >>> 2] = stdTimezoneOffset * 60;
|
||
|
|
HEAP32[daylight >>> 2] = Number(winterOffset != summerOffset);
|
||
|
|
function extractZone(date) {
|
||
|
|
var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
|
||
|
|
return match ? match[1] : "GMT";
|
||
|
|
}
|
||
|
|
var winterName = extractZone(winter);
|
||
|
|
var summerName = extractZone(summer);
|
||
|
|
var winterNamePtr = allocateUTF8(winterName);
|
||
|
|
var summerNamePtr = allocateUTF8(summerName);
|
||
|
|
if (summerOffset < winterOffset) {
|
||
|
|
HEAPU32[tzname >>> 2] = winterNamePtr;
|
||
|
|
HEAPU32[tzname + 4 >>> 2] = summerNamePtr;
|
||
|
|
} else {
|
||
|
|
HEAPU32[tzname >>> 2] = summerNamePtr;
|
||
|
|
HEAPU32[tzname + 4 >>> 2] = winterNamePtr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function __tzset_js(timezone, daylight, tzname) {
|
||
|
|
if (__tzset_js.called)
|
||
|
|
return;
|
||
|
|
__tzset_js.called = true;
|
||
|
|
_tzset_impl(timezone, daylight, tzname);
|
||
|
|
}
|
||
|
|
function _abort() {
|
||
|
|
abort("");
|
||
|
|
}
|
||
|
|
function _emscripten_date_now() {
|
||
|
|
return Date.now();
|
||
|
|
}
|
||
|
|
var _emscripten_get_now;
|
||
|
|
if (ENVIRONMENT_IS_NODE) {
|
||
|
|
_emscripten_get_now = () => {
|
||
|
|
var t = process["hrtime"]();
|
||
|
|
return t[0] * 1e3 + t[1] / 1e6;
|
||
|
|
};
|
||
|
|
} else
|
||
|
|
_emscripten_get_now = () => performance.now();
|
||
|
|
function _emscripten_memcpy_big(dest, src, num) {
|
||
|
|
HEAPU8.copyWithin(dest >>> 0, src >>> 0, src + num >>> 0);
|
||
|
|
}
|
||
|
|
function getHeapMax() {
|
||
|
|
return 4294901760;
|
||
|
|
}
|
||
|
|
function emscripten_realloc_buffer(size) {
|
||
|
|
try {
|
||
|
|
wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
|
||
|
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
||
|
|
return 1;
|
||
|
|
} catch (e) {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _emscripten_resize_heap(requestedSize) {
|
||
|
|
var oldSize = HEAPU8.length;
|
||
|
|
requestedSize = requestedSize >>> 0;
|
||
|
|
var maxHeapSize = getHeapMax();
|
||
|
|
if (requestedSize > maxHeapSize) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
|
||
|
|
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
|
||
|
|
var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
|
||
|
|
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
|
||
|
|
var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
|
||
|
|
var replacement = emscripten_realloc_buffer(newSize);
|
||
|
|
if (replacement) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var ENV = {};
|
||
|
|
function getExecutableName() {
|
||
|
|
return thisProgram || "./this.program";
|
||
|
|
}
|
||
|
|
function getEnvStrings() {
|
||
|
|
if (!getEnvStrings.strings) {
|
||
|
|
var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
|
||
|
|
var env = { "USER": "web_user", "LOGNAME": "web_user", "PATH": "/", "PWD": "/", "HOME": "/home/web_user", "LANG": lang, "_": getExecutableName() };
|
||
|
|
for (var x in ENV) {
|
||
|
|
if (ENV[x] === void 0)
|
||
|
|
delete env[x];
|
||
|
|
else
|
||
|
|
env[x] = ENV[x];
|
||
|
|
}
|
||
|
|
var strings = [];
|
||
|
|
for (var x in env) {
|
||
|
|
strings.push(x + "=" + env[x]);
|
||
|
|
}
|
||
|
|
getEnvStrings.strings = strings;
|
||
|
|
}
|
||
|
|
return getEnvStrings.strings;
|
||
|
|
}
|
||
|
|
function writeAsciiToMemory(str, buffer2, dontAddNull) {
|
||
|
|
for (var i = 0; i < str.length; ++i) {
|
||
|
|
HEAP8[buffer2++ >>> 0] = str.charCodeAt(i);
|
||
|
|
}
|
||
|
|
if (!dontAddNull)
|
||
|
|
HEAP8[buffer2 >>> 0] = 0;
|
||
|
|
}
|
||
|
|
function _environ_get(__environ, environ_buf) {
|
||
|
|
var bufSize = 0;
|
||
|
|
getEnvStrings().forEach(function(string, i) {
|
||
|
|
var ptr = environ_buf + bufSize;
|
||
|
|
HEAPU32[__environ + i * 4 >>> 2] = ptr;
|
||
|
|
writeAsciiToMemory(string, ptr);
|
||
|
|
bufSize += string.length + 1;
|
||
|
|
});
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
function _environ_sizes_get(penviron_count, penviron_buf_size) {
|
||
|
|
var strings = getEnvStrings();
|
||
|
|
HEAPU32[penviron_count >>> 2] = strings.length;
|
||
|
|
var bufSize = 0;
|
||
|
|
strings.forEach(function(string) {
|
||
|
|
bufSize += string.length + 1;
|
||
|
|
});
|
||
|
|
HEAPU32[penviron_buf_size >>> 2] = bufSize;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
function _fd_close(fd) {
|
||
|
|
try {
|
||
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
|
|
FS.close(stream);
|
||
|
|
return 0;
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _fd_fdstat_get(fd, pbuf) {
|
||
|
|
try {
|
||
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
|
|
var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
|
||
|
|
HEAP8[pbuf >>> 0] = type;
|
||
|
|
return 0;
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function 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 instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function convertI32PairToI53Checked(lo, hi) {
|
||
|
|
return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
|
||
|
|
}
|
||
|
|
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
|
||
|
|
try {
|
||
|
|
var offset = convertI32PairToI53Checked(offset_low, offset_high);
|
||
|
|
if (isNaN(offset))
|
||
|
|
return 61;
|
||
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
|
|
FS.llseek(stream, offset, whence);
|
||
|
|
tempI64 = [stream.position >>> 0, (tempDouble = stream.position, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[newOffset >>> 2] = tempI64[0], HEAP32[newOffset + 4 >>> 2] = tempI64[1];
|
||
|
|
if (stream.getdents && offset === 0 && whence === 0)
|
||
|
|
stream.getdents = null;
|
||
|
|
return 0;
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function doWritev(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.write(stream, HEAP8, ptr, len, offset);
|
||
|
|
if (curr < 0)
|
||
|
|
return -1;
|
||
|
|
ret += curr;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
function _fd_write(fd, iov, iovcnt, pnum) {
|
||
|
|
try {
|
||
|
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
|
|
var num = doWritev(stream, iov, iovcnt);
|
||
|
|
HEAPU32[pnum >>> 2] = num;
|
||
|
|
return 0;
|
||
|
|
} catch (e) {
|
||
|
|
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError))
|
||
|
|
throw e;
|
||
|
|
return e.errno;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _llvm_eh_typeid_for(type) {
|
||
|
|
return type;
|
||
|
|
}
|
||
|
|
function __isLeapYear(year) {
|
||
|
|
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
|
||
|
|
}
|
||
|
|
function __arraySum(array, index) {
|
||
|
|
var sum = 0;
|
||
|
|
for (var i = 0; i <= index; sum += array[i++]) {
|
||
|
|
}
|
||
|
|
return sum;
|
||
|
|
}
|
||
|
|
var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
||
|
|
var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
||
|
|
function __addDays(date, days) {
|
||
|
|
var newDate = new Date(date.getTime());
|
||
|
|
while (days > 0) {
|
||
|
|
var leap = __isLeapYear(newDate.getFullYear());
|
||
|
|
var currentMonth = newDate.getMonth();
|
||
|
|
var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
|
||
|
|
if (days > daysInCurrentMonth - newDate.getDate()) {
|
||
|
|
days -= daysInCurrentMonth - newDate.getDate() + 1;
|
||
|
|
newDate.setDate(1);
|
||
|
|
if (currentMonth < 11) {
|
||
|
|
newDate.setMonth(currentMonth + 1);
|
||
|
|
} else {
|
||
|
|
newDate.setMonth(0);
|
||
|
|
newDate.setFullYear(newDate.getFullYear() + 1);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
newDate.setDate(newDate.getDate() + days);
|
||
|
|
return newDate;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return newDate;
|
||
|
|
}
|
||
|
|
function _strftime(s, maxsize, format, tm) {
|
||
|
|
var tm_zone = HEAP32[tm + 40 >>> 2];
|
||
|
|
var date = { tm_sec: HEAP32[tm >>> 2], tm_min: HEAP32[tm + 4 >>> 2], tm_hour: HEAP32[tm + 8 >>> 2], tm_mday: HEAP32[tm + 12 >>> 2], tm_mon: HEAP32[tm + 16 >>> 2], tm_year: HEAP32[tm + 20 >>> 2], tm_wday: HEAP32[tm + 24 >>> 2], tm_yday: HEAP32[tm + 28 >>> 2], tm_isdst: HEAP32[tm + 32 >>> 2], tm_gmtoff: HEAP32[tm + 36 >>> 2], tm_zone: tm_zone ? UTF8ToString(tm_zone) : "" };
|
||
|
|
var pattern = UTF8ToString(format);
|
||
|
|
var EXPANSION_RULES_1 = { "%c": "%a %b %d %H:%M:%S %Y", "%D": "%m/%d/%y", "%F": "%Y-%m-%d", "%h": "%b", "%r": "%I:%M:%S %p", "%R": "%H:%M", "%T": "%H:%M:%S", "%x": "%m/%d/%y", "%X": "%H:%M:%S", "%Ec": "%c", "%EC": "%C", "%Ex": "%m/%d/%y", "%EX": "%H:%M:%S", "%Ey": "%y", "%EY": "%Y", "%Od": "%d", "%Oe": "%e", "%OH": "%H", "%OI": "%I", "%Om": "%m", "%OM": "%M", "%OS": "%S", "%Ou": "%u", "%OU": "%U", "%OV": "%V", "%Ow": "%w", "%OW": "%W", "%Oy": "%y" };
|
||
|
|
for (var rule in EXPANSION_RULES_1) {
|
||
|
|
pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
|
||
|
|
}
|
||
|
|
var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
|
||
|
|
var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
|
||
|
|
function leadingSomething(value, digits, character) {
|
||
|
|
var str = typeof value == "number" ? value.toString() : value || "";
|
||
|
|
while (str.length < digits) {
|
||
|
|
str = character[0] + str;
|
||
|
|
}
|
||
|
|
return str;
|
||
|
|
}
|
||
|
|
function leadingNulls(value, digits) {
|
||
|
|
return leadingSomething(value, digits, "0");
|
||
|
|
}
|
||
|
|
function compareByDay(date1, date2) {
|
||
|
|
function sgn(value) {
|
||
|
|
return value < 0 ? -1 : value > 0 ? 1 : 0;
|
||
|
|
}
|
||
|
|
var compare;
|
||
|
|
if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
|
||
|
|
if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
|
||
|
|
compare = sgn(date1.getDate() - date2.getDate());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return compare;
|
||
|
|
}
|
||
|
|
function getFirstWeekStartDate(janFourth) {
|
||
|
|
switch (janFourth.getDay()) {
|
||
|
|
case 0:
|
||
|
|
return new Date(janFourth.getFullYear() - 1, 11, 29);
|
||
|
|
case 1:
|
||
|
|
return janFourth;
|
||
|
|
case 2:
|
||
|
|
return new Date(janFourth.getFullYear(), 0, 3);
|
||
|
|
case 3:
|
||
|
|
return new Date(janFourth.getFullYear(), 0, 2);
|
||
|
|
case 4:
|
||
|
|
return new Date(janFourth.getFullYear(), 0, 1);
|
||
|
|
case 5:
|
||
|
|
return new Date(janFourth.getFullYear() - 1, 11, 31);
|
||
|
|
case 6:
|
||
|
|
return new Date(janFourth.getFullYear() - 1, 11, 30);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function getWeekBasedYear(date2) {
|
||
|
|
var thisDate = __addDays(new Date(date2.tm_year + 1900, 0, 1), date2.tm_yday);
|
||
|
|
var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
|
||
|
|
var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
|
||
|
|
var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
|
||
|
|
var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
|
||
|
|
if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
|
||
|
|
if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
|
||
|
|
return thisDate.getFullYear() + 1;
|
||
|
|
}
|
||
|
|
return thisDate.getFullYear();
|
||
|
|
}
|
||
|
|
return thisDate.getFullYear() - 1;
|
||
|
|
}
|
||
|
|
var EXPANSION_RULES_2 = { "%a": function(date2) {
|
||
|
|
return WEEKDAYS[date2.tm_wday].substring(0, 3);
|
||
|
|
}, "%A": function(date2) {
|
||
|
|
return WEEKDAYS[date2.tm_wday];
|
||
|
|
}, "%b": function(date2) {
|
||
|
|
return MONTHS[date2.tm_mon].substring(0, 3);
|
||
|
|
}, "%B": function(date2) {
|
||
|
|
return MONTHS[date2.tm_mon];
|
||
|
|
}, "%C": function(date2) {
|
||
|
|
var year = date2.tm_year + 1900;
|
||
|
|
return leadingNulls(year / 100 | 0, 2);
|
||
|
|
}, "%d": function(date2) {
|
||
|
|
return leadingNulls(date2.tm_mday, 2);
|
||
|
|
}, "%e": function(date2) {
|
||
|
|
return leadingSomething(date2.tm_mday, 2, " ");
|
||
|
|
}, "%g": function(date2) {
|
||
|
|
return getWeekBasedYear(date2).toString().substring(2);
|
||
|
|
}, "%G": function(date2) {
|
||
|
|
return getWeekBasedYear(date2);
|
||
|
|
}, "%H": function(date2) {
|
||
|
|
return leadingNulls(date2.tm_hour, 2);
|
||
|
|
}, "%I": function(date2) {
|
||
|
|
var twelveHour = date2.tm_hour;
|
||
|
|
if (twelveHour == 0)
|
||
|
|
twelveHour = 12;
|
||
|
|
else if (twelveHour > 12)
|
||
|
|
twelveHour -= 12;
|
||
|
|
return leadingNulls(twelveHour, 2);
|
||
|
|
}, "%j": function(date2) {
|
||
|
|
return leadingNulls(date2.tm_mday + __arraySum(__isLeapYear(date2.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date2.tm_mon - 1), 3);
|
||
|
|
}, "%m": function(date2) {
|
||
|
|
return leadingNulls(date2.tm_mon + 1, 2);
|
||
|
|
}, "%M": function(date2) {
|
||
|
|
return leadingNulls(date2.tm_min, 2);
|
||
|
|
}, "%n": function() {
|
||
|
|
return "\n";
|
||
|
|
}, "%p": function(date2) {
|
||
|
|
if (date2.tm_hour >= 0 && date2.tm_hour < 12) {
|
||
|
|
return "AM";
|
||
|
|
}
|
||
|
|
return "PM";
|
||
|
|
}, "%S": function(date2) {
|
||
|
|
return leadingNulls(date2.tm_sec, 2);
|
||
|
|
}, "%t": function() {
|
||
|
|
return " ";
|
||
|
|
}, "%u": function(date2) {
|
||
|
|
return date2.tm_wday || 7;
|
||
|
|
}, "%U": function(date2) {
|
||
|
|
var days = date2.tm_yday + 7 - date2.tm_wday;
|
||
|
|
return leadingNulls(Math.floor(days / 7), 2);
|
||
|
|
}, "%V": function(date2) {
|
||
|
|
var val = Math.floor((date2.tm_yday + 7 - (date2.tm_wday + 6) % 7) / 7);
|
||
|
|
if ((date2.tm_wday + 371 - date2.tm_yday - 2) % 7 <= 2) {
|
||
|
|
val++;
|
||
|
|
}
|
||
|
|
if (!val) {
|
||
|
|
val = 52;
|
||
|
|
var dec31 = (date2.tm_wday + 7 - date2.tm_yday - 1) % 7;
|
||
|
|
if (dec31 == 4 || dec31 == 5 && __isLeapYear(date2.tm_year % 400 - 1)) {
|
||
|
|
val++;
|
||
|
|
}
|
||
|
|
} else if (val == 53) {
|
||
|
|
var jan1 = (date2.tm_wday + 371 - date2.tm_yday) % 7;
|
||
|
|
if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date2.tm_year)))
|
||
|
|
val = 1;
|
||
|
|
}
|
||
|
|
return leadingNulls(val, 2);
|
||
|
|
}, "%w": function(date2) {
|
||
|
|
return date2.tm_wday;
|
||
|
|
}, "%W": function(date2) {
|
||
|
|
var days = date2.tm_yday + 7 - (date2.tm_wday + 6) % 7;
|
||
|
|
return leadingNulls(Math.floor(days / 7), 2);
|
||
|
|
}, "%y": function(date2) {
|
||
|
|
return (date2.tm_year + 1900).toString().substring(2);
|
||
|
|
}, "%Y": function(date2) {
|
||
|
|
return date2.tm_year + 1900;
|
||
|
|
}, "%z": function(date2) {
|
||
|
|
var off = date2.tm_gmtoff;
|
||
|
|
var ahead = off >= 0;
|
||
|
|
off = Math.abs(off) / 60;
|
||
|
|
off = off / 60 * 100 + off % 60;
|
||
|
|
return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
|
||
|
|
}, "%Z": function(date2) {
|
||
|
|
return date2.tm_zone;
|
||
|
|
}, "%%": function() {
|
||
|
|
return "%";
|
||
|
|
} };
|
||
|
|
pattern = pattern.replace(/%%/g, "\0\0");
|
||
|
|
for (var rule in EXPANSION_RULES_2) {
|
||
|
|
if (pattern.includes(rule)) {
|
||
|
|
pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pattern = pattern.replace(/\0\0/g, "%");
|
||
|
|
var bytes = intArrayFromString(pattern, false);
|
||
|
|
if (bytes.length > maxsize) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
writeArrayToMemory(bytes, s);
|
||
|
|
return bytes.length - 1;
|
||
|
|
}
|
||
|
|
function _strftime_l(s, maxsize, format, tm) {
|
||
|
|
return _strftime(s, maxsize, format, tm);
|
||
|
|
}
|
||
|
|
var FSNode = function(parent, name, mode, rdev) {
|
||
|
|
if (!parent) {
|
||
|
|
parent = this;
|
||
|
|
}
|
||
|
|
this.parent = parent;
|
||
|
|
this.mount = parent.mount;
|
||
|
|
this.mounted = null;
|
||
|
|
this.id = FS.nextInode++;
|
||
|
|
this.name = name;
|
||
|
|
this.mode = mode;
|
||
|
|
this.node_ops = {};
|
||
|
|
this.stream_ops = {};
|
||
|
|
this.rdev = rdev;
|
||
|
|
};
|
||
|
|
var readMode = 292 | 73;
|
||
|
|
var writeMode = 146;
|
||
|
|
Object.defineProperties(FSNode.prototype, { read: { get: function() {
|
||
|
|
return (this.mode & readMode) === readMode;
|
||
|
|
}, set: function(val) {
|
||
|
|
val ? this.mode |= readMode : this.mode &= ~readMode;
|
||
|
|
} }, write: { get: function() {
|
||
|
|
return (this.mode & writeMode) === writeMode;
|
||
|
|
}, set: function(val) {
|
||
|
|
val ? this.mode |= writeMode : this.mode &= ~writeMode;
|
||
|
|
} }, isFolder: { get: function() {
|
||
|
|
return FS.isDir(this.mode);
|
||
|
|
} }, isDevice: { get: function() {
|
||
|
|
return FS.isChrdev(this.mode);
|
||
|
|
} } });
|
||
|
|
FS.FSNode = FSNode;
|
||
|
|
FS.staticInit();
|
||
|
|
embind_init_charCodes();
|
||
|
|
BindingError = Module2["BindingError"] = extendError(Error, "BindingError");
|
||
|
|
InternalError = Module2["InternalError"] = extendError(Error, "InternalError");
|
||
|
|
init_emval();
|
||
|
|
UnboundTypeError = Module2["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
|
||
|
|
var ASSERTIONS = false;
|
||
|
|
var decodeBase64 = typeof atob == "function" ? atob : function(input) {
|
||
|
|
var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
|
||
|
|
var output = "";
|
||
|
|
var chr1, chr2, chr3;
|
||
|
|
var enc1, enc2, enc3, enc4;
|
||
|
|
var i = 0;
|
||
|
|
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
|
||
|
|
do {
|
||
|
|
enc1 = keyStr.indexOf(input.charAt(i++));
|
||
|
|
enc2 = keyStr.indexOf(input.charAt(i++));
|
||
|
|
enc3 = keyStr.indexOf(input.charAt(i++));
|
||
|
|
enc4 = keyStr.indexOf(input.charAt(i++));
|
||
|
|
chr1 = enc1 << 2 | enc2 >> 4;
|
||
|
|
chr2 = (enc2 & 15) << 4 | enc3 >> 2;
|
||
|
|
chr3 = (enc3 & 3) << 6 | enc4;
|
||
|
|
output = output + String.fromCharCode(chr1);
|
||
|
|
if (enc3 !== 64) {
|
||
|
|
output = output + String.fromCharCode(chr2);
|
||
|
|
}
|
||
|
|
if (enc4 !== 64) {
|
||
|
|
output = output + String.fromCharCode(chr3);
|
||
|
|
}
|
||
|
|
} while (i < input.length);
|
||
|
|
return output;
|
||
|
|
};
|
||
|
|
function intArrayFromBase64(s) {
|
||
|
|
if (typeof ENVIRONMENT_IS_NODE == "boolean" && ENVIRONMENT_IS_NODE) {
|
||
|
|
var buf = Buffer.from(s, "base64");
|
||
|
|
return new Uint8Array(buf["buffer"], buf["byteOffset"], buf["byteLength"]);
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
var decoded = decodeBase64(s);
|
||
|
|
var bytes = new Uint8Array(decoded.length);
|
||
|
|
for (var i = 0; i < decoded.length; ++i) {
|
||
|
|
bytes[i] = decoded.charCodeAt(i);
|
||
|
|
}
|
||
|
|
return bytes;
|
||
|
|
} catch (_) {
|
||
|
|
throw new Error("Converting base64 string to bytes failed.");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function tryParseAsDataURI(filename) {
|
||
|
|
if (!isDataURI(filename)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return intArrayFromBase64(filename.slice(dataURIPrefix.length));
|
||
|
|
}
|
||
|
|
var asmLibraryArg = { "u": ___cxa_allocate_exception, "q": ___cxa_begin_catch, "p": ___cxa_end_catch, "a": ___cxa_find_matching_catch_2, "o": ___cxa_find_matching_catch_3, "m": ___cxa_find_matching_catch_4, "y": ___cxa_free_exception, "Pa": ___cxa_rethrow, "v": ___cxa_throw, "f": ___resumeException, "T": ___syscall_fcntl64, "Aa": ___syscall_ioctl, "Ba": ___syscall_openat, "Ua": __embind_register_bigint, "Ka": __embind_register_bool, "Ja": __embind_register_emval, "Z": __embind_register_enum, "G": __embind_register_enum_value, "W": __embind_register_float, "M": __embind_register_function, "F": __embind_register_integer, "z": __embind_register_memory_view, "V": __embind_register_std_string, "O": __embind_register_std_wstring, "La": __embind_register_void, "Da": __emscripten_get_now_is_monotonic, "Ra": __emval_as, "K": __emval_call_void_method, "t": __emval_decref, "R": __emval_get_global, "L": __emval_get_method_caller, "$a": __emval_get_property, "H": __emval_incref, "Q": __emval_new, "A": __emval_new_cstring, "N": __emval_new_object, "Qa": __emval_run_destructors, "B": __emval_set_property, "D": __emval_take_value, "Fa": __gmtime_js, "Ga": __localtime_js, "Ha": __tzset_js, "J": _abort, "Ea": _emscripten_date_now, "Ca": _emscripten_get_now, "Ia": _emscripten_memcpy_big, "va": _emscripten_resize_heap, "xa": _environ_get, "ya": _environ_sizes_get, "U": _fd_close, "wa": _fd_fdstat_get, "za": _fd_read, "Ta": _fd_seek, "S": _fd_write, "X": invoke_di, "e": invoke_i, "I": invoke_idiii, "b": invoke_ii, "Y": invoke_iid, "Ma": invoke_iidii, "c": invoke_iii, "g": invoke_iiii, "w": invoke_iiiii, "s": invoke_iiiiii, "Sa": invoke_iiiiiii, "Na": invoke_iiiiiiii, "Xa": invoke_iiiijjiiij, "oa": invoke_iiij, "fa": invoke_iiiji, "ha": invoke_iij, "pa": invoke_iiji, "sa": invoke_iijiii, "ka": invoke_iijji, "qa": invoke_iijjiii, "_": invoke_iijjj, "ra": invoke_ijjiii, "ua": invoke_ji, "na": invoke_jii, "$": invoke_jij, "aa": invoke_jj, "l": invoke_v, "i": invoke_vi, "d": invoke_vii, "k": invoke_viii, "h": invoke_viiii, "j": invoke_viiiii, "n": invoke_viiiiii, "x": invoke_viiiiiii, "E": invoke_viiiiiiii, "P": invoke_viiiiiiiii, "Wa": invoke_viiiiiji, "Ya": invoke_viiiiijiijiiij, "Za": invoke_viiiiji, "da": invoke_viiij, "Va": invoke_viiiji, "ta": invoke_viiijj, "_a": invoke_viiijji, "ma": invoke_viij, "ca": invoke_viiji, "ba": invoke_viijii, "ja": invoke_viijj, "la": invoke_vij, "ga": invoke_vijii, "ia": invoke_vijj, "ea": invoke_vijji, "r": _llvm_eh_typeid_for, "Oa": _strftime, "C": _strftime_l };
|
||
|
|
var asm = createWasm();
|
||
|
|
var ___wasm_call_ctors = Module2["___wasm_call_ctors"] = function() {
|
||
|
|
return (___wasm_call_ctors = Module2["___wasm_call_ctors"] = Module2["asm"]["bb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var _free = Module2["_free"] = function() {
|
||
|
|
return (_free = Module2["_free"] = Module2["asm"]["db"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var ___getTypeName = Module2["___getTypeName"] = function() {
|
||
|
|
return (___getTypeName = Module2["___getTypeName"] = Module2["asm"]["eb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var __embind_initialize_bindings = Module2["__embind_initialize_bindings"] = function() {
|
||
|
|
return (__embind_initialize_bindings = Module2["__embind_initialize_bindings"] = Module2["asm"]["fb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var ___errno_location = Module2["___errno_location"] = function() {
|
||
|
|
return (___errno_location = Module2["___errno_location"] = Module2["asm"]["gb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var _malloc = Module2["_malloc"] = function() {
|
||
|
|
return (_malloc = Module2["_malloc"] = Module2["asm"]["hb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var _setThrew = Module2["_setThrew"] = function() {
|
||
|
|
return (_setThrew = Module2["_setThrew"] = Module2["asm"]["ib"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var setTempRet0 = Module2["setTempRet0"] = function() {
|
||
|
|
return (setTempRet0 = Module2["setTempRet0"] = Module2["asm"]["jb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var stackSave = Module2["stackSave"] = function() {
|
||
|
|
return (stackSave = Module2["stackSave"] = Module2["asm"]["kb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var stackRestore = Module2["stackRestore"] = function() {
|
||
|
|
return (stackRestore = Module2["stackRestore"] = Module2["asm"]["lb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var ___cxa_can_catch = Module2["___cxa_can_catch"] = function() {
|
||
|
|
return (___cxa_can_catch = Module2["___cxa_can_catch"] = Module2["asm"]["mb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var ___cxa_is_pointer_type = Module2["___cxa_is_pointer_type"] = function() {
|
||
|
|
return (___cxa_is_pointer_type = Module2["___cxa_is_pointer_type"] = Module2["asm"]["nb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiijj = Module2["dynCall_viiijj"] = function() {
|
||
|
|
return (dynCall_viiijj = Module2["dynCall_viiijj"] = Module2["asm"]["ob"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiij = Module2["dynCall_viiij"] = function() {
|
||
|
|
return (dynCall_viiij = Module2["dynCall_viiij"] = Module2["asm"]["pb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_ijjiii = Module2["dynCall_ijjiii"] = function() {
|
||
|
|
return (dynCall_ijjiii = Module2["dynCall_ijjiii"] = Module2["asm"]["qb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iijiii = Module2["dynCall_iijiii"] = function() {
|
||
|
|
return (dynCall_iijiii = Module2["dynCall_iijiii"] = Module2["asm"]["rb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iijjiii = Module2["dynCall_iijjiii"] = function() {
|
||
|
|
return (dynCall_iijjiii = Module2["dynCall_iijjiii"] = Module2["asm"]["sb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_ji = Module2["dynCall_ji"] = function() {
|
||
|
|
return (dynCall_ji = Module2["dynCall_ji"] = Module2["asm"]["tb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viijj = Module2["dynCall_viijj"] = function() {
|
||
|
|
return (dynCall_viijj = Module2["dynCall_viijj"] = Module2["asm"]["ub"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iij = Module2["dynCall_iij"] = function() {
|
||
|
|
return (dynCall_iij = Module2["dynCall_iij"] = Module2["asm"]["vb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_vij = Module2["dynCall_vij"] = function() {
|
||
|
|
return (dynCall_vij = Module2["dynCall_vij"] = Module2["asm"]["wb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiij = Module2["dynCall_iiij"] = function() {
|
||
|
|
return (dynCall_iiij = Module2["dynCall_iiij"] = Module2["asm"]["xb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_jii = Module2["dynCall_jii"] = function() {
|
||
|
|
return (dynCall_jii = Module2["dynCall_jii"] = Module2["asm"]["yb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viij = Module2["dynCall_viij"] = function() {
|
||
|
|
return (dynCall_viij = Module2["dynCall_viij"] = Module2["asm"]["zb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iijji = Module2["dynCall_iijji"] = function() {
|
||
|
|
return (dynCall_iijji = Module2["dynCall_iijji"] = Module2["asm"]["Ab"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_vijj = Module2["dynCall_vijj"] = function() {
|
||
|
|
return (dynCall_vijj = Module2["dynCall_vijj"] = Module2["asm"]["Bb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiiji = Module2["dynCall_iiiji"] = function() {
|
||
|
|
return (dynCall_iiiji = Module2["dynCall_iiiji"] = Module2["asm"]["Cb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_vijji = Module2["dynCall_vijji"] = function() {
|
||
|
|
return (dynCall_vijji = Module2["dynCall_vijji"] = Module2["asm"]["Db"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_vijii = Module2["dynCall_vijii"] = function() {
|
||
|
|
return (dynCall_vijii = Module2["dynCall_vijii"] = Module2["asm"]["Eb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_vijjii = Module2["dynCall_vijjii"] = function() {
|
||
|
|
return (dynCall_vijjii = Module2["dynCall_vijjii"] = Module2["asm"]["Fb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viijji = Module2["dynCall_viijji"] = function() {
|
||
|
|
return (dynCall_viijji = Module2["dynCall_viijji"] = Module2["asm"]["Gb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viijii = Module2["dynCall_viijii"] = function() {
|
||
|
|
return (dynCall_viijii = Module2["dynCall_viijii"] = Module2["asm"]["Hb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiji = Module2["dynCall_iiji"] = function() {
|
||
|
|
return (dynCall_iiji = Module2["dynCall_iiji"] = Module2["asm"]["Ib"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiji = Module2["dynCall_viiji"] = function() {
|
||
|
|
return (dynCall_viiji = Module2["dynCall_viiji"] = Module2["asm"]["Jb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_jj = Module2["dynCall_jj"] = function() {
|
||
|
|
return (dynCall_jj = Module2["dynCall_jj"] = Module2["asm"]["Kb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_jij = Module2["dynCall_jij"] = function() {
|
||
|
|
return (dynCall_jij = Module2["dynCall_jij"] = Module2["asm"]["Lb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiijji = Module2["dynCall_viiijji"] = function() {
|
||
|
|
return (dynCall_viiijji = Module2["dynCall_viiijji"] = Module2["asm"]["Mb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiiiji = Module2["dynCall_viiiiji"] = function() {
|
||
|
|
return (dynCall_viiiiji = Module2["dynCall_viiiiji"] = Module2["asm"]["Nb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iijjj = Module2["dynCall_iijjj"] = function() {
|
||
|
|
return (dynCall_iijjj = Module2["dynCall_iijjj"] = Module2["asm"]["Ob"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiiiijiijiiij = Module2["dynCall_viiiiijiijiiij"] = function() {
|
||
|
|
return (dynCall_viiiiijiijiiij = Module2["dynCall_viiiiijiijiiij"] = Module2["asm"]["Pb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiiiiji = Module2["dynCall_viiiiiji"] = function() {
|
||
|
|
return (dynCall_viiiiiji = Module2["dynCall_viiiiiji"] = Module2["asm"]["Qb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiiijjiiij = Module2["dynCall_iiiijjiiij"] = function() {
|
||
|
|
return (dynCall_iiiijjiiij = Module2["dynCall_iiiijjiiij"] = Module2["asm"]["Rb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_viiiji = Module2["dynCall_viiiji"] = function() {
|
||
|
|
return (dynCall_viiiji = Module2["dynCall_viiiji"] = Module2["asm"]["Sb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_jiji = Module2["dynCall_jiji"] = function() {
|
||
|
|
return (dynCall_jiji = Module2["dynCall_jiji"] = Module2["asm"]["Tb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiiiij = Module2["dynCall_iiiiij"] = function() {
|
||
|
|
return (dynCall_iiiiij = Module2["dynCall_iiiiij"] = Module2["asm"]["Ub"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiiiijj = Module2["dynCall_iiiiijj"] = function() {
|
||
|
|
return (dynCall_iiiiijj = Module2["dynCall_iiiiijj"] = Module2["asm"]["Vb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
var dynCall_iiiiiijj = Module2["dynCall_iiiiiijj"] = function() {
|
||
|
|
return (dynCall_iiiiiijj = Module2["dynCall_iiiiiijj"] = Module2["asm"]["Wb"]).apply(null, arguments);
|
||
|
|
};
|
||
|
|
function invoke_vii(index, a1, a2) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiii(index, a1, a2, a3) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iii(index, a1, a2) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_ii(index, a1) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_vi(index, a1) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_v(index) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)();
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_i(index) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)();
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viii(index, a1, a2, a3) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiiii(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_idiii(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiii(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiii(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iid(index, a1, a2) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_di(index, a1) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iidii(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return getWasmTableEntry(index)(a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_ji(index, a1) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_ji(index, a1);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiijj(index, a1, a2, a3, a4, a5, a6, a7) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiijj(index, a1, a2, a3, a4, a5, a6, a7);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iijiii(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iijiii(index, a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_ijjiii(index, a1, a2, a3, a4, a5, a6, a7) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_ijjiii(index, a1, a2, a3, a4, a5, a6, a7);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iijjiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiji(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iiji(index, a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiij(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iiij(index, a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_jii(index, a1, a2) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_jii(index, a1, a2);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viij(index, a1, a2, a3, a4) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viij(index, a1, a2, a3, a4);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_vij(index, a1, a2, a3) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_vij(index, a1, a2, a3);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iijji(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iijji(index, a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viijj(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viijj(index, a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_vijj(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_vijj(index, a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iij(index, a1, a2, a3) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iij(index, a1, a2, a3);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_vijii(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_vijii(index, a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiiji(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iiiji(index, a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_vijji(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_vijji(index, a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiij(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiij(index, a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiji(index, a1, a2, a3, a4, a5) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiji(index, a1, a2, a3, a4, a5);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viijii(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viijii(index, a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_jj(index, a1, a2) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_jj(index, a1, a2);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_jij(index, a1, a2, a3) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_jij(index, a1, a2, a3);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iijjj(index, a1, a2, a3, a4, a5, a6, a7) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iijjj(index, a1, a2, a3, a4, a5, a6, a7);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiijji(index, a1, a2, a3, a4, a5, a6, a7, a8) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiijji(index, a1, a2, a3, a4, a5, a6, a7, a8);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiji(index, a1, a2, a3, a4, a5, a6, a7) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiiiji(index, a1, a2, a3, a4, a5, a6, a7);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiijiijiiij(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiiiijiijiiij(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_iiiijjiiij(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
return dynCall_iiiijjiiij(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiiiiji(index, a1, a2, a3, a4, a5, a6, a7, a8);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function invoke_viiiji(index, a1, a2, a3, a4, a5, a6) {
|
||
|
|
var sp = stackSave();
|
||
|
|
try {
|
||
|
|
dynCall_viiiji(index, a1, a2, a3, a4, a5, a6);
|
||
|
|
} catch (e) {
|
||
|
|
stackRestore(sp);
|
||
|
|
if (e !== e + 0)
|
||
|
|
throw e;
|
||
|
|
_setThrew(1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var calledRun;
|
||
|
|
dependenciesFulfilled = function runCaller() {
|
||
|
|
if (!calledRun)
|
||
|
|
run();
|
||
|
|
if (!calledRun)
|
||
|
|
dependenciesFulfilled = runCaller;
|
||
|
|
};
|
||
|
|
function run(args) {
|
||
|
|
args = args || arguments_;
|
||
|
|
if (runDependencies > 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
preRun();
|
||
|
|
if (runDependencies > 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
function doRun() {
|
||
|
|
if (calledRun)
|
||
|
|
return;
|
||
|
|
calledRun = true;
|
||
|
|
Module2["calledRun"] = true;
|
||
|
|
if (ABORT)
|
||
|
|
return;
|
||
|
|
initRuntime();
|
||
|
|
readyPromiseResolve(Module2);
|
||
|
|
if (Module2["onRuntimeInitialized"])
|
||
|
|
Module2["onRuntimeInitialized"]();
|
||
|
|
postRun();
|
||
|
|
}
|
||
|
|
if (Module2["setStatus"]) {
|
||
|
|
Module2["setStatus"]("Running...");
|
||
|
|
setTimeout(function() {
|
||
|
|
setTimeout(function() {
|
||
|
|
Module2["setStatus"]("");
|
||
|
|
}, 1);
|
||
|
|
doRun();
|
||
|
|
}, 1);
|
||
|
|
} else {
|
||
|
|
doRun();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (Module2["preInit"]) {
|
||
|
|
if (typeof Module2["preInit"] == "function")
|
||
|
|
Module2["preInit"] = [Module2["preInit"]];
|
||
|
|
while (Module2["preInit"].length > 0) {
|
||
|
|
Module2["preInit"].pop()();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
run();
|
||
|
|
return Module2.ready;
|
||
|
|
};
|
||
|
|
})();
|
||
|
|
if (typeof exports2 === "object" && typeof module2 === "object")
|
||
|
|
module2.exports = Module;
|
||
|
|
else if (typeof define === "function" && define["amd"])
|
||
|
|
define([], function() {
|
||
|
|
return Module;
|
||
|
|
});
|
||
|
|
else if (typeof exports2 === "object")
|
||
|
|
exports2["Module"] = Module;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// api.js
|
||
|
|
var { constants, promises: fs } = require("fs");
|
||
|
|
var path = require("path");
|
||
|
|
var loadPostjectModule = require_postject();
|
||
|
|
async function inject(filename, resourceName, resourceData, options) {
|
||
|
|
const machoSegmentName = options?.machoSegmentName || "__POSTJECT";
|
||
|
|
const overwrite = options?.overwrite || false;
|
||
|
|
let sentinelFuse = options?.sentinelFuse || "POSTJECT_SENTINEL_fce680ab2cc467b6e072b8b5df1996b2";
|
||
|
|
if (!Buffer.isBuffer(resourceData)) {
|
||
|
|
throw new TypeError("resourceData must be a buffer");
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
await fs.access(filename, constants.R_OK | constants.W_OK);
|
||
|
|
} catch {
|
||
|
|
throw new Error("Can't read and write to target executable");
|
||
|
|
}
|
||
|
|
let executable;
|
||
|
|
const postject = await loadPostjectModule();
|
||
|
|
try {
|
||
|
|
executable = await fs.readFile(filename);
|
||
|
|
} catch {
|
||
|
|
throw new Error("Couldn't read target executable");
|
||
|
|
}
|
||
|
|
const executableFormat = postject.getExecutableFormat(executable);
|
||
|
|
if (executableFormat === postject.ExecutableFormat.kUnknown) {
|
||
|
|
throw new Error(
|
||
|
|
"Executable must be a supported format: ELF, PE, or Mach-O"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
let data;
|
||
|
|
let result;
|
||
|
|
switch (executableFormat) {
|
||
|
|
case postject.ExecutableFormat.kMachO:
|
||
|
|
{
|
||
|
|
let sectionName = resourceName;
|
||
|
|
if (!sectionName.startsWith("__")) {
|
||
|
|
sectionName = `__${sectionName}`;
|
||
|
|
}
|
||
|
|
({ result, data } = postject.injectIntoMachO(
|
||
|
|
executable,
|
||
|
|
machoSegmentName,
|
||
|
|
sectionName,
|
||
|
|
resourceData,
|
||
|
|
overwrite
|
||
|
|
));
|
||
|
|
if (result === postject.InjectResult.kAlreadyExists) {
|
||
|
|
throw new Error(
|
||
|
|
`Segment and section with that name already exists: ${machoSegmentName}/${sectionName}
|
||
|
|
Use --overwrite to overwrite the existing content`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case postject.ExecutableFormat.kELF:
|
||
|
|
{
|
||
|
|
let sectionName = resourceName;
|
||
|
|
({ result, data } = postject.injectIntoELF(
|
||
|
|
executable,
|
||
|
|
sectionName,
|
||
|
|
resourceData,
|
||
|
|
overwrite
|
||
|
|
));
|
||
|
|
if (result === postject.InjectResult.kAlreadyExists) {
|
||
|
|
throw new Error(
|
||
|
|
`Section with that name already exists: ${sectionName}Use --overwrite to overwrite the existing content`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case postject.ExecutableFormat.kPE:
|
||
|
|
{
|
||
|
|
resourceName = resourceName.toUpperCase();
|
||
|
|
({ result, data } = postject.injectIntoPE(
|
||
|
|
executable,
|
||
|
|
resourceName,
|
||
|
|
resourceData,
|
||
|
|
overwrite
|
||
|
|
));
|
||
|
|
if (result === postject.InjectResult.kAlreadyExists) {
|
||
|
|
throw new Error(
|
||
|
|
`Resource with that name already exists: ${resourceName}
|
||
|
|
Use --overwrite to overwrite the existing content`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (result !== postject.InjectResult.kSuccess) {
|
||
|
|
throw new Error("Error when injecting resource");
|
||
|
|
}
|
||
|
|
const buffer = Buffer.from(data.buffer);
|
||
|
|
const firstSentinel = buffer.indexOf(sentinelFuse);
|
||
|
|
if (firstSentinel === -1) {
|
||
|
|
throw new Error(
|
||
|
|
`Could not find the sentinel ${sentinelFuse} in the binary`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
const lastSentinel = buffer.lastIndexOf(sentinelFuse);
|
||
|
|
if (firstSentinel !== lastSentinel) {
|
||
|
|
throw new Error(
|
||
|
|
`Multiple occurences of sentinel "${sentinelFuse}" found in the binary`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
const colonIndex = firstSentinel + sentinelFuse.length;
|
||
|
|
if (buffer[colonIndex] !== ":".charCodeAt(0)) {
|
||
|
|
throw new Error(
|
||
|
|
`Value at index ${colonIndex} must be ':' but '${buffer[colonIndex].charCodeAt(0)}' was found`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
const hasResourceIndex = firstSentinel + sentinelFuse.length + 1;
|
||
|
|
const hasResourceValue = buffer[hasResourceIndex];
|
||
|
|
if (hasResourceValue === "0".charCodeAt(0)) {
|
||
|
|
buffer[hasResourceIndex] = "1".charCodeAt(0);
|
||
|
|
} else if (hasResourceValue != "1".charCodeAt(0)) {
|
||
|
|
throw new Error(
|
||
|
|
`Value at index ${hasResourceIndex} must be '0' or '1' but '${hasResourceValue.charCodeAt(
|
||
|
|
0
|
||
|
|
)}' was found`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
await fs.writeFile(filename, buffer);
|
||
|
|
} catch {
|
||
|
|
throw new Error("Couldn't write executable");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
module.exports = { inject };
|