Falln87/godot_editor
0
1var Godot = (() => {2 var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;3 4 return (5 function(Godot) {6 Godot = Godot || {};7 8 function GROWABLE_HEAP_I8() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAP8 }9 10 function GROWABLE_HEAP_U8() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAPU8 }11 12 function GROWABLE_HEAP_I16() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAP16 }13 14 function GROWABLE_HEAP_U16() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAPU16 }15 16 function GROWABLE_HEAP_I32() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAP32 }17 18 function GROWABLE_HEAP_U32() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAPU32 }19 20 function GROWABLE_HEAP_F32() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAPF32 }21 22 function GROWABLE_HEAP_F64() { if (wasmMemory.buffer != buffer) { updateGlobalBufferAndViews(wasmMemory.buffer) } return HEAPF64 }23 var Module = typeof Godot != "undefined" ? Godot : {};24 var readyPromiseResolve, readyPromiseReject;25 Module["ready"] = new Promise(function(resolve, reject) {26 readyPromiseResolve = resolve;27 readyPromiseReject = reject28 });29 var moduleOverrides = Object.assign({}, Module);30 var arguments_ = [];31 var thisProgram = "./this.program";32 var quit_ = (status, toThrow) => { throw toThrow };33 var ENVIRONMENT_IS_WEB = typeof window == "object";34 var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";35 var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";36 var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;37 var scriptDirectory = "";38 39 function locateFile(path) { if (Module["locateFile"]) { return Module["locateFile"](path, scriptDirectory) } return scriptDirectory + path }40 var read_, readAsync, readBinary, setWindowTitle;41 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {42 if (ENVIRONMENT_IS_WORKER) { scriptDirectory = self.location.href } else if (typeof document != "undefined" && document.currentScript) { scriptDirectory = document.currentScript.src }43 if (_scriptDir) { scriptDirectory = _scriptDir }44 if (scriptDirectory.indexOf("blob:") !== 0) { scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1) } else { scriptDirectory = "" } {45 read_ = (url => {46 var xhr = new XMLHttpRequest;47 xhr.open("GET", url, false);48 xhr.send(null);49 return xhr.responseText50 });51 if (ENVIRONMENT_IS_WORKER) {52 readBinary = (url => {53 var xhr = new XMLHttpRequest;54 xhr.open("GET", url, false);55 xhr.responseType = "arraybuffer";56 xhr.send(null);57 return new Uint8Array(xhr.response)58 })59 }60 readAsync = ((url, onload, onerror) => {61 var xhr = new XMLHttpRequest;62 xhr.open("GET", url, true);63 xhr.responseType = "arraybuffer";64 xhr.onload = (() => {65 if (xhr.status == 200 || xhr.status == 0 && xhr.response) { onload(xhr.response); return }66 onerror()67 });68 xhr.onerror = onerror;69 xhr.send(null)70 })71 }72 setWindowTitle = (title => document.title = title)73 } else {}74 var out = Module["print"] || console.log.bind(console);75 var err = Module["printErr"] || console.warn.bind(console);76 Object.assign(Module, moduleOverrides);77 moduleOverrides = null;78 if (Module["arguments"]) arguments_ = Module["arguments"];79 if (Module["thisProgram"]) thisProgram = Module["thisProgram"];80 if (Module["quit"]) quit_ = Module["quit"];81 82 function warnOnce(text) {83 if (!warnOnce.shown) warnOnce.shown = {};84 if (!warnOnce.shown[text]) {85 warnOnce.shown[text] = 1;86 err(text)87 }88 }89 var tempRet0 = 0;90 var setTempRet0 = value => { tempRet0 = value };91 var getTempRet0 = () => tempRet0;92 var Atomics_load = Atomics.load;93 var Atomics_store = Atomics.store;94 var Atomics_compareExchange = Atomics.compareExchange;95 var wasmBinary;96 if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];97 var noExitRuntime = Module["noExitRuntime"] || false;98 if (typeof WebAssembly != "object") { abort("no native wasm support detected") }99 100 function setValue(ptr, value, type = "i8", noSafe) {101 if (type.charAt(type.length - 1) === "*") type = "i32";102 switch (type) {103 case "i1":104 GROWABLE_HEAP_I8()[ptr >> 0] = value;105 break;106 case "i8":107 GROWABLE_HEAP_I8()[ptr >> 0] = value;108 break;109 case "i16":110 GROWABLE_HEAP_I16()[ptr >> 1] = value;111 break;112 case "i32":113 GROWABLE_HEAP_I32()[ptr >> 2] = value;114 break;115 case "i64":116 tempI64 = [value >>> 0, (tempDouble = value, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], GROWABLE_HEAP_I32()[ptr >> 2] = tempI64[0], GROWABLE_HEAP_I32()[ptr + 4 >> 2] = tempI64[1];117 break;118 case "float":119 GROWABLE_HEAP_F32()[ptr >> 2] = value;120 break;121 case "double":122 GROWABLE_HEAP_F64()[ptr >> 3] = value;123 break;124 default:125 abort("invalid type for setValue: " + type)126 }127 }128 129 function getValue(ptr, type = "i8", noSafe) {130 if (type.charAt(type.length - 1) === "*") type = "i32";131 switch (type) {132 case "i1":133 return GROWABLE_HEAP_I8()[ptr >> 0];134 case "i8":135 return GROWABLE_HEAP_I8()[ptr >> 0];136 case "i16":137 return GROWABLE_HEAP_I16()[ptr >> 1];138 case "i32":139 return GROWABLE_HEAP_I32()[ptr >> 2];140 case "i64":141 return GROWABLE_HEAP_I32()[ptr >> 2];142 case "float":143 return GROWABLE_HEAP_F32()[ptr >> 2];144 case "double":145 return Number(GROWABLE_HEAP_F64()[ptr >> 3]);146 default:147 abort("invalid type for getValue: " + type)148 }149 return null150 }151 var wasmMemory;152 var wasmModule;153 var ABORT = false;154 var EXITSTATUS;155 156 function assert(condition, text) { if (!condition) { abort(text) } }157 158 function getCFunc(ident) { var func = Module["_" + ident]; return func }159 160 function ccall(ident, returnType, argTypes, args, opts) {161 var toC = {162 "string": function(str) {163 var ret = 0;164 if (str !== null && str !== undefined && str !== 0) {165 var len = (str.length << 2) + 1;166 ret = stackAlloc(len);167 stringToUTF8(str, ret, len)168 }169 return ret170 },171 "array": function(arr) {172 var ret = stackAlloc(arr.length);173 writeArrayToMemory(arr, ret);174 return ret175 }176 };177 178 function convertReturnValue(ret) { if (returnType === "string") return UTF8ToString(ret); if (returnType === "boolean") return Boolean(ret); return ret }179 var func = getCFunc(ident);180 var cArgs = [];181 var stack = 0;182 if (args) {183 for (var i = 0; i < args.length; i++) {184 var converter = toC[argTypes[i]];185 if (converter) {186 if (stack === 0) stack = stackSave();187 cArgs[i] = converter(args[i])188 } else { cArgs[i] = args[i] }189 }190 }191 var ret = func.apply(null, cArgs);192 193 function onDone(ret) { if (stack !== 0) stackRestore(stack); return convertReturnValue(ret) }194 ret = onDone(ret);195 return ret196 }197 198 function cwrap(ident, returnType, argTypes, opts) { argTypes = argTypes || []; var numericArgs = argTypes.every(function(type) { return type === "number" }); var numericRet = returnType !== "string"; if (numericRet && numericArgs && !opts) { return getCFunc(ident) } return function() { return ccall(ident, returnType, argTypes, arguments, opts) } }199 200 function TextDecoderWrapper(encoding) {201 var textDecoder = new TextDecoder(encoding);202 this.decode = (data => { if (data.buffer instanceof SharedArrayBuffer) { data = new Uint8Array(data) } return textDecoder.decode.call(textDecoder, data) })203 }204 var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoderWrapper("utf8") : undefined;205 206 function UTF8ArrayToString(heap, idx, maxBytesToRead) {207 var endIdx = idx + maxBytesToRead;208 var endPtr = idx;209 while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;210 if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { return UTF8Decoder.decode(heap.subarray(idx, endPtr)) } else {211 var str = "";212 while (idx < endPtr) {213 var u0 = heap[idx++];214 if (!(u0 & 128)) { str += String.fromCharCode(u0); continue }215 var u1 = heap[idx++] & 63;216 if ((u0 & 224) == 192) { str += String.fromCharCode((u0 & 31) << 6 | u1); continue }217 var u2 = heap[idx++] & 63;218 if ((u0 & 240) == 224) { u0 = (u0 & 15) << 12 | u1 << 6 | u2 } else { u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++] & 63 }219 if (u0 < 65536) { str += String.fromCharCode(u0) } else {220 var ch = u0 - 65536;221 str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)222 }223 }224 }225 return str226 }227 228 function UTF8ToString(ptr, maxBytesToRead) { return ptr ? UTF8ArrayToString(GROWABLE_HEAP_U8(), ptr, maxBytesToRead) : "" }229 230 function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {231 if (!(maxBytesToWrite > 0)) return 0;232 var startIdx = outIdx;233 var endIdx = outIdx + maxBytesToWrite - 1;234 for (var i = 0; i < str.length; ++i) {235 var u = str.charCodeAt(i);236 if (u >= 55296 && u <= 57343) {237 var u1 = str.charCodeAt(++i);238 u = 65536 + ((u & 1023) << 10) | u1 & 1023239 }240 if (u <= 127) {241 if (outIdx >= endIdx) break;242 heap[outIdx++] = u243 } else if (u <= 2047) {244 if (outIdx + 1 >= endIdx) break;245 heap[outIdx++] = 192 | u >> 6;246 heap[outIdx++] = 128 | u & 63247 } else if (u <= 65535) {248 if (outIdx + 2 >= endIdx) break;249 heap[outIdx++] = 224 | u >> 12;250 heap[outIdx++] = 128 | u >> 6 & 63;251 heap[outIdx++] = 128 | u & 63252 } else {253 if (outIdx + 3 >= endIdx) break;254 heap[outIdx++] = 240 | u >> 18;255 heap[outIdx++] = 128 | u >> 12 & 63;256 heap[outIdx++] = 128 | u >> 6 & 63;257 heap[outIdx++] = 128 | u & 63258 }259 }260 heap[outIdx] = 0;261 return outIdx - startIdx262 }263 264 function stringToUTF8(str, outPtr, maxBytesToWrite) { return stringToUTF8Array(str, GROWABLE_HEAP_U8(), outPtr, maxBytesToWrite) }265 266 function lengthBytesUTF8(str) {267 var len = 0;268 for (var i = 0; i < str.length; ++i) {269 var u = str.charCodeAt(i);270 if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;271 if (u <= 127) ++len;272 else if (u <= 2047) len += 2;273 else if (u <= 65535) len += 3;274 else len += 4275 }276 return len277 }278 var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoderWrapper("utf-16le") : undefined;279 280 function allocateUTF8(str) { var size = lengthBytesUTF8(str) + 1; var ret = _malloc(size); if (ret) stringToUTF8Array(str, GROWABLE_HEAP_I8(), ret, size); return ret }281 282 function allocateUTF8OnStack(str) {283 var size = lengthBytesUTF8(str) + 1;284 var ret = stackAlloc(size);285 stringToUTF8Array(str, GROWABLE_HEAP_I8(), ret, size);286 return ret287 }288 289 function writeArrayToMemory(array, buffer) { GROWABLE_HEAP_I8().set(array, buffer) }290 291 function writeAsciiToMemory(str, buffer, dontAddNull) { for (var i = 0; i < str.length; ++i) { GROWABLE_HEAP_I8()[buffer++ >> 0] = str.charCodeAt(i) } if (!dontAddNull) GROWABLE_HEAP_I8()[buffer >> 0] = 0 }292 var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;293 if (ENVIRONMENT_IS_PTHREAD) { buffer = Module["buffer"] }294 295 function updateGlobalBufferAndViews(buf) {296 buffer = buf;297 Module["HEAP8"] = HEAP8 = new Int8Array(buf);298 Module["HEAP16"] = HEAP16 = new Int16Array(buf);299 Module["HEAP32"] = HEAP32 = new Int32Array(buf);300 Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);301 Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);302 Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);303 Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);304 Module["HEAPF64"] = HEAPF64 = new Float64Array(buf)305 }306 var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 67108864;307 if (ENVIRONMENT_IS_PTHREAD) {308 wasmMemory = Module["wasmMemory"];309 buffer = Module["buffer"]310 } else { if (Module["wasmMemory"]) { wasmMemory = Module["wasmMemory"] } else { wasmMemory = new WebAssembly.Memory({ "initial": INITIAL_MEMORY / 65536, "maximum": 2147483648 / 65536, "shared": true }); if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) { err("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag"); if (ENVIRONMENT_IS_NODE) { console.log("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and also use a recent version)") } throw Error("bad memory") } } }311 if (wasmMemory) { buffer = wasmMemory.buffer }312 INITIAL_MEMORY = buffer.byteLength;313 updateGlobalBufferAndViews(buffer);314 var wasmTable;315 var __ATPRERUN__ = [];316 var __ATINIT__ = [];317 var __ATMAIN__ = [];318 var __ATEXIT__ = [];319 var __ATPOSTRUN__ = [];320 var runtimeInitialized = false;321 var runtimeExited = false;322 var runtimeKeepaliveCounter = 0;323 324 function keepRuntimeAlive() { return noExitRuntime || runtimeKeepaliveCounter > 0 }325 326 function preRun() {327 if (Module["preRun"]) { if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]]; while (Module["preRun"].length) { addOnPreRun(Module["preRun"].shift()) } }328 callRuntimeCallbacks(__ATPRERUN__)329 }330 331 function initRuntime() {332 runtimeInitialized = true;333 if (ENVIRONMENT_IS_PTHREAD) return;334 if (!Module["noFSInit"] && !FS.init.initialized) FS.init();335 FS.ignorePermissions = false;336 TTY.init();337 SOCKFS.root = FS.mount(SOCKFS, {}, null);338 callRuntimeCallbacks(__ATINIT__)339 }340 341 function preMain() {342 if (ENVIRONMENT_IS_PTHREAD) return;343 callRuntimeCallbacks(__ATMAIN__)344 }345 346 function exitRuntime() {347 if (ENVIRONMENT_IS_PTHREAD) return;348 ___funcs_on_exit();349 callRuntimeCallbacks(__ATEXIT__);350 FS.quit();351 TTY.shutdown();352 PThread.terminateAllThreads();353 runtimeExited = true354 }355 356 function postRun() {357 if (ENVIRONMENT_IS_PTHREAD) return;358 if (Module["postRun"]) { if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]]; while (Module["postRun"].length) { addOnPostRun(Module["postRun"].shift()) } }359 callRuntimeCallbacks(__ATPOSTRUN__)360 }361 362 function addOnPreRun(cb) { __ATPRERUN__.unshift(cb) }363 364 function addOnInit(cb) { __ATINIT__.unshift(cb) }365 366 function addOnPostRun(cb) { __ATPOSTRUN__.unshift(cb) }367 var runDependencies = 0;368 var runDependencyWatcher = null;369 var dependenciesFulfilled = null;370 371 function getUniqueRunDependency(id) { return id }372 373 function addRunDependency(id) { runDependencies++; if (Module["monitorRunDependencies"]) { Module["monitorRunDependencies"](runDependencies) } }374 375 function removeRunDependency(id) {376 runDependencies--;377 if (Module["monitorRunDependencies"]) { Module["monitorRunDependencies"](runDependencies) }378 if (runDependencies == 0) {379 if (runDependencyWatcher !== null) {380 clearInterval(runDependencyWatcher);381 runDependencyWatcher = null382 }383 if (dependenciesFulfilled) {384 var callback = dependenciesFulfilled;385 dependenciesFulfilled = null;386 callback()387 }388 }389 }390 Module["preloadedImages"] = {};391 Module["preloadedAudios"] = {};392 393 function abort(what) {394 if (ENVIRONMENT_IS_PTHREAD) { postMessage({ "cmd": "onAbort", "arg": what }) } else { if (Module["onAbort"]) { Module["onAbort"](what) } }395 what = "Aborted(" + what + ")";396 err(what);397 ABORT = true;398 EXITSTATUS = 1;399 what += ". Build with -s ASSERTIONS=1 for more info.";400 var e = new WebAssembly.RuntimeError(what);401 readyPromiseReject(e);402 throw e403 }404 var dataURIPrefix = "data:application/octet-stream;base64,";405 406 function isDataURI(filename) { return filename.startsWith(dataURIPrefix) }407 var wasmBinaryFile;408 wasmBinaryFile = "godot.javascript.opt.tools.threads.wasm";409 if (!isDataURI(wasmBinaryFile)) { wasmBinaryFile = locateFile(wasmBinaryFile) }410 411 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 (err) { abort(err) } }412 413 function getBinaryPromise() { if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { if (typeof fetch == "function") { 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) }) } } return Promise.resolve().then(function() { return getBinary(wasmBinaryFile) }) }414 415 function createWasm() {416 var info = { "a": asmLibraryArg };417 418 function receiveInstance(instance, module) {419 var exports = instance.exports;420 Module["asm"] = exports;421 registerTlsInit(Module["asm"]["fi"]);422 wasmTable = Module["asm"]["Uh"];423 addOnInit(Module["asm"]["Th"]);424 wasmModule = module;425 if (!ENVIRONMENT_IS_PTHREAD) {426 var numWorkersToLoad = PThread.unusedWorkers.length;427 PThread.unusedWorkers.forEach(function(w) { PThread.loadWasmModuleToWorker(w, function() { if (!--numWorkersToLoad) removeRunDependency("wasm-instantiate") }) })428 }429 }430 if (!ENVIRONMENT_IS_PTHREAD) { addRunDependency("wasm-instantiate") }431 432 function receiveInstantiationResult(result) { receiveInstance(result["instance"], result["module"]) }433 434 function instantiateArrayBuffer(receiver) {435 return getBinaryPromise().then(function(binary) { return WebAssembly.instantiate(binary, info) }).then(function(instance) { return instance }).then(receiver, function(reason) {436 err("failed to asynchronously prepare wasm: " + reason);437 abort(reason)438 })439 }440 441 function instantiateAsync() {442 if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && typeof fetch == "function") {443 return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {444 var result = WebAssembly.instantiateStreaming(response, info);445 return result.then(receiveInstantiationResult, function(reason) {446 err("wasm streaming compile failed: " + reason);447 err("falling back to ArrayBuffer instantiation");448 return instantiateArrayBuffer(receiveInstantiationResult)449 })450 })451 } else { return instantiateArrayBuffer(receiveInstantiationResult) }452 }453 if (Module["instantiateWasm"]) { try { var exports = Module["instantiateWasm"](info, receiveInstance); return exports } catch (e) { err("Module.instantiateWasm callback failed with error: " + e); return false } }454 instantiateAsync().catch(readyPromiseReject);455 return {}456 }457 var tempDouble;458 var tempI64;459 var ASM_CONSTS = {};460 461 function callRuntimeCallbacks(callbacks) { while (callbacks.length > 0) { var callback = callbacks.shift(); if (typeof callback == "function") { callback(Module); continue } var func = callback.func; if (typeof func == "number") { if (callback.arg === undefined) { getWasmTableEntry(func)() } else { getWasmTableEntry(func)(callback.arg) } } else { func(callback.arg === undefined ? null : callback.arg) } } }462 463 function withStackSave(f) {464 var stack = stackSave();465 var ret = f();466 stackRestore(stack);467 return ret468 }469 470 function killThread(pthread_ptr) {471 GROWABLE_HEAP_I32()[pthread_ptr >> 2] = 0;472 var pthread = PThread.pthreads[pthread_ptr];473 delete PThread.pthreads[pthread_ptr];474 pthread.worker.terminate();475 __emscripten_thread_free_data(pthread_ptr);476 PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker), 1);477 pthread.worker.pthread = undefined478 }479 480 function cancelThread(pthread_ptr) {481 var pthread = PThread.pthreads[pthread_ptr];482 pthread.worker.postMessage({ "cmd": "cancel" })483 }484 485 function cleanupThread(pthread_ptr) {486 var pthread = PThread.pthreads[pthread_ptr];487 if (pthread) {488 GROWABLE_HEAP_I32()[pthread_ptr >> 2] = 0;489 var worker = pthread.worker;490 PThread.returnWorkerToPool(worker)491 }492 }493 494 function zeroMemory(address, size) { GROWABLE_HEAP_U8().fill(0, address, address + size) }495 496 function _exit(status) { exit(status) }497 498 function handleException(e) {499 if (e instanceof ExitStatus || e == "unwind") { return EXITSTATUS }500 quit_(1, e)501 }502 var PThread = {503 unusedWorkers: [],504 runningWorkers: [],505 tlsInitFunctions: [],506 init: function() { if (ENVIRONMENT_IS_PTHREAD) { PThread.initWorker() } else { PThread.initMainThread() } },507 initMainThread: function() { var pthreadPoolSize = 8; for (var i = 0; i < pthreadPoolSize; ++i) { PThread.allocateUnusedWorker() } },508 initWorker: function() { noExitRuntime = false },509 pthreads: {},510 setExitStatus: function(status) { EXITSTATUS = status },511 terminateAllThreads: function() {512 for (var t in PThread.pthreads) { var pthread = PThread.pthreads[t]; if (pthread && pthread.worker) { PThread.returnWorkerToPool(pthread.worker) } }513 for (var i = 0; i < PThread.unusedWorkers.length; ++i) {514 var worker = PThread.unusedWorkers[i];515 worker.terminate()516 }517 PThread.unusedWorkers = []518 },519 returnWorkerToPool: function(worker) {520 PThread.runWithoutMainThreadQueuedCalls(function() {521 delete PThread.pthreads[worker.pthread.threadInfoStruct];522 PThread.unusedWorkers.push(worker);523 PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);524 __emscripten_thread_free_data(worker.pthread.threadInfoStruct);525 worker.pthread = undefined526 })527 },528 runWithoutMainThreadQueuedCalls: function(func) { GROWABLE_HEAP_I32()[__emscripten_allow_main_runtime_queued_calls >> 2] = 0; try { func() } finally { GROWABLE_HEAP_I32()[__emscripten_allow_main_runtime_queued_calls >> 2] = 1 } },529 receiveObjectTransfer: function(data) {},530 threadInit: function() { for (var i in PThread.tlsInitFunctions) { if (PThread.tlsInitFunctions.hasOwnProperty(i)) PThread.tlsInitFunctions[i]() } },531 loadWasmModuleToWorker: function(worker, onFinishedLoading) {532 worker.onmessage = (e => {533 var d = e["data"];534 var cmd = d["cmd"];535 if (worker.pthread) PThread.currentProxiedOperationCallerThread = worker.pthread.threadInfoStruct;536 if (d["targetThread"] && d["targetThread"] != _pthread_self()) {537 var thread = PThread.pthreads[d.targetThread];538 if (thread) { thread.worker.postMessage(d, d["transferList"]) } else { err('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d["targetThread"] + ", but that thread no longer exists!") }539 PThread.currentProxiedOperationCallerThread = undefined;540 return541 }542 if (cmd === "processQueuedMainThreadWork") { _emscripten_main_thread_process_queued_calls() } else if (cmd === "spawnThread") { spawnThread(d) } else if (cmd === "cleanupThread") { cleanupThread(d["thread"]) } else if (cmd === "killThread") { killThread(d["thread"]) } else if (cmd === "cancelThread") { cancelThread(d["thread"]) } else if (cmd === "loaded") {543 worker.loaded = true;544 if (onFinishedLoading) onFinishedLoading(worker);545 if (worker.runPthread) {546 worker.runPthread();547 delete worker.runPthread548 }549 } else if (cmd === "print") { out("Thread " + d["threadId"] + ": " + d["text"]) } else if (cmd === "printErr") { err("Thread " + d["threadId"] + ": " + d["text"]) } else if (cmd === "alert") { alert("Thread " + d["threadId"] + ": " + d["text"]) } else if (d.target === "setimmediate") { worker.postMessage(d) } else if (cmd === "onAbort") { if (Module["onAbort"]) { Module["onAbort"](d["arg"]) } } else { err("worker sent an unknown command " + cmd) }550 PThread.currentProxiedOperationCallerThread = undefined551 });552 worker.onerror = (e => {553 var message = "worker sent an error!";554 err(message + " " + e.filename + ":" + e.lineno + ": " + e.message);555 throw e556 });557 worker.postMessage({ "cmd": "load", "urlOrBlob": Module["mainScriptUrlOrBlob"] || _scriptDir, "wasmMemory": wasmMemory, "wasmModule": wasmModule })558 },559 allocateUnusedWorker: function() {560 var pthreadMainJs = locateFile("godot.javascript.opt.tools.threads.worker.js");561 PThread.unusedWorkers.push(new Worker(pthreadMainJs))562 },563 getNewWorker: function() {564 if (PThread.unusedWorkers.length == 0) {565 PThread.allocateUnusedWorker();566 PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0])567 }568 return PThread.unusedWorkers.pop()569 }570 };571 572 function establishStackSpace() {573 var pthread_ptr = _pthread_self();574 var stackTop = GROWABLE_HEAP_I32()[pthread_ptr + 44 >> 2];575 var stackSize = GROWABLE_HEAP_I32()[pthread_ptr + 48 >> 2];576 var stackMax = stackTop - stackSize;577 _emscripten_stack_set_limits(stackTop, stackMax);578 stackRestore(stackTop)579 }580 Module["establishStackSpace"] = establishStackSpace;581 582 function exitOnMainThread(returnCode) { if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(1, 0, returnCode); try { _exit(returnCode) } catch (e) { handleException(e) } }583 584 function getWasmTableEntry(funcPtr) { return wasmTable.get(funcPtr) }585 586 function invokeEntryPoint(ptr, arg) { return getWasmTableEntry(ptr)(arg) }587 Module["invokeEntryPoint"] = invokeEntryPoint;588 589 function registerTlsInit(tlsInitFunc) { PThread.tlsInitFunctions.push(tlsInitFunc) }590 591 function ___assert_fail(condition, filename, line, func) { abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]) }592 593 function ___call_sighandler(fp, sig) { getWasmTableEntry(fp)(sig) }594 var _emscripten_get_now;595 if (ENVIRONMENT_IS_PTHREAD) { _emscripten_get_now = (() => performance.now() - Module["__performance_now_clock_drift"]) } else _emscripten_get_now = (() => performance.now());596 var _emscripten_get_now_is_monotonic = true;597 598 function setErrNo(value) { GROWABLE_HEAP_I32()[___errno_location() >> 2] = value; return value }599 600 function _clock_gettime(clk_id, tp) {601 var now;602 if (clk_id === 0) { now = Date.now() } else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) { now = _emscripten_get_now() } else { setErrNo(28); return -1 }603 GROWABLE_HEAP_I32()[tp >> 2] = now / 1e3 | 0;604 GROWABLE_HEAP_I32()[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0;605 return 0606 }607 608 function ___cxa_allocate_exception(size) { return _malloc(size + 16) + 16 }609 610 function ExceptionInfo(excPtr) {611 this.excPtr = excPtr;612 this.ptr = excPtr - 16;613 this.set_type = function(type) { GROWABLE_HEAP_I32()[this.ptr + 4 >> 2] = type };614 this.get_type = function() { return GROWABLE_HEAP_I32()[this.ptr + 4 >> 2] };615 this.set_destructor = function(destructor) { GROWABLE_HEAP_I32()[this.ptr + 8 >> 2] = destructor };616 this.get_destructor = function() { return GROWABLE_HEAP_I32()[this.ptr + 8 >> 2] };617 this.set_refcount = function(refcount) { GROWABLE_HEAP_I32()[this.ptr >> 2] = refcount };618 this.set_caught = function(caught) {619 caught = caught ? 1 : 0;620 GROWABLE_HEAP_I8()[this.ptr + 12 >> 0] = caught621 };622 this.get_caught = function() { return GROWABLE_HEAP_I8()[this.ptr + 12 >> 0] != 0 };623 this.set_rethrown = function(rethrown) {624 rethrown = rethrown ? 1 : 0;625 GROWABLE_HEAP_I8()[this.ptr + 13 >> 0] = rethrown626 };627 this.get_rethrown = function() { return GROWABLE_HEAP_I8()[this.ptr + 13 >> 0] != 0 };628 this.init = function(type, destructor) {629 this.set_type(type);630 this.set_destructor(destructor);631 this.set_refcount(0);632 this.set_caught(false);633 this.set_rethrown(false)634 };635 this.add_ref = function() { Atomics.add(GROWABLE_HEAP_I32(), this.ptr + 0 >> 2, 1) };636 this.release_ref = function() { var prev = Atomics.sub(GROWABLE_HEAP_I32(), this.ptr + 0 >> 2, 1); return prev === 1 }637 }638 var exceptionLast = 0;639 var uncaughtExceptionCount = 0;640 641 function ___cxa_throw(ptr, type, destructor) {642 var info = new ExceptionInfo(ptr);643 info.init(type, destructor);644 exceptionLast = ptr;645 uncaughtExceptionCount++;646 throw ptr647 }648 649 function ___emscripten_init_main_thread_js(tb) {650 __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, !ENVIRONMENT_IS_WEB);651 PThread.threadInit()652 }653 654 function ___emscripten_thread_cleanup(thread) {655 if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread);656 else postMessage({ "cmd": "cleanupThread", "thread": thread })657 }658 659 function spawnThread(threadParams) {660 var worker = PThread.getNewWorker();661 if (!worker) { return 6 }662 PThread.runningWorkers.push(worker);663 var pthread = PThread.pthreads[threadParams.pthread_ptr] = { worker: worker, threadInfoStruct: threadParams.pthread_ptr };664 worker.pthread = pthread;665 var msg = { "cmd": "run", "start_routine": threadParams.startRoutine, "arg": threadParams.arg, "threadInfoStruct": threadParams.pthread_ptr };666 worker.runPthread = (() => {667 msg.time = performance.now();668 worker.postMessage(msg, threadParams.transferList)669 });670 if (worker.loaded) {671 worker.runPthread();672 delete worker.runPthread673 }674 return 0675 }676 677 function ___pthread_create_js(pthread_ptr, attr, start_routine, arg) {678 if (typeof SharedArrayBuffer == "undefined") { err("Current environment does not support SharedArrayBuffer, pthreads are not available!"); return 6 }679 var transferList = [];680 var error = 0;681 if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) { return _emscripten_sync_run_in_main_thread_4(687865856, pthread_ptr, attr, start_routine, arg) }682 if (error) return error;683 var threadParams = { startRoutine: start_routine, pthread_ptr: pthread_ptr, arg: arg, transferList: transferList };684 if (ENVIRONMENT_IS_PTHREAD) {685 threadParams.cmd = "spawnThread";686 postMessage(threadParams, transferList);687 return 0688 }689 return spawnThread(threadParams)690 }691 var PATH = {692 splitPath: function(filename) { var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; return splitPathRe.exec(filename).slice(1) },693 normalizeArray: function(parts, allowAboveRoot) {694 var up = 0;695 for (var i = parts.length - 1; i >= 0; i--) {696 var last = parts[i];697 if (last === ".") { parts.splice(i, 1) } else if (last === "..") {698 parts.splice(i, 1);699 up++700 } else if (up) {701 parts.splice(i, 1);702 up--703 }704 }705 if (allowAboveRoot) { for (; up; up--) { parts.unshift("..") } }706 return parts707 },708 normalize: function(path) {709 var isAbsolute = path.charAt(0) === "/",710 trailingSlash = path.substr(-1) === "/";711 path = PATH.normalizeArray(path.split("/").filter(function(p) { return !!p }), !isAbsolute).join("/");712 if (!path && !isAbsolute) { path = "." }713 if (path && trailingSlash) { path += "/" }714 return (isAbsolute ? "/" : "") + path715 },716 dirname: function(path) {717 var result = PATH.splitPath(path),718 root = result[0],719 dir = result[1];720 if (!root && !dir) { return "." }721 if (dir) { dir = dir.substr(0, dir.length - 1) }722 return root + dir723 },724 basename: function(path) {725 if (path === "/") return "/";726 path = PATH.normalize(path);727 path = path.replace(/\/$/, "");728 var lastSlash = path.lastIndexOf("/");729 if (lastSlash === -1) return path;730 return path.substr(lastSlash + 1)731 },732 extname: function(path) { return PATH.splitPath(path)[3] },733 join: function() { var paths = Array.prototype.slice.call(arguments, 0); return PATH.normalize(paths.join("/")) },734 join2: function(l, r) { return PATH.normalize(l + "/" + r) }735 };736 737 function getRandomDevice() { if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") { var randomBuffer = new Uint8Array(1); return function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0] } } else return function() { abort("randomDevice") } }738 var PATH_FS = {739 resolve: function() {740 var resolvedPath = "",741 resolvedAbsolute = false;742 for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {743 var path = i >= 0 ? arguments[i] : FS.cwd();744 if (typeof path != "string") { throw new TypeError("Arguments to path.resolve must be strings") } else if (!path) { return "" }745 resolvedPath = path + "/" + resolvedPath;746 resolvedAbsolute = path.charAt(0) === "/"747 }748 resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function(p) { return !!p }), !resolvedAbsolute).join("/");749 return (resolvedAbsolute ? "/" : "") + resolvedPath || "."750 },751 relative: function(from, to) {752 from = PATH_FS.resolve(from).substr(1);753 to = PATH_FS.resolve(to).substr(1);754 755 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) }756 var fromParts = trim(from.split("/"));757 var toParts = trim(to.split("/"));758 var length = Math.min(fromParts.length, toParts.length);759 var samePartsLength = length;760 for (var i = 0; i < length; i++) { if (fromParts[i] !== toParts[i]) { samePartsLength = i; break } }761 var outputParts = [];762 for (var i = samePartsLength; i < fromParts.length; i++) { outputParts.push("..") }763 outputParts = outputParts.concat(toParts.slice(samePartsLength));764 return outputParts.join("/")765 }766 };767 var TTY = {768 ttys: [],769 init: function() {},770 shutdown: function() {},771 register: function(dev, ops) {772 TTY.ttys[dev] = { input: [], output: [], ops: ops };773 FS.registerDevice(dev, TTY.stream_ops)774 },775 stream_ops: {776 open: function(stream) {777 var tty = TTY.ttys[stream.node.rdev];778 if (!tty) { throw new FS.ErrnoError(43) }779 stream.tty = tty;780 stream.seekable = false781 },782 close: function(stream) { stream.tty.ops.flush(stream.tty) },783 flush: function(stream) { stream.tty.ops.flush(stream.tty) },784 read: function(stream, buffer, offset, length, pos) {785 if (!stream.tty || !stream.tty.ops.get_char) { throw new FS.ErrnoError(60) }786 var bytesRead = 0;787 for (var i = 0; i < length; i++) {788 var result;789 try { result = stream.tty.ops.get_char(stream.tty) } catch (e) { throw new FS.ErrnoError(29) }790 if (result === undefined && bytesRead === 0) { throw new FS.ErrnoError(6) }791 if (result === null || result === undefined) break;792 bytesRead++;793 buffer[offset + i] = result794 }795 if (bytesRead) { stream.node.timestamp = Date.now() }796 return bytesRead797 },798 write: function(stream, buffer, offset, length, pos) { if (!stream.tty || !stream.tty.ops.put_char) { throw new FS.ErrnoError(60) } try { for (var i = 0; i < length; i++) { stream.tty.ops.put_char(stream.tty, buffer[offset + i]) } } catch (e) { throw new FS.ErrnoError(29) } if (length) { stream.node.timestamp = Date.now() } return i }799 },800 default_tty_ops: {801 get_char: function(tty) {802 if (!tty.input.length) {803 var result = null;804 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" } }805 if (!result) { return null }806 tty.input = intArrayFromString(result, true)807 }808 return tty.input.shift()809 },810 put_char: function(tty, val) {811 if (val === null || val === 10) {812 out(UTF8ArrayToString(tty.output, 0));813 tty.output = []814 } else { if (val != 0) tty.output.push(val) }815 },816 flush: function(tty) {817 if (tty.output && tty.output.length > 0) {818 out(UTF8ArrayToString(tty.output, 0));819 tty.output = []820 }821 }822 },823 default_tty1_ops: {824 put_char: function(tty, val) {825 if (val === null || val === 10) {826 err(UTF8ArrayToString(tty.output, 0));827 tty.output = []828 } else { if (val != 0) tty.output.push(val) }829 },830 flush: function(tty) {831 if (tty.output && tty.output.length > 0) {832 err(UTF8ArrayToString(tty.output, 0));833 tty.output = []834 }835 }836 }837 };838 839 function alignMemory(size, alignment) { return Math.ceil(size / alignment) * alignment }840 841 function mmapAlloc(size) {842 size = alignMemory(size, 65536);843 var ptr = _emscripten_builtin_memalign(65536, size);844 if (!ptr) return 0;845 zeroMemory(ptr, size);846 return ptr847 }848 var MEMFS = {849 ops_table: null,850 mount: function(mount) { return MEMFS.createNode(null, "/", 16384 | 511, 0) },851 createNode: function(parent, name, mode, dev) {852 if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { throw new FS.ErrnoError(63) }853 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 } } }854 var node = FS.createNode(parent, name, mode, dev);855 if (FS.isDir(node.mode)) {856 node.node_ops = MEMFS.ops_table.dir.node;857 node.stream_ops = MEMFS.ops_table.dir.stream;858 node.contents = {}859 } else if (FS.isFile(node.mode)) {860 node.node_ops = MEMFS.ops_table.file.node;861 node.stream_ops = MEMFS.ops_table.file.stream;862 node.usedBytes = 0;863 node.contents = null864 } else if (FS.isLink(node.mode)) {865 node.node_ops = MEMFS.ops_table.link.node;866 node.stream_ops = MEMFS.ops_table.link.stream867 } else if (FS.isChrdev(node.mode)) {868 node.node_ops = MEMFS.ops_table.chrdev.node;869 node.stream_ops = MEMFS.ops_table.chrdev.stream870 }871 node.timestamp = Date.now();872 if (parent) {873 parent.contents[name] = node;874 parent.timestamp = node.timestamp875 }876 return node877 },878 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) },879 expandFileStorage: function(node, newCapacity) {880 var prevCapacity = node.contents ? node.contents.length : 0;881 if (prevCapacity >= newCapacity) return;882 var CAPACITY_DOUBLING_MAX = 1024 * 1024;883 newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);884 if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);885 var oldContents = node.contents;886 node.contents = new Uint8Array(newCapacity);887 if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0)888 },889 resizeFileStorage: function(node, newSize) {890 if (node.usedBytes == newSize) return;891 if (newSize == 0) {892 node.contents = null;893 node.usedBytes = 0894 } else {895 var oldContents = node.contents;896 node.contents = new Uint8Array(newSize);897 if (oldContents) { node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))) }898 node.usedBytes = newSize899 }900 },901 node_ops: {902 getattr: function(node) {903 var attr = {};904 attr.dev = FS.isChrdev(node.mode) ? node.id : 1;905 attr.ino = node.id;906 attr.mode = node.mode;907 attr.nlink = 1;908 attr.uid = 0;909 attr.gid = 0;910 attr.rdev = node.rdev;911 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 }912 attr.atime = new Date(node.timestamp);913 attr.mtime = new Date(node.timestamp);914 attr.ctime = new Date(node.timestamp);915 attr.blksize = 4096;916 attr.blocks = Math.ceil(attr.size / attr.blksize);917 return attr918 },919 setattr: function(node, attr) { if (attr.mode !== undefined) { node.mode = attr.mode } if (attr.timestamp !== undefined) { node.timestamp = attr.timestamp } if (attr.size !== undefined) { MEMFS.resizeFileStorage(node, attr.size) } },920 lookup: function(parent, name) { throw FS.genericErrors[44] },921 mknod: function(parent, name, mode, dev) { return MEMFS.createNode(parent, name, mode, dev) },922 rename: function(old_node, new_dir, new_name) {923 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) } } }924 delete old_node.parent.contents[old_node.name];925 old_node.parent.timestamp = Date.now();926 old_node.name = new_name;927 new_dir.contents[new_name] = old_node;928 new_dir.timestamp = old_node.parent.timestamp;929 old_node.parent = new_dir930 },931 unlink: function(parent, name) {932 delete parent.contents[name];933 parent.timestamp = Date.now()934 },935 rmdir: function(parent, name) {936 var node = FS.lookupNode(parent, name);937 for (var i in node.contents) { throw new FS.ErrnoError(55) }938 delete parent.contents[name];939 parent.timestamp = Date.now()940 },941 readdir: function(node) {942 var entries = [".", ".."];943 for (var key in node.contents) {944 if (!node.contents.hasOwnProperty(key)) { continue }945 entries.push(key)946 }947 return entries948 },949 symlink: function(parent, newname, oldpath) {950 var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);951 node.link = oldpath;952 return node953 },954 readlink: function(node) { if (!FS.isLink(node.mode)) { throw new FS.ErrnoError(28) } return node.link }955 },956 stream_ops: {957 read: function(stream, buffer, offset, length, position) { var contents = stream.node.contents; if (position >= stream.node.usedBytes) return 0; var size = Math.min(stream.node.usedBytes - position, length); if (size > 8 && contents.subarray) { buffer.set(contents.subarray(position, position + size), offset) } else { for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i] } return size },958 write: function(stream, buffer, offset, length, position, canOwn) {959 if (buffer.buffer === GROWABLE_HEAP_I8().buffer) { canOwn = false }960 if (!length) return 0;961 var node = stream.node;962 node.timestamp = Date.now();963 if (buffer.subarray && (!node.contents || node.contents.subarray)) {964 if (canOwn) {965 node.contents = buffer.subarray(offset, offset + length);966 node.usedBytes = length;967 return length968 } else if (node.usedBytes === 0 && position === 0) {969 node.contents = buffer.slice(offset, offset + length);970 node.usedBytes = length;971 return length972 } else if (position + length <= node.usedBytes) { node.contents.set(buffer.subarray(offset, offset + length), position); return length }973 }974 MEMFS.expandFileStorage(node, position + length);975 if (node.contents.subarray && buffer.subarray) { node.contents.set(buffer.subarray(offset, offset + length), position) } else { for (var i = 0; i < length; i++) { node.contents[position + i] = buffer[offset + i] } }976 node.usedBytes = Math.max(node.usedBytes, position + length);977 return length978 },979 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 },980 allocate: function(stream, offset, length) {981 MEMFS.expandFileStorage(stream.node, offset + length);982 stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length)983 },984 mmap: function(stream, address, length, position, prot, flags) {985 if (address !== 0) { throw new FS.ErrnoError(28) }986 if (!FS.isFile(stream.node.mode)) { throw new FS.ErrnoError(43) }987 var ptr;988 var allocated;989 var contents = stream.node.contents;990 if (!(flags & 2) && contents.buffer === buffer) {991 allocated = false;992 ptr = contents.byteOffset993 } else {994 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) } }995 allocated = true;996 ptr = mmapAlloc(length);997 if (!ptr) { throw new FS.ErrnoError(48) }998 GROWABLE_HEAP_I8().set(contents, ptr)999 }1000 return { ptr: ptr, allocated: allocated }1001 },1002 msync: function(stream, buffer, 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, buffer, 0, length, offset, false); return 0 }1003 }1004 };1005 1006 function asyncLoad(url, onload, onerror, noRunDep) {1007 var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";1008 readAsync(url, function(arrayBuffer) {1009 assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');1010 onload(new Uint8Array(arrayBuffer));1011 if (dep) removeRunDependency(dep)1012 }, function(event) { if (onerror) { onerror() } else { throw 'Loading data file "' + url + '" failed.' } });1013 if (dep) addRunDependency(dep)1014 }1015 var IDBFS = {1016 dbs: {},1017 indexedDB: () => {1018 if (typeof indexedDB != "undefined") return indexedDB;1019 var ret = null;1020 if (typeof window == "object") ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;1021 assert(ret, "IDBFS used, but indexedDB not supported");1022 return ret1023 },1024 DB_VERSION: 21,1025 DB_STORE_NAME: "FILE_DATA",1026 mount: function(mount) { return MEMFS.mount.apply(null, arguments) },1027 syncfs: (mount, populate, callback) => {1028 IDBFS.getLocalSet(mount, (err, local) => {1029 if (err) return callback(err);1030 IDBFS.getRemoteSet(mount, (err, remote) => {1031 if (err) return callback(err);1032 var src = populate ? remote : local;1033 var dst = populate ? local : remote;1034 IDBFS.reconcile(src, dst, callback)1035 })1036 })1037 },1038 getDB: (name, callback) => {1039 var db = IDBFS.dbs[name];1040 if (db) { return callback(null, db) }1041 var req;1042 try { req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION) } catch (e) { return callback(e) }1043 if (!req) { return callback("Unable to connect to IndexedDB") }1044 req.onupgradeneeded = (e => { var db = e.target.result; var transaction = e.target.transaction; var fileStore; if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) { fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME) } else { fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME) } if (!fileStore.indexNames.contains("timestamp")) { fileStore.createIndex("timestamp", "timestamp", { unique: false }) } });1045 req.onsuccess = (() => {1046 db = req.result;1047 IDBFS.dbs[name] = db;1048 callback(null, db)1049 });1050 req.onerror = (e => {1051 callback(this.error);1052 e.preventDefault()1053 })1054 },1055 getLocalSet: (mount, callback) => {1056 var entries = {};1057 1058 function isRealDir(p) { return p !== "." && p !== ".." }1059 1060 function toAbsolute(root) { return p => { return PATH.join2(root, p) } }1061 var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));1062 while (check.length) {1063 var path = check.pop();1064 var stat;1065 try { stat = FS.stat(path) } catch (e) { return callback(e) }1066 if (FS.isDir(stat.mode)) { check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path))) }1067 entries[path] = { "timestamp": stat.mtime }1068 }1069 return callback(null, { type: "local", entries: entries })1070 },1071 getRemoteSet: (mount, callback) => {1072 var entries = {};1073 IDBFS.getDB(mount.mountpoint, (err, db) => {1074 if (err) return callback(err);1075 try {1076 var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readonly");1077 transaction.onerror = (e => {1078 callback(this.error);1079 e.preventDefault()1080 });1081 var store = transaction.objectStore(IDBFS.DB_STORE_NAME);1082 var index = store.index("timestamp");1083 index.openKeyCursor().onsuccess = (event => {1084 var cursor = event.target.result;1085 if (!cursor) { return callback(null, { type: "remote", db: db, entries: entries }) }1086 entries[cursor.primaryKey] = { "timestamp": cursor.key };1087 cursor.continue()1088 })1089 } catch (e) { return callback(e) }1090 })1091 },1092 loadLocalEntry: (path, callback) => {1093 var stat, node;1094 try {1095 var lookup = FS.lookupPath(path);1096 node = lookup.node;1097 stat = FS.stat(path)1098 } catch (e) { return callback(e) }1099 if (FS.isDir(stat.mode)) { return callback(null, { "timestamp": stat.mtime, "mode": stat.mode }) } else if (FS.isFile(stat.mode)) { node.contents = MEMFS.getFileDataAsTypedArray(node); return callback(null, { "timestamp": stat.mtime, "mode": stat.mode, "contents": node.contents }) } else { return callback(new Error("node type not supported")) }1100 },1101 storeLocalEntry: (path, entry, callback) => {1102 try {1103 if (FS.isDir(entry["mode"])) { FS.mkdirTree(path, entry["mode"]) } else if (FS.isFile(entry["mode"])) { FS.writeFile(path, entry["contents"], { canOwn: true }) } else { return callback(new Error("node type not supported")) }1104 FS.chmod(path, entry["mode"]);1105 FS.utime(path, entry["timestamp"], entry["timestamp"])1106 } catch (e) { return callback(e) }1107 callback(null)1108 },1109 removeLocalEntry: (path, callback) => {1110 try { var lookup = FS.lookupPath(path); var stat = FS.stat(path); if (FS.isDir(stat.mode)) { FS.rmdir(path) } else if (FS.isFile(stat.mode)) { FS.unlink(path) } } catch (e) { return callback(e) }1111 callback(null)1112 },1113 loadRemoteEntry: (store, path, callback) => {1114 var req = store.get(path);1115 req.onsuccess = (event => { callback(null, event.target.result) });1116 req.onerror = (e => {1117 callback(this.error);1118 e.preventDefault()1119 })1120 },1121 storeRemoteEntry: (store, path, entry, callback) => {1122 try { var req = store.put(entry, path) } catch (e) { callback(e); return }1123 req.onsuccess = (() => { callback(null) });1124 req.onerror = (e => {1125 callback(this.error);1126 e.preventDefault()1127 })1128 },1129 removeRemoteEntry: (store, path, callback) => {1130 var req = store.delete(path);1131 req.onsuccess = (() => { callback(null) });1132 req.onerror = (e => {1133 callback(this.error);1134 e.preventDefault()1135 })1136 },1137 reconcile: (src, dst, callback) => {1138 var total = 0;1139 var create = [];1140 Object.keys(src.entries).forEach(function(key) {1141 var e = src.entries[key];1142 var e2 = dst.entries[key];1143 if (!e2 || e["timestamp"].getTime() != e2["timestamp"].getTime()) {1144 create.push(key);1145 total++1146 }1147 });1148 var remove = [];1149 Object.keys(dst.entries).forEach(function(key) {1150 if (!src.entries[key]) {1151 remove.push(key);1152 total++1153 }1154 });1155 if (!total) { return callback(null) }1156 var errored = false;1157 var db = src.type === "remote" ? src.db : dst.db;1158 var transaction = db.transaction([IDBFS.DB_STORE_NAME], "readwrite");1159 var store = transaction.objectStore(IDBFS.DB_STORE_NAME);1160 1161 function done(err) { if (err && !errored) { errored = true; return callback(err) } }1162 transaction.onerror = (e => {1163 done(this.error);1164 e.preventDefault()1165 });1166 transaction.oncomplete = (e => { if (!errored) { callback(null) } });1167 create.sort().forEach(path => {1168 if (dst.type === "local") {1169 IDBFS.loadRemoteEntry(store, path, (err, entry) => {1170 if (err) return done(err);1171 IDBFS.storeLocalEntry(path, entry, done)1172 })1173 } else {1174 IDBFS.loadLocalEntry(path, (err, entry) => {1175 if (err) return done(err);1176 IDBFS.storeRemoteEntry(store, path, entry, done)1177 })1178 }1179 });1180 remove.sort().reverse().forEach(path => { if (dst.type === "local") { IDBFS.removeLocalEntry(path, done) } else { IDBFS.removeRemoteEntry(store, path, done) } })1181 }1182 };1183 var FS = {1184 root: null,1185 mounts: [],1186 devices: {},1187 streams: [],1188 nextInode: 1,1189 nameTable: null,1190 currentPath: "/",1191 initialized: false,1192 ignorePermissions: true,1193 ErrnoError: null,1194 genericErrors: {},1195 filesystems: null,1196 syncFSRequests: 0,1197 lookupPath: (path, opts = {}) => {1198 path = PATH_FS.resolve(FS.cwd(), path);1199 if (!path) return { path: "", node: null };1200 var defaults = { follow_mount: true, recurse_count: 0 };