@polygonjs/polygonjs
Version:
node-based WebGL 3D engine https://polygonjs.com
1,461 lines • 199 kB
JavaScript
"use strict";
var Module = (() => {
var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0;
if (typeof __filename !== "undefined")
_scriptDir = _scriptDir || __filename;
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(path) {
if (Module2["locateFile"]) {
return Module2["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_, readAsync, readBinary, setWindowTitle;
function logExceptionOnExit(e) {
if (e instanceof ExitStatus)
return;
let toLog = e;
err("exiting due to exception: " + toLog);
}
var fs;
var nodePath;
var requireNodeFS;
if (ENVIRONMENT_IS_NODE) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = require("path").dirname(scriptDirectory) + "/";
} else {
scriptDirectory = __dirname + "/";
}
requireNodeFS = () => {
if (!nodePath) {
fs = require("fs");
nodePath = require("path");
}
};
read_ = function shell_read(filename, binary) {
requireNodeFS();
filename = nodePath["normalize"](filename);
return fs.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) => {
requireNodeFS();
filename = nodePath["normalize"](filename);
fs.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) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
readAsync = (url, onload, onerror) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
}
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;
function warnOnce(text) {
if (!warnOnce.shown)
warnOnce.shown = {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
err(text);
}
}
var tempRet0 = 0;
var setTempRet0 = (value) => {
tempRet0 = value;
};
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) {
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));
} else {
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) {
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0))
return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i2 = 0; i2 < str.length; ++i2) {
var u = str.charCodeAt(i2);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i2);
u = 65536 + ((u & 1023) << 10) | u1 & 1023;
}
if (u <= 127) {
if (outIdx >= endIdx)
break;
heap[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx)
break;
heap[outIdx++] = 192 | u >> 6;
heap[outIdx++] = 128 | u & 63;
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx)
break;
heap[outIdx++] = 224 | u >> 12;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63;
} else {
if (outIdx + 3 >= endIdx)
break;
heap[outIdx++] = 240 | u >> 18;
heap[outIdx++] = 128 | u >> 12 & 63;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63;
}
}
heap[outIdx] = 0;
return outIdx - startIdx;
}
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
function lengthBytesUTF8(str) {
var len = 0;
for (var i2 = 0; i2 < str.length; ++i2) {
var u = str.charCodeAt(i2);
if (u >= 55296 && u <= 57343)
u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i2) & 1023;
if (u <= 127)
++len;
else if (u <= 2047)
len += 2;
else if (u <= 65535)
len += 3;
else
len += 4;
}
return len;
}
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])
++idx;
endPtr = idx << 1;
if (endPtr - ptr > 32 && UTF16Decoder) {
return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
} else {
var str = "";
for (var i2 = 0; !(i2 >= maxBytesToRead / 2); ++i2) {
var codeUnit = HEAP16[ptr + i2 * 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 i2 = 0; i2 < numCharsToWrite; ++i2) {
var codeUnit = str.charCodeAt(i2);
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 i2 = 0;
var str = "";
while (!(i2 >= maxBytesToRead / 4)) {
var utf32 = HEAP32[ptr + i2 * 4 >> 2];
if (utf32 == 0)
break;
++i2;
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) {
if (maxBytesToWrite === void 0) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 4)
return 0;
var startPtr = outPtr;
var endPtr = startPtr + maxBytesToWrite - 4;
for (var i2 = 0; i2 < str.length; ++i2) {
var codeUnit = str.charCodeAt(i2);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++i2);
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 i2 = 0; i2 < str.length; ++i2) {
var codeUnit = str.charCodeAt(i2);
if (codeUnit >= 55296 && codeUnit <= 57343)
++i2;
len += 4;
}
return len;
}
function allocateUTF8(str) {
var size = lengthBytesUTF8(str) + 1;
var ret = _malloc(size);
if (ret)
stringToUTF8Array(str, HEAP8, ret, size);
return ret;
}
function writeArrayToMemory(array, buffer2) {
HEAP8.set(array, buffer2);
}
function writeAsciiToMemory(str, buffer2, dontAddNull) {
for (var i2 = 0; i2 < str.length; ++i2) {
HEAP8[buffer2++ >> 0] = str.charCodeAt(i2);
}
if (!dontAddNull)
HEAP8[buffer2 >> 0] = 0;
}
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"] || 16777216;
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 = "polygonjs-occt.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
function getBinary(file) {
try {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
} else {
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, module) {
var exports2 = instance.exports;
Module2["asm"] = exports2;
wasmMemory = Module2["asm"]["qa"];
updateGlobalBufferAndViews(wasmMemory.buffer);
wasmTable = Module2["asm"]["xa"];
addOnInit(Module2["asm"]["ra"]);
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 exports = Module2["instantiateWasm"](info, receiveInstance);
return exports;
} catch (e) {
err("Module.instantiateWasm callback failed with error: " + e);
return false;
}
}
instantiateAsync().catch(readyPromiseReject);
return {};
}
var tempDouble;
var tempI64;
function OSD_MemInfo_getModuleHeapLength() {
return Module2.HEAP8.length;
}
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback(Module2);
continue;
}
var func = callback.func;
if (typeof func == "number") {
if (callback.arg === void 0) {
getWasmTableEntry(func)();
} else {
getWasmTableEntry(func)(callback.arg);
}
} else {
func(callback.arg === void 0 ? null : callback.arg);
}
}
}
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 jsStackTrace() {
var error = new Error();
if (!error.stack) {
try {
throw new Error();
} catch (e) {
error = e;
}
if (!error.stack) {
return "(no stack trace available)";
}
}
return error.stack.toString();
}
function ___assert_fail(condition, filename, line, func) {
abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
}
function ___cxa_allocate_exception(size) {
return _malloc(size + 24) + 24;
}
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;
};
}
var exceptionLast = 0;
var uncaughtExceptionCount = 0;
function ___cxa_throw(ptr, type, destructor) {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw ptr;
}
var PATH = { isAbs: (path) => path.charAt(0) === "/", splitPath: (filename) => {
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
return splitPathRe.exec(filename).slice(1);
}, normalizeArray: (parts, allowAboveRoot) => {
var up = 0;
for (var i2 = parts.length - 1; i2 >= 0; i2--) {
var last = parts[i2];
if (last === ".") {
parts.splice(i2, 1);
} else if (last === "..") {
parts.splice(i2, 1);
up++;
} else if (up) {
parts.splice(i2, 1);
up--;
}
}
if (allowAboveRoot) {
for (; up; up--) {
parts.unshift("..");
}
}
return parts;
}, normalize: (path) => {
var isAbsolute = PATH.isAbs(path), trailingSlash = path.substr(-1) === "/";
path = PATH.normalizeArray(path.split("/").filter((p) => !!p), !isAbsolute).join("/");
if (!path && !isAbsolute) {
path = ".";
}
if (path && trailingSlash) {
path += "/";
}
return (isAbsolute ? "/" : "") + path;
}, dirname: (path) => {
var result = PATH.splitPath(path), root = result[0], dir = result[1];
if (!root && !dir) {
return ".";
}
if (dir) {
dir = dir.substr(0, dir.length - 1);
}
return root + dir;
}, basename: (path) => {
if (path === "/")
return "/";
path = PATH.normalize(path);
path = path.replace(/\/$/, "");
var lastSlash = path.lastIndexOf("/");
if (lastSlash === -1)
return path;
return path.substr(lastSlash + 1);
}, join: function() {
var paths = Array.prototype.slice.call(arguments, 0);
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 function() {
crypto.getRandomValues(randomBuffer);
return randomBuffer[0];
};
} else if (ENVIRONMENT_IS_NODE) {
try {
var crypto_module = require("crypto");
return function() {
return crypto_module["randomBytes"](1)[0];
};
} catch (e) {
}
}
return function() {
abort("randomDevice");
};
}
var PATH_FS = { resolve: function() {
var resolvedPath = "", resolvedAbsolute = false;
for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
var path = i2 >= 0 ? arguments[i2] : FS.cwd();
if (typeof path != "string") {
throw new TypeError("Arguments to path.resolve must be strings");
} else if (!path) {
return "";
}
resolvedPath = path + "/" + resolvedPath;
resolvedAbsolute = PATH.isAbs(path);
}
resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
}, relative: (from, to) => {
from = PATH_FS.resolve(from).substr(1);
to = PATH_FS.resolve(to).substr(1);
function trim(arr) {
var start = 0;
for (; start < arr.length; start++) {
if (arr[start] !== "")
break;
}
var end = arr.length - 1;
for (; end >= 0; end--) {
if (arr[end] !== "")
break;
}
if (start > end)
return [];
return arr.slice(start, end - start + 1);
}
var fromParts = trim(from.split("/"));
var toParts = trim(to.split("/"));
var length = Math.min(fromParts.length, toParts.length);
var samePartsLength = length;
for (var i2 = 0; i2 < length; i2++) {
if (fromParts[i2] !== toParts[i2]) {
samePartsLength = i2;
break;
}
}
var outputParts = [];
for (var i2 = samePartsLength; i2 < fromParts.length; i2++) {
outputParts.push("..");
}
outputParts = outputParts.concat(toParts.slice(samePartsLength));
return outputParts.join("/");
} };
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.flush(stream.tty);
}, flush: function(stream) {
stream.tty.ops.flush(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 i2 = 0; i2 < length; i2++) {
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 + i2] = 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 i2 = 0; i2 < length; i2++) {
stream.tty.ops.put_char(stream.tty, buffer2[offset + i2]);
}
} catch (e) {
throw new FS.ErrnoError(29);
}
if (length) {
stream.node.timestamp = Date.now();
}
return i2;
} }, 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 = fs.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);
}
}, flush: 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);
}
}, flush: function(tty) {
if (tty.output && tty.output.length > 0) {
err(UTF8ArrayToString(tty.output, 0));
tty.output = [];
}
} } };
function zeroMemory(address, size) {
HEAPU8.fill(0, address, address + size);
}
function alignMemory(size, alignment) {
return Math.ceil(size / alignment) * alignment;
}
function mmapAlloc(size) {
size = alignMemory(size, 65536);
var ptr = _emscripten_builtin_memalign(65536, size);
if (!ptr)
return 0;
zeroMemory(ptr, size);
return ptr;
}
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) {
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) {
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 i2 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 i2 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 i2 = 0; i2 < size; i2++)
buffer2[offset + i2] = contents[position + i2];
}
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 i2 = 0; i2 < length; i2++) {
node.contents[position + i2] = buffer2[offset + i2];
}
}
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);
}
HEAP8.set(contents, ptr);
}
return { ptr, allocated };
}, msync: function(stream, buffer2, offset, length, mmapFlags) {
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(43);
}
if (mmapFlags & 2) {
return 0;
}
var bytesWritten = 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, function(arrayBuffer) {
assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
onload(new Uint8Array(arrayBuffer));
if (dep)
removeRunDependency(dep);
}, function(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: (path, opts = {}) => {
path = PATH_FS.resolve(FS.cwd(), path);
if (!path)
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(path.split("/").filter((p) => !!p), false);
var current = FS.root;
var current_path = "/";
for (var i2 = 0; i2 < parts.length; i2++) {
var islast = i2 === parts.length - 1;
if (islast && opts.parent) {
break;
}
current = FS.lookupNode(current, parts[i2]);
current_path = PATH.join2(current_path, parts[i2]);
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 path;
while (true) {
if (FS.isRoot(node)) {
var mount = node.mount.mountpoint;
if (!path)
return mount;
return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path;
}
path = path ? node.name + "/" + path : node.name;
node = node.parent;
}
}, hashName: (parentid, name) => {
var hash = 0;
for (var i2 = 0; i2 < name.length; i2++) {
hash = (hash << 5) - hash + name.charCodeAt(i2) | 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