From e243b4e79075f02219e0eb8d3c9200e3a734f1bc Mon Sep 17 00:00:00 2001 From: "github-ci[bot]" Date: Sun, 7 Jan 2024 23:43:52 +0000 Subject: [PATCH] UPDATE GITHUB PAGES a5a9bd8c8763eac943f37f2fe06f766a1ee351be --- .nojekyll | 0 coi-serviceworker.js | 146 + index.apple-touch-icon.png | Bin 0 -> 12184 bytes index.audio.worklet.js | 213 + index.html | 249 + index.icon.png | Bin 0 -> 5584 bytes index.js | 14477 +++++++++++++++++++++++++++++++++++ index.pck | Bin 0 -> 6352 bytes index.png | Bin 0 -> 21443 bytes index.wasm | Bin 0 -> 35649444 bytes index.worker.js | 161 + 11 files changed, 15246 insertions(+) create mode 100644 .nojekyll create mode 100644 coi-serviceworker.js create mode 100644 index.apple-touch-icon.png create mode 100644 index.audio.worklet.js create mode 100644 index.html create mode 100644 index.icon.png create mode 100644 index.js create mode 100644 index.pck create mode 100644 index.png create mode 100644 index.wasm create mode 100644 index.worker.js diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000..e69de29 diff --git a/coi-serviceworker.js b/coi-serviceworker.js new file mode 100644 index 0000000..9901474 --- /dev/null +++ b/coi-serviceworker.js @@ -0,0 +1,146 @@ +/*! coi-serviceworker v0.1.7 - Guido Zuidhof and contributors, licensed under MIT */ +let coepCredentialless = false; +if (typeof window === 'undefined') { + self.addEventListener("install", () => self.skipWaiting()); + self.addEventListener("activate", (event) => event.waitUntil(self.clients.claim())); + + self.addEventListener("message", (ev) => { + if (!ev.data) { + return; + } else if (ev.data.type === "deregister") { + self.registration + .unregister() + .then(() => { + return self.clients.matchAll(); + }) + .then(clients => { + clients.forEach((client) => client.navigate(client.url)); + }); + } else if (ev.data.type === "coepCredentialless") { + coepCredentialless = ev.data.value; + } + }); + + self.addEventListener("fetch", function (event) { + const r = event.request; + if (r.cache === "only-if-cached" && r.mode !== "same-origin") { + return; + } + + const request = (coepCredentialless && r.mode === "no-cors") + ? new Request(r, { + credentials: "omit", + }) + : r; + event.respondWith( + fetch(request) + .then((response) => { + if (response.status === 0) { + return response; + } + + const newHeaders = new Headers(response.headers); + newHeaders.set("Cross-Origin-Embedder-Policy", + coepCredentialless ? "credentialless" : "require-corp" + ); + if (!coepCredentialless) { + newHeaders.set("Cross-Origin-Resource-Policy", "cross-origin"); + } + newHeaders.set("Cross-Origin-Opener-Policy", "same-origin"); + + return new Response(response.body, { + status: response.status, + statusText: response.statusText, + headers: newHeaders, + }); + }) + .catch((e) => console.error(e)) + ); + }); + +} else { + (() => { + const reloadedBySelf = window.sessionStorage.getItem("coiReloadedBySelf"); + window.sessionStorage.removeItem("coiReloadedBySelf"); + const coepDegrading = (reloadedBySelf == "coepdegrade"); + + // You can customize the behavior of this script through a global `coi` variable. + const coi = { + shouldRegister: () => !reloadedBySelf, + shouldDeregister: () => false, + coepCredentialless: () => true, + coepDegrade: () => true, + doReload: () => window.location.reload(), + quiet: false, + ...window.coi + }; + + const n = navigator; + const controlling = n.serviceWorker && n.serviceWorker.controller; + + // Record the failure if the page is served by serviceWorker. + if (controlling && !window.crossOriginIsolated) { + window.sessionStorage.setItem("coiCoepHasFailed", "true"); + } + const coepHasFailed = window.sessionStorage.getItem("coiCoepHasFailed"); + + if (controlling) { + // Reload only on the first failure. + const reloadToDegrade = coi.coepDegrade() && !( + coepDegrading || window.crossOriginIsolated + ); + n.serviceWorker.controller.postMessage({ + type: "coepCredentialless", + value: (reloadToDegrade || coepHasFailed && coi.coepDegrade()) + ? false + : coi.coepCredentialless(), + }); + if (reloadToDegrade) { + !coi.quiet && console.log("Reloading page to degrade COEP."); + window.sessionStorage.setItem("coiReloadedBySelf", "coepdegrade"); + coi.doReload("coepdegrade"); + } + + if (coi.shouldDeregister()) { + n.serviceWorker.controller.postMessage({ type: "deregister" }); + } + } + + // If we're already coi: do nothing. Perhaps it's due to this script doing its job, or COOP/COEP are + // already set from the origin server. Also if the browser has no notion of crossOriginIsolated, just give up here. + if (window.crossOriginIsolated !== false || !coi.shouldRegister()) return; + + if (!window.isSecureContext) { + !coi.quiet && console.log("COOP/COEP Service Worker not registered, a secure context is required."); + return; + } + + // In some environments (e.g. Firefox private mode) this won't be available + if (!n.serviceWorker) { + !coi.quiet && console.error("COOP/COEP Service Worker not registered, perhaps due to private mode."); + return; + } + + n.serviceWorker.register(window.document.currentScript.src).then( + (registration) => { + !coi.quiet && console.log("COOP/COEP Service Worker registered", registration.scope); + + registration.addEventListener("updatefound", () => { + !coi.quiet && console.log("Reloading page to make use of updated COOP/COEP Service Worker."); + window.sessionStorage.setItem("coiReloadedBySelf", "updatefound"); + coi.doReload(); + }); + + // If the registration is active, but it's not controlling the page + if (registration.active && !n.serviceWorker.controller) { + !coi.quiet && console.log("Reloading page to make use of COOP/COEP Service Worker."); + window.sessionStorage.setItem("coiReloadedBySelf", "notcontrolling"); + coi.doReload(); + } + }, + (err) => { + !coi.quiet && console.error("COOP/COEP Service Worker failed to register:", err); + } + ); + })(); +} diff --git a/index.apple-touch-icon.png b/index.apple-touch-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..33ade34aa833f758f6afb847c050280573c3a7db GIT binary patch literal 12184 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

*>$>Bt7(>*o8z7SXUfjlotEL_$ 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 z size) { + const high = size - this.rpos; + output.set(this.buffer.subarray(this.rpos, size)); + from = high; + to_write -= high; + this.rpos = 0; + } + if (to_write) { + output.set(this.buffer.subarray(this.rpos, this.rpos + to_write), from); + } + this.rpos += to_write; + if (this.threads) { + Atomics.add(this.avail, 0, -output.length); + Atomics.notify(this.avail, 0); + } else { + this.avail -= output.length; + } + } + + write(p_buffer) { + const to_write = p_buffer.length; + const mw = this.buffer.length - this.wpos; + if (mw >= to_write) { + this.buffer.set(p_buffer, this.wpos); + this.wpos += to_write; + if (mw === to_write) { + this.wpos = 0; + } + } else { + const high = p_buffer.subarray(0, mw); + const low = p_buffer.subarray(mw); + this.buffer.set(high, this.wpos); + this.buffer.set(low); + this.wpos = low.length; + } + if (this.threads) { + Atomics.add(this.avail, 0, to_write); + Atomics.notify(this.avail, 0); + } else { + this.avail += to_write; + } + } +} + +class GodotProcessor extends AudioWorkletProcessor { + constructor() { + super(); + this.threads = false; + this.running = true; + this.lock = null; + this.notifier = null; + this.output = null; + this.output_buffer = new Float32Array(); + this.input = null; + this.input_buffer = new Float32Array(); + this.port.onmessage = (event) => { + const cmd = event.data['cmd']; + const data = event.data['data']; + this.parse_message(cmd, data); + }; + } + + process_notify() { + if (this.notifier) { + Atomics.add(this.notifier, 0, 1); + Atomics.notify(this.notifier, 0); + } + } + + parse_message(p_cmd, p_data) { + if (p_cmd === 'start' && p_data) { + const state = p_data[0]; + let idx = 0; + this.threads = true; + this.lock = state.subarray(idx, ++idx); + this.notifier = state.subarray(idx, ++idx); + const avail_in = state.subarray(idx, ++idx); + const avail_out = state.subarray(idx, ++idx); + this.input = new RingBuffer(p_data[1], avail_in, true); + this.output = new RingBuffer(p_data[2], avail_out, true); + } else if (p_cmd === 'stop') { + this.running = false; + this.output = null; + this.input = null; + this.lock = null; + this.notifier = null; + } else if (p_cmd === 'start_nothreads') { + this.output = new RingBuffer(p_data[0], p_data[0].length, false); + } else if (p_cmd === 'chunk') { + this.output.write(p_data); + } + } + + static array_has_data(arr) { + return arr.length && arr[0].length && arr[0][0].length; + } + + process(inputs, outputs, parameters) { + if (!this.running) { + return false; // Stop processing. + } + if (this.output === null) { + return true; // Not ready yet, keep processing. + } + const process_input = GodotProcessor.array_has_data(inputs); + if (process_input) { + const input = inputs[0]; + const chunk = input[0].length * input.length; + if (this.input_buffer.length !== chunk) { + this.input_buffer = new Float32Array(chunk); + } + if (!this.threads) { + GodotProcessor.write_input(this.input_buffer, input); + this.port.postMessage({ 'cmd': 'input', 'data': this.input_buffer }); + } else if (this.input.space_left() >= chunk) { + GodotProcessor.write_input(this.input_buffer, input); + this.input.write(this.input_buffer); + } else { + this.port.postMessage('Input buffer is full! Skipping input frame.'); + } + } + const process_output = GodotProcessor.array_has_data(outputs); + if (process_output) { + const output = outputs[0]; + const chunk = output[0].length * output.length; + if (this.output_buffer.length !== chunk) { + this.output_buffer = new Float32Array(chunk); + } + if (this.output.data_left() >= chunk) { + this.output.read(this.output_buffer); + GodotProcessor.write_output(output, this.output_buffer); + if (!this.threads) { + this.port.postMessage({ 'cmd': 'read', 'data': chunk }); + } + } else { + this.port.postMessage('Output buffer has not enough frames! Skipping output frame.'); + } + } + this.process_notify(); + return true; + } + + static write_output(dest, source) { + const channels = dest.length; + for (let ch = 0; ch < channels; ch++) { + for (let sample = 0; sample < dest[ch].length; sample++) { + dest[ch][sample] = source[sample * channels + ch]; + } + } + } + + static write_input(dest, source) { + const channels = source.length; + for (let ch = 0; ch < channels; ch++) { + for (let sample = 0; sample < source[ch].length; sample++) { + dest[sample * channels + ch] = source[ch][sample]; + } + } + } +} + +registerProcessor('godot-processor', GodotProcessor); diff --git a/index.html b/index.html new file mode 100644 index 0000000..f5205ff --- /dev/null +++ b/index.html @@ -0,0 +1,249 @@ + + + + + + + Godot Template + + + + + + + + HTML5 canvas appears to be unsupported in the current browser.
+ Please try updating or use a different browser. + +

+ + + +
+ + + + + + diff --git a/index.icon.png b/index.icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ec72f56a98b82df386ca34765335349c298c6fd9 GIT binary patch literal 5584 zcmV;>6))Px~ib+I4RCt{2oq24WXPw8t&wI`7V|*WpV>>=_v`Lz?M+!YCly;%JOSeU=#I~gf zR=cVMEmW|jY0*lRfC8)43W=jD*dDaNZYTnpZlJVV5+^Y^n|P8q@f|z1#~#o1-p~Fq zK4!+(9Pc}xvEPq08o$T$yua7acb@b2JP)CiB30Vj_BJY1{WO4m02-!0#VJQ%VFm#J zz0;qgJmFsT`8uwq8knRafQ@atKB-gsG-3&Fk^dZJ2zlYM@5I67Zd_6TZEd^S6^icz z^d3Xav&a$T5Kr)g&v&A0(K{9sKy&Nvhbi=z0NBkk&mt#?1k5Ad7mvTT(8YxWK$=>2 zJqOTd=3O8Jyx@S{?gS^;z_2U`7&DBvND&Ghx~4&uC5U1KiX6qlKWg&LD;G~Z3n1a* zJOMPd?s|Tq#JAaO3GefzWUg2PJuRS3g!5QM}& zJy};CW{}jsZ%@i9ELIOThdbezQhGCk*ofXNoM6kPO%^$X`yNS^$J$zp^o-J8R>;GHVCR~Sv_MVDM$gZ4mX7LTVQM03=-G5k?aTK*m^6J zci+hBS&l8Y0fZ!+V?1669xsHZ?SK@4*mnVP&pBw3sjQy05)_O82qEAq*1^_z1Nf@O zd5N+RY-u%Y^{tQwE@t#hp?U+jigiohWOKsavJ;M$o1l#JLFzpRWuymG*Ov~LClrhT zithXj7 zq)jRbYk)Tt6+>Cakt+&D0JMO*U$uxO0K?J6@JgGIGE^!YTMI`3(Zcyv6_Tw5BLE9? z$op0R!*Z~-?SW(Cj(LMU`HFMLN5GX-B68sgA$sN=$RoXJ1?P&(!If4+>^WzWfpO0=`vJCfZE)_m8vvjT zUxC*c!GJR>CL2IE&!g_X+R=K19#F1AUp!EY{BIZ1$ z@Z9TntyYC0DLO0Hm?y zri7ffqIyGC4_VFGZp?*-$|%!ke*br`27=BjQ~d`3jVduw6exWkC3EK)#d*aE(C zy&-WKBY>JlP*_=iE)i-{_iQFL4x$Hg3@zMo|XzVy*{Pzt>LLH>v!Zv;?V;=q&lZkl)g%$YOz^}#pc^Z76~ zHio9ACT!WV8K3$4&!D(C<~;hPkGA8|NDu>lV;m=!qq4|`uiiIjYd93f%P+r-vuDqt zySp1+Zz)<^TXEn0_hIMGoe5!|xTg&lho{gxo*P@2!!)m8!t$`U+?4YD|8#dNnk(m) zeA6`@Kls59@ZA@`hpShwA{Y!p(=?2Yjp6+H3pn)FA#B*N0rmBDU>Slkw+-+5uBZGw zfn#uEeFKRbkm`ZQ5Q)ph~07VWS`&%m$&b|Kn>v-dh zUo0ACVqyXZo;`pc{rHEdtESpn>c9&RZbyYDwl{)5EaPjxIE|jM zyUr9K(yK&(bPOixd0o0Zx?q$=_aSTd|tAd?AeHx)qYyhgJ z#F0{%)@siJ=ZaDaJ7cRPNjQEiwJvX6*Kzbn;vi0Kinf|fUI@T#OPoD)@nU)_dtSPD z2|%nUNd;yB$5oa|&7;X}k3FNiyBm5My>mWa;ya~ktJ&m*00Pm(U%RHJH{zvCPnMWW zq5RL5scBo)3~iht7q+HCUI?H+srlC0mfp&qZPWKB$72Tl)6KV*mKKmST;SW2-YFNh zrb1o_;4eLXDB4^zY}c-xU{YM!v$eGq#l^+YDaDDaezQ!R<#hi9BvpsQ;lPbI-jH&* zJ$v@d{;gBscn)k$g}e|zRMBwg+_l-`#>PfG{P07|hGSV4Pd)V{0N~KMVT2@Ooh24R zQg!_HbZn^mOJDvn1Y!9}8V@}105)x&>o_`met5PhS!wb@008h`f9^^6r+oGwK8w5V zzH8C@?RGo9^3|u%ys;TUQN_>xd^Hzl0svm^=*472!Mb(z`1;qs2A6B`SDGvP4xwJ;wKDB#2?0n*sY)z+lts}LiTqIS;2ZI6JwYeINjSaZx zo{u0H3?dp85ex?5bULwR%N9KLxySJ6V~>L4WBqM91)e{64wtW|=Qn9)PoUw`!)IUw z2a50gT-xEb))nKKPi{qVQZtECifA+nr*m%E_@Jobn+MO~%)n%FG)wa87jHqSGcoHH z6%7yk+k0un(_T}AXCK&_5LYA;fy3dLS3wL(D*pA?AK+x)L|V@PfT_bjgBD8f9T&s& z>EYROZZLqyUpj{W?i_%q%&oak2$@ZMN!4-iOiqmz*JPh;6wzc`zIl* znY&1Bsx86`4{nETdK_QTbUgE`vpAJS0`V+^8|sTu?{%VN+SZ|o=xnPY8_diB@>&39 z;&lnw*IW*U0Xn+JF&Z?_?J8T$6hK~#2CfADu#DfHu{@Xat`1<4TPy*raV!C>aZIZN zIBhKcZj%cknIb6b2rCpJSx0F4J1kRZ)*M0rv7u-ePv8;=JUkQo76@EC3pWq^>Ijc9 zljhu-CIF6M@aV^PFL_T;RN)WHn2gBqhh7cFE&-)Z z0bZAY5?AcI)F~|M8}PfAe`=a-E7}V1*g1IY92&|N-W2kOf9l3BPxR;5Dr32CTP^e4qZ+-$FmGdoIFZh0!kbL zN?bfjoUv@M#3i7_$z#3Og)(=nZ{20j+`LckZNUB8YqNR>AlBcnY83x|II|6?!&uU$^^oopls^dJ3&-72?(nxx%m^GBUuxmri&AcYb zYdIZUaRLbDi4#aXCJG?4CSJS%7(!s&rE)|RG_MC>Q?mT2|(8YIhuC3U^MYpQd8nscB*(X@maP`foqfL+c6fD z5^|nYC!Nf|vt(Y;5zIgUFk;KxB`~!PpiYg0t5~>=zZl8?q;EeITZ33sGz6jwf>9NL zsEjF5#Z*+8{}B~ztel(qGaQH}cpRt0fIl)jVYRu^gTC%0d6}7x1FEvHjaI}Z9Lr5 z-N^CRTsAIYma(Ey{2_~#L*D7Sj!*4gKkGUM#1besihY+#*B-G*jnGKWgC<8u-y&vS{Svm6v3Z3{pGy|78U#%#^R}em#yH!?m zCIG6b2zI;)b+j*6k1RNpq00y#|GlX_f63(3Cy;6?LPy_(c&XFcVJIF-AznCw(DC2p zH1UBI7!9Plj_CP6L-P;8x$VOs_WA4etR?jDBqFE&2xV+#ipLcj4wi>|ppL%+d)pq^ zo3??HHRhnK>kuz@LcDka)Zk4Z(qTpY0dz%1OBwf zVrNd8dCQR(4k21Nfbhw~5HFs9(6AY{b#1GzXrPfPNc|Te^__3)FAz7q!lawz_W;N&<|H9s~svdA1&krAAnH^KC+ zOI^o*4a9W>@dQr*m@OnI)iE`39jao9piog28B>$jL1{w!KPoWH6Eg?10`U1xbP+I* z#NVlDDklBIR&h{(NKzP+{$Xf|6?)1LJkr&5+&6QABriYG)Vk|=fIgEPq0R1u+v5ep zuIlllf=Aa>go6HgWj+89g6Fz@od*)mEwKI!X>Qy3ETwpMegp)9V291&2FLMWI1a=b zPFPVWbm*!IRaGEGLy%>0p*4jlA$Y#q*ZCZh7H?We004lEZ95;*DP97QADi4-WJ;7F zc;vFL^XCg)T=eIA+1L4Vfnjz4c*``?EX?LDfnjzmmiWLDIY2xu?Ylpr>H5-222eBrFlM7ci%bcCpa&GagpeZw!@qXn e!jYa-1OGqH3xgglK8$++0000 { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(Godot = {}) { + +// Support for growable heap + pthreads, where the buffer may change, so JS views +// must be updated. +function GROWABLE_HEAP_I8() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP8; +} +function GROWABLE_HEAP_U8() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU8; +} +function GROWABLE_HEAP_I16() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP16; +} +function GROWABLE_HEAP_U16() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU16; +} +function GROWABLE_HEAP_I32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP32; +} +function GROWABLE_HEAP_U32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU32; +} +function GROWABLE_HEAP_F32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPF32; +} +function GROWABLE_HEAP_F64() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPF64; +} + +var Module = typeof Godot != "undefined" ? Godot : {}; + +var readyPromiseResolve, readyPromiseReject; + +Module["ready"] = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + +[ "_main", "__emscripten_thread_init", "__emscripten_thread_exit", "__emscripten_thread_crashed", "__emscripten_thread_mailbox_await", "__emscripten_tls_init", "_pthread_self", "checkMailbox", "establishStackSpace", "invokeEntryPoint", "PThread", "__Z14godot_web_mainiPPc", "_fflush", "__emwebxr_on_input_event", "__emwebxr_on_simple_event", "__emscripten_check_mailbox", "onRuntimeInitialized" ].forEach(prop => { + if (!Object.getOwnPropertyDescriptor(Module["ready"], prop)) { + Object.defineProperty(Module["ready"], prop, { + get: () => abort("You are getting " + prop + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"), + set: () => abort("You are setting " + prop + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js") + }); + } +}); + +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; + +var thisProgram = "./this.program"; + +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +var ENVIRONMENT_IS_WEB = typeof window == "object"; + +var ENVIRONMENT_IS_WORKER = typeof importScripts == "function"; + +var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string"; + +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (Module["ENVIRONMENT"]) { + throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)"); +} + +var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false; + +var scriptDirectory = ""; + +function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; +} + +var read_, readAsync, readBinary, setWindowTitle; + +if (ENVIRONMENT_IS_SHELL) { + if (typeof process == "object" && typeof require === "function" || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"); + if (typeof read != "undefined") { + read_ = f => { + return read(f); + }; + } + readBinary = f => { + let data; + if (typeof readbuffer == "function") { + return new Uint8Array(readbuffer(f)); + } + data = read(f, "binary"); + assert(typeof data == "object"); + return data; + }; + readAsync = (f, onload, onerror) => { + setTimeout(() => onload(readBinary(f)), 0); + }; + if (typeof clearTimeout == "undefined") { + globalThis.clearTimeout = id => {}; + } + if (typeof scriptArgs != "undefined") { + arguments_ = scriptArgs; + } else if (typeof arguments != "undefined") { + arguments_ = arguments; + } + if (typeof quit == "function") { + quit_ = (status, toThrow) => { + setTimeout(() => { + if (!(toThrow instanceof ExitStatus)) { + let toLog = toThrow; + if (toThrow && typeof toThrow == "object" && toThrow.stack) { + toLog = [ toThrow, toThrow.stack ]; + } + err(`exiting due to exception: ${toLog}`); + } + quit(status); + }); + throw toThrow; + }; + } + if (typeof print != "undefined") { + if (typeof console == "undefined") console = {}; + console.log = print; + console.warn = console.error = typeof printErr != "undefined" ? printErr : print; + } +} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href; + } else if (typeof document != "undefined" && document.currentScript) { + scriptDirectory = document.currentScript.src; + } + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1); + } else { + scriptDirectory = ""; + } + if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"); + { + read_ = url => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText; + }; + if (ENVIRONMENT_IS_WORKER) { + readBinary = url => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || xhr.status == 0 && xhr.response) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + } + setWindowTitle = title => document.title = title; +} else { + throw new Error("environment detection error"); +} + +var out = Module["print"] || console.log.bind(console); + +var err = Module["printErr"] || console.error.bind(console); + +Object.assign(Module, moduleOverrides); + +moduleOverrides = null; + +checkIncomingModuleAPI(); + +if (Module["arguments"]) arguments_ = Module["arguments"]; + +legacyModuleProp("arguments", "arguments_"); + +if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; + +legacyModuleProp("thisProgram", "thisProgram"); + +if (Module["quit"]) quit_ = Module["quit"]; + +legacyModuleProp("quit", "quit_"); + +assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead"); + +assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead"); + +assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead"); + +assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead"); + +assert(typeof Module["read"] == "undefined", "Module.read option was removed (modify read_ in JS)"); + +assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)"); + +assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)"); + +assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify setWindowTitle in JS)"); + +assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY"); + +legacyModuleProp("read", "read_"); + +legacyModuleProp("readAsync", "readAsync"); + +legacyModuleProp("readBinary", "readBinary"); + +legacyModuleProp("setWindowTitle", "setWindowTitle"); + +var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js"; + +var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js"; + +var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js"; + +assert(ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_NODE, "Pthreads do not work in this environment yet (need Web Workers, or an alternative to them)"); + +assert(!ENVIRONMENT_IS_NODE, "node environment detected but not enabled at build time. Add 'node' to `-sENVIRONMENT` to enable."); + +assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable."); + +var wasmBinary; + +if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; + +legacyModuleProp("wasmBinary", "wasmBinary"); + +var noExitRuntime = Module["noExitRuntime"] || false; + +legacyModuleProp("noExitRuntime", "noExitRuntime"); + +if (typeof WebAssembly != "object") { + abort("no native wasm support detected"); +} + +var wasmMemory; + +var wasmModule; + +var ABORT = false; + +var EXITSTATUS; + +function assert(condition, text) { + if (!condition) { + abort("Assertion failed" + (text ? ": " + text : "")); + } +} + +var HEAP, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module["HEAP8"] = HEAP8 = new Int8Array(b); + Module["HEAP16"] = HEAP16 = new Int16Array(b); + Module["HEAP32"] = HEAP32 = new Int32Array(b); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(b); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); + Module["HEAPF32"] = HEAPF32 = new Float32Array(b); + Module["HEAPF64"] = HEAPF64 = new Float64Array(b); +} + +assert(!Module["STACK_SIZE"], "STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time"); + +assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support"); + +var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432; + +legacyModuleProp("INITIAL_MEMORY", "INITIAL_MEMORY"); + +assert(INITIAL_MEMORY >= 5242880, "INITIAL_MEMORY should be larger than STACK_SIZE, was " + INITIAL_MEMORY + "! (STACK_SIZE=" + 5242880 + ")"); + +if (ENVIRONMENT_IS_PTHREAD) { + wasmMemory = Module["wasmMemory"]; +} 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) { + err("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)"); + } + throw Error("bad memory"); + } + } +} + +updateMemoryViews(); + +INITIAL_MEMORY = wasmMemory.buffer.byteLength; + +assert(INITIAL_MEMORY % 65536 === 0); + +var wasmTable; + +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + if (max == 0) { + max += 4; + } + GROWABLE_HEAP_U32()[max >> 2] = 34821223; + GROWABLE_HEAP_U32()[max + 4 >> 2] = 2310721022; + GROWABLE_HEAP_U32()[0] = 1668509029; +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + if (max == 0) { + max += 4; + } + var cookie1 = GROWABLE_HEAP_U32()[max >> 2]; + var cookie2 = GROWABLE_HEAP_U32()[max + 4 >> 2]; + if (cookie1 != 34821223 || cookie2 != 2310721022) { + abort("Stack overflow! Stack cookie has been overwritten at " + ptrToString(max) + ", expected hex dwords 0x89BACDFE and 0x2135467, but received " + ptrToString(cookie2) + " " + ptrToString(cookie1)); + } + if (GROWABLE_HEAP_U32()[0] !== 1668509029) { + abort("Runtime error: The application has corrupted its heap memory area (address zero)!"); + } +} + +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 25459; + if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)"; +})(); + +var __ATPRERUN__ = []; + +var __ATINIT__ = []; + +var __ATMAIN__ = []; + +var __ATEXIT__ = []; + +var __ATPOSTRUN__ = []; + +var runtimeInitialized = false; + +var runtimeExited = false; + +var runtimeKeepaliveCounter = 0; + +function keepRuntimeAlive() { + return noExitRuntime || runtimeKeepaliveCounter > 0; +} + +function preRun() { + assert(!ENVIRONMENT_IS_PTHREAD); + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + if (ENVIRONMENT_IS_PTHREAD) return; + checkStackCookie(); + if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); + FS.ignorePermissions = false; + TTY.init(); + SOCKFS.root = FS.mount(SOCKFS, {}, null); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + checkStackCookie(); + if (ENVIRONMENT_IS_PTHREAD) return; + callRuntimeCallbacks(__ATMAIN__); +} + +function exitRuntime() { + assert(!runtimeExited); + checkStackCookie(); + if (ENVIRONMENT_IS_PTHREAD) return; + ___funcs_on_exit(); + callRuntimeCallbacks(__ATEXIT__); + FS.quit(); + TTY.shutdown(); + IDBFS.quit(); + PThread.terminateAllThreads(); + runtimeExited = true; +} + +function postRun() { + checkStackCookie(); + if (ENVIRONMENT_IS_PTHREAD) return; + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()); + } + } + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { + __ATEXIT__.unshift(cb); +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"); + +assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"); + +assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"); + +assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"); + +var runDependencies = 0; + +var runDependencyWatcher = null; + +var dependenciesFulfilled = null; + +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != "undefined") { + runDependencyWatcher = setInterval(() => { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err("still waiting on run dependencies:"); + } + err("dependency: " + dep); + } + if (shown) { + err("(end of list)"); + } + }, 1e4); + } + } else { + err("warning: run dependency added without ID"); + } +} + +function removeRunDependency(id) { + runDependencies--; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err("warning: run dependency removed without ID"); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} + +function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + what = "Aborted(" + what + ")"; + err(what); + ABORT = true; + EXITSTATUS = 1; + var e = new WebAssembly.RuntimeError(what); + 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://"); +} + +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module["asm"]; + } + assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization"); + assert(!runtimeExited, "native function `" + displayName + "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)"); + if (!asm[name]) { + assert(asm[name], "exported native function `" + displayName + "` not found"); + } + return asm[name].apply(null, arguments); + }; +} + +var wasmBinaryFile; + +wasmBinaryFile = "godot.web.template_release.wasm32.wasm"; + +if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); +} + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; + } catch (err) { + abort(err); + } +} + +function getBinaryPromise(binaryFile) { + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == "function") { + return fetch(binaryFile, { + credentials: "same-origin" + }).then(response => { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + binaryFile + "'"; + } + return response["arrayBuffer"](); + }).catch(() => getBinary(binaryFile)); + } + } + return Promise.resolve().then(() => getBinary(binaryFile)); +} + +function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then(binary => { + return WebAssembly.instantiate(binary, imports); + }).then(instance => { + return instance; + }).then(receiver, reason => { + err("failed to asynchronously prepare wasm: " + reason); + if (isFileURI(wasmBinaryFile)) { + err("warning: Loading from a file URI (" + wasmBinaryFile + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing"); + } + abort(reason); + }); +} + +function instantiateAsync(binary, binaryFile, imports, callback) { + if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") { + return fetch(binaryFile, { + credentials: "same-origin" + }).then(response => { + var result = WebAssembly.instantiateStreaming(response, imports); + return result.then(callback, function(reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(binaryFile, imports, callback); + }); + }); + } else { + return instantiateArrayBuffer(binaryFile, imports, callback); + } +} + +function createWasm() { + var info = { + "env": wasmImports, + "wasi_snapshot_preview1": wasmImports + }; + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + registerTLSInit(Module["asm"]["_emscripten_tls_init"]); + wasmTable = Module["asm"]["__indirect_function_table"]; + assert(wasmTable, "table not found in wasm exports"); + addOnInit(Module["asm"]["__wasm_call_ctors"]); + wasmModule = module; + PThread.loadWasmModuleToAllWorkers(() => removeRunDependency("wasm-instantiate")); + return exports; + } + addRunDependency("wasm-instantiate"); + var trueModule = Module; + function receiveInstantiationResult(result) { + assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"); + trueModule = null; + receiveInstance(result["instance"], result["module"]); + } + if (Module["instantiateWasm"]) { + try { + return Module["instantiateWasm"](info, receiveInstance); + } catch (e) { + err("Module.instantiateWasm callback failed with error: " + e); + readyPromiseReject(e); + } + } + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject); + return {}; +} + +var tempDouble; + +var tempI64; + +function legacyModuleProp(prop, newName) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get: function() { + abort("Module." + prop + " has been replaced with plain " + newName + " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort("`Module." + prop + "` was supplied but `" + prop + "` not included in INCOMING_MODULE_JS_API"); + } +} + +function isExportedByForceFilesystem(name) { + return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency"; +} + +function missingGlobal(sym, msg) { + if (typeof globalThis !== "undefined") { + Object.defineProperty(globalThis, sym, { + configurable: true, + get: function() { + warnOnce("`" + sym + "` is not longer defined by emscripten. " + msg); + return undefined; + } + }); + } +} + +missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer"); + +function missingLibrarySymbol(sym) { + if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get: function() { + var msg = "`" + sym + "` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line"; + var librarySymbol = sym; + if (!librarySymbol.startsWith("_")) { + librarySymbol = "$" + sym; + } + msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=" + librarySymbol + ")"; + if (isExportedByForceFilesystem(sym)) { + msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"; + } + warnOnce(msg); + return undefined; + } + }); + } + unexportedRuntimeSymbol(sym); +} + +function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get: function() { + var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"; + if (isExportedByForceFilesystem(sym)) { + msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"; + } + abort(msg); + } + }); + } +} + +function dbg(text) { + console.warn.apply(console, arguments); +} + +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +function terminateWorker(worker) { + worker.terminate(); + worker.onmessage = e => { + var cmd = e["data"]["cmd"]; + err('received "' + cmd + '" command from terminated worker: ' + worker.workerID); + }; +} + +function killThread(pthread_ptr) { + assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! killThread() can only ever be called from main application thread!"); + assert(pthread_ptr, "Internal Error! Null pthread_ptr in killThread!"); + var worker = PThread.pthreads[pthread_ptr]; + delete PThread.pthreads[pthread_ptr]; + terminateWorker(worker); + __emscripten_thread_free_data(pthread_ptr); + PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); + worker.pthread_ptr = 0; +} + +function cancelThread(pthread_ptr) { + assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! cancelThread() can only ever be called from main application thread!"); + assert(pthread_ptr, "Internal Error! Null pthread_ptr in cancelThread!"); + var worker = PThread.pthreads[pthread_ptr]; + worker.postMessage({ + "cmd": "cancel" + }); +} + +function cleanupThread(pthread_ptr) { + assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! cleanupThread() can only ever be called from main application thread!"); + assert(pthread_ptr, "Internal Error! Null pthread_ptr in cleanupThread!"); + var worker = PThread.pthreads[pthread_ptr]; + assert(worker); + PThread.returnWorkerToPool(worker); +} + +function zeroMemory(address, size) { + GROWABLE_HEAP_U8().fill(0, address, address + size); + return address; +} + +function spawnThread(threadParams) { + assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! spawnThread() can only ever be called from main application thread!"); + assert(threadParams.pthread_ptr, "Internal error, no pthread ptr!"); + var worker = PThread.getNewWorker(); + if (!worker) { + return 6; + } + assert(!worker.pthread_ptr, "Internal error!"); + PThread.runningWorkers.push(worker); + PThread.pthreads[threadParams.pthread_ptr] = worker; + worker.pthread_ptr = threadParams.pthread_ptr; + var msg = { + "cmd": "run", + "start_routine": threadParams.startRoutine, + "arg": threadParams.arg, + "pthread_ptr": threadParams.pthread_ptr + }; + worker.postMessage(msg, threadParams.transferList); + return 0; +} + +var PATH = { + isAbs: path => path.charAt(0) === "/", + splitPath: filename => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray: (parts, allowAboveRoot) => { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1); + } else if (last === "..") { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + if (allowAboveRoot) { + for (;up; up--) { + parts.unshift(".."); + } + } + return parts; + }, + normalize: path => { + var isAbsolute = PATH.isAbs(path), trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray(path.split("/").filter(p => !!p), !isAbsolute).join("/"); + if (!path && !isAbsolute) { + path = "."; + } + if (path && trailingSlash) { + path += "/"; + } + return (isAbsolute ? "/" : "") + path; + }, + dirname: path => { + var result = PATH.splitPath(path), root = result[0], dir = result[1]; + if (!root && !dir) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename: path => { + if (path === "/") return "/"; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) return path; + return path.substr(lastSlash + 1); + }, + join: function() { + var paths = Array.prototype.slice.call(arguments); + return PATH.normalize(paths.join("/")); + }, + join2: (l, r) => { + return PATH.normalize(l + "/" + r); + } +}; + +function initRandomFill() { + if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") { + return view => (view.set(crypto.getRandomValues(new Uint8Array(view.byteLength))), + view); + } else abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };"); +} + +function randomFill(view) { + return (randomFill = initRandomFill())(view); +} + +var PATH_FS = { + resolve: function() { + var resolvedPath = "", resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path != "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; + }, + relative: (from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (;start < arr.length; start++) { + if (arr[start] !== "") break; + } + var end = arr.length - 1; + for (;end >= 0; end--) { + if (arr[end] !== "") break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split("/")); + var toParts = trim(to.split("/")); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push(".."); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join("/"); + } +}; + +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var c = str.charCodeAt(i); + if (c <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; +} + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + assert(typeof str === "string"); + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | u1 & 1023; + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | u >> 6; + heap[outIdx++] = 128 | u & 63; + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | u >> 12; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 1114111) warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF)."); + heap[outIdx++] = 240 | u >> 18; + heap[outIdx++] = 128 | u >> 12 & 63; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } + } + heap[outIdx] = 0; + return outIdx - startIdx; +} + +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined; + +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.buffer instanceof SharedArrayBuffer ? heapOrArray.slice(idx, endPtr) : heapOrArray.subarray(idx, endPtr)); + } + var str = ""; + while (idx < endPtr) { + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2; + } else { + if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!"); + u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63; + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } + } + return str; +} + +var TTY = { + ttys: [], + init: function() {}, + shutdown: function() {}, + register: function(dev, ops) { + TTY.ttys[dev] = { + input: [], + output: [], + ops: ops + }; + FS.registerDevice(dev, TTY.stream_ops); + }, + stream_ops: { + open: function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + }, + close: function(stream) { + stream.tty.ops.fsync(stream.tty); + }, + fsync: function(stream) { + stream.tty.ops.fsync(stream.tty); + }, + read: function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: 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; + } + }, + default_tty_ops: { + get_char: function(tty) { + if (!tty.input.length) { + var result = null; + if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + result = readline(); + if (result !== null) { + result += "\n"; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + }, + put_char: function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync: function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + } + }, + default_tty1_ops: { + put_char: function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync: function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + } + } +}; + +function alignMemory(size, alignment) { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; +} + +function mmapAlloc(size) { + abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported"); +} + +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 !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + }, + lookup: function(parent, name) { + throw FS.genericErrors[44]; + }, + mknod: function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + }, + rename: function(old_node, new_dir, new_name) { + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now(); + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + }, + unlink: function(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + rmdir: function(parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + readdir: function(node) { + var entries = [ ".", ".." ]; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue; + } + entries.push(key); + } + return entries; + }, + symlink: function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node; + }, + readlink: function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + } + }, + stream_ops: { + read: function(stream, 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); + assert(size >= 0); + if (size > 8 && contents.subarray) { + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + }, + write: function(stream, buffer, offset, length, position, canOwn) { + assert(!(buffer instanceof ArrayBuffer)); + if (buffer.buffer === GROWABLE_HEAP_I8().buffer) { + canOwn = false; + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + if (canOwn) { + assert(position === 0, "canOwn must imply no weird position inside the file"); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) { + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek: 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 === GROWABLE_HEAP_I8().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); + } + GROWABLE_HEAP_I8().set(contents, ptr); + } + return { + ptr: ptr, + allocated: allocated + }; + }, + msync: function(stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + return 0; + } + } +}; + +function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : ""; + readAsync(url, arrayBuffer => { + assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, event => { + if (onerror) { + onerror(); + } else { + throw `Loading data file "${url}" failed.`; + } + }); + if (dep) addRunDependency(dep); +} + +var preloadPlugins = Module["preloadPlugins"] || []; + +function FS_handledByPreloadPlugin(byteArray, fullname, finish, onerror) { + if (typeof Browser != "undefined") Browser.init(); + var handled = false; + preloadPlugins.forEach(function(plugin) { + if (handled) return; + if (plugin["canHandle"](fullname)) { + plugin["handle"](byteArray, fullname, finish, onerror); + handled = true; + } + }); + return handled; +} + +function FS_createPreloadedFile(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency(`cp ${fullname}`); + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == "string") { + asyncLoad(url, byteArray => processData(byteArray), onerror); + } else { + processData(url); + } +} + +function FS_modeStringToFlags(str) { + var flagModes = { + "r": 0, + "r+": 2, + "w": 512 | 64 | 1, + "w+": 512 | 64 | 2, + "a": 1024 | 64 | 1, + "a+": 1024 | 64 | 2 + }; + var flags = flagModes[str]; + if (typeof flags == "undefined") { + throw new Error(`Unknown file open mode: ${str}`); + } + return flags; +} + +function FS_getMode(canRead, canWrite) { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; +} + +var IDBFS = { + dbs: {}, + indexedDB: () => { + if (typeof indexedDB != "undefined") return indexedDB; + var ret = null; + if (typeof window == "object") ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + assert(ret, "IDBFS used, but indexedDB not supported"); + return ret; + }, + DB_VERSION: 21, + DB_STORE_NAME: "FILE_DATA", + mount: function(mount) { + return MEMFS.mount.apply(null, arguments); + }, + syncfs: (mount, populate, callback) => { + IDBFS.getLocalSet(mount, (err, local) => { + if (err) return callback(err); + IDBFS.getRemoteSet(mount, (err, remote) => { + if (err) return callback(err); + var src = populate ? remote : local; + var dst = populate ? local : remote; + IDBFS.reconcile(src, dst, callback); + }); + }); + }, + quit: () => { + Object.values(IDBFS.dbs).forEach(value => value.close()); + IDBFS.dbs = {}; + }, + getDB: (name, callback) => { + var db = IDBFS.dbs[name]; + if (db) { + return callback(null, db); + } + var req; + try { + req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION); + } catch (e) { + return callback(e); + } + if (!req) { + return callback("Unable to connect to IndexedDB"); + } + 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 + }); + } + }; + req.onsuccess = () => { + db = req.result; + IDBFS.dbs[name] = db; + callback(null, db); + }; + req.onerror = e => { + callback(this.error); + e.preventDefault(); + }; + }, + getLocalSet: (mount, callback) => { + var entries = {}; + function isRealDir(p) { + return p !== "." && p !== ".."; + } + function toAbsolute(root) { + return p => { + return PATH.join2(root, p); + }; + } + var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint)); + while (check.length) { + var path = check.pop(); + var stat; + try { + stat = FS.stat(path); + } catch (e) { + return callback(e); + } + if (FS.isDir(stat.mode)) { + check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path))); + } + entries[path] = { + "timestamp": stat.mtime + }; + } + return callback(null, { + type: "local", + entries: entries + }); + }, + getRemoteSet: (mount, callback) => { + var entries = {}; + IDBFS.getDB(mount.mountpoint, (err, db) => { + if (err) return callback(err); + try { + var transaction = db.transaction([ IDBFS.DB_STORE_NAME ], "readonly"); + transaction.onerror = e => { + callback(this.error); + e.preventDefault(); + }; + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + var index = store.index("timestamp"); + index.openKeyCursor().onsuccess = event => { + var cursor = event.target.result; + if (!cursor) { + return callback(null, { + type: "remote", + db: db, + entries: entries + }); + } + entries[cursor.primaryKey] = { + "timestamp": cursor.key + }; + cursor.continue(); + }; + } catch (e) { + return callback(e); + } + }); + }, + loadLocalEntry: (path, callback) => { + var stat, node; + try { + var lookup = FS.lookupPath(path); + node = lookup.node; + stat = FS.stat(path); + } catch (e) { + return callback(e); + } + 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")); + } + }, + storeLocalEntry: (path, entry, callback) => { + try { + 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")); + } + FS.chmod(path, entry["mode"]); + FS.utime(path, entry["timestamp"], entry["timestamp"]); + } catch (e) { + return callback(e); + } + callback(null); + }, + removeLocalEntry: (path, callback) => { + try { + 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); + } + callback(null); + }, + loadRemoteEntry: (store, path, callback) => { + var req = store.get(path); + req.onsuccess = event => { + callback(null, event.target.result); + }; + req.onerror = e => { + callback(this.error); + e.preventDefault(); + }; + }, + storeRemoteEntry: (store, path, entry, callback) => { + try { + var req = store.put(entry, path); + } catch (e) { + callback(e); + return; + } + req.onsuccess = () => { + callback(null); + }; + req.onerror = e => { + callback(this.error); + e.preventDefault(); + }; + }, + removeRemoteEntry: (store, path, callback) => { + var req = store.delete(path); + req.onsuccess = () => { + callback(null); + }; + req.onerror = e => { + callback(this.error); + e.preventDefault(); + }; + }, + reconcile: (src, dst, callback) => { + var total = 0; + var create = []; + Object.keys(src.entries).forEach(function(key) { + var e = src.entries[key]; + var e2 = dst.entries[key]; + if (!e2 || e["timestamp"].getTime() != e2["timestamp"].getTime()) { + create.push(key); + total++; + } + }); + var remove = []; + Object.keys(dst.entries).forEach(function(key) { + if (!src.entries[key]) { + remove.push(key); + total++; + } + }); + if (!total) { + return callback(null); + } + var errored = false; + var db = src.type === "remote" ? src.db : dst.db; + var transaction = db.transaction([ IDBFS.DB_STORE_NAME ], "readwrite"); + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + function done(err) { + if (err && !errored) { + errored = true; + return callback(err); + } + } + transaction.onerror = e => { + done(this.error); + e.preventDefault(); + }; + transaction.oncomplete = e => { + if (!errored) { + callback(null); + } + }; + create.sort().forEach(path => { + if (dst.type === "local") { + IDBFS.loadRemoteEntry(store, path, (err, entry) => { + if (err) return done(err); + IDBFS.storeLocalEntry(path, entry, done); + }); + } else { + IDBFS.loadLocalEntry(path, (err, entry) => { + if (err) return done(err); + IDBFS.storeRemoteEntry(store, path, entry, done); + }); + } + }); + remove.sort().reverse().forEach(path => { + if (dst.type === "local") { + IDBFS.removeLocalEntry(path, done); + } else { + IDBFS.removeRemoteEntry(store, path, done); + } + }); + } +}; + +var ERRNO_MESSAGES = { + 0: "Success", + 1: "Arg list too long", + 2: "Permission denied", + 3: "Address already in use", + 4: "Address not available", + 5: "Address family not supported by protocol family", + 6: "No more processes", + 7: "Socket already connected", + 8: "Bad file number", + 9: "Trying to read unreadable message", + 10: "Mount device busy", + 11: "Operation canceled", + 12: "No children", + 13: "Connection aborted", + 14: "Connection refused", + 15: "Connection reset by peer", + 16: "File locking deadlock error", + 17: "Destination address required", + 18: "Math arg out of domain of func", + 19: "Quota exceeded", + 20: "File exists", + 21: "Bad address", + 22: "File too large", + 23: "Host is unreachable", + 24: "Identifier removed", + 25: "Illegal byte sequence", + 26: "Connection already in progress", + 27: "Interrupted system call", + 28: "Invalid argument", + 29: "I/O error", + 30: "Socket is already connected", + 31: "Is a directory", + 32: "Too many symbolic links", + 33: "Too many open files", + 34: "Too many links", + 35: "Message too long", + 36: "Multihop attempted", + 37: "File or path name too long", + 38: "Network interface is not configured", + 39: "Connection reset by network", + 40: "Network is unreachable", + 41: "Too many open files in system", + 42: "No buffer space available", + 43: "No such device", + 44: "No such file or directory", + 45: "Exec format error", + 46: "No record locks available", + 47: "The link has been severed", + 48: "Not enough core", + 49: "No message of desired type", + 50: "Protocol not available", + 51: "No space left on device", + 52: "Function not implemented", + 53: "Socket is not connected", + 54: "Not a directory", + 55: "Directory not empty", + 56: "State not recoverable", + 57: "Socket operation on non-socket", + 59: "Not a typewriter", + 60: "No such device or address", + 61: "Value too large for defined data type", + 62: "Previous owner died", + 63: "Not super-user", + 64: "Broken pipe", + 65: "Protocol error", + 66: "Unknown protocol", + 67: "Protocol wrong type for socket", + 68: "Math result not representable", + 69: "Read only file system", + 70: "Illegal seek", + 71: "No such process", + 72: "Stale file handle", + 73: "Connection timed out", + 74: "Text file busy", + 75: "Cross-device link", + 100: "Device not a stream", + 101: "Bad font file fmt", + 102: "Invalid slot", + 103: "Invalid request code", + 104: "No anode", + 105: "Block device required", + 106: "Channel number out of range", + 107: "Level 3 halted", + 108: "Level 3 reset", + 109: "Link number out of range", + 110: "Protocol driver not attached", + 111: "No CSI structure available", + 112: "Level 2 halted", + 113: "Invalid exchange", + 114: "Invalid request descriptor", + 115: "Exchange full", + 116: "No data (for no delay io)", + 117: "Timer expired", + 118: "Out of streams resources", + 119: "Machine is not on the network", + 120: "Package not installed", + 121: "The object is remote", + 122: "Advertise error", + 123: "Srmount error", + 124: "Communication error on send", + 125: "Cross mount point (not really error)", + 126: "Given log. name not unique", + 127: "f.d. invalid for this operation", + 128: "Remote address changed", + 129: "Can access a needed shared lib", + 130: "Accessing a corrupted shared lib", + 131: ".lib section in a.out corrupted", + 132: "Attempting to link in too many libs", + 133: "Attempting to exec a shared library", + 135: "Streams pipe error", + 136: "Too many users", + 137: "Socket type not supported", + 138: "Not supported", + 139: "Protocol family not supported", + 140: "Can't send after socket shutdown", + 141: "Too many references", + 142: "Host is down", + 148: "No medium (in tape drive)", + 156: "Level 2 not synchronized" +}; + +var ERRNO_CODES = {}; + +function demangle(func) { + warnOnce("warning: build with -sDEMANGLE_SUPPORT to link in libcxxabi demangling"); + return func; +} + +function demangleAll(text) { + var regex = /\b_Z[\w\d_]+/g; + return text.replace(regex, function(x) { + var y = demangle(x); + return x === y ? x : y + " [" + x + "]"; + }); +} + +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(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.split("/").filter(p => !!p); + var current = FS.root; + var current_path = "/"; + for (var i = 0; i < parts.length; i++) { + var islast = i === parts.length - 1; + if (islast && opts.parent) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root; + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, { + recurse_count: opts.recurse_count + 1 + }); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(32); + } + } + } + } + return { + path: current_path, + node: current + }; + }, + getPath: node => { + var 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 i = 0; i < name.length; i++) { + hash = (hash << 5) - hash + name.charCodeAt(i) | 0; + } + return (parentid + hash >>> 0) % FS.nameTable.length; + }, + hashAddNode: node => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + }, + hashRemoveNode: node => { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + }, + lookupNode: (parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + return FS.lookup(parent, name); + }, + createNode: (parent, name, mode, rdev) => { + assert(typeof parent == "object"); + 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; + }, + flagsToPermissionString: flag => { + var perms = [ "r", "w", "rw" ][flag & 3]; + if (flag & 512) { + perms += "w"; + } + return perms; + }, + nodePermissions: (node, perms) => { + if (FS.ignorePermissions) { + return 0; + } + if (perms.includes("r") && !(node.mode & 292)) { + return 2; + } else if (perms.includes("w") && !(node.mode & 146)) { + return 2; + } else if (perms.includes("x") && !(node.mode & 73)) { + return 2; + } + return 0; + }, + mayLookup: dir => { + var errCode = FS.nodePermissions(dir, "x"); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + }, + mayCreate: (dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) {} + return FS.nodePermissions(dir, "wx"); + }, + mayDelete: (dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, "wx"); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + }, + mayOpen: (node, flags) => { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + }, + MAX_OPEN_FDS: 4096, + nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => { + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + }, + getStream: fd => FS.streams[fd], + createStream: (stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = function() { + this.shared = {}; + }; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + get: function() { + return this.node; + }, + set: function(val) { + this.node = val; + } + }, + isRead: { + get: function() { + return (this.flags & 2097155) !== 1; + } + }, + isWrite: { + get: function() { + return (this.flags & 2097155) !== 0; + } + }, + isAppend: { + get: function() { + return this.flags & 1024; + } + }, + flags: { + get: function() { + return this.shared.flags; + }, + set: function(val) { + this.shared.flags = val; + } + }, + position: { + get: function() { + return this.shared.position; + }, + set: function(val) { + this.shared.position = val; + } + } + }); + } + stream = Object.assign(new FS.FSStream(), stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + }, + closeStream: fd => { + FS.streams[fd] = null; + }, + chrdev_stream_ops: { + open: stream => { + var device = FS.getDevice(stream.node.rdev); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + }, + llseek: () => { + throw new FS.ErrnoError(70); + } + }, + major: dev => dev >> 8, + minor: dev => dev & 255, + makedev: (ma, mi) => ma << 8 | mi, + registerDevice: (dev, ops) => { + FS.devices[dev] = { + stream_ops: ops + }; + }, + getDevice: dev => FS.devices[dev], + getMounts: mount => { + var mounts = []; + var check = [ mount ]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push.apply(check, m.mounts); + } + return mounts; + }, + syncfs: (populate, callback) => { + if (typeof populate == "function") { + callback = populate; + populate = false; + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`); + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + } + mounts.forEach(mount => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, + mount: (type, opts, mountpoint) => { + if (typeof type == "string") { + throw type; + } + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + if (node.mount) { + node.mount.mounts.push(mount); + } + } + return mountRoot; + }, + unmount: mountpoint => { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + Object.keys(FS.nameTable).forEach(hash => { + var current = FS.nameTable[hash]; + while (current) { + var next = current.name_next; + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + current = next; + } + }); + node.mounted = null; + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + }, + lookup: (parent, name) => { + return parent.node_ops.lookup(parent, name); + }, + mknod: (path, mode, dev) => { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === "." || name === "..") { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + }, + create: (path, mode) => { + mode = mode !== undefined ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir: (path, mode) => { + mode = mode !== undefined ? mode : 511; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + }, + mkdirTree: (path, mode) => { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode); + } catch (e) { + if (e.errno != 20) throw e; + } + } + }, + mkdev: (path, mode, dev) => { + if (typeof dev == "undefined") { + dev = mode; + mode = 438; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }, + symlink: (oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + }, + rename: (old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + var lookup, old_dir, new_dir; + lookup = FS.lookupPath(old_path, { + parent: true + }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { + parent: true + }); + new_dir = lookup.node; + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28); + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) { + throw new FS.ErrnoError(10); + } + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + FS.hashAddNode(old_node); + } + }, + rmdir: path => { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + }, + readdir: path => { + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + }, + unlink: path => { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + }, + readlink: path => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + }, + stat: (path, dontFollow) => { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + }, + lstat: path => { + return FS.stat(path, true); + }, + chmod: (path, mode, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: mode & 4095 | node.mode & ~4095, + timestamp: Date.now() + }); + }, + lchmod: (path, mode) => { + FS.chmod(path, mode, true); + }, + fchmod: (fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + }, + chown: (path, uid, gid, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + }); + }, + lchown: (path, uid, gid) => { + FS.chown(path, uid, gid, true); + }, + fchown: (fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + }, + truncate: (path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { + follow: true + }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + }, + ftruncate: (fd, len) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + }, + utime: (path, atime, mtime) => { + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + }, + open: (path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags; + mode = typeof mode == "undefined" ? 438 : mode; + if (flags & 64) { + mode = mode & 4095 | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == "object") { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + if (flags & 512 && !created) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false + }); + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module["logReadFiles"] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + }, + close: stream => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + }, + isClosed: stream => { + return stream.fd === null; + }, + llseek: (stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + }, + read: (stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + }, + write: (stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + }, + allocate: (stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + }, + mmap: (stream, length, position, prot, flags) => { + if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + }, + msync: (stream, buffer, offset, length, mmapFlags) => { + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + }, + munmap: stream => 0, + ioctl: (stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + }, + readFile: (path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || "binary"; + if (opts.encoding !== "utf8" && opts.encoding !== "binary") { + throw new Error(`Invalid encoding type "${opts.encoding}"`); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === "utf8") { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === "binary") { + ret = buf; + } + FS.close(stream); + return ret; + }, + writeFile: (path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == "string") { + var buf = new Uint8Array(lengthBytesUTF8(data) + 1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error("Unsupported data type"); + } + FS.close(stream); + }, + cwd: () => FS.currentPath, + chdir: path => { + var lookup = FS.lookupPath(path, { + follow: true + }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, "x"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + }, + createDefaultDirectories: () => { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user"); + }, + createDefaultDevices: () => { + FS.mkdir("/dev"); + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length + }); + FS.mkdev("/dev/null", FS.makedev(1, 3)); + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev("/dev/tty", FS.makedev(5, 0)); + FS.mkdev("/dev/tty1", FS.makedev(6, 0)); + var randomBuffer = new Uint8Array(1024), randomLeft = 0; + var randomByte = () => { + if (randomLeft === 0) { + randomLeft = randomFill(randomBuffer).byteLength; + } + return randomBuffer[--randomLeft]; + }; + FS.createDevice("/dev", "random", randomByte); + FS.createDevice("/dev", "urandom", randomByte); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }, + createSpecialDirectories: () => { + FS.mkdir("/proc"); + var proc_self = FS.mkdir("/proc/self"); + FS.mkdir("/proc/self/fd"); + FS.mount({ + mount: () => { + var node = FS.createNode(proc_self, "fd", 16384 | 511, 73); + node.node_ops = { + lookup: (parent, name) => { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { + mountpoint: "fake" + }, + node_ops: { + readlink: () => stream.path + } + }; + ret.parent = ret; + return ret; + } + }; + return node; + } + }, {}, "/proc/self/fd"); + }, + createStandardStreams: () => { + if (Module["stdin"]) { + FS.createDevice("/dev", "stdin", Module["stdin"]); + } else { + FS.symlink("/dev/tty", "/dev/stdin"); + } + if (Module["stdout"]) { + FS.createDevice("/dev", "stdout", null, Module["stdout"]); + } else { + FS.symlink("/dev/tty", "/dev/stdout"); + } + if (Module["stderr"]) { + FS.createDevice("/dev", "stderr", null, Module["stderr"]); + } else { + FS.symlink("/dev/tty1", "/dev/stderr"); + } + var stdin = FS.open("/dev/stdin", 0); + var stdout = FS.open("/dev/stdout", 1); + var stderr = FS.open("/dev/stderr", 1); + assert(stdin.fd === 0, `invalid handle for stdin (${stdin.fd})`); + assert(stdout.fd === 1, `invalid handle for stdout (${stdout.fd})`); + assert(stderr.fd === 2, `invalid handle for stderr (${stderr.fd})`); + }, + ensureErrnoError: () => { + if (FS.ErrnoError) return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.name = "ErrnoError"; + this.node = node; + this.setErrno = function(errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + if (this.stack) { + Object.defineProperty(this, "stack", { + value: new Error().stack, + writable: true + }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [ 44 ].forEach(code => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ""; + }); + }, + staticInit: () => { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { + "MEMFS": MEMFS, + "IDBFS": IDBFS + }; + }, + init: (input, output, error) => { + assert(!FS.init.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)"); + FS.init.initialized = true; + FS.ensureErrnoError(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }, + quit: () => { + FS.init.initialized = false; + _fflush(0); + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + }, + findObject: (path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null; + } + return ret.object; + }, + analyzePath: (path, dontResolveLastLink) => { + try { + var lookup = FS.lookupPath(path, { + follow: !dontResolveLastLink + }); + path = lookup.path; + } catch (e) {} + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { + parent: true + }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { + follow: !dontResolveLastLink + }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === "/"; + } catch (e) { + ret.error = e.errno; + } + return ret; + }, + createPath: (parent, path, canRead, canWrite) => { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + var parts = path.split("/").reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) {} + parent = current; + } + return current; + }, + createFile: (parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS_getMode(canRead, canWrite); + return FS.create(path, mode); + }, + createDataFile: (parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS_getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == "string") { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + }, + createDevice: (parent, name, input, output) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS_getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + FS.registerDevice(dev, { + open: stream => { + stream.seekable = false; + }, + close: stream => { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset + i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + }, + forceLoadFile: obj => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != "undefined") { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + try { + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error("Cannot load without read() or XMLHttpRequest."); + } + }, + createLazyFile: (parent, name, url, canRead, canWrite) => { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length - 1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = idx / this.chunkSize | 0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + var xhr = new XMLHttpRequest(); + xhr.open("HEAD", url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + var chunkSize = 1024 * 1024; + if (!hasByteServing) chunkSize = datalength; + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!"); + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + xhr.responseType = "arraybuffer"; + if (xhr.overrideMimeType) { + xhr.overrideMimeType("text/plain; charset=x-user-defined"); + } + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []); + } + return intArrayFromString(xhr.responseText || "", true); + }; + var lazyArray = this; + lazyArray.setDataGetter(chunkNum => { + var start = chunkNum * chunkSize; + var end = (chunkNum + 1) * chunkSize - 1; + end = Math.min(end, datalength - 1); + if (typeof lazyArray.chunks[chunkNum] == "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum]; + }); + if (usesGzip || !datalength) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest != "undefined") { + if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc"; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + var properties = { + isDevice: false, + contents: lazyArray + }; + } else { + var properties = { + isDevice: false, + url: url + }; + } + var node = FS.createFile(parent, name, properties, canRead, canWrite); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, { + usedBytes: { + get: function() { + return this.contents.length; + } + } + }); + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(key => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position); + }; + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, GROWABLE_HEAP_I8(), ptr, length, position); + return { + ptr: ptr, + allocated: true + }; + }; + node.stream_ops = stream_ops; + return node; + }, + absolutePath: () => { + abort("FS.absolutePath has been removed; use PATH_FS.resolve instead"); + }, + createFolder: () => { + abort("FS.createFolder has been removed; use FS.mkdir instead"); + }, + createLink: () => { + abort("FS.createLink has been removed; use FS.symlink instead"); + }, + joinPath: () => { + abort("FS.joinPath has been removed; use PATH.join instead"); + }, + mmapAlloc: () => { + abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc"); + }, + standardizePath: () => { + abort("FS.standardizePath has been removed; use PATH.normalize instead"); + } +}; + +function UTF8ToString(ptr, maxBytesToRead) { + assert(typeof ptr == "number"); + return ptr ? UTF8ArrayToString(GROWABLE_HEAP_U8(), ptr, maxBytesToRead) : ""; +} + +var SYSCALLS = { + DEFAULT_POLLMASK: 5, + calculateAt: function(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44); + } + return dir; + } + return PATH.join2(dir, path); + }, + doStat: function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + return -54; + } + throw e; + } + GROWABLE_HEAP_I32()[buf >> 2] = stat.dev; + GROWABLE_HEAP_I32()[buf + 8 >> 2] = stat.ino; + GROWABLE_HEAP_I32()[buf + 12 >> 2] = stat.mode; + GROWABLE_HEAP_U32()[buf + 16 >> 2] = stat.nlink; + GROWABLE_HEAP_I32()[buf + 20 >> 2] = stat.uid; + GROWABLE_HEAP_I32()[buf + 24 >> 2] = stat.gid; + GROWABLE_HEAP_I32()[buf + 28 >> 2] = stat.rdev; + tempI64 = [ stat.size >>> 0, (tempDouble = stat.size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[buf + 40 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 44 >> 2] = tempI64[1]; + GROWABLE_HEAP_I32()[buf + 48 >> 2] = 4096; + GROWABLE_HEAP_I32()[buf + 52 >> 2] = stat.blocks; + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + tempI64 = [ Math.floor(atime / 1e3) >>> 0, (tempDouble = Math.floor(atime / 1e3), + +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[buf + 56 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 60 >> 2] = tempI64[1]; + GROWABLE_HEAP_U32()[buf + 64 >> 2] = atime % 1e3 * 1e3; + tempI64 = [ Math.floor(mtime / 1e3) >>> 0, (tempDouble = Math.floor(mtime / 1e3), + +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[buf + 72 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 76 >> 2] = tempI64[1]; + GROWABLE_HEAP_U32()[buf + 80 >> 2] = mtime % 1e3 * 1e3; + tempI64 = [ Math.floor(ctime / 1e3) >>> 0, (tempDouble = Math.floor(ctime / 1e3), + +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[buf + 88 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 92 >> 2] = tempI64[1]; + GROWABLE_HEAP_U32()[buf + 96 >> 2] = ctime % 1e3 * 1e3; + tempI64 = [ stat.ino >>> 0, (tempDouble = stat.ino, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[buf + 104 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 108 >> 2] = tempI64[1]; + return 0; + }, + doMsync: function(addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + return 0; + } + var buffer = GROWABLE_HEAP_U8().slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + }, + varargs: undefined, + get: function() { + assert(SYSCALLS.varargs != undefined); + SYSCALLS.varargs += 4; + var ret = GROWABLE_HEAP_I32()[SYSCALLS.varargs - 4 >> 2]; + return ret; + }, + getStr: function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, + getStreamFromFD: function(fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + } +}; + +function _proc_exit(code) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(1, 1, code); + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + PThread.terminateAllThreads(); + if (Module["onExit"]) Module["onExit"](code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); +} + +function exitJS(status, implicit) { + EXITSTATUS = status; + if (ENVIRONMENT_IS_PTHREAD) { + assert(!implicit); + exitOnMainThread(status); + throw "unwind"; + } + if (!keepRuntimeAlive()) { + exitRuntime(); + } + if (keepRuntimeAlive() && !implicit) { + var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`; + readyPromiseReject(msg); + err(msg); + } + _proc_exit(status); +} + +var _exit = exitJS; + +function ptrToString(ptr) { + assert(typeof ptr === "number"); + return "0x" + ptr.toString(16).padStart(8, "0"); +} + +function handleException(e) { + if (e instanceof ExitStatus || e == "unwind") { + return EXITSTATUS; + } + checkStackCookie(); + if (e instanceof WebAssembly.RuntimeError) { + if (_emscripten_stack_get_current() <= 0) { + err("Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 5242880)"); + } + } + quit_(1, e); +} + +var PThread = { + unusedWorkers: [], + runningWorkers: [], + tlsInitFunctions: [], + pthreads: {}, + nextWorkerID: 1, + debugInit: function() { + function pthreadLogPrefix() { + var t = 0; + if (runtimeInitialized && typeof _pthread_self != "undefined" && !runtimeExited) { + t = _pthread_self(); + } + return "w:" + (Module["workerID"] || 0) + ",t:" + ptrToString(t) + ": "; + } + var origDbg = dbg; + dbg = message => origDbg(pthreadLogPrefix() + message); + }, + init: function() { + PThread.debugInit(); + if (ENVIRONMENT_IS_PTHREAD) { + PThread.initWorker(); + } else { + PThread.initMainThread(); + } + }, + initMainThread: function() { + var pthreadPoolSize = 8; + while (pthreadPoolSize--) { + PThread.allocateUnusedWorker(); + } + }, + initWorker: function() { + noExitRuntime = false; + }, + setExitStatus: function(status) { + EXITSTATUS = status; + }, + terminateAllThreads__deps: [ "$terminateWorker" ], + terminateAllThreads: function() { + assert(!ENVIRONMENT_IS_PTHREAD, "Internal Error! terminateAllThreads() can only ever be called from main application thread!"); + for (var worker of PThread.runningWorkers) { + terminateWorker(worker); + } + for (var worker of PThread.unusedWorkers) { + terminateWorker(worker); + } + PThread.unusedWorkers = []; + PThread.runningWorkers = []; + PThread.pthreads = []; + }, + returnWorkerToPool: function(worker) { + var pthread_ptr = worker.pthread_ptr; + delete PThread.pthreads[pthread_ptr]; + PThread.unusedWorkers.push(worker); + PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); + worker.pthread_ptr = 0; + __emscripten_thread_free_data(pthread_ptr); + }, + receiveObjectTransfer: function(data) {}, + threadInitTLS: function() { + PThread.tlsInitFunctions.forEach(f => f()); + }, + loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => { + worker.onmessage = e => { + var d = e["data"]; + var cmd = d["cmd"]; + if (worker.pthread_ptr) PThread.currentProxiedOperationCallerThread = worker.pthread_ptr; + if (d["targetThread"] && d["targetThread"] != _pthread_self()) { + var targetWorker = PThread.pthreads[d.targetThread]; + if (targetWorker) { + targetWorker.postMessage(d, d["transferList"]); + } else { + err('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d["targetThread"] + ", but that thread no longer exists!"); + } + PThread.currentProxiedOperationCallerThread = undefined; + return; + } + if (cmd === "checkMailbox") { + checkMailbox(); + } 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") { + worker.loaded = true; + onFinishedLoading(worker); + } 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 === "callHandler") { + Module[d["handler"]](...d["args"]); + } else if (cmd) { + err("worker sent an unknown command " + cmd); + } + PThread.currentProxiedOperationCallerThread = undefined; + }; + worker.onerror = e => { + var message = "worker sent an error!"; + if (worker.pthread_ptr) { + message = "Pthread " + ptrToString(worker.pthread_ptr) + " sent an error!"; + } + err(message + " " + e.filename + ":" + e.lineno + ": " + e.message); + throw e; + }; + assert(wasmMemory instanceof WebAssembly.Memory, "WebAssembly memory should have been loaded by now!"); + assert(wasmModule instanceof WebAssembly.Module, "WebAssembly Module should have been loaded by now!"); + var handlers = []; + var knownHandlers = [ "onExit", "onAbort", "print", "printErr" ]; + for (var handler of knownHandlers) { + if (Module.hasOwnProperty(handler)) { + handlers.push(handler); + } + } + worker.workerID = PThread.nextWorkerID++; + worker.postMessage({ + "cmd": "load", + "handlers": handlers, + "urlOrBlob": Module["mainScriptUrlOrBlob"] || _scriptDir, + "wasmMemory": wasmMemory, + "wasmModule": wasmModule, + "workerID": worker.workerID + }); + }), + loadWasmModuleToAllWorkers: function(onMaybeReady) { + if (ENVIRONMENT_IS_PTHREAD) { + return onMaybeReady(); + } + let pthreadPoolReady = Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker)); + pthreadPoolReady.then(onMaybeReady); + }, + allocateUnusedWorker: function() { + var worker; + var pthreadMainJs = locateFile("godot.web.template_release.wasm32.worker.js"); + worker = new Worker(pthreadMainJs); + PThread.unusedWorkers.push(worker); + }, + getNewWorker: function() { + if (PThread.unusedWorkers.length == 0) { + err("Tried to spawn a new thread, but the thread pool is exhausted.\n" + "This might result in a deadlock unless some threads eventually exit or the code explicitly breaks out to the event loop.\n" + "If you want to increase the pool size, use setting `-sPTHREAD_POOL_SIZE=...`." + "\nIf you want to throw an explicit error instead of the risk of deadlocking in those cases, use setting `-sPTHREAD_POOL_SIZE_STRICT=2`."); + PThread.allocateUnusedWorker(); + PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]); + } + return PThread.unusedWorkers.pop(); + } +}; + +Module["PThread"] = PThread; + +function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + callbacks.shift()(Module); + } +} + +function establishStackSpace() { + var pthread_ptr = _pthread_self(); + var stackTop = GROWABLE_HEAP_I32()[pthread_ptr + 52 >> 2]; + var stackSize = GROWABLE_HEAP_I32()[pthread_ptr + 56 >> 2]; + var stackMax = stackTop - stackSize; + assert(stackTop != 0); + assert(stackMax != 0); + assert(stackTop > stackMax, "stackTop must be higher then stackMax"); + _emscripten_stack_set_limits(stackTop, stackMax); + stackRestore(stackTop); + writeStackCookie(); +} + +Module["establishStackSpace"] = establishStackSpace; + +function exitOnMainThread(returnCode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(2, 0, returnCode); + _exit(returnCode); +} + +function getValue(ptr, type = "i8") { + if (type.endsWith("*")) type = "*"; + switch (type) { + case "i1": + return GROWABLE_HEAP_I8()[ptr >> 0]; + + case "i8": + return GROWABLE_HEAP_I8()[ptr >> 0]; + + case "i16": + return GROWABLE_HEAP_I16()[ptr >> 1]; + + case "i32": + return GROWABLE_HEAP_I32()[ptr >> 2]; + + case "i64": + return GROWABLE_HEAP_I32()[ptr >> 2]; + + case "float": + return GROWABLE_HEAP_F32()[ptr >> 2]; + + case "double": + return GROWABLE_HEAP_F64()[ptr >> 3]; + + case "*": + return GROWABLE_HEAP_U32()[ptr >> 2]; + + default: + abort(`invalid type for getValue: ${type}`); + } +} + +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); + } + assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!"); + return func; +} + +function invokeEntryPoint(ptr, arg) { + runtimeKeepaliveCounter = 0; + var result = getWasmTableEntry(ptr)(arg); + checkStackCookie(); + if (keepRuntimeAlive()) { + PThread.setExitStatus(result); + } else { + __emscripten_thread_exit(result); + } +} + +Module["invokeEntryPoint"] = invokeEntryPoint; + +function registerTLSInit(tlsInitFunc) { + PThread.tlsInitFunctions.push(tlsInitFunc); +} + +function setValue(ptr, value, type = "i8") { + if (type.endsWith("*")) type = "*"; + switch (type) { + case "i1": + GROWABLE_HEAP_I8()[ptr >> 0] = value; + break; + + case "i8": + GROWABLE_HEAP_I8()[ptr >> 0] = value; + break; + + case "i16": + GROWABLE_HEAP_I16()[ptr >> 1] = value; + break; + + case "i32": + GROWABLE_HEAP_I32()[ptr >> 2] = value; + break; + + case "i64": + tempI64 = [ value >>> 0, (tempDouble = value, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[ptr >> 2] = tempI64[0], GROWABLE_HEAP_I32()[ptr + 4 >> 2] = tempI64[1]; + break; + + case "float": + GROWABLE_HEAP_F32()[ptr >> 2] = value; + break; + + case "double": + GROWABLE_HEAP_F64()[ptr >> 3] = value; + break; + + case "*": + GROWABLE_HEAP_U32()[ptr >> 2] = value; + break; + + default: + abort(`invalid type for setValue: ${type}`); + } +} + +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } +} + +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 ___call_sighandler(fp, sig) { + getWasmTableEntry(fp)(sig); +} + +var dlopenMissingError = "To use dlopen, you need enable dynamic linking, see https://emscripten.org/docs/compiling/Dynamic-Linking.html"; + +function ___dlsym(handle, symbol) { + abort(dlopenMissingError); +} + +function ___emscripten_init_main_thread_js(tb) { + __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1, !ENVIRONMENT_IS_WEB, 2097152); + PThread.threadInitTLS(); +} + +function ___emscripten_thread_cleanup(thread) { + if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread); else postMessage({ + "cmd": "cleanupThread", + "thread": thread + }); +} + +function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(3, 1, pthread_ptr, attr, startRoutine, arg); + return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg); +} + +function ___pthread_create_js(pthread_ptr, attr, startRoutine, arg) { + if (typeof SharedArrayBuffer == "undefined") { + err("Current environment does not support SharedArrayBuffer, pthreads are not available!"); + return 6; + } + var transferList = []; + var error = 0; + if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) { + return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg); + } + if (error) return error; + var threadParams = { + startRoutine: startRoutine, + pthread_ptr: pthread_ptr, + arg: arg, + transferList: transferList + }; + if (ENVIRONMENT_IS_PTHREAD) { + threadParams.cmd = "spawnThread"; + postMessage(threadParams, transferList); + return 0; + } + return spawnThread(threadParams); +} + +function ___syscall__newselect(nfds, readfds, writefds, exceptfds, timeout) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(4, 1, nfds, readfds, writefds, exceptfds, timeout); + try { + assert(nfds <= 64, "nfds must be less than or equal to 64"); + assert(!exceptfds, "exceptfds not supported"); + var total = 0; + var srcReadLow = readfds ? GROWABLE_HEAP_I32()[readfds >> 2] : 0, srcReadHigh = readfds ? GROWABLE_HEAP_I32()[readfds + 4 >> 2] : 0; + var srcWriteLow = writefds ? GROWABLE_HEAP_I32()[writefds >> 2] : 0, srcWriteHigh = writefds ? GROWABLE_HEAP_I32()[writefds + 4 >> 2] : 0; + var srcExceptLow = exceptfds ? GROWABLE_HEAP_I32()[exceptfds >> 2] : 0, srcExceptHigh = exceptfds ? GROWABLE_HEAP_I32()[exceptfds + 4 >> 2] : 0; + var dstReadLow = 0, dstReadHigh = 0; + var dstWriteLow = 0, dstWriteHigh = 0; + var dstExceptLow = 0, dstExceptHigh = 0; + var allLow = (readfds ? GROWABLE_HEAP_I32()[readfds >> 2] : 0) | (writefds ? GROWABLE_HEAP_I32()[writefds >> 2] : 0) | (exceptfds ? GROWABLE_HEAP_I32()[exceptfds >> 2] : 0); + var allHigh = (readfds ? GROWABLE_HEAP_I32()[readfds + 4 >> 2] : 0) | (writefds ? GROWABLE_HEAP_I32()[writefds + 4 >> 2] : 0) | (exceptfds ? GROWABLE_HEAP_I32()[exceptfds + 4 >> 2] : 0); + var check = function(fd, low, high, val) { + return fd < 32 ? low & val : high & val; + }; + for (var fd = 0; fd < nfds; fd++) { + var mask = 1 << fd % 32; + if (!check(fd, allLow, allHigh, mask)) { + continue; + } + var stream = SYSCALLS.getStreamFromFD(fd); + var flags = SYSCALLS.DEFAULT_POLLMASK; + if (stream.stream_ops.poll) { + flags = stream.stream_ops.poll(stream); + } + if (flags & 1 && check(fd, srcReadLow, srcReadHigh, mask)) { + fd < 32 ? dstReadLow = dstReadLow | mask : dstReadHigh = dstReadHigh | mask; + total++; + } + if (flags & 4 && check(fd, srcWriteLow, srcWriteHigh, mask)) { + fd < 32 ? dstWriteLow = dstWriteLow | mask : dstWriteHigh = dstWriteHigh | mask; + total++; + } + if (flags & 2 && check(fd, srcExceptLow, srcExceptHigh, mask)) { + fd < 32 ? dstExceptLow = dstExceptLow | mask : dstExceptHigh = dstExceptHigh | mask; + total++; + } + } + if (readfds) { + GROWABLE_HEAP_I32()[readfds >> 2] = dstReadLow; + GROWABLE_HEAP_I32()[readfds + 4 >> 2] = dstReadHigh; + } + if (writefds) { + GROWABLE_HEAP_I32()[writefds >> 2] = dstWriteLow; + GROWABLE_HEAP_I32()[writefds + 4 >> 2] = dstWriteHigh; + } + if (exceptfds) { + GROWABLE_HEAP_I32()[exceptfds >> 2] = dstExceptLow; + GROWABLE_HEAP_I32()[exceptfds + 4 >> 2] = dstExceptHigh; + } + return total; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var SOCKFS = { + mount: function(mount) { + Module["websocket"] = Module["websocket"] && "object" === typeof Module["websocket"] ? Module["websocket"] : {}; + Module["websocket"]._callbacks = {}; + Module["websocket"]["on"] = function(event, callback) { + if ("function" === typeof callback) { + this._callbacks[event] = callback; + } + return this; + }; + Module["websocket"].emit = function(event, param) { + if ("function" === typeof this._callbacks[event]) { + this._callbacks[event].call(this, param); + } + }; + return FS.createNode(null, "/", 16384 | 511, 0); + }, + createSocket: function(family, type, protocol) { + type &= ~526336; + var streaming = type == 1; + if (streaming && protocol && protocol != 6) { + throw new FS.ErrnoError(66); + } + var sock = { + family: family, + type: type, + protocol: protocol, + server: null, + error: null, + peers: {}, + pending: [], + recv_queue: [], + sock_ops: SOCKFS.websocket_sock_ops + }; + var name = SOCKFS.nextname(); + var node = FS.createNode(SOCKFS.root, name, 49152, 0); + node.sock = sock; + var stream = FS.createStream({ + path: name, + node: node, + flags: 2, + seekable: false, + stream_ops: SOCKFS.stream_ops + }); + sock.stream = stream; + return sock; + }, + getSocket: function(fd) { + var stream = FS.getStream(fd); + if (!stream || !FS.isSocket(stream.node.mode)) { + return null; + } + return stream.node.sock; + }, + stream_ops: { + poll: function(stream) { + var sock = stream.node.sock; + return sock.sock_ops.poll(sock); + }, + ioctl: function(stream, request, varargs) { + var sock = stream.node.sock; + return sock.sock_ops.ioctl(sock, request, varargs); + }, + read: function(stream, buffer, offset, length, position) { + var sock = stream.node.sock; + var msg = sock.sock_ops.recvmsg(sock, length); + if (!msg) { + return 0; + } + buffer.set(msg.buffer, offset); + return msg.buffer.length; + }, + write: function(stream, buffer, offset, length, position) { + var sock = stream.node.sock; + return sock.sock_ops.sendmsg(sock, buffer, offset, length); + }, + close: function(stream) { + var sock = stream.node.sock; + sock.sock_ops.close(sock); + } + }, + nextname: function() { + if (!SOCKFS.nextname.current) { + SOCKFS.nextname.current = 0; + } + return "socket[" + SOCKFS.nextname.current++ + "]"; + }, + websocket_sock_ops: { + createPeer: function(sock, addr, port) { + var ws; + if (typeof addr == "object") { + ws = addr; + addr = null; + port = null; + } + if (ws) { + if (ws._socket) { + addr = ws._socket.remoteAddress; + port = ws._socket.remotePort; + } else { + var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url); + if (!result) { + throw new Error("WebSocket URL must be in the format ws(s)://address:port"); + } + addr = result[1]; + port = parseInt(result[2], 10); + } + } else { + try { + var runtimeConfig = Module["websocket"] && "object" === typeof Module["websocket"]; + var url = "ws:#".replace("#", "//"); + if (runtimeConfig) { + if ("string" === typeof Module["websocket"]["url"]) { + url = Module["websocket"]["url"]; + } + } + if (url === "ws://" || url === "wss://") { + var parts = addr.split("/"); + url = url + parts[0] + ":" + port + "/" + parts.slice(1).join("/"); + } + var subProtocols = "binary"; + if (runtimeConfig) { + if ("string" === typeof Module["websocket"]["subprotocol"]) { + subProtocols = Module["websocket"]["subprotocol"]; + } + } + var opts = undefined; + if (subProtocols !== "null") { + subProtocols = subProtocols.replace(/^ +| +$/g, "").split(/ *, */); + opts = subProtocols; + } + if (runtimeConfig && null === Module["websocket"]["subprotocol"]) { + subProtocols = "null"; + opts = undefined; + } + var WebSocketConstructor; + { + WebSocketConstructor = WebSocket; + } + ws = new WebSocketConstructor(url, opts); + ws.binaryType = "arraybuffer"; + } catch (e) { + throw new FS.ErrnoError(23); + } + } + var peer = { + addr: addr, + port: port, + socket: ws, + dgram_send_queue: [] + }; + SOCKFS.websocket_sock_ops.addPeer(sock, peer); + SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer); + if (sock.type === 2 && typeof sock.sport != "undefined") { + peer.dgram_send_queue.push(new Uint8Array([ 255, 255, 255, 255, "p".charCodeAt(0), "o".charCodeAt(0), "r".charCodeAt(0), "t".charCodeAt(0), (sock.sport & 65280) >> 8, sock.sport & 255 ])); + } + return peer; + }, + getPeer: function(sock, addr, port) { + return sock.peers[addr + ":" + port]; + }, + addPeer: function(sock, peer) { + sock.peers[peer.addr + ":" + peer.port] = peer; + }, + removePeer: function(sock, peer) { + delete sock.peers[peer.addr + ":" + peer.port]; + }, + handlePeerEvents: function(sock, peer) { + var first = true; + var handleOpen = function() { + Module["websocket"].emit("open", sock.stream.fd); + try { + var queued = peer.dgram_send_queue.shift(); + while (queued) { + peer.socket.send(queued); + queued = peer.dgram_send_queue.shift(); + } + } catch (e) { + peer.socket.close(); + } + }; + function handleMessage(data) { + if (typeof data == "string") { + var encoder = new TextEncoder(); + data = encoder.encode(data); + } else { + assert(data.byteLength !== undefined); + if (data.byteLength == 0) { + return; + } + data = new Uint8Array(data); + } + var wasfirst = first; + first = false; + if (wasfirst && data.length === 10 && data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 && data[4] === "p".charCodeAt(0) && data[5] === "o".charCodeAt(0) && data[6] === "r".charCodeAt(0) && data[7] === "t".charCodeAt(0)) { + var newport = data[8] << 8 | data[9]; + SOCKFS.websocket_sock_ops.removePeer(sock, peer); + peer.port = newport; + SOCKFS.websocket_sock_ops.addPeer(sock, peer); + return; + } + sock.recv_queue.push({ + addr: peer.addr, + port: peer.port, + data: data + }); + Module["websocket"].emit("message", sock.stream.fd); + } + if (ENVIRONMENT_IS_NODE) { + peer.socket.on("open", handleOpen); + peer.socket.on("message", function(data, isBinary) { + if (!isBinary) { + return; + } + handleMessage(new Uint8Array(data).buffer); + }); + peer.socket.on("close", function() { + Module["websocket"].emit("close", sock.stream.fd); + }); + peer.socket.on("error", function(error) { + sock.error = 14; + Module["websocket"].emit("error", [ sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused" ]); + }); + } else { + peer.socket.onopen = handleOpen; + peer.socket.onclose = function() { + Module["websocket"].emit("close", sock.stream.fd); + }; + peer.socket.onmessage = function peer_socket_onmessage(event) { + handleMessage(event.data); + }; + peer.socket.onerror = function(error) { + sock.error = 14; + Module["websocket"].emit("error", [ sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused" ]); + }; + } + }, + poll: function(sock) { + if (sock.type === 1 && sock.server) { + return sock.pending.length ? 64 | 1 : 0; + } + var mask = 0; + var dest = sock.type === 1 ? SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) : null; + if (sock.recv_queue.length || !dest || dest && dest.socket.readyState === dest.socket.CLOSING || dest && dest.socket.readyState === dest.socket.CLOSED) { + mask |= 64 | 1; + } + if (!dest || dest && dest.socket.readyState === dest.socket.OPEN) { + mask |= 4; + } + if (dest && dest.socket.readyState === dest.socket.CLOSING || dest && dest.socket.readyState === dest.socket.CLOSED) { + mask |= 16; + } + return mask; + }, + ioctl: function(sock, request, arg) { + switch (request) { + case 21531: + var bytes = 0; + if (sock.recv_queue.length) { + bytes = sock.recv_queue[0].data.length; + } + GROWABLE_HEAP_I32()[arg >> 2] = bytes; + return 0; + + default: + return 28; + } + }, + close: function(sock) { + if (sock.server) { + try { + sock.server.close(); + } catch (e) {} + sock.server = null; + } + var peers = Object.keys(sock.peers); + for (var i = 0; i < peers.length; i++) { + var peer = sock.peers[peers[i]]; + try { + peer.socket.close(); + } catch (e) {} + SOCKFS.websocket_sock_ops.removePeer(sock, peer); + } + return 0; + }, + bind: function(sock, addr, port) { + if (typeof sock.saddr != "undefined" || typeof sock.sport != "undefined") { + throw new FS.ErrnoError(28); + } + sock.saddr = addr; + sock.sport = port; + if (sock.type === 2) { + if (sock.server) { + sock.server.close(); + sock.server = null; + } + try { + sock.sock_ops.listen(sock, 0); + } catch (e) { + if (!(e.name === "ErrnoError")) throw e; + if (e.errno !== 138) throw e; + } + } + }, + connect: function(sock, addr, port) { + if (sock.server) { + throw new FS.ErrnoError(138); + } + if (typeof sock.daddr != "undefined" && typeof sock.dport != "undefined") { + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport); + if (dest) { + if (dest.socket.readyState === dest.socket.CONNECTING) { + throw new FS.ErrnoError(7); + } else { + throw new FS.ErrnoError(30); + } + } + } + var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); + sock.daddr = peer.addr; + sock.dport = peer.port; + throw new FS.ErrnoError(26); + }, + listen: function(sock, backlog) { + if (!ENVIRONMENT_IS_NODE) { + throw new FS.ErrnoError(138); + } + }, + accept: function(listensock) { + if (!listensock.server || !listensock.pending.length) { + throw new FS.ErrnoError(28); + } + var newsock = listensock.pending.shift(); + newsock.stream.flags = listensock.stream.flags; + return newsock; + }, + getname: function(sock, peer) { + var addr, port; + if (peer) { + if (sock.daddr === undefined || sock.dport === undefined) { + throw new FS.ErrnoError(53); + } + addr = sock.daddr; + port = sock.dport; + } else { + addr = sock.saddr || 0; + port = sock.sport || 0; + } + return { + addr: addr, + port: port + }; + }, + sendmsg: function(sock, buffer, offset, length, addr, port) { + if (sock.type === 2) { + if (addr === undefined || port === undefined) { + addr = sock.daddr; + port = sock.dport; + } + if (addr === undefined || port === undefined) { + throw new FS.ErrnoError(17); + } + } else { + addr = sock.daddr; + port = sock.dport; + } + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port); + if (sock.type === 1) { + if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + throw new FS.ErrnoError(53); + } else if (dest.socket.readyState === dest.socket.CONNECTING) { + throw new FS.ErrnoError(6); + } + } + if (ArrayBuffer.isView(buffer)) { + offset += buffer.byteOffset; + buffer = buffer.buffer; + } + var data; + if (buffer instanceof SharedArrayBuffer) { + data = new Uint8Array(new Uint8Array(buffer.slice(offset, offset + length))).buffer; + } else { + data = buffer.slice(offset, offset + length); + } + if (sock.type === 2) { + if (!dest || dest.socket.readyState !== dest.socket.OPEN) { + if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); + } + dest.dgram_send_queue.push(data); + return length; + } + } + try { + dest.socket.send(data); + return length; + } catch (e) { + throw new FS.ErrnoError(28); + } + }, + recvmsg: function(sock, length) { + if (sock.type === 1 && sock.server) { + throw new FS.ErrnoError(53); + } + var queued = sock.recv_queue.shift(); + if (!queued) { + if (sock.type === 1) { + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport); + if (!dest) { + throw new FS.ErrnoError(53); + } + if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + return null; + } + throw new FS.ErrnoError(6); + } + throw new FS.ErrnoError(6); + } + var queuedLength = queued.data.byteLength || queued.data.length; + var queuedOffset = queued.data.byteOffset || 0; + var queuedBuffer = queued.data.buffer || queued.data; + var bytesRead = Math.min(length, queuedLength); + var res = { + buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead), + addr: queued.addr, + port: queued.port + }; + if (sock.type === 1 && bytesRead < queuedLength) { + var bytesRemaining = queuedLength - bytesRead; + queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining); + sock.recv_queue.unshift(queued); + } + return res; + } + } +}; + +function getSocketFromFD(fd) { + var socket = SOCKFS.getSocket(fd); + if (!socket) throw new FS.ErrnoError(8); + return socket; +} + +function setErrNo(value) { + GROWABLE_HEAP_I32()[___errno_location() >> 2] = value; + return value; +} + +var Sockets = { + BUFFER_SIZE: 10240, + MAX_BUFFER_SIZE: 10485760, + nextFd: 1, + fds: {}, + nextport: 1, + maxport: 65535, + peer: null, + connections: {}, + portmap: {}, + localAddr: 4261412874, + addrPool: [ 33554442, 50331658, 67108874, 83886090, 100663306, 117440522, 134217738, 150994954, 167772170, 184549386, 201326602, 218103818, 234881034 ] +}; + +function inetPton4(str) { + var b = str.split("."); + for (var i = 0; i < 4; i++) { + var tmp = Number(b[i]); + if (isNaN(tmp)) return null; + b[i] = tmp; + } + return (b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24) >>> 0; +} + +function jstoi_q(str) { + return parseInt(str); +} + +function inetPton6(str) { + var words; + var w, offset, z, i; + var valid6regx = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i; + var parts = []; + if (!valid6regx.test(str)) { + return null; + } + if (str === "::") { + return [ 0, 0, 0, 0, 0, 0, 0, 0 ]; + } + if (str.startsWith("::")) { + str = str.replace("::", "Z:"); + } else { + str = str.replace("::", ":Z:"); + } + if (str.indexOf(".") > 0) { + str = str.replace(new RegExp("[.]", "g"), ":"); + words = str.split(":"); + words[words.length - 4] = jstoi_q(words[words.length - 4]) + jstoi_q(words[words.length - 3]) * 256; + words[words.length - 3] = jstoi_q(words[words.length - 2]) + jstoi_q(words[words.length - 1]) * 256; + words = words.slice(0, words.length - 2); + } else { + words = str.split(":"); + } + offset = 0; + z = 0; + for (w = 0; w < words.length; w++) { + if (typeof words[w] == "string") { + if (words[w] === "Z") { + for (z = 0; z < 8 - words.length + 1; z++) { + parts[w + z] = 0; + } + offset = z - 1; + } else { + parts[w + offset] = _htons(parseInt(words[w], 16)); + } + } else { + parts[w + offset] = words[w]; + } + } + return [ parts[1] << 16 | parts[0], parts[3] << 16 | parts[2], parts[5] << 16 | parts[4], parts[7] << 16 | parts[6] ]; +} + +function writeSockaddr(sa, family, addr, port, addrlen) { + switch (family) { + case 2: + addr = inetPton4(addr); + zeroMemory(sa, 16); + if (addrlen) { + GROWABLE_HEAP_I32()[addrlen >> 2] = 16; + } + GROWABLE_HEAP_I16()[sa >> 1] = family; + GROWABLE_HEAP_I32()[sa + 4 >> 2] = addr; + GROWABLE_HEAP_I16()[sa + 2 >> 1] = _htons(port); + break; + + case 10: + addr = inetPton6(addr); + zeroMemory(sa, 28); + if (addrlen) { + GROWABLE_HEAP_I32()[addrlen >> 2] = 28; + } + GROWABLE_HEAP_I32()[sa >> 2] = family; + GROWABLE_HEAP_I32()[sa + 8 >> 2] = addr[0]; + GROWABLE_HEAP_I32()[sa + 12 >> 2] = addr[1]; + GROWABLE_HEAP_I32()[sa + 16 >> 2] = addr[2]; + GROWABLE_HEAP_I32()[sa + 20 >> 2] = addr[3]; + GROWABLE_HEAP_I16()[sa + 2 >> 1] = _htons(port); + break; + + default: + return 5; + } + return 0; +} + +var DNS = { + address_map: { + id: 1, + addrs: {}, + names: {} + }, + lookup_name: function(name) { + var res = inetPton4(name); + if (res !== null) { + return name; + } + res = inetPton6(name); + if (res !== null) { + return name; + } + var addr; + if (DNS.address_map.addrs[name]) { + addr = DNS.address_map.addrs[name]; + } else { + var id = DNS.address_map.id++; + assert(id < 65535, "exceeded max address mappings of 65535"); + addr = "172.29." + (id & 255) + "." + (id & 65280); + DNS.address_map.names[addr] = name; + DNS.address_map.addrs[name] = addr; + } + return addr; + }, + lookup_addr: function(addr) { + if (DNS.address_map.names[addr]) { + return DNS.address_map.names[addr]; + } + return null; + } +}; + +function ___syscall_accept4(fd, addr, addrlen, flags, d1, d2) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(5, 1, fd, addr, addrlen, flags, d1, d2); + try { + var sock = getSocketFromFD(fd); + var newsock = sock.sock_ops.accept(sock); + if (addr) { + var errno = writeSockaddr(addr, newsock.family, DNS.lookup_name(newsock.daddr), newsock.dport, addrlen); + assert(!errno); + } + return newsock.stream.fd; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function inetNtop4(addr) { + return (addr & 255) + "." + (addr >> 8 & 255) + "." + (addr >> 16 & 255) + "." + (addr >> 24 & 255); +} + +function inetNtop6(ints) { + var str = ""; + var word = 0; + var longest = 0; + var lastzero = 0; + var zstart = 0; + var len = 0; + var i = 0; + var parts = [ ints[0] & 65535, ints[0] >> 16, ints[1] & 65535, ints[1] >> 16, ints[2] & 65535, ints[2] >> 16, ints[3] & 65535, ints[3] >> 16 ]; + var hasipv4 = true; + var v4part = ""; + for (i = 0; i < 5; i++) { + if (parts[i] !== 0) { + hasipv4 = false; + break; + } + } + if (hasipv4) { + v4part = inetNtop4(parts[6] | parts[7] << 16); + if (parts[5] === -1) { + str = "::ffff:"; + str += v4part; + return str; + } + if (parts[5] === 0) { + str = "::"; + if (v4part === "0.0.0.0") v4part = ""; + if (v4part === "0.0.0.1") v4part = "1"; + str += v4part; + return str; + } + } + for (word = 0; word < 8; word++) { + if (parts[word] === 0) { + if (word - lastzero > 1) { + len = 0; + } + lastzero = word; + len++; + } + if (len > longest) { + longest = len; + zstart = word - longest + 1; + } + } + for (word = 0; word < 8; word++) { + if (longest > 1) { + if (parts[word] === 0 && word >= zstart && word < zstart + longest) { + if (word === zstart) { + str += ":"; + if (zstart === 0) str += ":"; + } + continue; + } + } + str += Number(_ntohs(parts[word] & 65535)).toString(16); + str += word < 7 ? ":" : ""; + } + return str; +} + +function readSockaddr(sa, salen) { + var family = GROWABLE_HEAP_I16()[sa >> 1]; + var port = _ntohs(GROWABLE_HEAP_U16()[sa + 2 >> 1]); + var addr; + switch (family) { + case 2: + if (salen !== 16) { + return { + errno: 28 + }; + } + addr = GROWABLE_HEAP_I32()[sa + 4 >> 2]; + addr = inetNtop4(addr); + break; + + case 10: + if (salen !== 28) { + return { + errno: 28 + }; + } + addr = [ GROWABLE_HEAP_I32()[sa + 8 >> 2], GROWABLE_HEAP_I32()[sa + 12 >> 2], GROWABLE_HEAP_I32()[sa + 16 >> 2], GROWABLE_HEAP_I32()[sa + 20 >> 2] ]; + addr = inetNtop6(addr); + break; + + default: + return { + errno: 5 + }; + } + return { + family: family, + addr: addr, + port: port + }; +} + +function getSocketAddress(addrp, addrlen, allowNull) { + if (allowNull && addrp === 0) return null; + var info = readSockaddr(addrp, addrlen); + if (info.errno) throw new FS.ErrnoError(info.errno); + info.addr = DNS.lookup_addr(info.addr) || info.addr; + return info; +} + +function ___syscall_bind(fd, addr, addrlen, d1, d2, d3) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(6, 1, fd, addr, addrlen, d1, d2, d3); + try { + var sock = getSocketFromFD(fd); + var info = getSocketAddress(addr, addrlen); + sock.sock_ops.bind(sock, info.addr, info.port); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_chdir(path) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(7, 1, path); + try { + path = SYSCALLS.getStr(path); + FS.chdir(path); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_chmod(path, mode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(8, 1, path, mode); + try { + path = SYSCALLS.getStr(path); + FS.chmod(path, mode); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_connect(fd, addr, addrlen, d1, d2, d3) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(9, 1, fd, addr, addrlen, d1, d2, d3); + try { + var sock = getSocketFromFD(fd); + var info = getSocketAddress(addr, addrlen); + sock.sock_ops.connect(sock, info.addr, info.port); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_faccessat(dirfd, path, amode, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(10, 1, dirfd, path, amode, flags); + try { + path = SYSCALLS.getStr(path); + assert(flags === 0); + path = SYSCALLS.calculateAt(dirfd, path); + if (amode & ~7) { + return -28; + } + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + if (!node) { + return -44; + } + var perms = ""; + if (amode & 4) perms += "r"; + if (amode & 2) perms += "w"; + if (amode & 1) perms += "x"; + if (perms && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_fchmod(fd, mode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(11, 1, fd, mode); + try { + FS.fchmod(fd, mode); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_fcntl64(fd, cmd, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(12, 1, fd, cmd, varargs); + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: + { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + + case 1: + case 2: + return 0; + + case 3: + return stream.flags; + + case 4: + { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + + case 5: + { + var arg = SYSCALLS.get(); + var offset = 0; + GROWABLE_HEAP_I16()[arg + offset >> 1] = 2; + return 0; + } + + case 6: + case 7: + return 0; + + case 16: + case 8: + return -28; + + case 9: + setErrNo(28); + return -1; + + default: + { + return -28; + } + } + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"); + return stringToUTF8Array(str, GROWABLE_HEAP_U8(), outPtr, maxBytesToWrite); +} + +function ___syscall_getcwd(buf, size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(13, 1, buf, size); + try { + if (size === 0) return -28; + var cwd = FS.cwd(); + var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1; + if (size < cwdLengthInBytes) return -68; + stringToUTF8(cwd, buf, size); + return cwdLengthInBytes; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_getdents64(fd, dirp, count) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(14, 1, fd, dirp, count); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + if (!stream.getdents) { + stream.getdents = FS.readdir(stream.path); + } + var struct_size = 280; + var pos = 0; + var off = FS.llseek(stream, 0, 1); + var idx = Math.floor(off / struct_size); + while (idx < stream.getdents.length && pos + struct_size <= count) { + var id; + var type; + var name = stream.getdents[idx]; + if (name === ".") { + id = stream.node.id; + type = 4; + } else if (name === "..") { + var lookup = FS.lookupPath(stream.path, { + parent: true + }); + id = lookup.node.id; + type = 4; + } else { + var child = FS.lookupNode(stream.node, name); + id = child.id; + type = FS.isChrdev(child.mode) ? 2 : FS.isDir(child.mode) ? 4 : FS.isLink(child.mode) ? 10 : 8; + } + assert(id); + tempI64 = [ id >>> 0, (tempDouble = id, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[dirp + pos >> 2] = tempI64[0], GROWABLE_HEAP_I32()[dirp + pos + 4 >> 2] = tempI64[1]; + tempI64 = [ (idx + 1) * struct_size >>> 0, (tempDouble = (idx + 1) * struct_size, + +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[dirp + pos + 8 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[dirp + pos + 12 >> 2] = tempI64[1]; + GROWABLE_HEAP_I16()[dirp + pos + 16 >> 1] = 280; + GROWABLE_HEAP_I8()[dirp + pos + 18 >> 0] = type; + stringToUTF8(name, dirp + pos + 19, 256); + pos += struct_size; + idx += 1; + } + FS.llseek(stream, idx * struct_size, 0); + return pos; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_getsockname(fd, addr, addrlen, d1, d2, d3) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(15, 1, fd, addr, addrlen, d1, d2, d3); + try { + var sock = getSocketFromFD(fd); + var errno = writeSockaddr(addr, sock.family, DNS.lookup_name(sock.saddr || "0.0.0.0"), sock.sport, addrlen); + assert(!errno); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_getsockopt(fd, level, optname, optval, optlen, d1) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(16, 1, fd, level, optname, optval, optlen, d1); + try { + var sock = getSocketFromFD(fd); + if (level === 1) { + if (optname === 4) { + GROWABLE_HEAP_I32()[optval >> 2] = sock.error; + GROWABLE_HEAP_I32()[optlen >> 2] = 4; + sock.error = null; + return 0; + } + } + return -50; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_ioctl(fd, op, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(17, 1, fd, op, varargs); + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: + { + if (!stream.tty) return -59; + return 0; + } + + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: + { + if (!stream.tty) return -59; + return 0; + } + + case 21519: + { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + GROWABLE_HEAP_I32()[argp >> 2] = 0; + return 0; + } + + case 21520: + { + if (!stream.tty) return -59; + return -28; + } + + case 21531: + { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + + case 21523: + { + if (!stream.tty) return -59; + return 0; + } + + case 21524: + { + if (!stream.tty) return -59; + return 0; + } + + default: + return -28; + } + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_listen(fd, backlog) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(18, 1, fd, backlog); + try { + var sock = getSocketFromFD(fd); + sock.sock_ops.listen(sock, backlog); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_lstat64(path, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(19, 1, path, buf); + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_mkdirat(dirfd, path, mode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(20, 1, dirfd, path, mode); + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + path = PATH.normalize(path); + if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1); + FS.mkdir(path, mode, 0); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_newfstatat(dirfd, path, buf, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(21, 1, dirfd, path, buf, flags); + try { + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & ~6400; + assert(!flags, "unknown flags in __syscall_newfstatat: " + flags); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_openat(dirfd, path, flags, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(22, 1, dirfd, path, flags, varargs); + SYSCALLS.varargs = varargs; + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_poll(fds, nfds, timeout) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(23, 1, fds, nfds, timeout); + try { + var nonzero = 0; + for (var i = 0; i < nfds; i++) { + var pollfd = fds + 8 * i; + var fd = GROWABLE_HEAP_I32()[pollfd >> 2]; + var events = GROWABLE_HEAP_I16()[pollfd + 4 >> 1]; + var mask = 32; + var stream = FS.getStream(fd); + if (stream) { + mask = SYSCALLS.DEFAULT_POLLMASK; + if (stream.stream_ops.poll) { + mask = stream.stream_ops.poll(stream); + } + } + mask &= events | 8 | 16; + if (mask) nonzero++; + GROWABLE_HEAP_I16()[pollfd + 6 >> 1] = mask; + } + return nonzero; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_readlinkat(dirfd, path, buf, bufsize) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(24, 1, dirfd, path, buf, bufsize); + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (bufsize <= 0) return -28; + var ret = FS.readlink(path); + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = GROWABLE_HEAP_I8()[buf + len]; + stringToUTF8(ret, buf, bufsize + 1); + GROWABLE_HEAP_I8()[buf + len] = endChar; + return len; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_recvfrom(fd, buf, len, flags, addr, addrlen) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(25, 1, fd, buf, len, flags, addr, addrlen); + try { + var sock = getSocketFromFD(fd); + var msg = sock.sock_ops.recvmsg(sock, len); + if (!msg) return 0; + if (addr) { + var errno = writeSockaddr(addr, sock.family, DNS.lookup_name(msg.addr), msg.port, addrlen); + assert(!errno); + } + GROWABLE_HEAP_U8().set(msg.buffer, buf); + return msg.buffer.byteLength; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(26, 1, olddirfd, oldpath, newdirfd, newpath); + try { + oldpath = SYSCALLS.getStr(oldpath); + newpath = SYSCALLS.getStr(newpath); + oldpath = SYSCALLS.calculateAt(olddirfd, oldpath); + newpath = SYSCALLS.calculateAt(newdirfd, newpath); + FS.rename(oldpath, newpath); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_rmdir(path) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(27, 1, path); + try { + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_sendto(fd, message, length, flags, addr, addr_len) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(28, 1, fd, message, length, flags, addr, addr_len); + try { + var sock = getSocketFromFD(fd); + var dest = getSocketAddress(addr, addr_len, true); + if (!dest) { + return FS.write(sock.stream, GROWABLE_HEAP_I8(), message, length); + } + return sock.sock_ops.sendmsg(sock, GROWABLE_HEAP_I8(), message, length, dest.addr, dest.port); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_socket(domain, type, protocol) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(29, 1, domain, type, protocol); + try { + var sock = SOCKFS.createSocket(domain, type, protocol); + assert(sock.stream.fd < 64); + return sock.stream.fd; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_stat64(path, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(30, 1, path, buf); + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_statfs64(path, size, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(31, 1, path, size, buf); + try { + path = SYSCALLS.getStr(path); + assert(size === 64); + GROWABLE_HEAP_I32()[buf + 4 >> 2] = 4096; + GROWABLE_HEAP_I32()[buf + 40 >> 2] = 4096; + GROWABLE_HEAP_I32()[buf + 8 >> 2] = 1e6; + GROWABLE_HEAP_I32()[buf + 12 >> 2] = 5e5; + GROWABLE_HEAP_I32()[buf + 16 >> 2] = 5e5; + GROWABLE_HEAP_I32()[buf + 20 >> 2] = FS.nextInode; + GROWABLE_HEAP_I32()[buf + 24 >> 2] = 1e6; + GROWABLE_HEAP_I32()[buf + 28 >> 2] = 42; + GROWABLE_HEAP_I32()[buf + 44 >> 2] = 2; + GROWABLE_HEAP_I32()[buf + 36 >> 2] = 255; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_symlink(target, linkpath) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(32, 1, target, linkpath); + try { + target = SYSCALLS.getStr(target); + linkpath = SYSCALLS.getStr(linkpath); + FS.symlink(target, linkpath); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_unlinkat(dirfd, path, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(33, 1, dirfd, path, flags); + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path); + } else if (flags === 512) { + FS.rmdir(path); + } else { + abort("Invalid flags passed to unlinkat"); + } + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var nowIsMonotonic = true; + +function __emscripten_get_now_is_monotonic() { + return nowIsMonotonic; +} + +function maybeExit() { + if (runtimeExited) { + return; + } + if (!keepRuntimeAlive()) { + try { + if (ENVIRONMENT_IS_PTHREAD) __emscripten_thread_exit(EXITSTATUS); else _exit(EXITSTATUS); + } catch (e) { + handleException(e); + } + } +} + +function callUserCallback(func) { + if (runtimeExited || ABORT) { + err("user callback triggered after runtime exited or application aborted. Ignoring."); + return; + } + try { + func(); + maybeExit(); + } catch (e) { + handleException(e); + } +} + +function __emscripten_thread_mailbox_await(pthread_ptr) { + if (typeof Atomics.waitAsync === "function") { + var wait = Atomics.waitAsync(GROWABLE_HEAP_I32(), pthread_ptr >> 2, pthread_ptr); + assert(wait.async); + wait.value.then(checkMailbox); + var waitingAsync = pthread_ptr + 128; + Atomics.store(GROWABLE_HEAP_I32(), waitingAsync >> 2, 1); + } +} + +Module["__emscripten_thread_mailbox_await"] = __emscripten_thread_mailbox_await; + +function checkMailbox() { + var pthread_ptr = _pthread_self(); + if (pthread_ptr) { + __emscripten_thread_mailbox_await(pthread_ptr); + callUserCallback(() => __emscripten_check_mailbox()); + } +} + +Module["checkMailbox"] = checkMailbox; + +function __emscripten_notify_mailbox_postmessage(targetThreadId, currThreadId, mainThreadId) { + if (targetThreadId == currThreadId) { + setTimeout(() => checkMailbox()); + } else if (ENVIRONMENT_IS_PTHREAD) { + postMessage({ + "targetThread": targetThreadId, + "cmd": "checkMailbox" + }); + } else { + var worker = PThread.pthreads[targetThreadId]; + if (!worker) { + err("Cannot send message to thread with ID " + targetThreadId + ", unknown thread ID!"); + return; + } + worker.postMessage({ + "cmd": "checkMailbox" + }); + } +} + +function webgl_enable_ANGLE_instanced_arrays(ctx) { + var ext = ctx.getExtension("ANGLE_instanced_arrays"); + if (ext) { + ctx["vertexAttribDivisor"] = function(index, divisor) { + ext["vertexAttribDivisorANGLE"](index, divisor); + }; + ctx["drawArraysInstanced"] = function(mode, first, count, primcount) { + ext["drawArraysInstancedANGLE"](mode, first, count, primcount); + }; + ctx["drawElementsInstanced"] = function(mode, count, type, indices, primcount) { + ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount); + }; + return 1; + } +} + +function webgl_enable_OES_vertex_array_object(ctx) { + var ext = ctx.getExtension("OES_vertex_array_object"); + if (ext) { + ctx["createVertexArray"] = function() { + return ext["createVertexArrayOES"](); + }; + ctx["deleteVertexArray"] = function(vao) { + ext["deleteVertexArrayOES"](vao); + }; + ctx["bindVertexArray"] = function(vao) { + ext["bindVertexArrayOES"](vao); + }; + ctx["isVertexArray"] = function(vao) { + return ext["isVertexArrayOES"](vao); + }; + return 1; + } +} + +function webgl_enable_WEBGL_draw_buffers(ctx) { + var ext = ctx.getExtension("WEBGL_draw_buffers"); + if (ext) { + ctx["drawBuffers"] = function(n, bufs) { + ext["drawBuffersWEBGL"](n, bufs); + }; + return 1; + } +} + +function webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) { + return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance")); +} + +function webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) { + return !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance")); +} + +function webgl_enable_WEBGL_multi_draw(ctx) { + return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw")); +} + +var GL = { + counter: 1, + buffers: [], + programs: [], + framebuffers: [], + renderbuffers: [], + textures: [], + shaders: [], + vaos: [], + contexts: {}, + offscreenCanvases: {}, + queries: [], + samplers: [], + transformFeedbacks: [], + syncs: [], + stringCache: {}, + stringiCache: {}, + unpackAlignment: 4, + recordError: function recordError(errorCode) { + if (!GL.lastError) { + GL.lastError = errorCode; + } + }, + getNewId: function(table) { + var ret = GL.counter++; + for (var i = table.length; i < ret; i++) { + table[i] = null; + } + return ret; + }, + getSource: function(shader, count, string, length) { + var source = ""; + for (var i = 0; i < count; ++i) { + var len = length ? GROWABLE_HEAP_I32()[length + i * 4 >> 2] : -1; + source += UTF8ToString(GROWABLE_HEAP_I32()[string + i * 4 >> 2], len < 0 ? undefined : len); + } + return source; + }, + createContext: function(canvas, webGLContextAttributes) { + if (webGLContextAttributes.renderViaOffscreenBackBuffer) webGLContextAttributes["preserveDrawingBuffer"] = true; + var ctx = webGLContextAttributes.majorVersion > 1 ? canvas.getContext("webgl2", webGLContextAttributes) : canvas.getContext("webgl", webGLContextAttributes); + if (!ctx) return 0; + var handle = GL.registerContext(ctx, webGLContextAttributes); + return handle; + }, + enableOffscreenFramebufferAttributes: function(webGLContextAttributes) { + webGLContextAttributes.renderViaOffscreenBackBuffer = true; + webGLContextAttributes.preserveDrawingBuffer = true; + }, + createOffscreenFramebuffer: function(context) { + var gl = context.GLctx; + var fbo = gl.createFramebuffer(); + gl.bindFramebuffer(36160, fbo); + context.defaultFbo = fbo; + context.defaultFboForbidBlitFramebuffer = false; + if (gl.getContextAttributes().antialias) { + context.defaultFboForbidBlitFramebuffer = true; + } + context.defaultColorTarget = gl.createTexture(); + context.defaultDepthTarget = gl.createRenderbuffer(); + GL.resizeOffscreenFramebuffer(context); + gl.bindTexture(3553, context.defaultColorTarget); + gl.texParameteri(3553, 10241, 9728); + gl.texParameteri(3553, 10240, 9728); + gl.texParameteri(3553, 10242, 33071); + gl.texParameteri(3553, 10243, 33071); + gl.texImage2D(3553, 0, 6408, gl.canvas.width, gl.canvas.height, 0, 6408, 5121, null); + gl.framebufferTexture2D(36160, 36064, 3553, context.defaultColorTarget, 0); + gl.bindTexture(3553, null); + var depthTarget = gl.createRenderbuffer(); + gl.bindRenderbuffer(36161, context.defaultDepthTarget); + gl.renderbufferStorage(36161, 33189, gl.canvas.width, gl.canvas.height); + gl.framebufferRenderbuffer(36160, 36096, 36161, context.defaultDepthTarget); + gl.bindRenderbuffer(36161, null); + var vertices = [ -1, -1, -1, 1, 1, -1, 1, 1 ]; + var vb = gl.createBuffer(); + gl.bindBuffer(34962, vb); + gl.bufferData(34962, new Float32Array(vertices), 35044); + gl.bindBuffer(34962, null); + context.blitVB = vb; + var vsCode = "attribute vec2 pos;" + "varying lowp vec2 tex;" + "void main() { tex = pos * 0.5 + vec2(0.5,0.5); gl_Position = vec4(pos, 0.0, 1.0); }"; + var vs = gl.createShader(35633); + gl.shaderSource(vs, vsCode); + gl.compileShader(vs); + var fsCode = "varying lowp vec2 tex;" + "uniform sampler2D sampler;" + "void main() { gl_FragColor = texture2D(sampler, tex); }"; + var fs = gl.createShader(35632); + gl.shaderSource(fs, fsCode); + gl.compileShader(fs); + var blitProgram = gl.createProgram(); + gl.attachShader(blitProgram, vs); + gl.attachShader(blitProgram, fs); + gl.linkProgram(blitProgram); + context.blitProgram = blitProgram; + context.blitPosLoc = gl.getAttribLocation(blitProgram, "pos"); + gl.useProgram(blitProgram); + gl.uniform1i(gl.getUniformLocation(blitProgram, "sampler"), 0); + gl.useProgram(null); + context.defaultVao = undefined; + if (gl.createVertexArray) { + context.defaultVao = gl.createVertexArray(); + gl.bindVertexArray(context.defaultVao); + gl.enableVertexAttribArray(context.blitPosLoc); + gl.bindVertexArray(null); + } + }, + resizeOffscreenFramebuffer: function(context) { + var gl = context.GLctx; + if (context.defaultColorTarget) { + var prevTextureBinding = gl.getParameter(32873); + gl.bindTexture(3553, context.defaultColorTarget); + gl.texImage2D(3553, 0, 6408, gl.drawingBufferWidth, gl.drawingBufferHeight, 0, 6408, 5121, null); + gl.bindTexture(3553, prevTextureBinding); + } + if (context.defaultDepthTarget) { + var prevRenderBufferBinding = gl.getParameter(36007); + gl.bindRenderbuffer(36161, context.defaultDepthTarget); + gl.renderbufferStorage(36161, 33189, gl.drawingBufferWidth, gl.drawingBufferHeight); + gl.bindRenderbuffer(36161, prevRenderBufferBinding); + } + }, + blitOffscreenFramebuffer: function(context) { + var gl = context.GLctx; + var prevScissorTest = gl.getParameter(3089); + if (prevScissorTest) gl.disable(3089); + var prevFbo = gl.getParameter(36006); + if (gl.blitFramebuffer && !context.defaultFboForbidBlitFramebuffer) { + gl.bindFramebuffer(36008, context.defaultFbo); + gl.bindFramebuffer(36009, null); + gl.blitFramebuffer(0, 0, gl.canvas.width, gl.canvas.height, 0, 0, gl.canvas.width, gl.canvas.height, 16384, 9728); + } else { + gl.bindFramebuffer(36160, null); + var prevProgram = gl.getParameter(35725); + gl.useProgram(context.blitProgram); + var prevVB = gl.getParameter(34964); + gl.bindBuffer(34962, context.blitVB); + var prevActiveTexture = gl.getParameter(34016); + gl.activeTexture(33984); + var prevTextureBinding = gl.getParameter(32873); + gl.bindTexture(3553, context.defaultColorTarget); + var prevBlend = gl.getParameter(3042); + if (prevBlend) gl.disable(3042); + var prevCullFace = gl.getParameter(2884); + if (prevCullFace) gl.disable(2884); + var prevDepthTest = gl.getParameter(2929); + if (prevDepthTest) gl.disable(2929); + var prevStencilTest = gl.getParameter(2960); + if (prevStencilTest) gl.disable(2960); + function draw() { + gl.vertexAttribPointer(context.blitPosLoc, 2, 5126, false, 0, 0); + gl.drawArrays(5, 0, 4); + } + if (context.defaultVao) { + var prevVAO = gl.getParameter(34229); + gl.bindVertexArray(context.defaultVao); + draw(); + gl.bindVertexArray(prevVAO); + } else { + var prevVertexAttribPointer = { + buffer: gl.getVertexAttrib(context.blitPosLoc, 34975), + size: gl.getVertexAttrib(context.blitPosLoc, 34339), + stride: gl.getVertexAttrib(context.blitPosLoc, 34340), + type: gl.getVertexAttrib(context.blitPosLoc, 34341), + normalized: gl.getVertexAttrib(context.blitPosLoc, 34922), + pointer: gl.getVertexAttribOffset(context.blitPosLoc, 34373) + }; + var maxVertexAttribs = gl.getParameter(34921); + var prevVertexAttribEnables = []; + for (var i = 0; i < maxVertexAttribs; ++i) { + var prevEnabled = gl.getVertexAttrib(i, 34338); + var wantEnabled = i == context.blitPosLoc; + if (prevEnabled && !wantEnabled) { + gl.disableVertexAttribArray(i); + } + if (!prevEnabled && wantEnabled) { + gl.enableVertexAttribArray(i); + } + prevVertexAttribEnables[i] = prevEnabled; + } + draw(); + for (var i = 0; i < maxVertexAttribs; ++i) { + var prevEnabled = prevVertexAttribEnables[i]; + var nowEnabled = i == context.blitPosLoc; + if (prevEnabled && !nowEnabled) { + gl.enableVertexAttribArray(i); + } + if (!prevEnabled && nowEnabled) { + gl.disableVertexAttribArray(i); + } + } + gl.bindBuffer(34962, prevVertexAttribPointer.buffer); + gl.vertexAttribPointer(context.blitPosLoc, prevVertexAttribPointer.size, prevVertexAttribPointer.type, prevVertexAttribPointer.normalized, prevVertexAttribPointer.stride, prevVertexAttribPointer.offset); + } + if (prevStencilTest) gl.enable(2960); + if (prevDepthTest) gl.enable(2929); + if (prevCullFace) gl.enable(2884); + if (prevBlend) gl.enable(3042); + gl.bindTexture(3553, prevTextureBinding); + gl.activeTexture(prevActiveTexture); + gl.bindBuffer(34962, prevVB); + gl.useProgram(prevProgram); + } + gl.bindFramebuffer(36160, prevFbo); + if (prevScissorTest) gl.enable(3089); + }, + registerContext: function(ctx, webGLContextAttributes) { + var handle = _malloc(8); + GROWABLE_HEAP_I32()[handle + 4 >> 2] = _pthread_self(); + var context = { + handle: handle, + attributes: webGLContextAttributes, + version: webGLContextAttributes.majorVersion, + GLctx: ctx + }; + if (ctx.canvas) ctx.canvas.GLctxObject = context; + GL.contexts[handle] = context; + if (typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || webGLContextAttributes.enableExtensionsByDefault) { + GL.initExtensions(context); + } + if (webGLContextAttributes.renderViaOffscreenBackBuffer) GL.createOffscreenFramebuffer(context); + return handle; + }, + makeContextCurrent: function(contextHandle) { + GL.currentContext = GL.contexts[contextHandle]; + Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx; + return !(contextHandle && !GLctx); + }, + getContext: function(contextHandle) { + return GL.contexts[contextHandle]; + }, + deleteContext: function(contextHandle) { + if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null; + if (typeof JSEvents == "object") JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); + if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; + _free(GL.contexts[contextHandle].handle); + GL.contexts[contextHandle] = null; + }, + initExtensions: function(context) { + if (!context) context = GL.currentContext; + if (context.initExtensionsDone) return; + context.initExtensionsDone = true; + var GLctx = context.GLctx; + webgl_enable_ANGLE_instanced_arrays(GLctx); + webgl_enable_OES_vertex_array_object(GLctx); + webgl_enable_WEBGL_draw_buffers(GLctx); + webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx); + webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx); + if (context.version >= 2) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2"); + } + if (context.version < 2 || !GLctx.disjointTimerQueryExt) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query"); + } + webgl_enable_WEBGL_multi_draw(GLctx); + var exts = GLctx.getSupportedExtensions() || []; + exts.forEach(function(ext) { + if (!ext.includes("lose_context") && !ext.includes("debug")) { + GLctx.getExtension(ext); + } + }); + } +}; + +function __emscripten_proxied_gl_context_activated_from_main_browser_thread(contextHandle) { + GLctx = Module.ctx = GL.currentContext = contextHandle; + GL.currentContextIsProxied = true; +} + +function __emscripten_set_offscreencanvas_size(target, width, height) { + err("emscripten_set_offscreencanvas_size: Build with -sOFFSCREENCANVAS_SUPPORT=1 to enable transferring canvases to pthreads."); + return -1; +} + +function __emscripten_thread_set_strongref(thread) {} + +function __emscripten_throw_longjmp() { + throw Infinity; +} + +function readI53FromI64(ptr) { + return GROWABLE_HEAP_U32()[ptr >> 2] + GROWABLE_HEAP_I32()[ptr + 4 >> 2] * 4294967296; +} + +function __gmtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + GROWABLE_HEAP_I32()[tmPtr >> 2] = date.getUTCSeconds(); + GROWABLE_HEAP_I32()[tmPtr + 4 >> 2] = date.getUTCMinutes(); + GROWABLE_HEAP_I32()[tmPtr + 8 >> 2] = date.getUTCHours(); + GROWABLE_HEAP_I32()[tmPtr + 12 >> 2] = date.getUTCDate(); + GROWABLE_HEAP_I32()[tmPtr + 16 >> 2] = date.getUTCMonth(); + GROWABLE_HEAP_I32()[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900; + GROWABLE_HEAP_I32()[tmPtr + 24 >> 2] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0; + GROWABLE_HEAP_I32()[tmPtr + 28 >> 2] = yday; +} + +function isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); +} + +var MONTH_DAYS_LEAP_CUMULATIVE = [ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 ]; + +var MONTH_DAYS_REGULAR_CUMULATIVE = [ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 ]; + +function ydayFromDate(date) { + var leap = isLeapYear(date.getFullYear()); + var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE; + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + return yday; +} + +function __localtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + GROWABLE_HEAP_I32()[tmPtr >> 2] = date.getSeconds(); + GROWABLE_HEAP_I32()[tmPtr + 4 >> 2] = date.getMinutes(); + GROWABLE_HEAP_I32()[tmPtr + 8 >> 2] = date.getHours(); + GROWABLE_HEAP_I32()[tmPtr + 12 >> 2] = date.getDate(); + GROWABLE_HEAP_I32()[tmPtr + 16 >> 2] = date.getMonth(); + GROWABLE_HEAP_I32()[tmPtr + 20 >> 2] = date.getFullYear() - 1900; + GROWABLE_HEAP_I32()[tmPtr + 24 >> 2] = date.getDay(); + var yday = ydayFromDate(date) | 0; + GROWABLE_HEAP_I32()[tmPtr + 28 >> 2] = yday; + GROWABLE_HEAP_I32()[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + GROWABLE_HEAP_I32()[tmPtr + 32 >> 2] = dst; +} + +var timers = {}; + +var _emscripten_get_now; + +_emscripten_get_now = () => performance.timeOrigin + performance.now(); + +function __setitimer_js(which, timeout_ms) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(34, 1, which, timeout_ms); + if (timers[which]) { + clearTimeout(timers[which].id); + delete timers[which]; + } + if (!timeout_ms) return 0; + var id = setTimeout(() => { + assert(which in timers); + delete timers[which]; + callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now())); + }, timeout_ms); + timers[which] = { + id: id, + timeout_ms: timeout_ms + }; + return 0; +} + +function stringToNewUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8(str, ret, size); + return ret; +} + +function __tzset_js(timezone, daylight, tzname) { + var currentYear = new Date().getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + GROWABLE_HEAP_U32()[timezone >> 2] = stdTimezoneOffset * 60; + GROWABLE_HEAP_I32()[daylight >> 2] = Number(winterOffset != summerOffset); + function extractZone(date) { + var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return match ? match[1] : "GMT"; + } + var winterName = extractZone(winter); + var summerName = extractZone(summer); + var winterNamePtr = stringToNewUTF8(winterName); + var summerNamePtr = stringToNewUTF8(summerName); + if (summerOffset < winterOffset) { + GROWABLE_HEAP_U32()[tzname >> 2] = winterNamePtr; + GROWABLE_HEAP_U32()[tzname + 4 >> 2] = summerNamePtr; + } else { + GROWABLE_HEAP_U32()[tzname >> 2] = summerNamePtr; + GROWABLE_HEAP_U32()[tzname + 4 >> 2] = winterNamePtr; + } +} + +function _abort() { + abort("native code called abort()"); +} + +function _dlopen(handle) { + abort(dlopenMissingError); +} + +function runtimeKeepalivePush() { + runtimeKeepaliveCounter += 1; +} + +function _emscripten_set_main_loop_timing(mode, value) { + Browser.mainLoop.timingMode = mode; + Browser.mainLoop.timingValue = value; + if (!Browser.mainLoop.func) { + err("emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up."); + return 1; + } + if (!Browser.mainLoop.running) { + runtimeKeepalivePush(); + Browser.mainLoop.running = true; + } + if (mode == 0) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() { + var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0; + setTimeout(Browser.mainLoop.runner, timeUntilNextTick); + }; + Browser.mainLoop.method = "timeout"; + } else if (mode == 1) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() { + Browser.requestAnimationFrame(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "rAF"; + } else if (mode == 2) { + if (typeof setImmediate == "undefined") { + var setImmediates = []; + var emscriptenMainLoopMessageId = "setimmediate"; + var Browser_setImmediate_messageHandler = event => { + if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) { + event.stopPropagation(); + setImmediates.shift()(); + } + }; + addEventListener("message", Browser_setImmediate_messageHandler, true); + setImmediate = function Browser_emulated_setImmediate(func) { + setImmediates.push(func); + if (ENVIRONMENT_IS_WORKER) { + if (Module["setImmediates"] === undefined) Module["setImmediates"] = []; + Module["setImmediates"].push(func); + postMessage({ + target: emscriptenMainLoopMessageId + }); + } else postMessage(emscriptenMainLoopMessageId, "*"); + }; + } + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() { + setImmediate(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "immediate"; + } + return 0; +} + +function runtimeKeepalivePop() { + assert(runtimeKeepaliveCounter > 0); + runtimeKeepaliveCounter -= 1; +} + +function setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop, arg, noSetTiming) { + assert(!Browser.mainLoop.func, "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters."); + Browser.mainLoop.func = browserIterationFunc; + Browser.mainLoop.arg = arg; + var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop; + function checkIsRunning() { + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) { + runtimeKeepalivePop(); + maybeExit(); + return false; + } + return true; + } + Browser.mainLoop.running = false; + Browser.mainLoop.runner = function Browser_mainLoop_runner() { + if (ABORT) return; + if (Browser.mainLoop.queue.length > 0) { + var start = Date.now(); + var blocker = Browser.mainLoop.queue.shift(); + blocker.func(blocker.arg); + if (Browser.mainLoop.remainingBlockers) { + var remaining = Browser.mainLoop.remainingBlockers; + var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining); + if (blocker.counted) { + Browser.mainLoop.remainingBlockers = next; + } else { + next = next + .5; + Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9; + } + } + out('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms"); + Browser.mainLoop.updateStatus(); + if (!checkIsRunning()) return; + setTimeout(Browser.mainLoop.runner, 0); + return; + } + if (!checkIsRunning()) return; + Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0; + if (Browser.mainLoop.timingMode == 1 && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) { + Browser.mainLoop.scheduler(); + return; + } else if (Browser.mainLoop.timingMode == 0) { + Browser.mainLoop.tickStartTime = _emscripten_get_now(); + } + if (Browser.mainLoop.method === "timeout" && Module.ctx) { + warnOnce("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!"); + Browser.mainLoop.method = ""; + } + Browser.mainLoop.runIter(browserIterationFunc); + checkStackCookie(); + if (!checkIsRunning()) return; + if (typeof SDL == "object" && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData(); + Browser.mainLoop.scheduler(); + }; + if (!noSetTiming) { + if (fps && fps > 0) { + _emscripten_set_main_loop_timing(0, 1e3 / fps); + } else { + _emscripten_set_main_loop_timing(1, 1); + } + Browser.mainLoop.scheduler(); + } + if (simulateInfiniteLoop) { + throw "unwind"; + } +} + +function safeSetTimeout(func, timeout) { + runtimeKeepalivePush(); + return setTimeout(() => { + runtimeKeepalivePop(); + callUserCallback(func); + }, timeout); +} + +var Browser = { + mainLoop: { + running: false, + scheduler: null, + method: "", + currentlyRunningMainloop: 0, + func: null, + arg: 0, + timingMode: 0, + timingValue: 0, + currentFrameNumber: 0, + queue: [], + pause: function() { + Browser.mainLoop.scheduler = null; + Browser.mainLoop.currentlyRunningMainloop++; + }, + resume: function() { + Browser.mainLoop.currentlyRunningMainloop++; + var timingMode = Browser.mainLoop.timingMode; + var timingValue = Browser.mainLoop.timingValue; + var func = Browser.mainLoop.func; + Browser.mainLoop.func = null; + setMainLoop(func, 0, false, Browser.mainLoop.arg, true); + _emscripten_set_main_loop_timing(timingMode, timingValue); + Browser.mainLoop.scheduler(); + }, + updateStatus: function() { + if (Module["setStatus"]) { + var message = Module["statusMessage"] || "Please wait..."; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")"); + } else { + Module["setStatus"](message); + } + } else { + Module["setStatus"](""); + } + } + }, + runIter: function(func) { + if (ABORT) return; + if (Module["preMainLoop"]) { + var preRet = Module["preMainLoop"](); + if (preRet === false) { + return; + } + } + callUserCallback(func); + if (Module["postMainLoop"]) Module["postMainLoop"](); + } + }, + isFullscreen: false, + pointerLock: false, + moduleContextCreatedCallbacks: [], + workers: [], + init: function() { + if (Browser.initted) return; + Browser.initted = true; + var imagePlugin = {}; + imagePlugin["canHandle"] = function imagePlugin_canHandle(name) { + return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name); + }; + imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) { + var b = new Blob([ byteArray ], { + type: Browser.getMimetype(name) + }); + if (b.size !== byteArray.length) { + b = new Blob([ new Uint8Array(byteArray).buffer ], { + type: Browser.getMimetype(name) + }); + } + var url = URL.createObjectURL(b); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var img = new Image(); + img.onload = () => { + assert(img.complete, "Image " + name + " could not be decoded"); + var canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0); + preloadedImages[name] = canvas; + URL.revokeObjectURL(url); + if (onload) onload(byteArray); + }; + img.onerror = event => { + out("Image " + url + " could not be decoded"); + if (onerror) onerror(); + }; + img.src = url; + }; + preloadPlugins.push(imagePlugin); + var audioPlugin = {}; + audioPlugin["canHandle"] = function audioPlugin_canHandle(name) { + return !Module.noAudioDecoding && name.substr(-4) in { + ".ogg": 1, + ".wav": 1, + ".mp3": 1 + }; + }; + audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) { + var done = false; + function finish(audio) { + if (done) return; + done = true; + preloadedAudios[name] = audio; + if (onload) onload(byteArray); + } + function fail() { + if (done) return; + done = true; + preloadedAudios[name] = new Audio(); + if (onerror) onerror(); + } + var b = new Blob([ byteArray ], { + type: Browser.getMimetype(name) + }); + var url = URL.createObjectURL(b); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var audio = new Audio(); + audio.addEventListener("canplaythrough", () => finish(audio), false); + audio.onerror = function audio_onerror(event) { + if (done) return; + err("warning: browser could not fully decode audio " + name + ", trying slower base64 approach"); + function encode64(data) { + var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var PAD = "="; + var ret = ""; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = leftchar << 8 | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = leftchar >> leftbits - 6 & 63; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar & 3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar & 15) << 2]; + ret += PAD; + } + return ret; + } + audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray); + finish(audio); + }; + audio.src = url; + safeSetTimeout(() => { + finish(audio); + }, 1e4); + }; + preloadPlugins.push(audioPlugin); + function pointerLockChange() { + Browser.pointerLock = document["pointerLockElement"] === Module["canvas"] || document["mozPointerLockElement"] === Module["canvas"] || document["webkitPointerLockElement"] === Module["canvas"] || document["msPointerLockElement"] === Module["canvas"]; + } + var canvas = Module["canvas"]; + if (canvas) { + canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || (() => {}); + canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || (() => {}); + canvas.exitPointerLock = canvas.exitPointerLock.bind(document); + document.addEventListener("pointerlockchange", pointerLockChange, false); + document.addEventListener("mozpointerlockchange", pointerLockChange, false); + document.addEventListener("webkitpointerlockchange", pointerLockChange, false); + document.addEventListener("mspointerlockchange", pointerLockChange, false); + if (Module["elementPointerLock"]) { + canvas.addEventListener("click", ev => { + if (!Browser.pointerLock && Module["canvas"].requestPointerLock) { + Module["canvas"].requestPointerLock(); + ev.preventDefault(); + } + }, false); + } + } + }, + createContext: function(canvas, useWebGL, setInModule, webGLContextAttributes) { + if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; + var ctx; + var contextHandle; + if (useWebGL) { + var contextAttributes = { + antialias: false, + alpha: false, + majorVersion: typeof WebGL2RenderingContext != "undefined" ? 2 : 1 + }; + if (webGLContextAttributes) { + for (var attribute in webGLContextAttributes) { + contextAttributes[attribute] = webGLContextAttributes[attribute]; + } + } + if (typeof GL != "undefined") { + contextHandle = GL.createContext(canvas, contextAttributes); + if (contextHandle) { + ctx = GL.getContext(contextHandle).GLctx; + } + } + } else { + ctx = canvas.getContext("2d"); + } + if (!ctx) return null; + if (setInModule) { + if (!useWebGL) assert(typeof GLctx == "undefined", "cannot set in module if GLctx is used, but we are a non-GL context that would replace it"); + Module.ctx = ctx; + if (useWebGL) GL.makeContextCurrent(contextHandle); + Module.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach(callback => callback()); + Browser.init(); + } + return ctx; + }, + destroyContext: function(canvas, useWebGL, setInModule) {}, + fullscreenHandlersInstalled: false, + lockPointer: undefined, + resizeCanvas: undefined, + requestFullscreen: function(lockPointer, resizeCanvas) { + Browser.lockPointer = lockPointer; + Browser.resizeCanvas = resizeCanvas; + if (typeof Browser.lockPointer == "undefined") Browser.lockPointer = true; + if (typeof Browser.resizeCanvas == "undefined") Browser.resizeCanvas = false; + var canvas = Module["canvas"]; + function fullscreenChange() { + Browser.isFullscreen = false; + var canvasContainer = canvas.parentNode; + if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvasContainer) { + canvas.exitFullscreen = Browser.exitFullscreen; + if (Browser.lockPointer) canvas.requestPointerLock(); + Browser.isFullscreen = true; + if (Browser.resizeCanvas) { + Browser.setFullscreenCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } else { + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + if (Browser.resizeCanvas) { + Browser.setWindowedCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } + if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen); + if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen); + } + if (!Browser.fullscreenHandlersInstalled) { + Browser.fullscreenHandlersInstalled = true; + document.addEventListener("fullscreenchange", fullscreenChange, false); + document.addEventListener("mozfullscreenchange", fullscreenChange, false); + document.addEventListener("webkitfullscreenchange", fullscreenChange, false); + document.addEventListener("MSFullscreenChange", fullscreenChange, false); + } + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + canvasContainer.requestFullscreen = canvasContainer["requestFullscreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullscreen"] ? () => canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]) : null) || (canvasContainer["webkitRequestFullScreen"] ? () => canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]) : null); + canvasContainer.requestFullscreen(); + }, + requestFullScreen: function() { + abort("Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)"); + }, + exitFullscreen: function() { + if (!Browser.isFullscreen) { + return false; + } + var CFS = document["exitFullscreen"] || document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["msExitFullscreen"] || document["webkitCancelFullScreen"] || (() => {}); + CFS.apply(document, []); + return true; + }, + nextRAF: 0, + fakeRequestAnimationFrame: function(func) { + var now = Date.now(); + if (Browser.nextRAF === 0) { + Browser.nextRAF = now + 1e3 / 60; + } else { + while (now + 2 >= Browser.nextRAF) { + Browser.nextRAF += 1e3 / 60; + } + } + var delay = Math.max(Browser.nextRAF - now, 0); + setTimeout(func, delay); + }, + requestAnimationFrame: function(func) { + if (typeof requestAnimationFrame == "function") { + requestAnimationFrame(func); + return; + } + var RAF = Browser.fakeRequestAnimationFrame; + RAF(func); + }, + safeSetTimeout: function(func, timeout) { + return safeSetTimeout(func, timeout); + }, + safeRequestAnimationFrame: function(func) { + runtimeKeepalivePush(); + return Browser.requestAnimationFrame(() => { + runtimeKeepalivePop(); + callUserCallback(func); + }); + }, + getMimetype: function(name) { + return { + "jpg": "image/jpeg", + "jpeg": "image/jpeg", + "png": "image/png", + "bmp": "image/bmp", + "ogg": "audio/ogg", + "wav": "audio/wav", + "mp3": "audio/mpeg" + }[name.substr(name.lastIndexOf(".") + 1)]; + }, + getUserMedia: function(func) { + if (!window.getUserMedia) { + window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"]; + } + window.getUserMedia(func); + }, + getMovementX: function(event) { + return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0; + }, + getMovementY: function(event) { + return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0; + }, + getMouseWheelDelta: function(event) { + var delta = 0; + switch (event.type) { + case "DOMMouseScroll": + delta = event.detail / 3; + break; + + case "mousewheel": + delta = event.wheelDelta / 120; + break; + + case "wheel": + delta = event.deltaY; + switch (event.deltaMode) { + case 0: + delta /= 100; + break; + + case 1: + delta /= 3; + break; + + case 2: + delta *= 80; + break; + + default: + throw "unrecognized mouse wheel delta mode: " + event.deltaMode; + } + break; + + default: + throw "unrecognized mouse wheel event: " + event.type; + } + return delta; + }, + mouseX: 0, + mouseY: 0, + mouseMovementX: 0, + mouseMovementY: 0, + touches: {}, + lastTouches: {}, + calculateMouseEvent: function(event) { + if (Browser.pointerLock) { + if (event.type != "mousemove" && "mozMovementX" in event) { + Browser.mouseMovementX = Browser.mouseMovementY = 0; + } else { + Browser.mouseMovementX = Browser.getMovementX(event); + Browser.mouseMovementY = Browser.getMovementY(event); + } + if (typeof SDL != "undefined") { + Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; + Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; + } else { + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY; + } + } else { + var rect = Module["canvas"].getBoundingClientRect(); + var cw = Module["canvas"].width; + var ch = Module["canvas"].height; + var scrollX = typeof window.scrollX != "undefined" ? window.scrollX : window.pageXOffset; + var scrollY = typeof window.scrollY != "undefined" ? window.scrollY : window.pageYOffset; + assert(typeof scrollX != "undefined" && typeof scrollY != "undefined", "Unable to retrieve scroll position, mouse positions likely broken."); + if (event.type === "touchstart" || event.type === "touchend" || event.type === "touchmove") { + var touch = event.touch; + if (touch === undefined) { + return; + } + var adjustedX = touch.pageX - (scrollX + rect.left); + var adjustedY = touch.pageY - (scrollY + rect.top); + adjustedX = adjustedX * (cw / rect.width); + adjustedY = adjustedY * (ch / rect.height); + var coords = { + x: adjustedX, + y: adjustedY + }; + if (event.type === "touchstart") { + Browser.lastTouches[touch.identifier] = coords; + Browser.touches[touch.identifier] = coords; + } else if (event.type === "touchend" || event.type === "touchmove") { + var last = Browser.touches[touch.identifier]; + if (!last) last = coords; + Browser.lastTouches[touch.identifier] = last; + Browser.touches[touch.identifier] = coords; + } + return; + } + var x = event.pageX - (scrollX + rect.left); + var y = event.pageY - (scrollY + rect.top); + x = x * (cw / rect.width); + y = y * (ch / rect.height); + Browser.mouseMovementX = x - Browser.mouseX; + Browser.mouseMovementY = y - Browser.mouseY; + Browser.mouseX = x; + Browser.mouseY = y; + } + }, + resizeListeners: [], + updateResizeListeners: function() { + var canvas = Module["canvas"]; + Browser.resizeListeners.forEach(listener => listener(canvas.width, canvas.height)); + }, + setCanvasSize: function(width, height, noUpdates) { + var canvas = Module["canvas"]; + Browser.updateCanvasDimensions(canvas, width, height); + if (!noUpdates) Browser.updateResizeListeners(); + }, + windowedWidth: 0, + windowedHeight: 0, + setFullscreenCanvasSize: function() { + if (typeof SDL != "undefined") { + var flags = GROWABLE_HEAP_U32()[SDL.screen >> 2]; + flags = flags | 8388608; + GROWABLE_HEAP_I32()[SDL.screen >> 2] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + setWindowedCanvasSize: function() { + if (typeof SDL != "undefined") { + var flags = GROWABLE_HEAP_U32()[SDL.screen >> 2]; + flags = flags & ~8388608; + GROWABLE_HEAP_I32()[SDL.screen >> 2] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + updateCanvasDimensions: function(canvas, wNative, hNative) { + if (wNative && hNative) { + canvas.widthNative = wNative; + canvas.heightNative = hNative; + } else { + wNative = canvas.widthNative; + hNative = canvas.heightNative; + } + var w = wNative; + var h = hNative; + if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) { + if (w / h < Module["forcedAspectRatio"]) { + w = Math.round(h * Module["forcedAspectRatio"]); + } else { + h = Math.round(w / Module["forcedAspectRatio"]); + } + } + if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvas.parentNode && typeof screen != "undefined") { + var factor = Math.min(screen.width / w, screen.height / h); + w = Math.round(w * factor); + h = Math.round(h * factor); + } + if (Browser.resizeCanvas) { + if (canvas.width != w) canvas.width = w; + if (canvas.height != h) canvas.height = h; + if (typeof canvas.style != "undefined") { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height"); + } + } else { + if (canvas.width != wNative) canvas.width = wNative; + if (canvas.height != hNative) canvas.height = hNative; + if (typeof canvas.style != "undefined") { + if (w != wNative || h != hNative) { + canvas.style.setProperty("width", w + "px", "important"); + canvas.style.setProperty("height", h + "px", "important"); + } else { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height"); + } + } + } + } +}; + +function _emscripten_cancel_main_loop() { + Browser.mainLoop.pause(); + Browser.mainLoop.func = null; +} + +function _emscripten_check_blocking_allowed() { + if (ENVIRONMENT_IS_WORKER) return; + warnOnce("Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread"); +} + +function _emscripten_console_error(str) { + assert(typeof str == "number"); + console.error(UTF8ToString(str)); +} + +function _emscripten_date_now() { + return Date.now(); +} + +function _emscripten_exit_with_live_runtime() { + runtimeKeepalivePush(); + throw "unwind"; +} + +function _emscripten_force_exit(status) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(35, 1, status); + noExitRuntime = false; + runtimeKeepaliveCounter = 0; + _exit(status); +} + +function _glActiveTexture(x0) { + GLctx.activeTexture(x0); +} + +var _emscripten_glActiveTexture = _glActiveTexture; + +function _glAttachShader(program, shader) { + GLctx.attachShader(GL.programs[program], GL.shaders[shader]); +} + +var _emscripten_glAttachShader = _glAttachShader; + +function _glBeginTransformFeedback(x0) { + GLctx.beginTransformFeedback(x0); +} + +var _emscripten_glBeginTransformFeedback = _glBeginTransformFeedback; + +function _glBindBuffer(target, buffer) { + if (target == 35051) { + GLctx.currentPixelPackBufferBinding = buffer; + } else if (target == 35052) { + GLctx.currentPixelUnpackBufferBinding = buffer; + } + GLctx.bindBuffer(target, GL.buffers[buffer]); +} + +var _emscripten_glBindBuffer = _glBindBuffer; + +function _glBindBufferBase(target, index, buffer) { + GLctx.bindBufferBase(target, index, GL.buffers[buffer]); +} + +var _emscripten_glBindBufferBase = _glBindBufferBase; + +function _glBindBufferRange(target, index, buffer, offset, ptrsize) { + GLctx.bindBufferRange(target, index, GL.buffers[buffer], offset, ptrsize); +} + +var _emscripten_glBindBufferRange = _glBindBufferRange; + +function _glBindFramebuffer(target, framebuffer) { + GLctx.bindFramebuffer(target, framebuffer ? GL.framebuffers[framebuffer] : GL.currentContext.defaultFbo); +} + +var _emscripten_glBindFramebuffer = _glBindFramebuffer; + +function _glBindRenderbuffer(target, renderbuffer) { + GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]); +} + +var _emscripten_glBindRenderbuffer = _glBindRenderbuffer; + +function _glBindTexture(target, texture) { + GLctx.bindTexture(target, GL.textures[texture]); +} + +var _emscripten_glBindTexture = _glBindTexture; + +function _glBindVertexArray(vao) { + GLctx.bindVertexArray(GL.vaos[vao]); +} + +var _emscripten_glBindVertexArray = _glBindVertexArray; + +function _glBlendColor(x0, x1, x2, x3) { + GLctx.blendColor(x0, x1, x2, x3); +} + +var _emscripten_glBlendColor = _glBlendColor; + +function _glBlendEquation(x0) { + GLctx.blendEquation(x0); +} + +var _emscripten_glBlendEquation = _glBlendEquation; + +function _glBlendFunc(x0, x1) { + GLctx.blendFunc(x0, x1); +} + +var _emscripten_glBlendFunc = _glBlendFunc; + +function _glBlendFuncSeparate(x0, x1, x2, x3) { + GLctx.blendFuncSeparate(x0, x1, x2, x3); +} + +var _emscripten_glBlendFuncSeparate = _glBlendFuncSeparate; + +function _glBlitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) { + GLctx.blitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); +} + +var _emscripten_glBlitFramebuffer = _glBlitFramebuffer; + +function _glBufferData(target, size, data, usage) { + if (GL.currentContext.version >= 2) { + if (data && size) { + GLctx.bufferData(target, GROWABLE_HEAP_U8(), usage, data, size); + } else { + GLctx.bufferData(target, size, usage); + } + } else { + GLctx.bufferData(target, data ? GROWABLE_HEAP_U8().subarray(data, data + size) : size, usage); + } +} + +var _emscripten_glBufferData = _glBufferData; + +function _glBufferSubData(target, offset, size, data) { + if (GL.currentContext.version >= 2) { + size && GLctx.bufferSubData(target, offset, GROWABLE_HEAP_U8(), data, size); + return; + } + GLctx.bufferSubData(target, offset, GROWABLE_HEAP_U8().subarray(data, data + size)); +} + +var _emscripten_glBufferSubData = _glBufferSubData; + +function _glCheckFramebufferStatus(x0) { + return GLctx.checkFramebufferStatus(x0); +} + +var _emscripten_glCheckFramebufferStatus = _glCheckFramebufferStatus; + +function _glClear(x0) { + GLctx.clear(x0); +} + +var _emscripten_glClear = _glClear; + +function _glClearBufferfv(buffer, drawbuffer, value) { + GLctx.clearBufferfv(buffer, drawbuffer, GROWABLE_HEAP_F32(), value >> 2); +} + +var _emscripten_glClearBufferfv = _glClearBufferfv; + +function _glClearColor(x0, x1, x2, x3) { + GLctx.clearColor(x0, x1, x2, x3); +} + +var _emscripten_glClearColor = _glClearColor; + +function _glClearDepthf(x0) { + GLctx.clearDepth(x0); +} + +var _emscripten_glClearDepthf = _glClearDepthf; + +function _glColorMask(red, green, blue, alpha) { + GLctx.colorMask(!!red, !!green, !!blue, !!alpha); +} + +var _emscripten_glColorMask = _glColorMask; + +function _glCompileShader(shader) { + GLctx.compileShader(GL.shaders[shader]); +} + +var _emscripten_glCompileShader = _glCompileShader; + +function _glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding || !imageSize) { + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); + } else { + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, GROWABLE_HEAP_U8(), data, imageSize); + } + return; + } + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, data ? GROWABLE_HEAP_U8().subarray(data, data + imageSize) : null); +} + +var _emscripten_glCompressedTexImage2D = _glCompressedTexImage2D; + +function _glCopyBufferSubData(x0, x1, x2, x3, x4) { + GLctx.copyBufferSubData(x0, x1, x2, x3, x4); +} + +var _emscripten_glCopyBufferSubData = _glCopyBufferSubData; + +function _glCreateProgram() { + var id = GL.getNewId(GL.programs); + var program = GLctx.createProgram(); + program.name = id; + program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0; + program.uniformIdCounter = 1; + GL.programs[id] = program; + return id; +} + +var _emscripten_glCreateProgram = _glCreateProgram; + +function _glCreateShader(shaderType) { + var id = GL.getNewId(GL.shaders); + GL.shaders[id] = GLctx.createShader(shaderType); + return id; +} + +var _emscripten_glCreateShader = _glCreateShader; + +function _glCullFace(x0) { + GLctx.cullFace(x0); +} + +var _emscripten_glCullFace = _glCullFace; + +function _glDeleteBuffers(n, buffers) { + for (var i = 0; i < n; i++) { + var id = GROWABLE_HEAP_I32()[buffers + i * 4 >> 2]; + var buffer = GL.buffers[id]; + if (!buffer) continue; + GLctx.deleteBuffer(buffer); + buffer.name = 0; + GL.buffers[id] = null; + if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0; + if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0; + } +} + +var _emscripten_glDeleteBuffers = _glDeleteBuffers; + +function _glDeleteFramebuffers(n, framebuffers) { + for (var i = 0; i < n; ++i) { + var id = GROWABLE_HEAP_I32()[framebuffers + i * 4 >> 2]; + var framebuffer = GL.framebuffers[id]; + if (!framebuffer) continue; + GLctx.deleteFramebuffer(framebuffer); + framebuffer.name = 0; + GL.framebuffers[id] = null; + } +} + +var _emscripten_glDeleteFramebuffers = _glDeleteFramebuffers; + +function _glDeleteProgram(id) { + if (!id) return; + var program = GL.programs[id]; + if (!program) { + GL.recordError(1281); + return; + } + GLctx.deleteProgram(program); + program.name = 0; + GL.programs[id] = null; +} + +var _emscripten_glDeleteProgram = _glDeleteProgram; + +function _glDeleteQueries(n, ids) { + for (var i = 0; i < n; i++) { + var id = GROWABLE_HEAP_I32()[ids + i * 4 >> 2]; + var query = GL.queries[id]; + if (!query) continue; + GLctx.deleteQuery(query); + GL.queries[id] = null; + } +} + +var _emscripten_glDeleteQueries = _glDeleteQueries; + +function _glDeleteRenderbuffers(n, renderbuffers) { + for (var i = 0; i < n; i++) { + var id = GROWABLE_HEAP_I32()[renderbuffers + i * 4 >> 2]; + var renderbuffer = GL.renderbuffers[id]; + if (!renderbuffer) continue; + GLctx.deleteRenderbuffer(renderbuffer); + renderbuffer.name = 0; + GL.renderbuffers[id] = null; + } +} + +var _emscripten_glDeleteRenderbuffers = _glDeleteRenderbuffers; + +function _glDeleteShader(id) { + if (!id) return; + var shader = GL.shaders[id]; + if (!shader) { + GL.recordError(1281); + return; + } + GLctx.deleteShader(shader); + GL.shaders[id] = null; +} + +var _emscripten_glDeleteShader = _glDeleteShader; + +function _glDeleteSync(id) { + if (!id) return; + var sync = GL.syncs[id]; + if (!sync) { + GL.recordError(1281); + return; + } + GLctx.deleteSync(sync); + sync.name = 0; + GL.syncs[id] = null; +} + +var _emscripten_glDeleteSync = _glDeleteSync; + +function _glDeleteTextures(n, textures) { + for (var i = 0; i < n; i++) { + var id = GROWABLE_HEAP_I32()[textures + i * 4 >> 2]; + var texture = GL.textures[id]; + if (!texture) continue; + GLctx.deleteTexture(texture); + texture.name = 0; + GL.textures[id] = null; + } +} + +var _emscripten_glDeleteTextures = _glDeleteTextures; + +function _glDeleteVertexArrays(n, vaos) { + for (var i = 0; i < n; i++) { + var id = GROWABLE_HEAP_I32()[vaos + i * 4 >> 2]; + GLctx.deleteVertexArray(GL.vaos[id]); + GL.vaos[id] = null; + } +} + +var _emscripten_glDeleteVertexArrays = _glDeleteVertexArrays; + +function _glDepthFunc(x0) { + GLctx.depthFunc(x0); +} + +var _emscripten_glDepthFunc = _glDepthFunc; + +function _glDepthMask(flag) { + GLctx.depthMask(!!flag); +} + +var _emscripten_glDepthMask = _glDepthMask; + +function _glDisable(x0) { + GLctx.disable(x0); +} + +var _emscripten_glDisable = _glDisable; + +function _glDisableVertexAttribArray(index) { + GLctx.disableVertexAttribArray(index); +} + +var _emscripten_glDisableVertexAttribArray = _glDisableVertexAttribArray; + +function _glDrawArrays(mode, first, count) { + GLctx.drawArrays(mode, first, count); +} + +var _emscripten_glDrawArrays = _glDrawArrays; + +function _glDrawArraysInstanced(mode, first, count, primcount) { + GLctx.drawArraysInstanced(mode, first, count, primcount); +} + +var _emscripten_glDrawArraysInstanced = _glDrawArraysInstanced; + +function _glDrawElements(mode, count, type, indices) { + GLctx.drawElements(mode, count, type, indices); +} + +var _emscripten_glDrawElements = _glDrawElements; + +function _glDrawElementsInstanced(mode, count, type, indices, primcount) { + GLctx.drawElementsInstanced(mode, count, type, indices, primcount); +} + +var _emscripten_glDrawElementsInstanced = _glDrawElementsInstanced; + +function _glEnable(x0) { + GLctx.enable(x0); +} + +var _emscripten_glEnable = _glEnable; + +function _glEnableVertexAttribArray(index) { + GLctx.enableVertexAttribArray(index); +} + +var _emscripten_glEnableVertexAttribArray = _glEnableVertexAttribArray; + +function _glEndTransformFeedback() { + GLctx.endTransformFeedback(); +} + +var _emscripten_glEndTransformFeedback = _glEndTransformFeedback; + +function _glFenceSync(condition, flags) { + var sync = GLctx.fenceSync(condition, flags); + if (sync) { + var id = GL.getNewId(GL.syncs); + sync.name = id; + GL.syncs[id] = sync; + return id; + } + return 0; +} + +var _emscripten_glFenceSync = _glFenceSync; + +function _glFinish() { + GLctx.finish(); +} + +var _emscripten_glFinish = _glFinish; + +function _glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) { + GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]); +} + +var _emscripten_glFramebufferRenderbuffer = _glFramebufferRenderbuffer; + +function _glFramebufferTexture2D(target, attachment, textarget, texture, level) { + GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level); +} + +var _emscripten_glFramebufferTexture2D = _glFramebufferTexture2D; + +function _glFramebufferTextureLayer(target, attachment, texture, level, layer) { + GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer); +} + +var _emscripten_glFramebufferTextureLayer = _glFramebufferTextureLayer; + +function _glFrontFace(x0) { + GLctx.frontFace(x0); +} + +var _emscripten_glFrontFace = _glFrontFace; + +function __glGenObject(n, buffers, createFunction, objectTable) { + for (var i = 0; i < n; i++) { + var buffer = GLctx[createFunction](); + var id = buffer && GL.getNewId(objectTable); + if (buffer) { + buffer.name = id; + objectTable[id] = buffer; + } else { + GL.recordError(1282); + } + GROWABLE_HEAP_I32()[buffers + i * 4 >> 2] = id; + } +} + +function _glGenBuffers(n, buffers) { + __glGenObject(n, buffers, "createBuffer", GL.buffers); +} + +var _emscripten_glGenBuffers = _glGenBuffers; + +function _glGenFramebuffers(n, ids) { + __glGenObject(n, ids, "createFramebuffer", GL.framebuffers); +} + +var _emscripten_glGenFramebuffers = _glGenFramebuffers; + +function _glGenQueries(n, ids) { + __glGenObject(n, ids, "createQuery", GL.queries); +} + +var _emscripten_glGenQueries = _glGenQueries; + +function _glGenRenderbuffers(n, renderbuffers) { + __glGenObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers); +} + +var _emscripten_glGenRenderbuffers = _glGenRenderbuffers; + +function _glGenTextures(n, textures) { + __glGenObject(n, textures, "createTexture", GL.textures); +} + +var _emscripten_glGenTextures = _glGenTextures; + +function _glGenVertexArrays(n, arrays) { + __glGenObject(n, arrays, "createVertexArray", GL.vaos); +} + +var _emscripten_glGenVertexArrays = _glGenVertexArrays; + +function _glGenerateMipmap(x0) { + GLctx.generateMipmap(x0); +} + +var _emscripten_glGenerateMipmap = _glGenerateMipmap; + +function readI53FromU64(ptr) { + return GROWABLE_HEAP_U32()[ptr >> 2] + GROWABLE_HEAP_U32()[ptr + 4 >> 2] * 4294967296; +} + +function writeI53ToI64(ptr, num) { + GROWABLE_HEAP_U32()[ptr >> 2] = num; + GROWABLE_HEAP_U32()[ptr + 4 >> 2] = (num - GROWABLE_HEAP_U32()[ptr >> 2]) / 4294967296; + var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr); + if (deserialized != num) warnOnce("writeI53ToI64() out of range: serialized JS Number " + num + " to Wasm heap as bytes lo=" + ptrToString(GROWABLE_HEAP_U32()[ptr >> 2]) + ", hi=" + ptrToString(GROWABLE_HEAP_U32()[ptr + 4 >> 2]) + ", which deserializes back to " + deserialized + " instead!"); +} + +function emscriptenWebGLGet(name_, p, type) { + if (!p) { + GL.recordError(1281); + return; + } + var ret = undefined; + switch (name_) { + case 36346: + ret = 1; + break; + + case 36344: + if (type != 0 && type != 1) { + GL.recordError(1280); + } + return; + + case 34814: + case 36345: + ret = 0; + break; + + case 34466: + var formats = GLctx.getParameter(34467); + ret = formats ? formats.length : 0; + break; + + case 33309: + if (GL.currentContext.version < 2) { + GL.recordError(1282); + return; + } + var exts = GLctx.getSupportedExtensions() || []; + ret = 2 * exts.length; + break; + + case 33307: + case 33308: + if (GL.currentContext.version < 2) { + GL.recordError(1280); + return; + } + ret = name_ == 33307 ? 3 : 0; + break; + } + if (ret === undefined) { + var result = GLctx.getParameter(name_); + switch (typeof result) { + case "number": + ret = result; + break; + + case "boolean": + ret = result ? 1 : 0; + break; + + case "string": + GL.recordError(1280); + return; + + case "object": + if (result === null) { + switch (name_) { + case 34964: + case 35725: + case 34965: + case 36006: + case 36007: + case 32873: + case 34229: + case 36662: + case 36663: + case 35053: + case 35055: + case 36010: + case 35097: + case 35869: + case 32874: + case 36389: + case 35983: + case 35368: + case 34068: + { + ret = 0; + break; + } + + default: + { + GL.recordError(1280); + return; + } + } + } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) { + for (var i = 0; i < result.length; ++i) { + switch (type) { + case 0: + GROWABLE_HEAP_I32()[p + i * 4 >> 2] = result[i]; + break; + + case 2: + GROWABLE_HEAP_F32()[p + i * 4 >> 2] = result[i]; + break; + + case 4: + GROWABLE_HEAP_I8()[p + i >> 0] = result[i] ? 1 : 0; + break; + } + } + return; + } else { + try { + ret = result.name | 0; + } catch (e) { + GL.recordError(1280); + err("GL_INVALID_ENUM in glGet" + type + "v: Unknown object returned from WebGL getParameter(" + name_ + ")! (error: " + e + ")"); + return; + } + } + break; + + default: + GL.recordError(1280); + err("GL_INVALID_ENUM in glGet" + type + "v: Native code calling glGet" + type + "v(" + name_ + ") and it returns " + result + " of type " + typeof result + "!"); + return; + } + } + switch (type) { + case 1: + writeI53ToI64(p, ret); + break; + + case 0: + GROWABLE_HEAP_I32()[p >> 2] = ret; + break; + + case 2: + GROWABLE_HEAP_F32()[p >> 2] = ret; + break; + + case 4: + GROWABLE_HEAP_I8()[p >> 0] = ret ? 1 : 0; + break; + } +} + +function _glGetFloatv(name_, p) { + emscriptenWebGLGet(name_, p, 2); +} + +var _emscripten_glGetFloatv = _glGetFloatv; + +function _glGetInteger64v(name_, p) { + emscriptenWebGLGet(name_, p, 1); +} + +var _emscripten_glGetInteger64v = _glGetInteger64v; + +function _glGetProgramInfoLog(program, maxLength, length, infoLog) { + var log = GLctx.getProgramInfoLog(GL.programs[program]); + if (log === null) log = "(unknown error)"; + var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0; + if (length) GROWABLE_HEAP_I32()[length >> 2] = numBytesWrittenExclNull; +} + +var _emscripten_glGetProgramInfoLog = _glGetProgramInfoLog; + +function _glGetProgramiv(program, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (program >= GL.counter) { + GL.recordError(1281); + return; + } + program = GL.programs[program]; + if (pname == 35716) { + var log = GLctx.getProgramInfoLog(program); + if (log === null) log = "(unknown error)"; + GROWABLE_HEAP_I32()[p >> 2] = log.length + 1; + } else if (pname == 35719) { + if (!program.maxUniformLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) { + program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length + 1); + } + } + GROWABLE_HEAP_I32()[p >> 2] = program.maxUniformLength; + } else if (pname == 35722) { + if (!program.maxAttributeLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35721); ++i) { + program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length + 1); + } + } + GROWABLE_HEAP_I32()[p >> 2] = program.maxAttributeLength; + } else if (pname == 35381) { + if (!program.maxUniformBlockNameLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35382); ++i) { + program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length + 1); + } + } + GROWABLE_HEAP_I32()[p >> 2] = program.maxUniformBlockNameLength; + } else { + GROWABLE_HEAP_I32()[p >> 2] = GLctx.getProgramParameter(program, pname); + } +} + +var _emscripten_glGetProgramiv = _glGetProgramiv; + +function _glGetShaderInfoLog(shader, maxLength, length, infoLog) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0; + if (length) GROWABLE_HEAP_I32()[length >> 2] = numBytesWrittenExclNull; +} + +var _emscripten_glGetShaderInfoLog = _glGetShaderInfoLog; + +function _glGetShaderiv(shader, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (pname == 35716) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + var logLength = log ? log.length + 1 : 0; + GROWABLE_HEAP_I32()[p >> 2] = logLength; + } else if (pname == 35720) { + var source = GLctx.getShaderSource(GL.shaders[shader]); + var sourceLength = source ? source.length + 1 : 0; + GROWABLE_HEAP_I32()[p >> 2] = sourceLength; + } else { + GROWABLE_HEAP_I32()[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname); + } +} + +var _emscripten_glGetShaderiv = _glGetShaderiv; + +function _glGetString(name_) { + var ret = GL.stringCache[name_]; + if (!ret) { + switch (name_) { + case 7939: + var exts = GLctx.getSupportedExtensions() || []; + exts = exts.concat(exts.map(function(e) { + return "GL_" + e; + })); + ret = stringToNewUTF8(exts.join(" ")); + break; + + case 7936: + case 7937: + case 37445: + case 37446: + var s = GLctx.getParameter(name_); + if (!s) { + GL.recordError(1280); + } + ret = s && stringToNewUTF8(s); + break; + + case 7938: + var glVersion = GLctx.getParameter(7938); + if (GL.currentContext.version >= 2) glVersion = "OpenGL ES 3.0 (" + glVersion + ")"; else { + glVersion = "OpenGL ES 2.0 (" + glVersion + ")"; + } + ret = stringToNewUTF8(glVersion); + break; + + case 35724: + var glslVersion = GLctx.getParameter(35724); + var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/; + var ver_num = glslVersion.match(ver_re); + if (ver_num !== null) { + if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0"; + glslVersion = "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")"; + } + ret = stringToNewUTF8(glslVersion); + break; + + default: + GL.recordError(1280); + } + GL.stringCache[name_] = ret; + } + return ret; +} + +var _emscripten_glGetString = _glGetString; + +function _glGetStringi(name, index) { + if (GL.currentContext.version < 2) { + GL.recordError(1282); + return 0; + } + var stringiCache = GL.stringiCache[name]; + if (stringiCache) { + if (index < 0 || index >= stringiCache.length) { + GL.recordError(1281); + return 0; + } + return stringiCache[index]; + } + switch (name) { + case 7939: + var exts = GLctx.getSupportedExtensions() || []; + exts = exts.concat(exts.map(function(e) { + return "GL_" + e; + })); + exts = exts.map(function(e) { + return stringToNewUTF8(e); + }); + stringiCache = GL.stringiCache[name] = exts; + if (index < 0 || index >= stringiCache.length) { + GL.recordError(1281); + return 0; + } + return stringiCache[index]; + + default: + GL.recordError(1280); + return 0; + } +} + +var _emscripten_glGetStringi = _glGetStringi; + +function _glGetSynciv(sync, pname, bufSize, length, values) { + if (bufSize < 0) { + GL.recordError(1281); + return; + } + if (!values) { + GL.recordError(1281); + return; + } + var ret = GLctx.getSyncParameter(GL.syncs[sync], pname); + if (ret !== null) { + GROWABLE_HEAP_I32()[values >> 2] = ret; + if (length) GROWABLE_HEAP_I32()[length >> 2] = 1; + } +} + +var _emscripten_glGetSynciv = _glGetSynciv; + +function _glGetUniformBlockIndex(program, uniformBlockName) { + return GLctx.getUniformBlockIndex(GL.programs[program], UTF8ToString(uniformBlockName)); +} + +var _emscripten_glGetUniformBlockIndex = _glGetUniformBlockIndex; + +function webglGetLeftBracePos(name) { + return name.slice(-1) == "]" && name.lastIndexOf("["); +} + +function webglPrepareUniformLocationsBeforeFirstUse(program) { + var uniformLocsById = program.uniformLocsById, uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, i, j; + if (!uniformLocsById) { + program.uniformLocsById = uniformLocsById = {}; + program.uniformArrayNamesById = {}; + for (i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) { + var u = GLctx.getActiveUniform(program, i); + var nm = u.name; + var sz = u.size; + var lb = webglGetLeftBracePos(nm); + var arrayName = lb > 0 ? nm.slice(0, lb) : nm; + var id = program.uniformIdCounter; + program.uniformIdCounter += sz; + uniformSizeAndIdsByName[arrayName] = [ sz, id ]; + for (j = 0; j < sz; ++j) { + uniformLocsById[id] = j; + program.uniformArrayNamesById[id++] = arrayName; + } + } + } +} + +function _glGetUniformLocation(program, name) { + name = UTF8ToString(name); + if (program = GL.programs[program]) { + webglPrepareUniformLocationsBeforeFirstUse(program); + var uniformLocsById = program.uniformLocsById; + var arrayIndex = 0; + var uniformBaseName = name; + var leftBrace = webglGetLeftBracePos(name); + if (leftBrace > 0) { + arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0; + uniformBaseName = name.slice(0, leftBrace); + } + var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName]; + if (sizeAndId && arrayIndex < sizeAndId[0]) { + arrayIndex += sizeAndId[1]; + if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) { + return arrayIndex; + } + } + } else { + GL.recordError(1281); + } + return -1; +} + +var _emscripten_glGetUniformLocation = _glGetUniformLocation; + +function _glLinkProgram(program) { + program = GL.programs[program]; + GLctx.linkProgram(program); + program.uniformLocsById = 0; + program.uniformSizeAndIdsByName = {}; +} + +var _emscripten_glLinkProgram = _glLinkProgram; + +function _glPixelStorei(pname, param) { + if (pname == 3317) { + GL.unpackAlignment = param; + } + GLctx.pixelStorei(pname, param); +} + +var _emscripten_glPixelStorei = _glPixelStorei; + +function _glReadBuffer(x0) { + GLctx.readBuffer(x0); +} + +var _emscripten_glReadBuffer = _glReadBuffer; + +function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) { + function roundedToNextMultipleOf(x, y) { + return x + y - 1 & -y; + } + var plainRowSize = width * sizePerPixel; + var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment); + return height * alignedRowSize; +} + +function colorChannelsInGlTextureFormat(format) { + var colorChannels = { + 5: 3, + 6: 4, + 8: 2, + 29502: 3, + 29504: 4, + 26917: 2, + 26918: 2, + 29846: 3, + 29847: 4 + }; + return colorChannels[format - 6402] || 1; +} + +function heapObjectForWebGLType(type) { + type -= 5120; + if (type == 0) return GROWABLE_HEAP_I8(); + if (type == 1) return GROWABLE_HEAP_U8(); + if (type == 2) return GROWABLE_HEAP_I16(); + if (type == 4) return GROWABLE_HEAP_I32(); + if (type == 6) return GROWABLE_HEAP_F32(); + if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return GROWABLE_HEAP_U32(); + return GROWABLE_HEAP_U16(); +} + +function heapAccessShiftForWebGLHeap(heap) { + return 31 - Math.clz32(heap.BYTES_PER_ELEMENT); +} + +function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) { + var heap = heapObjectForWebGLType(type); + var shift = heapAccessShiftForWebGLHeap(heap); + var byteSize = 1 << shift; + var sizePerPixel = colorChannelsInGlTextureFormat(format) * byteSize; + var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment); + return heap.subarray(pixels >> shift, pixels + bytes >> shift); +} + +function _glReadPixels(x, y, width, height, format, type, pixels) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelPackBufferBinding) { + GLctx.readPixels(x, y, width, height, format, type, pixels); + } else { + var heap = heapObjectForWebGLType(type); + GLctx.readPixels(x, y, width, height, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } + return; + } + var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format); + if (!pixelData) { + GL.recordError(1280); + return; + } + GLctx.readPixels(x, y, width, height, format, type, pixelData); +} + +var _emscripten_glReadPixels = _glReadPixels; + +function _glRenderbufferStorage(x0, x1, x2, x3) { + GLctx.renderbufferStorage(x0, x1, x2, x3); +} + +var _emscripten_glRenderbufferStorage = _glRenderbufferStorage; + +function _glScissor(x0, x1, x2, x3) { + GLctx.scissor(x0, x1, x2, x3); +} + +var _emscripten_glScissor = _glScissor; + +function _glShaderSource(shader, count, string, length) { + var source = GL.getSource(shader, count, string, length); + GLctx.shaderSource(GL.shaders[shader], source); +} + +var _emscripten_glShaderSource = _glShaderSource; + +function _glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, null); + } + return; + } + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null); +} + +var _emscripten_glTexImage2D = _glTexImage2D; + +function _glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, null); + } +} + +var _emscripten_glTexImage3D = _glTexImage3D; + +function _glTexParameterf(x0, x1, x2) { + GLctx.texParameterf(x0, x1, x2); +} + +var _emscripten_glTexParameterf = _glTexParameterf; + +function _glTexParameteri(x0, x1, x2) { + GLctx.texParameteri(x0, x1, x2); +} + +var _emscripten_glTexParameteri = _glTexParameteri; + +function _glTexStorage2D(x0, x1, x2, x3, x4) { + GLctx.texStorage2D(x0, x1, x2, x3, x4); +} + +var _emscripten_glTexStorage2D = _glTexStorage2D; + +function _glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap)); + } else { + GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null); + } +} + +var _emscripten_glTexSubImage3D = _glTexSubImage3D; + +function _glTransformFeedbackVaryings(program, count, varyings, bufferMode) { + program = GL.programs[program]; + var vars = []; + for (var i = 0; i < count; i++) vars.push(UTF8ToString(GROWABLE_HEAP_I32()[varyings + i * 4 >> 2])); + GLctx.transformFeedbackVaryings(program, vars, bufferMode); +} + +var _emscripten_glTransformFeedbackVaryings = _glTransformFeedbackVaryings; + +function webglGetUniformLocation(location) { + var p = GLctx.currentProgram; + if (p) { + var webglLoc = p.uniformLocsById[location]; + if (typeof webglLoc == "number") { + p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? "[" + webglLoc + "]" : "")); + } + return webglLoc; + } else { + GL.recordError(1282); + } +} + +function _glUniform1f(location, v0) { + GLctx.uniform1f(webglGetUniformLocation(location), v0); +} + +var _emscripten_glUniform1f = _glUniform1f; + +function _glUniform1i(location, v0) { + GLctx.uniform1i(webglGetUniformLocation(location), v0); +} + +var _emscripten_glUniform1i = _glUniform1i; + +var miniTempWebGLIntBuffers = []; + +function _glUniform1iv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform1iv(webglGetUniformLocation(location), GROWABLE_HEAP_I32(), value >> 2, count); + return; + } + if (count <= 288) { + var view = miniTempWebGLIntBuffers[count - 1]; + for (var i = 0; i < count; ++i) { + view[i] = GROWABLE_HEAP_I32()[value + 4 * i >> 2]; + } + } else { + var view = GROWABLE_HEAP_I32().subarray(value >> 2, value + count * 4 >> 2); + } + GLctx.uniform1iv(webglGetUniformLocation(location), view); +} + +var _emscripten_glUniform1iv = _glUniform1iv; + +function _glUniform1ui(location, v0) { + GLctx.uniform1ui(webglGetUniformLocation(location), v0); +} + +var _emscripten_glUniform1ui = _glUniform1ui; + +function _glUniform1uiv(location, count, value) { + count && GLctx.uniform1uiv(webglGetUniformLocation(location), GROWABLE_HEAP_U32(), value >> 2, count); +} + +var _emscripten_glUniform1uiv = _glUniform1uiv; + +function _glUniform2f(location, v0, v1) { + GLctx.uniform2f(webglGetUniformLocation(location), v0, v1); +} + +var _emscripten_glUniform2f = _glUniform2f; + +var miniTempWebGLFloatBuffers = []; + +function _glUniform2fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform2fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), value >> 2, count * 2); + return; + } + if (count <= 144) { + var view = miniTempWebGLFloatBuffers[2 * count - 1]; + for (var i = 0; i < 2 * count; i += 2) { + view[i] = GROWABLE_HEAP_F32()[value + 4 * i >> 2]; + view[i + 1] = GROWABLE_HEAP_F32()[value + (4 * i + 4) >> 2]; + } + } else { + var view = GROWABLE_HEAP_F32().subarray(value >> 2, value + count * 8 >> 2); + } + GLctx.uniform2fv(webglGetUniformLocation(location), view); +} + +var _emscripten_glUniform2fv = _glUniform2fv; + +function _glUniform2iv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform2iv(webglGetUniformLocation(location), GROWABLE_HEAP_I32(), value >> 2, count * 2); + return; + } + if (count <= 144) { + var view = miniTempWebGLIntBuffers[2 * count - 1]; + for (var i = 0; i < 2 * count; i += 2) { + view[i] = GROWABLE_HEAP_I32()[value + 4 * i >> 2]; + view[i + 1] = GROWABLE_HEAP_I32()[value + (4 * i + 4) >> 2]; + } + } else { + var view = GROWABLE_HEAP_I32().subarray(value >> 2, value + count * 8 >> 2); + } + GLctx.uniform2iv(webglGetUniformLocation(location), view); +} + +var _emscripten_glUniform2iv = _glUniform2iv; + +function _glUniform3fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform3fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), value >> 2, count * 3); + return; + } + if (count <= 96) { + var view = miniTempWebGLFloatBuffers[3 * count - 1]; + for (var i = 0; i < 3 * count; i += 3) { + view[i] = GROWABLE_HEAP_F32()[value + 4 * i >> 2]; + view[i + 1] = GROWABLE_HEAP_F32()[value + (4 * i + 4) >> 2]; + view[i + 2] = GROWABLE_HEAP_F32()[value + (4 * i + 8) >> 2]; + } + } else { + var view = GROWABLE_HEAP_F32().subarray(value >> 2, value + count * 12 >> 2); + } + GLctx.uniform3fv(webglGetUniformLocation(location), view); +} + +var _emscripten_glUniform3fv = _glUniform3fv; + +function _glUniform4f(location, v0, v1, v2, v3) { + GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3); +} + +var _emscripten_glUniform4f = _glUniform4f; + +function _glUniform4fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform4fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), value >> 2, count * 4); + return; + } + if (count <= 72) { + var view = miniTempWebGLFloatBuffers[4 * count - 1]; + var heap = GROWABLE_HEAP_F32(); + value >>= 2; + for (var i = 0; i < 4 * count; i += 4) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + } + } else { + var view = GROWABLE_HEAP_F32().subarray(value >> 2, value + count * 16 >> 2); + } + GLctx.uniform4fv(webglGetUniformLocation(location), view); +} + +var _emscripten_glUniform4fv = _glUniform4fv; + +function _glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) { + program = GL.programs[program]; + GLctx.uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); +} + +var _emscripten_glUniformBlockBinding = _glUniformBlockBinding; + +function _glUniformMatrix4fv(location, count, transpose, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), value >> 2, count * 16); + return; + } + if (count <= 18) { + var view = miniTempWebGLFloatBuffers[16 * count - 1]; + var heap = GROWABLE_HEAP_F32(); + value >>= 2; + for (var i = 0; i < 16 * count; i += 16) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + view[i + 4] = heap[dst + 4]; + view[i + 5] = heap[dst + 5]; + view[i + 6] = heap[dst + 6]; + view[i + 7] = heap[dst + 7]; + view[i + 8] = heap[dst + 8]; + view[i + 9] = heap[dst + 9]; + view[i + 10] = heap[dst + 10]; + view[i + 11] = heap[dst + 11]; + view[i + 12] = heap[dst + 12]; + view[i + 13] = heap[dst + 13]; + view[i + 14] = heap[dst + 14]; + view[i + 15] = heap[dst + 15]; + } + } else { + var view = GROWABLE_HEAP_F32().subarray(value >> 2, value + count * 64 >> 2); + } + GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view); +} + +var _emscripten_glUniformMatrix4fv = _glUniformMatrix4fv; + +function _glUseProgram(program) { + program = GL.programs[program]; + GLctx.useProgram(program); + GLctx.currentProgram = program; +} + +var _emscripten_glUseProgram = _glUseProgram; + +function _glVertexAttrib4f(x0, x1, x2, x3, x4) { + GLctx.vertexAttrib4f(x0, x1, x2, x3, x4); +} + +var _emscripten_glVertexAttrib4f = _glVertexAttrib4f; + +function _glVertexAttribDivisor(index, divisor) { + GLctx.vertexAttribDivisor(index, divisor); +} + +var _emscripten_glVertexAttribDivisor = _glVertexAttribDivisor; + +function _glVertexAttribI4ui(x0, x1, x2, x3, x4) { + GLctx.vertexAttribI4ui(x0, x1, x2, x3, x4); +} + +var _emscripten_glVertexAttribI4ui = _glVertexAttribI4ui; + +function _glVertexAttribIPointer(index, size, type, stride, ptr) { + GLctx.vertexAttribIPointer(index, size, type, stride, ptr); +} + +var _emscripten_glVertexAttribIPointer = _glVertexAttribIPointer; + +function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) { + GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); +} + +var _emscripten_glVertexAttribPointer = _glVertexAttribPointer; + +function _glViewport(x0, x1, x2, x3) { + GLctx.viewport(x0, x1, x2, x3); +} + +var _emscripten_glViewport = _glViewport; + +function _emscripten_num_logical_cores() { + return navigator["hardwareConcurrency"]; +} + +function withStackSave(f) { + var stack = stackSave(); + var ret = f(); + stackRestore(stack); + return ret; +} + +function proxyToMainThread(index, sync) { + var numCallArgs = arguments.length - 2; + var outerArgs = arguments; + var maxArgs = 19; + if (numCallArgs > maxArgs) { + throw "proxyToMainThread: Too many arguments " + numCallArgs + " to proxied function idx=" + index + ", maximum supported is " + maxArgs; + } + return withStackSave(() => { + var serializedNumCallArgs = numCallArgs; + var args = stackAlloc(serializedNumCallArgs * 8); + var b = args >> 3; + for (var i = 0; i < numCallArgs; i++) { + var arg = outerArgs[2 + i]; + GROWABLE_HEAP_F64()[b + i] = arg; + } + return __emscripten_run_in_main_runtime_thread_js(index, serializedNumCallArgs, args, sync); + }); +} + +var emscripten_receive_on_main_thread_js_callArgs = []; + +function _emscripten_receive_on_main_thread_js(index, numCallArgs, args) { + emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs; + var b = args >> 3; + for (var i = 0; i < numCallArgs; i++) { + emscripten_receive_on_main_thread_js_callArgs[i] = GROWABLE_HEAP_F64()[b + i]; + } + var func = proxiedFunctionTable[index]; + assert(func.length == numCallArgs, "Call args mismatch in emscripten_receive_on_main_thread_js"); + return func.apply(null, emscripten_receive_on_main_thread_js_callArgs); +} + +function getHeapMax() { + return 2147483648; +} + +function emscripten_realloc_buffer(size) { + var b = wasmMemory.buffer; + try { + wasmMemory.grow(size - b.byteLength + 65535 >>> 16); + updateMemoryViews(); + return 1; + } catch (e) { + err(`emscripten_realloc_buffer: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`); + } +} + +function _emscripten_resize_heap(requestedSize) { + var oldSize = GROWABLE_HEAP_U8().length; + requestedSize = requestedSize >>> 0; + if (requestedSize <= oldSize) { + return false; + } + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err(`Cannot enlarge memory, asked to go up to ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`); + return false; + } + var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true; + } + } + err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`); + return false; +} + +var JSEvents = { + inEventHandler: 0, + removeAllEventListeners: function() { + for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) { + JSEvents._removeHandler(i); + } + JSEvents.eventHandlers = []; + JSEvents.deferredCalls = []; + }, + registerRemoveEventListeners: function() { + if (!JSEvents.removeEventListenersRegistered) { + __ATEXIT__.push(JSEvents.removeAllEventListeners); + JSEvents.removeEventListenersRegistered = true; + } + }, + deferredCalls: [], + deferCall: function(targetFunction, precedence, argsList) { + function arraysHaveEqualContent(arrA, arrB) { + if (arrA.length != arrB.length) return false; + for (var i in arrA) { + if (arrA[i] != arrB[i]) return false; + } + return true; + } + for (var i in JSEvents.deferredCalls) { + var call = JSEvents.deferredCalls[i]; + if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) { + return; + } + } + JSEvents.deferredCalls.push({ + targetFunction: targetFunction, + precedence: precedence, + argsList: argsList + }); + JSEvents.deferredCalls.sort(function(x, y) { + return x.precedence < y.precedence; + }); + }, + removeDeferredCalls: function(targetFunction) { + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + if (JSEvents.deferredCalls[i].targetFunction == targetFunction) { + JSEvents.deferredCalls.splice(i, 1); + --i; + } + } + }, + canPerformEventHandlerRequests: function() { + return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls; + }, + runDeferredCalls: function() { + if (!JSEvents.canPerformEventHandlerRequests()) { + return; + } + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + var call = JSEvents.deferredCalls[i]; + JSEvents.deferredCalls.splice(i, 1); + --i; + call.targetFunction.apply(null, call.argsList); + } + }, + eventHandlers: [], + removeAllHandlersOnTarget: function(target, eventTypeString) { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) { + JSEvents._removeHandler(i--); + } + } + }, + _removeHandler: function(i) { + var h = JSEvents.eventHandlers[i]; + h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture); + JSEvents.eventHandlers.splice(i, 1); + }, + registerOrRemoveHandler: function(eventHandler) { + if (!eventHandler.target) { + err("registerOrRemoveHandler: the target element for event handler registration does not exist, when processing the following event handler registration:"); + console.dir(eventHandler); + return -4; + } + var jsEventHandler = function jsEventHandler(event) { + ++JSEvents.inEventHandler; + JSEvents.currentEventHandler = eventHandler; + JSEvents.runDeferredCalls(); + eventHandler.handlerFunc(event); + JSEvents.runDeferredCalls(); + --JSEvents.inEventHandler; + }; + if (eventHandler.callbackfunc) { + eventHandler.eventListenerFunc = jsEventHandler; + eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture); + JSEvents.eventHandlers.push(eventHandler); + JSEvents.registerRemoveEventListeners(); + } else { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) { + JSEvents._removeHandler(i--); + } + } + } + return 0; + }, + queueEventHandlerOnThread_iiii: function(targetThread, eventHandlerFunc, eventTypeId, eventData, userData) { + withStackSave(function() { + var varargs = stackAlloc(12); + GROWABLE_HEAP_I32()[varargs >> 2] = eventTypeId; + GROWABLE_HEAP_I32()[varargs + 4 >> 2] = eventData; + GROWABLE_HEAP_I32()[varargs + 8 >> 2] = userData; + _emscripten_dispatch_to_thread_(targetThread, 637534208, eventHandlerFunc, eventData, varargs); + }); + }, + getTargetThreadForEventCallback: function(targetThread) { + switch (targetThread) { + case 1: + return 0; + + case 2: + return PThread.currentProxiedOperationCallerThread; + + default: + return targetThread; + } + }, + getNodeNameForTarget: function(target) { + if (!target) return ""; + if (target == window) return "#window"; + if (target == screen) return "#screen"; + return target && target.nodeName ? target.nodeName : ""; + }, + fullscreenEnabled: function() { + return document.fullscreenEnabled || document.webkitFullscreenEnabled; + } +}; + +function maybeCStringToJsString(cString) { + return cString > 2 ? UTF8ToString(cString) : cString; +} + +var specialHTMLTargets = [ 0, typeof document != "undefined" ? document : 0, typeof window != "undefined" ? window : 0 ]; + +function findEventTarget(target) { + target = maybeCStringToJsString(target); + var domElement = specialHTMLTargets[target] || (typeof document != "undefined" ? document.querySelector(target) : undefined); + return domElement; +} + +function findCanvasEventTarget(target) { + return findEventTarget(target); +} + +function setCanvasElementSizeCallingThread(target, width, height) { + var canvas = findCanvasEventTarget(target); + if (!canvas) return -4; + if (!canvas.controlTransferredOffscreen) { + var autoResizeViewport = false; + if (canvas.GLctxObject && canvas.GLctxObject.GLctx) { + var prevViewport = canvas.GLctxObject.GLctx.getParameter(2978); + autoResizeViewport = prevViewport[0] === 0 && prevViewport[1] === 0 && prevViewport[2] === canvas.width && prevViewport[3] === canvas.height; + } + canvas.width = width; + canvas.height = height; + if (autoResizeViewport) { + canvas.GLctxObject.GLctx.viewport(0, 0, width, height); + } + } else { + return -4; + } + if (canvas.GLctxObject) GL.resizeOffscreenFramebuffer(canvas.GLctxObject); + return 0; +} + +function setCanvasElementSizeMainThread(target, width, height) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(36, 1, target, width, height); + return setCanvasElementSizeCallingThread(target, width, height); +} + +function _emscripten_set_canvas_element_size(target, width, height) { + var canvas = findCanvasEventTarget(target); + if (canvas) { + return setCanvasElementSizeCallingThread(target, width, height); + } + return setCanvasElementSizeMainThread(target, width, height); +} + +function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop) { + var browserIterationFunc = getWasmTableEntry(func); + setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop); +} + +function _emscripten_supports_offscreencanvas() { + return 0; +} + +function _emscripten_webgl_destroy_context(contextHandle) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(37, 1, contextHandle); + if (GL.currentContext == contextHandle) GL.currentContext = 0; + GL.deleteContext(contextHandle); +} + +function _emscripten_webgl_do_commit_frame() { + if (!GL.currentContext || !GL.currentContext.GLctx) { + return -3; + } + if (GL.currentContext.defaultFbo) { + GL.blitOffscreenFramebuffer(GL.currentContext); + return 0; + } + if (!GL.currentContext.attributes.explicitSwapControl) { + return -3; + } + return 0; +} + +function _emscripten_webgl_create_context_proxied(target, attributes) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(38, 1, target, attributes); + return _emscripten_webgl_do_create_context(target, attributes); +} + +var emscripten_webgl_power_preferences = [ "default", "low-power", "high-performance" ]; + +function _emscripten_webgl_do_create_context(target, attributes) { + assert(attributes); + var a = attributes >> 2; + var powerPreference = GROWABLE_HEAP_I32()[a + (24 >> 2)]; + var contextAttributes = { + "alpha": !!GROWABLE_HEAP_I32()[a + (0 >> 2)], + "depth": !!GROWABLE_HEAP_I32()[a + (4 >> 2)], + "stencil": !!GROWABLE_HEAP_I32()[a + (8 >> 2)], + "antialias": !!GROWABLE_HEAP_I32()[a + (12 >> 2)], + "premultipliedAlpha": !!GROWABLE_HEAP_I32()[a + (16 >> 2)], + "preserveDrawingBuffer": !!GROWABLE_HEAP_I32()[a + (20 >> 2)], + "powerPreference": emscripten_webgl_power_preferences[powerPreference], + "failIfMajorPerformanceCaveat": !!GROWABLE_HEAP_I32()[a + (28 >> 2)], + majorVersion: GROWABLE_HEAP_I32()[a + (32 >> 2)], + minorVersion: GROWABLE_HEAP_I32()[a + (36 >> 2)], + enableExtensionsByDefault: GROWABLE_HEAP_I32()[a + (40 >> 2)], + explicitSwapControl: GROWABLE_HEAP_I32()[a + (44 >> 2)], + proxyContextToMainThread: GROWABLE_HEAP_I32()[a + (48 >> 2)], + renderViaOffscreenBackBuffer: GROWABLE_HEAP_I32()[a + (52 >> 2)] + }; + var canvas = findCanvasEventTarget(target); + if (ENVIRONMENT_IS_PTHREAD) { + if (contextAttributes.proxyContextToMainThread === 2 || !canvas && contextAttributes.proxyContextToMainThread === 1) { + if (typeof OffscreenCanvas == "undefined") { + GROWABLE_HEAP_I32()[attributes + 52 >> 2] = 1; + GROWABLE_HEAP_I32()[attributes + 20 >> 2] = 1; + } + return _emscripten_webgl_create_context_proxied(target, attributes); + } + } + if (!canvas) { + return 0; + } + if (contextAttributes.explicitSwapControl && !contextAttributes.renderViaOffscreenBackBuffer) { + contextAttributes.renderViaOffscreenBackBuffer = true; + } + var contextHandle = GL.createContext(canvas, contextAttributes); + return contextHandle; +} + +function _emscripten_webgl_enable_extension(contextHandle, extension) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(39, 1, contextHandle, extension); + var context = GL.getContext(contextHandle); + var extString = UTF8ToString(extension); + if (extString.startsWith("GL_")) extString = extString.substr(3); + if (extString == "ANGLE_instanced_arrays") webgl_enable_ANGLE_instanced_arrays(GLctx); + if (extString == "OES_vertex_array_object") webgl_enable_OES_vertex_array_object(GLctx); + if (extString == "WEBGL_draw_buffers") webgl_enable_WEBGL_draw_buffers(GLctx); + if (extString == "WEBGL_draw_instanced_base_vertex_base_instance") webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx); + if (extString == "WEBGL_multi_draw_instanced_base_vertex_base_instance") webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx); + if (extString == "WEBGL_multi_draw") webgl_enable_WEBGL_multi_draw(GLctx); + var ext = context.GLctx.getExtension(extString); + return !!ext; +} + +function _emscripten_webgl_init_context_attributes(attributes) { + assert(attributes); + var a = attributes >> 2; + for (var i = 0; i < 56 >> 2; ++i) { + GROWABLE_HEAP_I32()[a + i] = 0; + } + GROWABLE_HEAP_I32()[a + (0 >> 2)] = GROWABLE_HEAP_I32()[a + (4 >> 2)] = GROWABLE_HEAP_I32()[a + (12 >> 2)] = GROWABLE_HEAP_I32()[a + (16 >> 2)] = GROWABLE_HEAP_I32()[a + (32 >> 2)] = GROWABLE_HEAP_I32()[a + (40 >> 2)] = 1; + if (ENVIRONMENT_IS_WORKER) GROWABLE_HEAP_I32()[attributes + 48 >> 2] = 1; +} + +function _emscripten_webgl_make_context_current_calling_thread(contextHandle) { + var success = GL.makeContextCurrent(contextHandle); + if (success) GL.currentContextIsProxied = false; + return success ? 0 : -5; +} + +var ENV = {}; + +function getExecutableName() { + return thisProgram || "./this.program"; +} + +function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8"; + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": lang, + "_": getExecutableName() + }; + for (var x in ENV) { + if (ENV[x] === undefined) delete env[x]; else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + "=" + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; +} + +function stringToAscii(str, buffer) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === (str.charCodeAt(i) & 255)); + GROWABLE_HEAP_I8()[buffer++ >> 0] = str.charCodeAt(i); + } + GROWABLE_HEAP_I8()[buffer >> 0] = 0; +} + +function _environ_get(__environ, environ_buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(40, 1, __environ, environ_buf); + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + GROWABLE_HEAP_U32()[__environ + i * 4 >> 2] = ptr; + stringToAscii(string, ptr); + bufSize += string.length + 1; + }); + return 0; +} + +function _environ_sizes_get(penviron_count, penviron_buf_size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(41, 1, penviron_count, penviron_buf_size); + var strings = getEnvStrings(); + GROWABLE_HEAP_U32()[penviron_count >> 2] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + GROWABLE_HEAP_U32()[penviron_buf_size >> 2] = bufSize; + return 0; +} + +function _fd_close(fd) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(42, 1, fd); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +function _fd_fdstat_get(fd, pbuf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(43, 1, fd, pbuf); + try { + var rightsBase = 0; + var rightsInheriting = 0; + var flags = 0; + { + var stream = SYSCALLS.getStreamFromFD(fd); + var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4; + } + GROWABLE_HEAP_I8()[pbuf >> 0] = type; + GROWABLE_HEAP_I16()[pbuf + 2 >> 1] = flags; + tempI64 = [ rightsBase >>> 0, (tempDouble = rightsBase, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[pbuf + 8 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[pbuf + 12 >> 2] = tempI64[1]; + tempI64 = [ rightsInheriting >>> 0, (tempDouble = rightsInheriting, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[pbuf + 16 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[pbuf + 20 >> 2] = tempI64[1]; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = GROWABLE_HEAP_U32()[iov >> 2]; + var len = GROWABLE_HEAP_U32()[iov + 4 >> 2]; + iov += 8; + var curr = FS.read(stream, GROWABLE_HEAP_I8(), ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; + if (typeof offset !== "undefined") { + offset += curr; + } + } + return ret; +} + +function _fd_read(fd, iov, iovcnt, pnum) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(44, 1, fd, iov, iovcnt, pnum); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + GROWABLE_HEAP_U32()[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +function convertI32PairToI53Checked(lo, hi) { + assert(lo == lo >>> 0 || lo == (lo | 0)); + assert(hi === (hi | 0)); + return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN; +} + +function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(45, 1, fd, offset_low, offset_high, whence, newOffset); + try { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + tempI64 = [ stream.position >>> 0, (tempDouble = stream.position, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? +Math.floor(tempDouble / 4294967296) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + GROWABLE_HEAP_I32()[newOffset >> 2] = tempI64[0], GROWABLE_HEAP_I32()[newOffset + 4 >> 2] = tempI64[1]; + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = GROWABLE_HEAP_U32()[iov >> 2]; + var len = GROWABLE_HEAP_U32()[iov + 4 >> 2]; + iov += 8; + var curr = FS.write(stream, GROWABLE_HEAP_I8(), ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (typeof offset !== "undefined") { + offset += curr; + } + } + return ret; +} + +function _fd_write(fd, iov, iovcnt, pnum) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(46, 1, fd, iov, iovcnt, pnum); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + GROWABLE_HEAP_U32()[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +function _getaddrinfo(node, service, hint, out) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(47, 1, node, service, hint, out); + var addrs = []; + var canon = null; + var addr = 0; + var port = 0; + var flags = 0; + var family = 0; + var type = 0; + var proto = 0; + var ai, last; + function allocaddrinfo(family, type, proto, canon, addr, port) { + var sa, salen, ai; + var errno; + salen = family === 10 ? 28 : 16; + addr = family === 10 ? inetNtop6(addr) : inetNtop4(addr); + sa = _malloc(salen); + errno = writeSockaddr(sa, family, addr, port); + assert(!errno); + ai = _malloc(32); + GROWABLE_HEAP_I32()[ai + 4 >> 2] = family; + GROWABLE_HEAP_I32()[ai + 8 >> 2] = type; + GROWABLE_HEAP_I32()[ai + 12 >> 2] = proto; + GROWABLE_HEAP_U32()[ai + 24 >> 2] = canon; + GROWABLE_HEAP_U32()[ai + 20 >> 2] = sa; + if (family === 10) { + GROWABLE_HEAP_I32()[ai + 16 >> 2] = 28; + } else { + GROWABLE_HEAP_I32()[ai + 16 >> 2] = 16; + } + GROWABLE_HEAP_I32()[ai + 28 >> 2] = 0; + return ai; + } + if (hint) { + flags = GROWABLE_HEAP_I32()[hint >> 2]; + family = GROWABLE_HEAP_I32()[hint + 4 >> 2]; + type = GROWABLE_HEAP_I32()[hint + 8 >> 2]; + proto = GROWABLE_HEAP_I32()[hint + 12 >> 2]; + } + if (type && !proto) { + proto = type === 2 ? 17 : 6; + } + if (!type && proto) { + type = proto === 17 ? 2 : 1; + } + if (proto === 0) { + proto = 6; + } + if (type === 0) { + type = 1; + } + if (!node && !service) { + return -2; + } + if (flags & ~(1 | 2 | 4 | 1024 | 8 | 16 | 32)) { + return -1; + } + if (hint !== 0 && GROWABLE_HEAP_I32()[hint >> 2] & 2 && !node) { + return -1; + } + if (flags & 32) { + return -2; + } + if (type !== 0 && type !== 1 && type !== 2) { + return -7; + } + if (family !== 0 && family !== 2 && family !== 10) { + return -6; + } + if (service) { + service = UTF8ToString(service); + port = parseInt(service, 10); + if (isNaN(port)) { + if (flags & 1024) { + return -2; + } + return -8; + } + } + if (!node) { + if (family === 0) { + family = 2; + } + if ((flags & 1) === 0) { + if (family === 2) { + addr = _htonl(2130706433); + } else { + addr = [ 0, 0, 0, 1 ]; + } + } + ai = allocaddrinfo(family, type, proto, null, addr, port); + GROWABLE_HEAP_U32()[out >> 2] = ai; + return 0; + } + node = UTF8ToString(node); + addr = inetPton4(node); + if (addr !== null) { + if (family === 0 || family === 2) { + family = 2; + } else if (family === 10 && flags & 8) { + addr = [ 0, 0, _htonl(65535), addr ]; + family = 10; + } else { + return -2; + } + } else { + addr = inetPton6(node); + if (addr !== null) { + if (family === 0 || family === 10) { + family = 10; + } else { + return -2; + } + } + } + if (addr != null) { + ai = allocaddrinfo(family, type, proto, node, addr, port); + GROWABLE_HEAP_U32()[out >> 2] = ai; + return 0; + } + if (flags & 4) { + return -2; + } + node = DNS.lookup_name(node); + addr = inetPton4(node); + if (family === 0) { + family = 2; + } else if (family === 10) { + addr = [ 0, 0, _htonl(65535), addr ]; + } + ai = allocaddrinfo(family, type, proto, null, addr, port); + GROWABLE_HEAP_U32()[out >> 2] = ai; + return 0; +} + +function _getnameinfo(sa, salen, node, nodelen, serv, servlen, flags) { + var info = readSockaddr(sa, salen); + if (info.errno) { + return -6; + } + var port = info.port; + var addr = info.addr; + var overflowed = false; + if (node && nodelen) { + var lookup; + if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) { + if (flags & 8) { + return -2; + } + } else { + addr = lookup; + } + var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen); + if (numBytesWrittenExclNull + 1 >= nodelen) { + overflowed = true; + } + } + if (serv && servlen) { + port = "" + port; + var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen); + if (numBytesWrittenExclNull + 1 >= servlen) { + overflowed = true; + } + } + if (overflowed) { + return -12; + } + return 0; +} + +var GodotRuntime = { + get_func: function(ptr) { + return wasmTable.get(ptr); + }, + error: function() { + err.apply(null, Array.from(arguments)); + }, + print: function() { + out.apply(null, Array.from(arguments)); + }, + malloc: function(p_size) { + return _malloc(p_size); + }, + free: function(p_ptr) { + _free(p_ptr); + }, + getHeapValue: function(p_ptr, p_type) { + return getValue(p_ptr, p_type); + }, + setHeapValue: function(p_ptr, p_value, p_type) { + setValue(p_ptr, p_value, p_type); + }, + heapSub: function(p_heap, p_ptr, p_len) { + const bytes = p_heap.BYTES_PER_ELEMENT; + return p_heap.subarray(p_ptr / bytes, p_ptr / bytes + p_len); + }, + heapSlice: function(p_heap, p_ptr, p_len) { + const bytes = p_heap.BYTES_PER_ELEMENT; + return p_heap.slice(p_ptr / bytes, p_ptr / bytes + p_len); + }, + heapCopy: function(p_dst, p_src, p_ptr) { + const bytes = p_src.BYTES_PER_ELEMENT; + return p_dst.set(p_src, p_ptr / bytes); + }, + parseString: function(p_ptr) { + return UTF8ToString(p_ptr); + }, + parseStringArray: function(p_ptr, p_size) { + const strings = []; + const ptrs = GodotRuntime.heapSub(GROWABLE_HEAP_I32(), p_ptr, p_size); + ptrs.forEach(function(ptr) { + strings.push(GodotRuntime.parseString(ptr)); + }); + return strings; + }, + strlen: function(p_str) { + return lengthBytesUTF8(p_str); + }, + allocString: function(p_str) { + const length = GodotRuntime.strlen(p_str) + 1; + const c_str = GodotRuntime.malloc(length); + stringToUTF8(p_str, c_str, length); + return c_str; + }, + allocStringArray: function(p_strings) { + const size = p_strings.length; + const c_ptr = GodotRuntime.malloc(size * 4); + for (let i = 0; i < size; i++) { + GROWABLE_HEAP_I32()[(c_ptr >> 2) + i] = GodotRuntime.allocString(p_strings[i]); + } + return c_ptr; + }, + freeStringArray: function(p_ptr, p_len) { + for (let i = 0; i < p_len; i++) { + GodotRuntime.free(GROWABLE_HEAP_I32()[(p_ptr >> 2) + i]); + } + GodotRuntime.free(p_ptr); + }, + stringToHeap: function(p_str, p_ptr, p_len) { + return stringToUTF8Array(p_str, GROWABLE_HEAP_I8(), p_ptr, p_len); + } +}; + +var GodotConfig = { + canvas: null, + locale: "en", + canvas_resize_policy: 2, + virtual_keyboard: false, + persistent_drops: false, + on_execute: null, + on_exit: null, + init_config: function(p_opts) { + GodotConfig.canvas_resize_policy = p_opts["canvasResizePolicy"]; + GodotConfig.canvas = p_opts["canvas"]; + GodotConfig.locale = p_opts["locale"] || GodotConfig.locale; + GodotConfig.virtual_keyboard = p_opts["virtualKeyboard"]; + GodotConfig.persistent_drops = !!p_opts["persistentDrops"]; + GodotConfig.on_execute = p_opts["onExecute"]; + GodotConfig.on_exit = p_opts["onExit"]; + if (p_opts["focusCanvas"]) { + GodotConfig.canvas.focus(); + } + }, + locate_file: function(file) { + return Module["locateFile"](file); + }, + clear: function() { + GodotConfig.canvas = null; + GodotConfig.locale = "en"; + GodotConfig.canvas_resize_policy = 2; + GodotConfig.virtual_keyboard = false; + GodotConfig.persistent_drops = false; + GodotConfig.on_execute = null; + GodotConfig.on_exit = null; + } +}; + +var GodotFS = { + ENOENT: 44, + _idbfs: false, + _syncing: false, + _mount_points: [], + is_persistent: function() { + return GodotFS._idbfs ? 1 : 0; + }, + init: function(persistentPaths) { + GodotFS._idbfs = false; + if (!Array.isArray(persistentPaths)) { + return Promise.reject(new Error("Persistent paths must be an array")); + } + if (!persistentPaths.length) { + return Promise.resolve(); + } + GodotFS._mount_points = persistentPaths.slice(); + function createRecursive(dir) { + try { + FS.stat(dir); + } catch (e) { + if (e.errno !== GodotFS.ENOENT) { + GodotRuntime.error(e); + } + FS.mkdirTree(dir); + } + } + GodotFS._mount_points.forEach(function(path) { + createRecursive(path); + FS.mount(IDBFS, {}, path); + }); + return new Promise(function(resolve, reject) { + FS.syncfs(true, function(err) { + if (err) { + GodotFS._mount_points = []; + GodotFS._idbfs = false; + GodotRuntime.print(`IndexedDB not available: ${err.message}`); + } else { + GodotFS._idbfs = true; + } + resolve(err); + }); + }); + }, + deinit: function() { + GodotFS._mount_points.forEach(function(path) { + try { + FS.unmount(path); + } catch (e) { + GodotRuntime.print("Already unmounted", e); + } + if (GodotFS._idbfs && IDBFS.dbs[path]) { + IDBFS.dbs[path].close(); + delete IDBFS.dbs[path]; + } + }); + GodotFS._mount_points = []; + GodotFS._idbfs = false; + GodotFS._syncing = false; + }, + sync: function() { + if (GodotFS._syncing) { + GodotRuntime.error("Already syncing!"); + return Promise.resolve(); + } + GodotFS._syncing = true; + return new Promise(function(resolve, reject) { + FS.syncfs(false, function(error) { + if (error) { + GodotRuntime.error(`Failed to save IDB file system: ${error.message}`); + } + GodotFS._syncing = false; + resolve(error); + }); + }); + }, + copy_to_fs: function(path, buffer) { + const idx = path.lastIndexOf("/"); + let dir = "/"; + if (idx > 0) { + dir = path.slice(0, idx); + } + try { + FS.stat(dir); + } catch (e) { + if (e.errno !== GodotFS.ENOENT) { + GodotRuntime.error(e); + } + FS.mkdirTree(dir); + } + FS.writeFile(path, new Uint8Array(buffer)); + } +}; + +var GodotOS = { + request_quit: function() {}, + _async_cbs: [], + _fs_sync_promise: null, + atexit: function(p_promise_cb) { + GodotOS._async_cbs.push(p_promise_cb); + }, + cleanup: function(exit_code) { + const cb = GodotConfig.on_exit; + GodotFS.deinit(); + GodotConfig.clear(); + if (cb) { + cb(exit_code); + } + }, + finish_async: function(callback) { + GodotOS._fs_sync_promise.then(function(err) { + const promises = []; + GodotOS._async_cbs.forEach(function(cb) { + promises.push(new Promise(cb)); + }); + return Promise.all(promises); + }).then(function() { + return GodotFS.sync(); + }).then(function(err) { + setTimeout(function() { + callback(); + }, 0); + }); + } +}; + +var GodotAudio = { + ctx: null, + input: null, + driver: null, + interval: 0, + init: function(mix_rate, latency, onstatechange, onlatencyupdate) { + const opts = {}; + if (mix_rate) { + opts["sampleRate"] = mix_rate; + } + const ctx = new (window.AudioContext || window.webkitAudioContext)(opts); + GodotAudio.ctx = ctx; + ctx.onstatechange = function() { + let state = 0; + switch (ctx.state) { + case "suspended": + state = 0; + break; + + case "running": + state = 1; + break; + + case "closed": + state = 2; + break; + } + onstatechange(state); + }; + ctx.onstatechange(); + GodotAudio.interval = setInterval(function() { + let computed_latency = 0; + if (ctx.baseLatency) { + computed_latency += GodotAudio.ctx.baseLatency; + } + if (ctx.outputLatency) { + computed_latency += GodotAudio.ctx.outputLatency; + } + onlatencyupdate(computed_latency); + }, 1e3); + GodotOS.atexit(GodotAudio.close_async); + return ctx.destination.channelCount; + }, + create_input: function(callback) { + if (GodotAudio.input) { + return 0; + } + function gotMediaInput(stream) { + try { + GodotAudio.input = GodotAudio.ctx.createMediaStreamSource(stream); + callback(GodotAudio.input); + } catch (e) { + GodotRuntime.error("Failed creating input.", e); + } + } + if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) { + navigator.mediaDevices.getUserMedia({ + "audio": true + }).then(gotMediaInput, function(e) { + GodotRuntime.error("Error getting user media.", e); + }); + } else { + if (!navigator.getUserMedia) { + navigator.getUserMedia = navigator.webkitGetUserMedia || navigator.mozGetUserMedia; + } + if (!navigator.getUserMedia) { + GodotRuntime.error("getUserMedia not available."); + return 1; + } + navigator.getUserMedia({ + "audio": true + }, gotMediaInput, function(e) { + GodotRuntime.print(e); + }); + } + return 0; + }, + close_async: function(resolve, reject) { + const ctx = GodotAudio.ctx; + GodotAudio.ctx = null; + if (!ctx) { + resolve(); + return; + } + if (GodotAudio.interval) { + clearInterval(GodotAudio.interval); + GodotAudio.interval = 0; + } + if (GodotAudio.input) { + GodotAudio.input.disconnect(); + GodotAudio.input = null; + } + let closed = Promise.resolve(); + if (GodotAudio.driver) { + closed = GodotAudio.driver.close(); + } + closed.then(function() { + return ctx.close(); + }).then(function() { + ctx.onstatechange = null; + resolve(); + }).catch(function(e) { + ctx.onstatechange = null; + GodotRuntime.error("Error closing AudioContext", e); + resolve(); + }); + } +}; + +function _godot_audio_has_worklet() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(48, 1); + return GodotAudio.ctx && GodotAudio.ctx.audioWorklet ? 1 : 0; +} + +function _godot_audio_init(p_mix_rate, p_latency, p_state_change, p_latency_update) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(49, 1, p_mix_rate, p_latency, p_state_change, p_latency_update); + const statechange = GodotRuntime.get_func(p_state_change); + const latencyupdate = GodotRuntime.get_func(p_latency_update); + const mix_rate = GodotRuntime.getHeapValue(p_mix_rate, "i32"); + const channels = GodotAudio.init(mix_rate, p_latency, statechange, latencyupdate); + GodotRuntime.setHeapValue(p_mix_rate, GodotAudio.ctx.sampleRate, "i32"); + return channels; +} + +function _godot_audio_input_start() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(50, 1); + return GodotAudio.create_input(function(input) { + input.connect(GodotAudio.driver.get_node()); + }); +} + +function _godot_audio_input_stop() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(51, 1); + if (GodotAudio.input) { + const tracks = GodotAudio.input["mediaStream"]["getTracks"](); + for (let i = 0; i < tracks.length; i++) { + tracks[i]["stop"](); + } + GodotAudio.input.disconnect(); + GodotAudio.input = null; + } +} + +function _godot_audio_is_available() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(52, 1); + if (!(window.AudioContext || window.webkitAudioContext)) { + return 0; + } + return 1; +} + +function _godot_audio_resume() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(53, 1); + if (GodotAudio.ctx && GodotAudio.ctx.state !== "running") { + GodotAudio.ctx.resume(); + } +} + +var GodotAudioWorklet = { + promise: null, + worklet: null, + ring_buffer: null, + create: function(channels) { + const path = GodotConfig.locate_file("godot.audio.worklet.js"); + GodotAudioWorklet.promise = GodotAudio.ctx.audioWorklet.addModule(path).then(function() { + GodotAudioWorklet.worklet = new AudioWorkletNode(GodotAudio.ctx, "godot-processor", { + "outputChannelCount": [ channels ] + }); + return Promise.resolve(); + }); + GodotAudio.driver = GodotAudioWorklet; + }, + start: function(in_buf, out_buf, state) { + GodotAudioWorklet.promise.then(function() { + const node = GodotAudioWorklet.worklet; + node.connect(GodotAudio.ctx.destination); + node.port.postMessage({ + "cmd": "start", + "data": [ state, in_buf, out_buf ] + }); + node.port.onmessage = function(event) { + GodotRuntime.error(event.data); + }; + }); + }, + start_no_threads: function(p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback) { + function RingBuffer() { + let wpos = 0; + let rpos = 0; + let pending_samples = 0; + const wbuf = new Float32Array(p_out_size); + function send(port) { + if (pending_samples === 0) { + return; + } + const buffer = GodotRuntime.heapSub(GROWABLE_HEAP_F32(), p_out_buf, p_out_size); + const size = buffer.length; + const tot_sent = pending_samples; + out_callback(wpos, pending_samples); + if (wpos + pending_samples >= size) { + const high = size - wpos; + wbuf.set(buffer.subarray(wpos, size)); + pending_samples -= high; + wpos = 0; + } + if (pending_samples > 0) { + wbuf.set(buffer.subarray(wpos, wpos + pending_samples), tot_sent - pending_samples); + } + port.postMessage({ + "cmd": "chunk", + "data": wbuf.subarray(0, tot_sent) + }); + wpos += pending_samples; + pending_samples = 0; + } + this.receive = function(recv_buf) { + const buffer = GodotRuntime.heapSub(GROWABLE_HEAP_F32(), p_in_buf, p_in_size); + const from = rpos; + let to_write = recv_buf.length; + let high = 0; + if (rpos + to_write >= p_in_size) { + high = p_in_size - rpos; + buffer.set(recv_buf.subarray(0, high), rpos); + to_write -= high; + rpos = 0; + } + if (to_write) { + buffer.set(recv_buf.subarray(high, to_write), rpos); + } + in_callback(from, recv_buf.length); + rpos += to_write; + }; + this.consumed = function(size, port) { + pending_samples += size; + send(port); + }; + } + GodotAudioWorklet.ring_buffer = new RingBuffer(); + GodotAudioWorklet.promise.then(function() { + const node = GodotAudioWorklet.worklet; + const buffer = GodotRuntime.heapSlice(GROWABLE_HEAP_F32(), p_out_buf, p_out_size); + node.connect(GodotAudio.ctx.destination); + node.port.postMessage({ + "cmd": "start_nothreads", + "data": [ buffer, p_in_size ] + }); + node.port.onmessage = function(event) { + if (!GodotAudioWorklet.worklet) { + return; + } + if (event.data["cmd"] === "read") { + const read = event.data["data"]; + GodotAudioWorklet.ring_buffer.consumed(read, GodotAudioWorklet.worklet.port); + } else if (event.data["cmd"] === "input") { + const buf = event.data["data"]; + if (buf.length > p_in_size) { + GodotRuntime.error("Input chunk is too big"); + return; + } + GodotAudioWorklet.ring_buffer.receive(buf); + } else { + GodotRuntime.error(event.data); + } + }; + }); + }, + get_node: function() { + return GodotAudioWorklet.worklet; + }, + close: function() { + return new Promise(function(resolve, reject) { + if (GodotAudioWorklet.promise === null) { + return; + } + const p = GodotAudioWorklet.promise; + p.then(function() { + GodotAudioWorklet.worklet.port.postMessage({ + "cmd": "stop", + "data": null + }); + GodotAudioWorklet.worklet.disconnect(); + GodotAudioWorklet.worklet.port.onmessage = null; + GodotAudioWorklet.worklet = null; + GodotAudioWorklet.promise = null; + resolve(); + }).catch(function(err) { + GodotRuntime.error(err); + }); + }); + } +}; + +function _godot_audio_worklet_create(channels) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(54, 1, channels); + try { + GodotAudioWorklet.create(channels); + } catch (e) { + GodotRuntime.error("Error starting AudioDriverWorklet", e); + return 1; + } + return 0; +} + +function _godot_audio_worklet_start(p_in_buf, p_in_size, p_out_buf, p_out_size, p_state) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(55, 1, p_in_buf, p_in_size, p_out_buf, p_out_size, p_state); + const out_buffer = GodotRuntime.heapSub(GROWABLE_HEAP_F32(), p_out_buf, p_out_size); + const in_buffer = GodotRuntime.heapSub(GROWABLE_HEAP_F32(), p_in_buf, p_in_size); + const state = GodotRuntime.heapSub(GROWABLE_HEAP_I32(), p_state, 4); + GodotAudioWorklet.start(in_buffer, out_buffer, state); +} + +function _godot_audio_worklet_state_add(p_state, p_idx, p_value) { + return Atomics.add(GROWABLE_HEAP_I32(), (p_state >> 2) + p_idx, p_value); +} + +function _godot_audio_worklet_state_get(p_state, p_idx) { + return Atomics.load(GROWABLE_HEAP_I32(), (p_state >> 2) + p_idx); +} + +function _godot_audio_worklet_state_wait(p_state, p_idx, p_expected, p_timeout) { + Atomics.wait(GROWABLE_HEAP_I32(), (p_state >> 2) + p_idx, p_expected, p_timeout); + return Atomics.load(GROWABLE_HEAP_I32(), (p_state >> 2) + p_idx); +} + +function _godot_js_config_canvas_id_get(p_ptr, p_ptr_max) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(56, 1, p_ptr, p_ptr_max); + GodotRuntime.stringToHeap(`#${GodotConfig.canvas.id}`, p_ptr, p_ptr_max); +} + +function _godot_js_config_locale_get(p_ptr, p_ptr_max) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(57, 1, p_ptr, p_ptr_max); + GodotRuntime.stringToHeap(GodotConfig.locale, p_ptr, p_ptr_max); +} + +var GodotDisplayCursor = { + shape: "default", + visible: true, + cursors: {}, + set_style: function(style) { + GodotConfig.canvas.style.cursor = style; + }, + set_shape: function(shape) { + GodotDisplayCursor.shape = shape; + let css = shape; + if (shape in GodotDisplayCursor.cursors) { + const c = GodotDisplayCursor.cursors[shape]; + css = `url("${c.url}") ${c.x} ${c.y}, default`; + } + if (GodotDisplayCursor.visible) { + GodotDisplayCursor.set_style(css); + } + }, + clear: function() { + GodotDisplayCursor.set_style(""); + GodotDisplayCursor.shape = "default"; + GodotDisplayCursor.visible = true; + Object.keys(GodotDisplayCursor.cursors).forEach(function(key) { + URL.revokeObjectURL(GodotDisplayCursor.cursors[key]); + delete GodotDisplayCursor.cursors[key]; + }); + }, + lockPointer: function() { + const canvas = GodotConfig.canvas; + if (canvas.requestPointerLock) { + canvas.requestPointerLock(); + } + }, + releasePointer: function() { + if (document.exitPointerLock) { + document.exitPointerLock(); + } + }, + isPointerLocked: function() { + return document.pointerLockElement === GodotConfig.canvas; + } +}; + +var GodotEventListeners = { + handlers: [], + has: function(target, event, method, capture) { + return GodotEventListeners.handlers.findIndex(function(e) { + return e.target === target && e.event === event && e.method === method && e.capture === capture; + }) !== -1; + }, + add: function(target, event, method, capture) { + if (GodotEventListeners.has(target, event, method, capture)) { + return; + } + function Handler(p_target, p_event, p_method, p_capture) { + this.target = p_target; + this.event = p_event; + this.method = p_method; + this.capture = p_capture; + } + GodotEventListeners.handlers.push(new Handler(target, event, method, capture)); + target.addEventListener(event, method, capture); + }, + clear: function() { + GodotEventListeners.handlers.forEach(function(h) { + h.target.removeEventListener(h.event, h.method, h.capture); + }); + GodotEventListeners.handlers.length = 0; + } +}; + +var GodotDisplayScreen = { + desired_size: [ 0, 0 ], + hidpi: true, + getPixelRatio: function() { + return GodotDisplayScreen.hidpi ? window.devicePixelRatio || 1 : 1; + }, + isFullscreen: function() { + const elem = document.fullscreenElement || document.mozFullscreenElement || document.webkitFullscreenElement || document.msFullscreenElement; + if (elem) { + return elem === GodotConfig.canvas; + } + return document.fullscreen || document.mozFullScreen || document.webkitIsFullscreen; + }, + hasFullscreen: function() { + return document.fullscreenEnabled || document.mozFullScreenEnabled || document.webkitFullscreenEnabled; + }, + requestFullscreen: function() { + if (!GodotDisplayScreen.hasFullscreen()) { + return 1; + } + const canvas = GodotConfig.canvas; + try { + const promise = (canvas.requestFullscreen || canvas.msRequestFullscreen || canvas.mozRequestFullScreen || canvas.mozRequestFullscreen || canvas.webkitRequestFullscreen).call(canvas); + if (promise) { + promise.catch(function() {}); + } + } catch (e) { + return 1; + } + return 0; + }, + exitFullscreen: function() { + if (!GodotDisplayScreen.isFullscreen()) { + return 0; + } + try { + const promise = document.exitFullscreen(); + if (promise) { + promise.catch(function() {}); + } + } catch (e) { + return 1; + } + return 0; + }, + _updateGL: function() { + const gl_context_handle = _emscripten_webgl_get_current_context(); + const gl = GL.getContext(gl_context_handle); + if (gl) { + GL.resizeOffscreenFramebuffer(gl); + } + }, + updateSize: function() { + const isFullscreen = GodotDisplayScreen.isFullscreen(); + const wantsFullWindow = GodotConfig.canvas_resize_policy === 2; + const noResize = GodotConfig.canvas_resize_policy === 0; + const dWidth = GodotDisplayScreen.desired_size[0]; + const dHeight = GodotDisplayScreen.desired_size[1]; + const canvas = GodotConfig.canvas; + let width = dWidth; + let height = dHeight; + if (noResize) { + if (canvas.width !== width || canvas.height !== height) { + GodotDisplayScreen.desired_size = [ canvas.width, canvas.height ]; + GodotDisplayScreen._updateGL(); + return 1; + } + return 0; + } + const scale = GodotDisplayScreen.getPixelRatio(); + if (isFullscreen || wantsFullWindow) { + width = window.innerWidth * scale; + height = window.innerHeight * scale; + } + const csw = `${width / scale}px`; + const csh = `${height / scale}px`; + if (canvas.style.width !== csw || canvas.style.height !== csh || canvas.width !== width || canvas.height !== height) { + canvas.width = width; + canvas.height = height; + canvas.style.width = csw; + canvas.style.height = csh; + GodotDisplayScreen._updateGL(); + return 1; + } + return 0; + } +}; + +var GodotDisplayVK = { + textinput: null, + textarea: null, + available: function() { + return GodotConfig.virtual_keyboard && "ontouchstart" in window; + }, + init: function(input_cb) { + function create(what) { + const elem = document.createElement(what); + elem.style.display = "none"; + elem.style.position = "absolute"; + elem.style.zIndex = "-1"; + elem.style.background = "transparent"; + elem.style.padding = "0px"; + elem.style.margin = "0px"; + elem.style.overflow = "hidden"; + elem.style.width = "0px"; + elem.style.height = "0px"; + elem.style.border = "0px"; + elem.style.outline = "none"; + elem.readonly = true; + elem.disabled = true; + GodotEventListeners.add(elem, "input", function(evt) { + const c_str = GodotRuntime.allocString(elem.value); + input_cb(c_str, elem.selectionEnd); + GodotRuntime.free(c_str); + }, false); + GodotEventListeners.add(elem, "blur", function(evt) { + elem.style.display = "none"; + elem.readonly = true; + elem.disabled = true; + }, false); + GodotConfig.canvas.insertAdjacentElement("beforebegin", elem); + return elem; + } + GodotDisplayVK.textinput = create("input"); + GodotDisplayVK.textarea = create("textarea"); + GodotDisplayVK.updateSize(); + }, + show: function(text, type, start, end) { + if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) { + return; + } + if (GodotDisplayVK.textinput.style.display !== "" || GodotDisplayVK.textarea.style.display !== "") { + GodotDisplayVK.hide(); + } + GodotDisplayVK.updateSize(); + let elem = GodotDisplayVK.textinput; + switch (type) { + case 0: + elem.type = "text"; + elem.inputmode = ""; + break; + + case 1: + elem = GodotDisplayVK.textarea; + break; + + case 2: + elem.type = "text"; + elem.inputmode = "numeric"; + break; + + case 3: + elem.type = "text"; + elem.inputmode = "decimal"; + break; + + case 4: + elem.type = "tel"; + elem.inputmode = ""; + break; + + case 5: + elem.type = "email"; + elem.inputmode = ""; + break; + + case 6: + elem.type = "password"; + elem.inputmode = ""; + break; + + case 7: + elem.type = "url"; + elem.inputmode = ""; + break; + + default: + elem.type = "text"; + elem.inputmode = ""; + break; + } + elem.readonly = false; + elem.disabled = false; + elem.value = text; + elem.style.display = "block"; + elem.focus(); + elem.setSelectionRange(start, end); + }, + hide: function() { + if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) { + return; + } + [ GodotDisplayVK.textinput, GodotDisplayVK.textarea ].forEach(function(elem) { + elem.blur(); + elem.style.display = "none"; + elem.value = ""; + }); + }, + updateSize: function() { + if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) { + return; + } + const rect = GodotConfig.canvas.getBoundingClientRect(); + function update(elem) { + elem.style.left = `${rect.left}px`; + elem.style.top = `${rect.top}px`; + elem.style.width = `${rect.width}px`; + elem.style.height = `${rect.height}px`; + } + update(GodotDisplayVK.textinput); + update(GodotDisplayVK.textarea); + }, + clear: function() { + if (GodotDisplayVK.textinput) { + GodotDisplayVK.textinput.remove(); + GodotDisplayVK.textinput = null; + } + if (GodotDisplayVK.textarea) { + GodotDisplayVK.textarea.remove(); + GodotDisplayVK.textarea = null; + } + } +}; + +var GodotDisplay = { + window_icon: "", + getDPI: function() { + const dpi = Math.round(window.devicePixelRatio * 96); + return dpi >= 96 ? dpi : 96; + } +}; + +function _godot_js_display_alert(p_text) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(58, 1, p_text); + window.alert(GodotRuntime.parseString(p_text)); +} + +function _godot_js_display_canvas_focus() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(59, 1); + GodotConfig.canvas.focus(); +} + +function _godot_js_display_canvas_is_focused() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(60, 1); + return document.activeElement === GodotConfig.canvas; +} + +function _godot_js_display_clipboard_get(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(61, 1, callback); + const func = GodotRuntime.get_func(callback); + try { + navigator.clipboard.readText().then(function(result) { + const ptr = GodotRuntime.allocString(result); + func(ptr); + GodotRuntime.free(ptr); + }).catch(function(e) {}); + } catch (e) {} +} + +function _godot_js_display_clipboard_set(p_text) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(62, 1, p_text); + const text = GodotRuntime.parseString(p_text); + if (!navigator.clipboard || !navigator.clipboard.writeText) { + return 1; + } + navigator.clipboard.writeText(text).catch(function(e) { + GodotRuntime.error("Setting OS clipboard is only possible from an input callback for the Web platform. Exception:", e); + }); + return 0; +} + +function _godot_js_display_cursor_is_hidden() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(63, 1); + return !GodotDisplayCursor.visible; +} + +function _godot_js_display_cursor_is_locked() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(64, 1); + return GodotDisplayCursor.isPointerLocked() ? 1 : 0; +} + +function _godot_js_display_cursor_lock_set(p_lock) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(65, 1, p_lock); + if (p_lock) { + GodotDisplayCursor.lockPointer(); + } else { + GodotDisplayCursor.releasePointer(); + } +} + +function _godot_js_display_cursor_set_custom_shape(p_shape, p_ptr, p_len, p_hotspot_x, p_hotspot_y) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(66, 1, p_shape, p_ptr, p_len, p_hotspot_x, p_hotspot_y); + const shape = GodotRuntime.parseString(p_shape); + const old_shape = GodotDisplayCursor.cursors[shape]; + if (p_len > 0) { + const png = new Blob([ GodotRuntime.heapSlice(GROWABLE_HEAP_U8(), p_ptr, p_len) ], { + type: "image/png" + }); + const url = URL.createObjectURL(png); + GodotDisplayCursor.cursors[shape] = { + url: url, + x: p_hotspot_x, + y: p_hotspot_y + }; + } else { + delete GodotDisplayCursor.cursors[shape]; + } + if (shape === GodotDisplayCursor.shape) { + GodotDisplayCursor.set_shape(GodotDisplayCursor.shape); + } + if (old_shape) { + URL.revokeObjectURL(old_shape.url); + } +} + +function _godot_js_display_cursor_set_shape(p_string) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(67, 1, p_string); + GodotDisplayCursor.set_shape(GodotRuntime.parseString(p_string)); +} + +function _godot_js_display_cursor_set_visible(p_visible) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(68, 1, p_visible); + const visible = p_visible !== 0; + if (visible === GodotDisplayCursor.visible) { + return; + } + GodotDisplayCursor.visible = visible; + if (visible) { + GodotDisplayCursor.set_shape(GodotDisplayCursor.shape); + } else { + GodotDisplayCursor.set_style("none"); + } +} + +function _godot_js_display_desired_size_set(width, height) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(69, 1, width, height); + GodotDisplayScreen.desired_size = [ width, height ]; + GodotDisplayScreen.updateSize(); +} + +function _godot_js_display_fullscreen_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(70, 1, callback); + const canvas = GodotConfig.canvas; + const func = GodotRuntime.get_func(callback); + function change_cb(evt) { + if (evt.target === canvas) { + func(GodotDisplayScreen.isFullscreen()); + } + } + GodotEventListeners.add(document, "fullscreenchange", change_cb, false); + GodotEventListeners.add(document, "mozfullscreenchange", change_cb, false); + GodotEventListeners.add(document, "webkitfullscreenchange", change_cb, false); +} + +function _godot_js_display_fullscreen_exit() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(71, 1); + return GodotDisplayScreen.exitFullscreen(); +} + +function _godot_js_display_fullscreen_request() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(72, 1); + return GodotDisplayScreen.requestFullscreen(); +} + +function _godot_js_display_has_webgl(p_version) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(73, 1, p_version); + if (p_version !== 1 && p_version !== 2) { + return false; + } + try { + return !!document.createElement("canvas").getContext(p_version === 2 ? "webgl2" : "webgl"); + } catch (e) {} + return false; +} + +function _godot_js_display_is_swap_ok_cancel() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(74, 1); + const win = [ "Windows", "Win64", "Win32", "WinCE" ]; + const plat = navigator.platform || ""; + if (win.indexOf(plat) !== -1) { + return 1; + } + return 0; +} + +function _godot_js_display_notification_cb(callback, p_enter, p_exit, p_in, p_out) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(75, 1, callback, p_enter, p_exit, p_in, p_out); + const canvas = GodotConfig.canvas; + const func = GodotRuntime.get_func(callback); + const notif = [ p_enter, p_exit, p_in, p_out ]; + [ "mouseover", "mouseleave", "focus", "blur" ].forEach(function(evt_name, idx) { + GodotEventListeners.add(canvas, evt_name, function() { + func(notif[idx]); + }, true); + }); +} + +function _godot_js_display_pixel_ratio_get() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(76, 1); + return GodotDisplayScreen.getPixelRatio(); +} + +function _godot_js_display_screen_dpi_get() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(77, 1); + return GodotDisplay.getDPI(); +} + +function _godot_js_display_screen_size_get(width, height) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(78, 1, width, height); + const scale = GodotDisplayScreen.getPixelRatio(); + GodotRuntime.setHeapValue(width, window.screen.width * scale, "i32"); + GodotRuntime.setHeapValue(height, window.screen.height * scale, "i32"); +} + +function _godot_js_display_setup_canvas(p_width, p_height, p_fullscreen, p_hidpi) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(79, 1, p_width, p_height, p_fullscreen, p_hidpi); + const canvas = GodotConfig.canvas; + GodotEventListeners.add(canvas, "contextmenu", function(ev) { + ev.preventDefault(); + }, false); + GodotEventListeners.add(canvas, "webglcontextlost", function(ev) { + alert("WebGL context lost, please reload the page"); + ev.preventDefault(); + }, false); + GodotDisplayScreen.hidpi = !!p_hidpi; + switch (GodotConfig.canvas_resize_policy) { + case 0: + GodotDisplayScreen.desired_size = [ canvas.width, canvas.height ]; + break; + + case 1: + GodotDisplayScreen.desired_size = [ p_width, p_height ]; + break; + + default: + canvas.style.position = "absolute"; + canvas.style.top = 0; + canvas.style.left = 0; + break; + } + GodotDisplayScreen.updateSize(); + if (p_fullscreen) { + GodotDisplayScreen.requestFullscreen(); + } +} + +function _godot_js_display_size_update() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(80, 1); + const updated = GodotDisplayScreen.updateSize(); + if (updated) { + GodotDisplayVK.updateSize(); + } + return updated; +} + +function _godot_js_display_touchscreen_is_available() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(81, 1); + return "ontouchstart" in window; +} + +function _godot_js_display_tts_available() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(82, 1); + return "speechSynthesis" in window; +} + +function _godot_js_display_vk_available() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(83, 1); + return GodotDisplayVK.available(); +} + +function _godot_js_display_vk_cb(p_input_cb) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(84, 1, p_input_cb); + const input_cb = GodotRuntime.get_func(p_input_cb); + if (GodotDisplayVK.available()) { + GodotDisplayVK.init(input_cb); + } +} + +function _godot_js_display_vk_hide() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(85, 1); + GodotDisplayVK.hide(); +} + +function _godot_js_display_vk_show(p_text, p_type, p_start, p_end) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(86, 1, p_text, p_type, p_start, p_end); + const text = GodotRuntime.parseString(p_text); + const start = p_start > 0 ? p_start : 0; + const end = p_end > 0 ? p_end : start; + GodotDisplayVK.show(text, p_type, start, end); +} + +function _godot_js_display_window_blur_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(87, 1, callback); + const func = GodotRuntime.get_func(callback); + GodotEventListeners.add(window, "blur", function() { + func(); + }, false); +} + +function _godot_js_display_window_icon_set(p_ptr, p_len) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(88, 1, p_ptr, p_len); + let link = document.getElementById("-gd-engine-icon"); + const old_icon = GodotDisplay.window_icon; + if (p_ptr) { + if (link === null) { + link = document.createElement("link"); + link.rel = "icon"; + link.id = "-gd-engine-icon"; + document.head.appendChild(link); + } + const png = new Blob([ GodotRuntime.heapSlice(GROWABLE_HEAP_U8(), p_ptr, p_len) ], { + type: "image/png" + }); + GodotDisplay.window_icon = URL.createObjectURL(png); + link.href = GodotDisplay.window_icon; + } else { + if (link) { + link.remove(); + } + GodotDisplay.window_icon = null; + } + if (old_icon) { + URL.revokeObjectURL(old_icon); + } +} + +function _godot_js_display_window_size_get(p_width, p_height) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(89, 1, p_width, p_height); + GodotRuntime.setHeapValue(p_width, GodotConfig.canvas.width, "i32"); + GodotRuntime.setHeapValue(p_height, GodotConfig.canvas.height, "i32"); +} + +function _godot_js_display_window_title_set(p_data) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(90, 1, p_data); + document.title = GodotRuntime.parseString(p_data); +} + +function _godot_js_eval(p_js, p_use_global_ctx, p_union_ptr, p_byte_arr, p_byte_arr_write, p_callback) { + const js_code = GodotRuntime.parseString(p_js); + let eval_ret = null; + try { + if (p_use_global_ctx) { + const global_eval = eval; + eval_ret = global_eval(js_code); + } else { + eval_ret = eval(js_code); + } + } catch (e) { + GodotRuntime.error(e); + } + switch (typeof eval_ret) { + case "boolean": + GodotRuntime.setHeapValue(p_union_ptr, eval_ret, "i32"); + return 1; + + case "number": + GodotRuntime.setHeapValue(p_union_ptr, eval_ret, "double"); + return 3; + + case "string": + GodotRuntime.setHeapValue(p_union_ptr, GodotRuntime.allocString(eval_ret), "*"); + return 4; + + case "object": + if (eval_ret === null) { + break; + } + if (ArrayBuffer.isView(eval_ret) && !(eval_ret instanceof Uint8Array)) { + eval_ret = new Uint8Array(eval_ret.buffer); + } else if (eval_ret instanceof ArrayBuffer) { + eval_ret = new Uint8Array(eval_ret); + } + if (eval_ret instanceof Uint8Array) { + const func = GodotRuntime.get_func(p_callback); + const bytes_ptr = func(p_byte_arr, p_byte_arr_write, eval_ret.length); + GROWABLE_HEAP_U8().set(eval_ret, bytes_ptr); + return 29; + } + break; + } + return 0; +} + +var IDHandler = { + _last_id: 0, + _references: {}, + get: function(p_id) { + return IDHandler._references[p_id]; + }, + add: function(p_data) { + const id = ++IDHandler._last_id; + IDHandler._references[id] = p_data; + return id; + }, + remove: function(p_id) { + delete IDHandler._references[p_id]; + } +}; + +var GodotFetch = { + onread: function(id, result) { + const obj = IDHandler.get(id); + if (!obj) { + return; + } + if (result.value) { + obj.chunks.push(result.value); + } + obj.reading = false; + obj.done = result.done; + }, + onresponse: function(id, response) { + const obj = IDHandler.get(id); + if (!obj) { + return; + } + let chunked = false; + response.headers.forEach(function(value, header) { + const v = value.toLowerCase().trim(); + const h = header.toLowerCase().trim(); + if (h === "transfer-encoding" && v === "chunked") { + chunked = true; + } + }); + obj.status = response.status; + obj.response = response; + obj.reader = response.body.getReader(); + obj.chunked = chunked; + }, + onerror: function(id, err) { + GodotRuntime.error(err); + const obj = IDHandler.get(id); + if (!obj) { + return; + } + obj.error = err; + }, + create: function(method, url, headers, body) { + const obj = { + request: null, + response: null, + reader: null, + error: null, + done: false, + reading: false, + status: 0, + chunks: [] + }; + const id = IDHandler.add(obj); + const init = { + method: method, + headers: headers, + body: body + }; + obj.request = fetch(url, init); + obj.request.then(GodotFetch.onresponse.bind(null, id)).catch(GodotFetch.onerror.bind(null, id)); + return id; + }, + free: function(id) { + const obj = IDHandler.get(id); + if (!obj) { + return; + } + IDHandler.remove(id); + if (!obj.request) { + return; + } + obj.request.then(function(response) { + response.abort(); + }).catch(function(e) {}); + }, + read: function(id) { + const obj = IDHandler.get(id); + if (!obj) { + return; + } + if (obj.reader && !obj.reading) { + if (obj.done) { + obj.reader = null; + return; + } + obj.reading = true; + obj.reader.read().then(GodotFetch.onread.bind(null, id)).catch(GodotFetch.onerror.bind(null, id)); + } + } +}; + +function _godot_js_fetch_create(p_method, p_url, p_headers, p_headers_size, p_body, p_body_size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(91, 1, p_method, p_url, p_headers, p_headers_size, p_body, p_body_size); + const method = GodotRuntime.parseString(p_method); + const url = GodotRuntime.parseString(p_url); + const headers = GodotRuntime.parseStringArray(p_headers, p_headers_size); + const body = p_body_size ? GodotRuntime.heapSlice(GROWABLE_HEAP_I8(), p_body, p_body_size) : null; + return GodotFetch.create(method, url, headers.map(function(hv) { + const idx = hv.indexOf(":"); + if (idx <= 0) { + return []; + } + return [ hv.slice(0, idx).trim(), hv.slice(idx + 1).trim() ]; + }).filter(function(v) { + return v.length === 2; + }), body); +} + +function _godot_js_fetch_free(id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(92, 1, id); + GodotFetch.free(id); +} + +function _godot_js_fetch_http_status_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(93, 1, p_id); + const obj = IDHandler.get(p_id); + if (!obj || !obj.response) { + return 0; + } + return obj.status; +} + +function _godot_js_fetch_is_chunked(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(94, 1, p_id); + const obj = IDHandler.get(p_id); + if (!obj || !obj.response) { + return -1; + } + return obj.chunked ? 1 : 0; +} + +function _godot_js_fetch_read_chunk(p_id, p_buf, p_buf_size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(95, 1, p_id, p_buf, p_buf_size); + const obj = IDHandler.get(p_id); + if (!obj || !obj.response) { + return 0; + } + let to_read = p_buf_size; + const chunks = obj.chunks; + while (to_read && chunks.length) { + const chunk = obj.chunks[0]; + if (chunk.length > to_read) { + GodotRuntime.heapCopy(GROWABLE_HEAP_I8(), chunk.slice(0, to_read), p_buf); + chunks[0] = chunk.slice(to_read); + to_read = 0; + } else { + GodotRuntime.heapCopy(GROWABLE_HEAP_I8(), chunk, p_buf); + to_read -= chunk.length; + chunks.pop(); + } + } + if (!chunks.length) { + GodotFetch.read(p_id); + } + return p_buf_size - to_read; +} + +function _godot_js_fetch_read_headers(p_id, p_parse_cb, p_ref) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(96, 1, p_id, p_parse_cb, p_ref); + const obj = IDHandler.get(p_id); + if (!obj || !obj.response) { + return 1; + } + const cb = GodotRuntime.get_func(p_parse_cb); + const arr = []; + obj.response.headers.forEach(function(v, h) { + arr.push(`${h}:${v}`); + }); + const c_ptr = GodotRuntime.allocStringArray(arr); + cb(arr.length, c_ptr, p_ref); + GodotRuntime.freeStringArray(c_ptr, arr.length); + return 0; +} + +function _godot_js_fetch_state_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(97, 1, p_id); + const obj = IDHandler.get(p_id); + if (!obj) { + return -1; + } + if (obj.error) { + return -1; + } + if (!obj.response) { + return 0; + } + if (obj.reader) { + return 1; + } + if (obj.done) { + return 2; + } + return -1; +} + +var GodotInputGamepads = { + samples: [], + get_pads: function() { + try { + const pads = navigator.getGamepads(); + if (pads) { + return pads; + } + return []; + } catch (e) { + return []; + } + }, + get_samples: function() { + return GodotInputGamepads.samples; + }, + get_sample: function(index) { + const samples = GodotInputGamepads.samples; + return index < samples.length ? samples[index] : null; + }, + sample: function() { + const pads = GodotInputGamepads.get_pads(); + const samples = []; + for (let i = 0; i < pads.length; i++) { + const pad = pads[i]; + if (!pad) { + samples.push(null); + continue; + } + const s = { + standard: pad.mapping === "standard", + buttons: [], + axes: [], + connected: pad.connected + }; + for (let b = 0; b < pad.buttons.length; b++) { + s.buttons.push(pad.buttons[b].value); + } + for (let a = 0; a < pad.axes.length; a++) { + s.axes.push(pad.axes[a]); + } + samples.push(s); + } + GodotInputGamepads.samples = samples; + }, + init: function(onchange) { + GodotInputGamepads.samples = []; + function add(pad) { + const guid = GodotInputGamepads.get_guid(pad); + const c_id = GodotRuntime.allocString(pad.id); + const c_guid = GodotRuntime.allocString(guid); + onchange(pad.index, 1, c_id, c_guid); + GodotRuntime.free(c_id); + GodotRuntime.free(c_guid); + } + const pads = GodotInputGamepads.get_pads(); + for (let i = 0; i < pads.length; i++) { + if (pads[i]) { + add(pads[i]); + } + } + GodotEventListeners.add(window, "gamepadconnected", function(evt) { + if (evt.gamepad) { + add(evt.gamepad); + } + }, false); + GodotEventListeners.add(window, "gamepaddisconnected", function(evt) { + if (evt.gamepad) { + onchange(evt.gamepad.index, 0); + } + }, false); + }, + get_guid: function(pad) { + if (pad.mapping) { + return pad.mapping; + } + const ua = navigator.userAgent; + let os = "Unknown"; + if (ua.indexOf("Android") >= 0) { + os = "Android"; + } else if (ua.indexOf("Linux") >= 0) { + os = "Linux"; + } else if (ua.indexOf("iPhone") >= 0) { + os = "iOS"; + } else if (ua.indexOf("Macintosh") >= 0) { + os = "MacOSX"; + } else if (ua.indexOf("Windows") >= 0) { + os = "Windows"; + } + const id = pad.id; + const exp1 = /vendor: ([0-9a-f]{4}) product: ([0-9a-f]{4})/i; + const exp2 = /^([0-9a-f]+)-([0-9a-f]+)-/i; + let vendor = ""; + let product = ""; + if (exp1.test(id)) { + const match = exp1.exec(id); + vendor = match[1].padStart(4, "0"); + product = match[2].padStart(4, "0"); + } else if (exp2.test(id)) { + const match = exp2.exec(id); + vendor = match[1].padStart(4, "0"); + product = match[2].padStart(4, "0"); + } + if (!vendor || !product) { + return `${os}Unknown`; + } + return os + vendor + product; + } +}; + +var GodotInputDragDrop = { + promises: [], + pending_files: [], + add_entry: function(entry) { + if (entry.isDirectory) { + GodotInputDragDrop.add_dir(entry); + } else if (entry.isFile) { + GodotInputDragDrop.add_file(entry); + } else { + GodotRuntime.error("Unrecognized entry...", entry); + } + }, + add_dir: function(entry) { + GodotInputDragDrop.promises.push(new Promise(function(resolve, reject) { + const reader = entry.createReader(); + reader.readEntries(function(entries) { + for (let i = 0; i < entries.length; i++) { + GodotInputDragDrop.add_entry(entries[i]); + } + resolve(); + }); + })); + }, + add_file: function(entry) { + GodotInputDragDrop.promises.push(new Promise(function(resolve, reject) { + entry.file(function(file) { + const reader = new FileReader(); + reader.onload = function() { + const f = { + "path": file.relativePath || file.webkitRelativePath, + "name": file.name, + "type": file.type, + "size": file.size, + "data": reader.result + }; + if (!f["path"]) { + f["path"] = f["name"]; + } + GodotInputDragDrop.pending_files.push(f); + resolve(); + }; + reader.onerror = function() { + GodotRuntime.print("Error reading file"); + reject(); + }; + reader.readAsArrayBuffer(file); + }, function(err) { + GodotRuntime.print("Error!"); + reject(); + }); + })); + }, + process: function(resolve, reject) { + if (GodotInputDragDrop.promises.length === 0) { + resolve(); + return; + } + GodotInputDragDrop.promises.pop().then(function() { + setTimeout(function() { + GodotInputDragDrop.process(resolve, reject); + }, 0); + }); + }, + _process_event: function(ev, callback) { + ev.preventDefault(); + if (ev.dataTransfer.items) { + for (let i = 0; i < ev.dataTransfer.items.length; i++) { + const item = ev.dataTransfer.items[i]; + let entry = null; + if ("getAsEntry" in item) { + entry = item.getAsEntry(); + } else if ("webkitGetAsEntry" in item) { + entry = item.webkitGetAsEntry(); + } + if (entry) { + GodotInputDragDrop.add_entry(entry); + } + } + } else { + GodotRuntime.error("File upload not supported"); + } + new Promise(GodotInputDragDrop.process).then(function() { + const DROP = `/tmp/drop-${parseInt(Math.random() * (1 << 30), 10)}/`; + const drops = []; + const files = []; + FS.mkdir(DROP.slice(0, -1)); + GodotInputDragDrop.pending_files.forEach(elem => { + const path = elem["path"]; + GodotFS.copy_to_fs(DROP + path, elem["data"]); + let idx = path.indexOf("/"); + if (idx === -1) { + drops.push(DROP + path); + } else { + const sub = path.substr(0, idx); + idx = sub.indexOf("/"); + if (idx < 0 && drops.indexOf(DROP + sub) === -1) { + drops.push(DROP + sub); + } + } + files.push(DROP + path); + }); + GodotInputDragDrop.promises = []; + GodotInputDragDrop.pending_files = []; + callback(drops); + if (GodotConfig.persistent_drops) { + GodotOS.atexit(function(resolve, reject) { + GodotInputDragDrop.remove_drop(files, DROP); + resolve(); + }); + } else { + GodotInputDragDrop.remove_drop(files, DROP); + } + }); + }, + remove_drop: function(files, drop_path) { + const dirs = [ drop_path.substr(0, drop_path.length - 1) ]; + files.forEach(function(file) { + FS.unlink(file); + let dir = file.replace(drop_path, ""); + let idx = dir.lastIndexOf("/"); + while (idx > 0) { + dir = dir.substr(0, idx); + if (dirs.indexOf(drop_path + dir) === -1) { + dirs.push(drop_path + dir); + } + idx = dir.lastIndexOf("/"); + } + }); + dirs.sort(function(a, b) { + const al = (a.match(/\//g) || []).length; + const bl = (b.match(/\//g) || []).length; + if (al > bl) { + return -1; + } else if (al < bl) { + return 1; + } + return 0; + }).forEach(function(dir) { + FS.rmdir(dir); + }); + }, + handler: function(callback) { + return function(ev) { + GodotInputDragDrop._process_event(ev, callback); + }; + } +}; + +var GodotInput = { + getModifiers: function(evt) { + return evt.shiftKey + 0 + (evt.altKey + 0 << 1) + (evt.ctrlKey + 0 << 2) + (evt.metaKey + 0 << 3); + }, + computePosition: function(evt, rect) { + const canvas = GodotConfig.canvas; + const rw = canvas.width / rect.width; + const rh = canvas.height / rect.height; + const x = (evt.clientX - rect.x) * rw; + const y = (evt.clientY - rect.y) * rh; + return [ x, y ]; + } +}; + +function _godot_js_input_drop_files_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(98, 1, callback); + const func = GodotRuntime.get_func(callback); + const dropFiles = function(files) { + const args = files || []; + if (!args.length) { + return; + } + const argc = args.length; + const argv = GodotRuntime.allocStringArray(args); + func(argv, argc); + GodotRuntime.freeStringArray(argv, argc); + }; + const canvas = GodotConfig.canvas; + GodotEventListeners.add(canvas, "dragover", function(ev) { + ev.preventDefault(); + }, false); + GodotEventListeners.add(canvas, "drop", GodotInputDragDrop.handler(dropFiles)); +} + +function _godot_js_input_gamepad_cb(change_cb) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(99, 1, change_cb); + const onchange = GodotRuntime.get_func(change_cb); + GodotInputGamepads.init(onchange); +} + +function _godot_js_input_gamepad_sample() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(100, 1); + GodotInputGamepads.sample(); + return 0; +} + +function _godot_js_input_gamepad_sample_count() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(101, 1); + return GodotInputGamepads.get_samples().length; +} + +function _godot_js_input_gamepad_sample_get(p_index, r_btns, r_btns_num, r_axes, r_axes_num, r_standard) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(102, 1, p_index, r_btns, r_btns_num, r_axes, r_axes_num, r_standard); + const sample = GodotInputGamepads.get_sample(p_index); + if (!sample || !sample.connected) { + return 1; + } + const btns = sample.buttons; + const btns_len = btns.length < 16 ? btns.length : 16; + for (let i = 0; i < btns_len; i++) { + GodotRuntime.setHeapValue(r_btns + (i << 2), btns[i], "float"); + } + GodotRuntime.setHeapValue(r_btns_num, btns_len, "i32"); + const axes = sample.axes; + const axes_len = axes.length < 10 ? axes.length : 10; + for (let i = 0; i < axes_len; i++) { + GodotRuntime.setHeapValue(r_axes + (i << 2), axes[i], "float"); + } + GodotRuntime.setHeapValue(r_axes_num, axes_len, "i32"); + const is_standard = sample.standard ? 1 : 0; + GodotRuntime.setHeapValue(r_standard, is_standard, "i32"); + return 0; +} + +function _godot_js_input_key_cb(callback, code, key) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(103, 1, callback, code, key); + const func = GodotRuntime.get_func(callback); + function key_cb(pressed, evt) { + const modifiers = GodotInput.getModifiers(evt); + GodotRuntime.stringToHeap(evt.code, code, 32); + GodotRuntime.stringToHeap(evt.key, key, 32); + func(pressed, evt.repeat, modifiers); + evt.preventDefault(); + } + GodotEventListeners.add(GodotConfig.canvas, "keydown", key_cb.bind(null, 1), false); + GodotEventListeners.add(GodotConfig.canvas, "keyup", key_cb.bind(null, 0), false); +} + +function _godot_js_input_mouse_button_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(104, 1, callback); + const func = GodotRuntime.get_func(callback); + const canvas = GodotConfig.canvas; + function button_cb(p_pressed, evt) { + const rect = canvas.getBoundingClientRect(); + const pos = GodotInput.computePosition(evt, rect); + const modifiers = GodotInput.getModifiers(evt); + if (p_pressed) { + GodotConfig.canvas.focus(); + } + if (func(p_pressed, evt.button, pos[0], pos[1], modifiers)) { + evt.preventDefault(); + } + } + GodotEventListeners.add(canvas, "mousedown", button_cb.bind(null, 1), false); + GodotEventListeners.add(window, "mouseup", button_cb.bind(null, 0), false); +} + +function _godot_js_input_mouse_move_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(105, 1, callback); + const func = GodotRuntime.get_func(callback); + const canvas = GodotConfig.canvas; + function move_cb(evt) { + const rect = canvas.getBoundingClientRect(); + const pos = GodotInput.computePosition(evt, rect); + const rw = canvas.width / rect.width; + const rh = canvas.height / rect.height; + const rel_pos_x = evt.movementX * rw; + const rel_pos_y = evt.movementY * rh; + const modifiers = GodotInput.getModifiers(evt); + func(pos[0], pos[1], rel_pos_x, rel_pos_y, modifiers); + } + GodotEventListeners.add(window, "mousemove", move_cb, false); +} + +function _godot_js_input_mouse_wheel_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(106, 1, callback); + const func = GodotRuntime.get_func(callback); + function wheel_cb(evt) { + if (func(evt["deltaX"] || 0, evt["deltaY"] || 0)) { + evt.preventDefault(); + } + } + GodotEventListeners.add(GodotConfig.canvas, "wheel", wheel_cb, false); +} + +function _godot_js_input_paste_cb(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(107, 1, callback); + const func = GodotRuntime.get_func(callback); + GodotEventListeners.add(window, "paste", function(evt) { + const text = evt.clipboardData.getData("text"); + const ptr = GodotRuntime.allocString(text); + func(ptr); + GodotRuntime.free(ptr); + }, false); +} + +function _godot_js_input_touch_cb(callback, ids, coords) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(108, 1, callback, ids, coords); + const func = GodotRuntime.get_func(callback); + const canvas = GodotConfig.canvas; + function touch_cb(type, evt) { + if (type === 0) { + GodotConfig.canvas.focus(); + } + const rect = canvas.getBoundingClientRect(); + const touches = evt.changedTouches; + for (let i = 0; i < touches.length; i++) { + const touch = touches[i]; + const pos = GodotInput.computePosition(touch, rect); + GodotRuntime.setHeapValue(coords + i * 2 * 8, pos[0], "double"); + GodotRuntime.setHeapValue(coords + (i * 2 + 1) * 8, pos[1], "double"); + GodotRuntime.setHeapValue(ids + i * 4, touch.identifier, "i32"); + } + func(type, touches.length); + if (evt.cancelable) { + evt.preventDefault(); + } + } + GodotEventListeners.add(canvas, "touchstart", touch_cb.bind(null, 0), false); + GodotEventListeners.add(canvas, "touchend", touch_cb.bind(null, 1), false); + GodotEventListeners.add(canvas, "touchcancel", touch_cb.bind(null, 1), false); + GodotEventListeners.add(canvas, "touchmove", touch_cb.bind(null, 2), false); +} + +function _godot_js_input_vibrate_handheld(p_duration_ms) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(109, 1, p_duration_ms); + if (typeof navigator.vibrate !== "function") { + GodotRuntime.print("This browser does not support vibration."); + } else { + navigator.vibrate(p_duration_ms); + } +} + +function _godot_js_os_download_buffer(p_ptr, p_size, p_name, p_mime) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(110, 1, p_ptr, p_size, p_name, p_mime); + const buf = GodotRuntime.heapSlice(GROWABLE_HEAP_I8(), p_ptr, p_size); + const name = GodotRuntime.parseString(p_name); + const mime = GodotRuntime.parseString(p_mime); + const blob = new Blob([ buf ], { + type: mime + }); + const url = window.URL.createObjectURL(blob); + const a = document.createElement("a"); + a.href = url; + a.download = name; + a.style.display = "none"; + document.body.appendChild(a); + a.click(); + a.remove(); + window.URL.revokeObjectURL(url); +} + +function _godot_js_os_execute(p_json) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(111, 1, p_json); + const json_args = GodotRuntime.parseString(p_json); + const args = JSON.parse(json_args); + if (GodotConfig.on_execute) { + GodotConfig.on_execute(args); + return 0; + } + return 1; +} + +function _godot_js_os_finish_async(p_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(112, 1, p_callback); + const func = GodotRuntime.get_func(p_callback); + GodotOS.finish_async(func); +} + +function _godot_js_os_fs_is_persistent() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(113, 1); + return GodotFS.is_persistent(); +} + +function _godot_js_os_fs_sync(callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(114, 1, callback); + const func = GodotRuntime.get_func(callback); + GodotOS._fs_sync_promise = GodotFS.sync(); + GodotOS._fs_sync_promise.then(function(err) { + func(); + }); +} + +function _godot_js_os_has_feature(p_ftr) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(115, 1, p_ftr); + const ftr = GodotRuntime.parseString(p_ftr); + const ua = navigator.userAgent; + if (ftr === "web_macos") { + return ua.indexOf("Mac") !== -1 ? 1 : 0; + } + if (ftr === "web_windows") { + return ua.indexOf("Windows") !== -1 ? 1 : 0; + } + if (ftr === "web_android") { + return ua.indexOf("Android") !== -1 ? 1 : 0; + } + if (ftr === "web_ios") { + return ua.indexOf("iPhone") !== -1 || ua.indexOf("iPad") !== -1 || ua.indexOf("iPod") !== -1 ? 1 : 0; + } + if (ftr === "web_linuxbsd") { + return ua.indexOf("CrOS") !== -1 || ua.indexOf("BSD") !== -1 || ua.indexOf("Linux") !== -1 || ua.indexOf("X11") !== -1 ? 1 : 0; + } + return 0; +} + +function _godot_js_os_hw_concurrency_get() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(116, 1); + const concurrency = navigator.hardwareConcurrency || 1; + return concurrency < 2 ? concurrency : 2; +} + +function _godot_js_os_request_quit_cb(p_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(117, 1, p_callback); + GodotOS.request_quit = GodotRuntime.get_func(p_callback); +} + +function _godot_js_os_shell_open(p_uri) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(118, 1, p_uri); + window.open(GodotRuntime.parseString(p_uri), "_blank"); +} + +var GodotPWA = { + hasUpdate: false, + updateState: function(cb, reg) { + if (!reg) { + return; + } + if (!reg.active) { + return; + } + if (reg.waiting) { + GodotPWA.hasUpdate = true; + cb(); + } + GodotEventListeners.add(reg, "updatefound", function() { + const installing = reg.installing; + GodotEventListeners.add(installing, "statechange", function() { + if (installing.state === "installed") { + GodotPWA.hasUpdate = true; + cb(); + } + }); + }); + } +}; + +function _godot_js_pwa_cb(p_update_cb) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(119, 1, p_update_cb); + if ("serviceWorker" in navigator) { + const cb = GodotRuntime.get_func(p_update_cb); + navigator.serviceWorker.getRegistration().then(GodotPWA.updateState.bind(null, cb)); + } +} + +function _godot_js_pwa_update() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(120, 1); + if ("serviceWorker" in navigator && GodotPWA.hasUpdate) { + navigator.serviceWorker.getRegistration().then(function(reg) { + if (!reg || !reg.waiting) { + return; + } + reg.waiting.postMessage("update"); + }); + return 0; + } + return 1; +} + +var GodotRTCDataChannel = { + connect: function(p_id, p_on_open, p_on_message, p_on_error, p_on_close) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + ref.binaryType = "arraybuffer"; + ref.onopen = function(event) { + p_on_open(); + }; + ref.onclose = function(event) { + p_on_close(); + }; + ref.onerror = function(event) { + p_on_error(); + }; + ref.onmessage = function(event) { + let buffer; + let is_string = 0; + if (event.data instanceof ArrayBuffer) { + buffer = new Uint8Array(event.data); + } else if (event.data instanceof Blob) { + GodotRuntime.error("Blob type not supported"); + return; + } else if (typeof event.data === "string") { + is_string = 1; + const enc = new TextEncoder("utf-8"); + buffer = new Uint8Array(enc.encode(event.data)); + } else { + GodotRuntime.error("Unknown message type"); + return; + } + const len = buffer.length * buffer.BYTES_PER_ELEMENT; + const out = GodotRuntime.malloc(len); + GROWABLE_HEAP_U8().set(buffer, out); + p_on_message(out, len, is_string); + GodotRuntime.free(out); + }; + }, + close: function(p_id) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + ref.onopen = null; + ref.onmessage = null; + ref.onerror = null; + ref.onclose = null; + ref.close(); + }, + get_prop: function(p_id, p_prop, p_def) { + const ref = IDHandler.get(p_id); + return ref && ref[p_prop] !== undefined ? ref[p_prop] : p_def; + } +}; + +function _godot_js_rtc_datachannel_close(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(121, 1, p_id); + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + GodotRTCDataChannel.close(p_id); +} + +function _godot_js_rtc_datachannel_connect(p_id, p_ref, p_on_open, p_on_message, p_on_error, p_on_close) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(122, 1, p_id, p_ref, p_on_open, p_on_message, p_on_error, p_on_close); + const onopen = GodotRuntime.get_func(p_on_open).bind(null, p_ref); + const onmessage = GodotRuntime.get_func(p_on_message).bind(null, p_ref); + const onerror = GodotRuntime.get_func(p_on_error).bind(null, p_ref); + const onclose = GodotRuntime.get_func(p_on_close).bind(null, p_ref); + GodotRTCDataChannel.connect(p_id, onopen, onmessage, onerror, onclose); +} + +function _godot_js_rtc_datachannel_destroy(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(123, 1, p_id); + GodotRTCDataChannel.close(p_id); + IDHandler.remove(p_id); +} + +function _godot_js_rtc_datachannel_get_buffered_amount(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(124, 1, p_id); + return GodotRTCDataChannel.get_prop(p_id, "bufferedAmount", 0); +} + +function _godot_js_rtc_datachannel_id_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(125, 1, p_id); + return GodotRTCDataChannel.get_prop(p_id, "id", 65535); +} + +function _godot_js_rtc_datachannel_is_negotiated(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(126, 1, p_id); + return GodotRTCDataChannel.get_prop(p_id, "negotiated", 65535); +} + +function _godot_js_rtc_datachannel_is_ordered(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(127, 1, p_id); + return GodotRTCDataChannel.get_prop(p_id, "ordered", true); +} + +function _godot_js_rtc_datachannel_label_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(128, 1, p_id); + const ref = IDHandler.get(p_id); + if (!ref || !ref.label) { + return 0; + } + return GodotRuntime.allocString(ref.label); +} + +function _godot_js_rtc_datachannel_max_packet_lifetime_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(129, 1, p_id); + const ref = IDHandler.get(p_id); + if (!ref) { + return 65535; + } + if (ref["maxPacketLifeTime"] !== undefined) { + return ref["maxPacketLifeTime"]; + } else if (ref["maxRetransmitTime"] !== undefined) { + return ref["maxRetransmitTime"]; + } + return 65535; +} + +function _godot_js_rtc_datachannel_max_retransmits_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(130, 1, p_id); + return GodotRTCDataChannel.get_prop(p_id, "maxRetransmits", 65535); +} + +function _godot_js_rtc_datachannel_protocol_get(p_id) { + const ref = IDHandler.get(p_id); + if (!ref || !ref.protocol) { + return 0; + } + return GodotRuntime.allocString(ref.protocol); +} + +function _godot_js_rtc_datachannel_ready_state_get(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(131, 1, p_id); + const ref = IDHandler.get(p_id); + if (!ref) { + return 3; + } + switch (ref.readyState) { + case "connecting": + return 0; + + case "open": + return 1; + + case "closing": + return 2; + + case "closed": + default: + return 3; + } +} + +function _godot_js_rtc_datachannel_send(p_id, p_buffer, p_length, p_raw) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(132, 1, p_id, p_buffer, p_length, p_raw); + const ref = IDHandler.get(p_id); + if (!ref) { + return 1; + } + const bytes_array = new Uint8Array(p_length); + for (let i = 0; i < p_length; i++) { + bytes_array[i] = GodotRuntime.getHeapValue(p_buffer + i, "i8"); + } + if (p_raw) { + ref.send(bytes_array.buffer); + } else { + const string = new TextDecoder("utf-8").decode(bytes_array); + ref.send(string); + } + return 0; +} + +var GodotRTCPeerConnection = { + ConnectionState: { + new: 0, + connecting: 1, + connected: 2, + disconnected: 3, + failed: 4, + closed: 5 + }, + ConnectionStateCompat: { + new: 0, + checking: 1, + connected: 2, + completed: 2, + disconnected: 3, + failed: 4, + closed: 5 + }, + IceGatheringState: { + new: 0, + gathering: 1, + complete: 2 + }, + SignalingState: { + stable: 0, + "have-local-offer": 1, + "have-remote-offer": 2, + "have-local-pranswer": 3, + "have-remote-pranswer": 4, + closed: 5 + }, + create: function(config, onConnectionChange, onSignalingChange, onIceGatheringChange, onIceCandidate, onDataChannel) { + let conn = null; + try { + conn = new RTCPeerConnection(config); + } catch (e) { + GodotRuntime.error(e); + return 0; + } + const id = IDHandler.add(conn); + if ("connectionState" in conn && conn["connectionState"] !== undefined) { + conn.onconnectionstatechange = function(event) { + if (!IDHandler.get(id)) { + return; + } + onConnectionChange(GodotRTCPeerConnection.ConnectionState[conn.connectionState] || 0); + }; + } else { + conn.oniceconnectionstatechange = function(event) { + if (!IDHandler.get(id)) { + return; + } + onConnectionChange(GodotRTCPeerConnection.ConnectionStateCompat[conn.iceConnectionState] || 0); + }; + } + conn.onicegatheringstatechange = function(event) { + if (!IDHandler.get(id)) { + return; + } + onIceGatheringChange(GodotRTCPeerConnection.IceGatheringState[conn.iceGatheringState] || 0); + }; + conn.onsignalingstatechange = function(event) { + if (!IDHandler.get(id)) { + return; + } + onSignalingChange(GodotRTCPeerConnection.SignalingState[conn.signalingState] || 0); + }; + conn.onicecandidate = function(event) { + if (!IDHandler.get(id)) { + return; + } + const c = event.candidate; + if (!c || !c.candidate) { + return; + } + const candidate_str = GodotRuntime.allocString(c.candidate); + const mid_str = GodotRuntime.allocString(c.sdpMid); + onIceCandidate(mid_str, c.sdpMLineIndex, candidate_str); + GodotRuntime.free(candidate_str); + GodotRuntime.free(mid_str); + }; + conn.ondatachannel = function(event) { + if (!IDHandler.get(id)) { + return; + } + const cid = IDHandler.add(event.channel); + onDataChannel(cid); + }; + return id; + }, + destroy: function(p_id) { + const conn = IDHandler.get(p_id); + if (!conn) { + return; + } + conn.onconnectionstatechange = null; + conn.oniceconnectionstatechange = null; + conn.onicegatheringstatechange = null; + conn.onsignalingstatechange = null; + conn.onicecandidate = null; + conn.ondatachannel = null; + IDHandler.remove(p_id); + }, + onsession: function(p_id, callback, session) { + if (!IDHandler.get(p_id)) { + return; + } + const type_str = GodotRuntime.allocString(session.type); + const sdp_str = GodotRuntime.allocString(session.sdp); + callback(type_str, sdp_str); + GodotRuntime.free(type_str); + GodotRuntime.free(sdp_str); + }, + onerror: function(p_id, callback, error) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + GodotRuntime.error(error); + callback(); + } +}; + +function _godot_js_rtc_pc_close(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(133, 1, p_id); + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + ref.close(); +} + +function _godot_js_rtc_pc_create(p_config, p_ref, p_on_connection_state_change, p_on_ice_gathering_state_change, p_on_signaling_state_change, p_on_ice_candidate, p_on_datachannel) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(134, 1, p_config, p_ref, p_on_connection_state_change, p_on_ice_gathering_state_change, p_on_signaling_state_change, p_on_ice_candidate, p_on_datachannel); + const wrap = function(p_func) { + return GodotRuntime.get_func(p_func).bind(null, p_ref); + }; + return GodotRTCPeerConnection.create(JSON.parse(GodotRuntime.parseString(p_config)), wrap(p_on_connection_state_change), wrap(p_on_signaling_state_change), wrap(p_on_ice_gathering_state_change), wrap(p_on_ice_candidate), wrap(p_on_datachannel)); +} + +function _godot_js_rtc_pc_datachannel_create(p_id, p_label, p_config) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(135, 1, p_id, p_label, p_config); + try { + const ref = IDHandler.get(p_id); + if (!ref) { + return 0; + } + const label = GodotRuntime.parseString(p_label); + const config = JSON.parse(GodotRuntime.parseString(p_config)); + const channel = ref.createDataChannel(label, config); + return IDHandler.add(channel); + } catch (e) { + GodotRuntime.error(e); + return 0; + } +} + +function _godot_js_rtc_pc_destroy(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(136, 1, p_id); + GodotRTCPeerConnection.destroy(p_id); +} + +function _godot_js_rtc_pc_ice_candidate_add(p_id, p_mid_name, p_mline_idx, p_sdp) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(137, 1, p_id, p_mid_name, p_mline_idx, p_sdp); + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + const sdpMidName = GodotRuntime.parseString(p_mid_name); + const sdpName = GodotRuntime.parseString(p_sdp); + ref.addIceCandidate(new RTCIceCandidate({ + "candidate": sdpName, + "sdpMid": sdpMidName, + "sdpMlineIndex": p_mline_idx + })); +} + +function _godot_js_rtc_pc_local_description_set(p_id, p_type, p_sdp, p_obj, p_on_error) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(138, 1, p_id, p_type, p_sdp, p_obj, p_on_error); + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + const type = GodotRuntime.parseString(p_type); + const sdp = GodotRuntime.parseString(p_sdp); + const onerror = GodotRuntime.get_func(p_on_error).bind(null, p_obj); + ref.setLocalDescription({ + "sdp": sdp, + "type": type + }).catch(function(error) { + GodotRTCPeerConnection.onerror(p_id, onerror, error); + }); +} + +function _godot_js_rtc_pc_offer_create(p_id, p_obj, p_on_session, p_on_error) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(139, 1, p_id, p_obj, p_on_session, p_on_error); + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + const onsession = GodotRuntime.get_func(p_on_session).bind(null, p_obj); + const onerror = GodotRuntime.get_func(p_on_error).bind(null, p_obj); + ref.createOffer().then(function(session) { + GodotRTCPeerConnection.onsession(p_id, onsession, session); + }).catch(function(error) { + GodotRTCPeerConnection.onerror(p_id, onerror, error); + }); +} + +function _godot_js_rtc_pc_remote_description_set(p_id, p_type, p_sdp, p_obj, p_session_created, p_on_error) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(140, 1, p_id, p_type, p_sdp, p_obj, p_session_created, p_on_error); + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + const type = GodotRuntime.parseString(p_type); + const sdp = GodotRuntime.parseString(p_sdp); + const onerror = GodotRuntime.get_func(p_on_error).bind(null, p_obj); + const onsession = GodotRuntime.get_func(p_session_created).bind(null, p_obj); + ref.setRemoteDescription({ + "sdp": sdp, + "type": type + }).then(function() { + if (type !== "offer") { + return Promise.resolve(); + } + return ref.createAnswer().then(function(session) { + GodotRTCPeerConnection.onsession(p_id, onsession, session); + }); + }).catch(function(error) { + GodotRTCPeerConnection.onerror(p_id, onerror, error); + }); +} + +function _godot_js_tts_get_voices(p_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(141, 1, p_callback); + const func = GodotRuntime.get_func(p_callback); + try { + const arr = []; + const voices = window.speechSynthesis.getVoices(); + for (let i = 0; i < voices.length; i++) { + arr.push(`${voices[i].lang};${voices[i].name}`); + } + const c_ptr = GodotRuntime.allocStringArray(arr); + func(arr.length, c_ptr); + GodotRuntime.freeStringArray(c_ptr, arr.length); + } catch (e) {} +} + +function _godot_js_tts_is_paused() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(142, 1); + return window.speechSynthesis.paused; +} + +function _godot_js_tts_is_speaking() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(143, 1); + return window.speechSynthesis.speaking; +} + +function _godot_js_tts_pause() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(144, 1); + window.speechSynthesis.pause(); +} + +function _godot_js_tts_resume() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(145, 1); + window.speechSynthesis.resume(); +} + +function _godot_js_tts_speak(p_text, p_voice, p_volume, p_pitch, p_rate, p_utterance_id, p_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(146, 1, p_text, p_voice, p_volume, p_pitch, p_rate, p_utterance_id, p_callback); + const func = GodotRuntime.get_func(p_callback); + function listener_end(evt) { + evt.currentTarget.cb(1, evt.currentTarget.id, 0); + } + function listener_start(evt) { + evt.currentTarget.cb(0, evt.currentTarget.id, 0); + } + function listener_error(evt) { + evt.currentTarget.cb(2, evt.currentTarget.id, 0); + } + function listener_bound(evt) { + evt.currentTarget.cb(3, evt.currentTarget.id, evt.charIndex); + } + const utterance = new SpeechSynthesisUtterance(GodotRuntime.parseString(p_text)); + utterance.rate = p_rate; + utterance.pitch = p_pitch; + utterance.volume = p_volume / 100; + utterance.addEventListener("end", listener_end); + utterance.addEventListener("start", listener_start); + utterance.addEventListener("error", listener_error); + utterance.addEventListener("boundary", listener_bound); + utterance.id = p_utterance_id; + utterance.cb = func; + const voice = GodotRuntime.parseString(p_voice); + const voices = window.speechSynthesis.getVoices(); + for (let i = 0; i < voices.length; i++) { + if (voices[i].name === voice) { + utterance.voice = voices[i]; + break; + } + } + window.speechSynthesis.resume(); + window.speechSynthesis.speak(utterance); +} + +function _godot_js_tts_stop() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(147, 1); + window.speechSynthesis.cancel(); + window.speechSynthesis.resume(); +} + +var GodotWebSocket = { + _onopen: function(p_id, callback, event) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + const c_str = GodotRuntime.allocString(ref.protocol); + callback(c_str); + GodotRuntime.free(c_str); + }, + _onmessage: function(p_id, callback, event) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + let buffer; + let is_string = 0; + if (event.data instanceof ArrayBuffer) { + buffer = new Uint8Array(event.data); + } else if (event.data instanceof Blob) { + GodotRuntime.error("Blob type not supported"); + return; + } else if (typeof event.data === "string") { + is_string = 1; + const enc = new TextEncoder("utf-8"); + buffer = new Uint8Array(enc.encode(event.data)); + } else { + GodotRuntime.error("Unknown message type"); + return; + } + const len = buffer.length * buffer.BYTES_PER_ELEMENT; + const out = GodotRuntime.malloc(len); + GROWABLE_HEAP_U8().set(buffer, out); + callback(out, len, is_string); + GodotRuntime.free(out); + }, + _onerror: function(p_id, callback, event) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + callback(); + }, + _onclose: function(p_id, callback, event) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + const c_str = GodotRuntime.allocString(event.reason); + callback(event.code, c_str, event.wasClean ? 1 : 0); + GodotRuntime.free(c_str); + }, + send: function(p_id, p_data) { + const ref = IDHandler.get(p_id); + if (!ref || ref.readyState !== ref.OPEN) { + return 1; + } + ref.send(p_data); + return 0; + }, + bufferedAmount: function(p_id) { + const ref = IDHandler.get(p_id); + if (!ref) { + return 0; + } + return ref.bufferedAmount; + }, + create: function(socket, p_on_open, p_on_message, p_on_error, p_on_close) { + const id = IDHandler.add(socket); + socket.onopen = GodotWebSocket._onopen.bind(null, id, p_on_open); + socket.onmessage = GodotWebSocket._onmessage.bind(null, id, p_on_message); + socket.onerror = GodotWebSocket._onerror.bind(null, id, p_on_error); + socket.onclose = GodotWebSocket._onclose.bind(null, id, p_on_close); + return id; + }, + close: function(p_id, p_code, p_reason) { + const ref = IDHandler.get(p_id); + if (ref && ref.readyState < ref.CLOSING) { + const code = p_code; + const reason = p_reason; + ref.close(code, reason); + } + }, + destroy: function(p_id) { + const ref = IDHandler.get(p_id); + if (!ref) { + return; + } + GodotWebSocket.close(p_id, 3001, "destroyed"); + IDHandler.remove(p_id); + ref.onopen = null; + ref.onmessage = null; + ref.onerror = null; + ref.onclose = null; + } +}; + +function _godot_js_websocket_buffered_amount(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(148, 1, p_id); + return GodotWebSocket.bufferedAmount(p_id); +} + +function _godot_js_websocket_close(p_id, p_code, p_reason) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(149, 1, p_id, p_code, p_reason); + const code = p_code; + const reason = GodotRuntime.parseString(p_reason); + GodotWebSocket.close(p_id, code, reason); +} + +function _godot_js_websocket_create(p_ref, p_url, p_proto, p_on_open, p_on_message, p_on_error, p_on_close) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(150, 1, p_ref, p_url, p_proto, p_on_open, p_on_message, p_on_error, p_on_close); + const on_open = GodotRuntime.get_func(p_on_open).bind(null, p_ref); + const on_message = GodotRuntime.get_func(p_on_message).bind(null, p_ref); + const on_error = GodotRuntime.get_func(p_on_error).bind(null, p_ref); + const on_close = GodotRuntime.get_func(p_on_close).bind(null, p_ref); + const url = GodotRuntime.parseString(p_url); + const protos = GodotRuntime.parseString(p_proto); + let socket = null; + try { + if (protos) { + socket = new WebSocket(url, protos.split(",")); + } else { + socket = new WebSocket(url); + } + } catch (e) { + return 0; + } + socket.binaryType = "arraybuffer"; + return GodotWebSocket.create(socket, on_open, on_message, on_error, on_close); +} + +function _godot_js_websocket_destroy(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(151, 1, p_id); + GodotWebSocket.destroy(p_id); +} + +function _godot_js_websocket_send(p_id, p_buf, p_buf_len, p_raw) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(152, 1, p_id, p_buf, p_buf_len, p_raw); + const bytes_array = new Uint8Array(p_buf_len); + let i = 0; + for (i = 0; i < p_buf_len; i++) { + bytes_array[i] = GodotRuntime.getHeapValue(p_buf + i, "i8"); + } + let out = bytes_array.buffer; + if (!p_raw) { + out = new TextDecoder("utf-8").decode(bytes_array); + } + return GodotWebSocket.send(p_id, out); +} + +var GodotJSWrapper = { + proxies: null, + cb_ret: null, + MyProxy: function(val) { + const id = IDHandler.add(this); + GodotJSWrapper.proxies.set(val, id); + let refs = 1; + this.ref = function() { + refs++; + }; + this.unref = function() { + refs--; + if (refs === 0) { + IDHandler.remove(id); + GodotJSWrapper.proxies.delete(val); + } + }; + this.get_val = function() { + return val; + }; + this.get_id = function() { + return id; + }; + }, + get_proxied: function(val) { + const id = GodotJSWrapper.proxies.get(val); + if (id === undefined) { + const proxy = new GodotJSWrapper.MyProxy(val); + return proxy.get_id(); + } + IDHandler.get(id).ref(); + return id; + }, + get_proxied_value: function(id) { + const proxy = IDHandler.get(id); + if (proxy === undefined) { + return undefined; + } + return proxy.get_val(); + }, + variant2js: function(type, val) { + switch (type) { + case 0: + return null; + + case 1: + return !!GodotRuntime.getHeapValue(val, "i64"); + + case 2: + return GodotRuntime.getHeapValue(val, "i64"); + + case 3: + return GodotRuntime.getHeapValue(val, "double"); + + case 4: + return GodotRuntime.parseString(GodotRuntime.getHeapValue(val, "*")); + + case 24: + return GodotJSWrapper.get_proxied_value(GodotRuntime.getHeapValue(val, "i64")); + + default: + return undefined; + } + }, + js2variant: function(p_val, p_exchange) { + if (p_val === undefined || p_val === null) { + return 0; + } + const type = typeof p_val; + if (type === "boolean") { + GodotRuntime.setHeapValue(p_exchange, p_val, "i64"); + return 1; + } else if (type === "number") { + if (Number.isInteger(p_val)) { + GodotRuntime.setHeapValue(p_exchange, p_val, "i64"); + return 2; + } + GodotRuntime.setHeapValue(p_exchange, p_val, "double"); + return 3; + } else if (type === "string") { + const c_str = GodotRuntime.allocString(p_val); + GodotRuntime.setHeapValue(p_exchange, c_str, "*"); + return 4; + } + const id = GodotJSWrapper.get_proxied(p_val); + GodotRuntime.setHeapValue(p_exchange, id, "i64"); + return 24; + } +}; + +function _godot_js_wrapper_create_cb(p_ref, p_func) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(153, 1, p_ref, p_func); + const func = GodotRuntime.get_func(p_func); + let id = 0; + const cb = function() { + if (!GodotJSWrapper.get_proxied_value(id)) { + return undefined; + } + GodotJSWrapper.cb_ret = null; + const args = Array.from(arguments); + const argsProxy = new GodotJSWrapper.MyProxy(args); + func(p_ref, argsProxy.get_id(), args.length); + argsProxy.unref(); + const ret = GodotJSWrapper.cb_ret; + GodotJSWrapper.cb_ret = null; + return ret; + }; + id = GodotJSWrapper.get_proxied(cb); + return id; +} + +function _godot_js_wrapper_create_object(p_object, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(154, 1, p_object, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback); + const name = GodotRuntime.parseString(p_object); + if (typeof window[name] === "undefined") { + return -1; + } + const convert = GodotRuntime.get_func(p_convert_callback); + const freeLock = GodotRuntime.get_func(p_free_lock_callback); + const args = new Array(p_argc); + for (let i = 0; i < p_argc; i++) { + const type = convert(p_args, i, p_exchange, p_lock); + const lock = GodotRuntime.getHeapValue(p_lock, "*"); + args[i] = GodotJSWrapper.variant2js(type, p_exchange); + if (lock) { + freeLock(p_lock, type); + } + } + try { + const res = new window[name](...args); + return GodotJSWrapper.js2variant(res, p_exchange); + } catch (e) { + GodotRuntime.error(`Error calling constructor ${name} with args:`, args, "error:", e); + return -1; + } +} + +function _godot_js_wrapper_interface_get(p_name) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(155, 1, p_name); + const name = GodotRuntime.parseString(p_name); + if (typeof window[name] !== "undefined") { + return GodotJSWrapper.get_proxied(window[name]); + } + return 0; +} + +function _godot_js_wrapper_object_call(p_id, p_method, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(156, 1, p_id, p_method, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback); + const obj = GodotJSWrapper.get_proxied_value(p_id); + if (obj === undefined) { + return -1; + } + const method = GodotRuntime.parseString(p_method); + const convert = GodotRuntime.get_func(p_convert_callback); + const freeLock = GodotRuntime.get_func(p_free_lock_callback); + const args = new Array(p_argc); + for (let i = 0; i < p_argc; i++) { + const type = convert(p_args, i, p_exchange, p_lock); + const lock = GodotRuntime.getHeapValue(p_lock, "*"); + args[i] = GodotJSWrapper.variant2js(type, p_exchange); + if (lock) { + freeLock(p_lock, type); + } + } + try { + const res = obj[method](...args); + return GodotJSWrapper.js2variant(res, p_exchange); + } catch (e) { + GodotRuntime.error(`Error calling method ${method} on:`, obj, "error:", e); + return -1; + } +} + +function _godot_js_wrapper_object_get(p_id, p_exchange, p_prop) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(157, 1, p_id, p_exchange, p_prop); + const obj = GodotJSWrapper.get_proxied_value(p_id); + if (obj === undefined) { + return 0; + } + if (p_prop) { + const prop = GodotRuntime.parseString(p_prop); + try { + return GodotJSWrapper.js2variant(obj[prop], p_exchange); + } catch (e) { + GodotRuntime.error(`Error getting variable ${prop} on object`, obj); + return 0; + } + } + return GodotJSWrapper.js2variant(obj, p_exchange); +} + +function _godot_js_wrapper_object_getvar(p_id, p_type, p_exchange) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(158, 1, p_id, p_type, p_exchange); + const obj = GodotJSWrapper.get_proxied_value(p_id); + if (obj === undefined) { + return -1; + } + const prop = GodotJSWrapper.variant2js(p_type, p_exchange); + if (prop === undefined || prop === null) { + return -1; + } + try { + return GodotJSWrapper.js2variant(obj[prop], p_exchange); + } catch (e) { + GodotRuntime.error(`Error getting variable ${prop} on object`, obj, e); + return -1; + } +} + +function _godot_js_wrapper_object_set(p_id, p_name, p_type, p_exchange) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(159, 1, p_id, p_name, p_type, p_exchange); + const obj = GodotJSWrapper.get_proxied_value(p_id); + if (obj === undefined) { + return; + } + const name = GodotRuntime.parseString(p_name); + try { + obj[name] = GodotJSWrapper.variant2js(p_type, p_exchange); + } catch (e) { + GodotRuntime.error(`Error setting variable ${name} on object`, obj); + } +} + +function _godot_js_wrapper_object_set_cb_ret(p_val_type, p_val_ex) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(160, 1, p_val_type, p_val_ex); + GodotJSWrapper.cb_ret = GodotJSWrapper.variant2js(p_val_type, p_val_ex); +} + +function _godot_js_wrapper_object_setvar(p_id, p_key_type, p_key_ex, p_val_type, p_val_ex) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(161, 1, p_id, p_key_type, p_key_ex, p_val_type, p_val_ex); + const obj = GodotJSWrapper.get_proxied_value(p_id); + if (obj === undefined) { + return -1; + } + const key = GodotJSWrapper.variant2js(p_key_type, p_key_ex); + try { + obj[key] = GodotJSWrapper.variant2js(p_val_type, p_val_ex); + return 0; + } catch (e) { + GodotRuntime.error(`Error setting variable ${key} on object`, obj); + return -1; + } +} + +function _godot_js_wrapper_object_unref(p_id) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(162, 1, p_id); + const proxy = IDHandler.get(p_id); + if (proxy !== undefined) { + proxy.unref(); + } +} + +var GodotWebGL2 = {}; + +function _godot_webgl2_glFramebufferTextureMultiviewOVR(target, attachment, texture, level, base_view_index, num_views) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(163, 1, target, attachment, texture, level, base_view_index, num_views); + const context = GL.currentContext; + if (typeof context.multiviewExt === "undefined") { + const ext = context.GLctx.getExtension("OVR_multiview2"); + if (!ext) { + GodotRuntime.error("Trying to call glFramebufferTextureMultiviewOVR() without the OVR_multiview2 extension"); + return; + } + context.multiviewExt = ext; + } + const ext = context.multiviewExt; + ext.framebufferTextureMultiviewOVR(target, attachment, GL.textures[texture], level, base_view_index, num_views); +} + +function _godot_webgl2_glGetBufferSubData(target, offset, size, data) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(164, 1, target, offset, size, data); + const gl_context_handle = _emscripten_webgl_get_current_context(); + const gl = GL.getContext(gl_context_handle); + if (gl) { + gl.GLctx["getBufferSubData"](target, offset, GROWABLE_HEAP_U8(), data, size); + } +} + +var GodotWebXR = { + gl: null, + session: null, + gl_binding: null, + layer: null, + space: null, + frame: null, + pose: null, + view_count: 1, + input_sources: [ , , , , , , , , , , , , , , , ], + touches: [ , , , , ], + onsimpleevent: null, + orig_requestAnimationFrame: null, + requestAnimationFrame: callback => { + if (GodotWebXR.session && GodotWebXR.space) { + const onFrame = function(time, frame) { + GodotWebXR.frame = frame; + GodotWebXR.pose = frame.getViewerPose(GodotWebXR.space); + callback(time); + GodotWebXR.frame = null; + GodotWebXR.pose = null; + }; + GodotWebXR.session.requestAnimationFrame(onFrame); + } else { + GodotWebXR.orig_requestAnimationFrame(callback); + } + }, + monkeyPatchRequestAnimationFrame: enable => { + if (GodotWebXR.orig_requestAnimationFrame === null) { + GodotWebXR.orig_requestAnimationFrame = Browser.requestAnimationFrame; + } + Browser.requestAnimationFrame = enable ? GodotWebXR.requestAnimationFrame : GodotWebXR.orig_requestAnimationFrame; + }, + pauseResumeMainLoop: () => { + Browser.mainLoop.pause(); + runtimeKeepalivePush(); + window.setTimeout(function() { + runtimeKeepalivePop(); + Browser.mainLoop.resume(); + }, 0); + }, + getLayer: () => { + const new_view_count = GodotWebXR.pose ? GodotWebXR.pose.views.length : 1; + let layer = GodotWebXR.layer; + if (layer && GodotWebXR.view_count === new_view_count) { + return layer; + } + if (!GodotWebXR.session || !GodotWebXR.gl_binding) { + return null; + } + const gl = GodotWebXR.gl; + layer = GodotWebXR.gl_binding.createProjectionLayer({ + textureType: new_view_count > 1 ? "texture-array" : "texture", + colorFormat: gl.RGBA8, + depthFormat: gl.DEPTH_COMPONENT24 + }); + GodotWebXR.session.updateRenderState({ + layers: [ layer ] + }); + GodotWebXR.layer = layer; + GodotWebXR.view_count = new_view_count; + return layer; + }, + getSubImage: () => { + if (!GodotWebXR.pose) { + return null; + } + const layer = GodotWebXR.getLayer(); + if (layer === null) { + return null; + } + return GodotWebXR.gl_binding.getViewSubImage(layer, GodotWebXR.pose.views[0]); + }, + getTextureId: texture => { + if (texture.name !== undefined) { + return texture.name; + } + const id = GL.getNewId(GL.textures); + texture.name = id; + GL.textures[id] = texture; + return id; + }, + addInputSource: input_source => { + let name = -1; + if (input_source.targetRayMode === "tracked-pointer" && input_source.handedness === "left") { + name = 0; + } else if (input_source.targetRayMode === "tracked-pointer" && input_source.handedness === "right") { + name = 1; + } else { + for (let i = 2; i < 16; i++) { + if (!GodotWebXR.input_sources[i]) { + name = i; + break; + } + } + } + if (name >= 0) { + GodotWebXR.input_sources[name] = input_source; + input_source.name = name; + if (input_source.targetRayMode === "screen") { + let touch_index = -1; + for (let i = 0; i < 5; i++) { + if (!GodotWebXR.touches[i]) { + touch_index = i; + break; + } + } + if (touch_index >= 0) { + GodotWebXR.touches[touch_index] = input_source; + input_source.touch_index = touch_index; + } + } + } + return name; + }, + removeInputSource: input_source => { + if (input_source.name !== undefined) { + const name = input_source.name; + if (name >= 0 && name < 16) { + GodotWebXR.input_sources[name] = null; + } + if (input_source.touch_index !== undefined) { + const touch_index = input_source.touch_index; + if (touch_index >= 0 && touch_index < 5) { + GodotWebXR.touches[touch_index] = null; + } + } + return name; + } + return -1; + }, + getInputSourceId: input_source => { + if (input_source !== undefined) { + return input_source.name; + } + return -1; + }, + getTouchIndex: input_source => { + if (input_source.touch_index !== undefined) { + return input_source.touch_index; + } + return -1; + } +}; + +function _godot_webxr_get_bounds_geometry(r_points) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(165, 1, r_points); + if (!GodotWebXR.space || !GodotWebXR.space.boundsGeometry) { + return 0; + } + const point_count = GodotWebXR.space.boundsGeometry.length; + if (point_count === 0) { + return 0; + } + const buf = GodotRuntime.malloc(point_count * 3 * 4); + for (let i = 0; i < point_count; i++) { + const point = GodotWebXR.space.boundsGeometry[i]; + GodotRuntime.setHeapValue(buf + (i * 3 + 0) * 4, point.x, "float"); + GodotRuntime.setHeapValue(buf + (i * 3 + 1) * 4, point.y, "float"); + GodotRuntime.setHeapValue(buf + (i * 3 + 2) * 4, point.z, "float"); + } + GodotRuntime.setHeapValue(r_points, buf, "i32"); + return point_count; +} + +function _godot_webxr_get_color_texture() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(166, 1); + const subimage = GodotWebXR.getSubImage(); + if (subimage === null) { + return 0; + } + return GodotWebXR.getTextureId(subimage.colorTexture); +} + +function _godot_webxr_get_depth_texture() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(167, 1); + const subimage = GodotWebXR.getSubImage(); + if (subimage === null) { + return 0; + } + if (!subimage.depthStencilTexture) { + return 0; + } + return GodotWebXR.getTextureId(subimage.depthStencilTexture); +} + +function _godot_webxr_get_frame_rate() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(168, 1); + if (!GodotWebXR.session || GodotWebXR.session.frameRate === undefined) { + return 0; + } + return GodotWebXR.session.frameRate; +} + +function _godot_webxr_get_projection_for_view(p_view, r_transform) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(169, 1, p_view, r_transform); + if (!GodotWebXR.session || !GodotWebXR.pose) { + return false; + } + const matrix = GodotWebXR.pose.views[p_view].projectionMatrix; + for (let i = 0; i < 16; i++) { + GodotRuntime.setHeapValue(r_transform + i * 4, matrix[i], "float"); + } + return true; +} + +function _godot_webxr_get_render_target_size(r_size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(170, 1, r_size); + const subimage = GodotWebXR.getSubImage(); + if (subimage === null) { + return false; + } + GodotRuntime.setHeapValue(r_size + 0, subimage.viewport.width, "i32"); + GodotRuntime.setHeapValue(r_size + 4, subimage.viewport.height, "i32"); + return true; +} + +function _godot_webxr_get_supported_frame_rates(r_frame_rates) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(171, 1, r_frame_rates); + if (!GodotWebXR.session || GodotWebXR.session.supportedFrameRates === undefined) { + return 0; + } + const frame_rate_count = GodotWebXR.session.supportedFrameRates.length; + if (frame_rate_count === 0) { + return 0; + } + const buf = GodotRuntime.malloc(frame_rate_count * 4); + for (let i = 0; i < frame_rate_count; i++) { + GodotRuntime.setHeapValue(buf + i * 4, GodotWebXR.session.supportedFrameRates[i], "float"); + } + GodotRuntime.setHeapValue(r_frame_rates, buf, "i32"); + return frame_rate_count; +} + +function _godot_webxr_get_transform_for_view(p_view, r_transform) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(172, 1, p_view, r_transform); + if (!GodotWebXR.session || !GodotWebXR.pose) { + return false; + } + const views = GodotWebXR.pose.views; + let matrix; + if (p_view >= 0) { + matrix = views[p_view].transform.matrix; + } else { + matrix = GodotWebXR.pose.transform.matrix; + } + for (let i = 0; i < 16; i++) { + GodotRuntime.setHeapValue(r_transform + i * 4, matrix[i], "float"); + } + return true; +} + +function _godot_webxr_get_velocity_texture() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(173, 1); + const subimage = GodotWebXR.getSubImage(); + if (subimage === null) { + return 0; + } + if (!subimage.motionVectorTexture) { + return 0; + } + return GodotWebXR.getTextureId(subimage.motionVectorTexture); +} + +function _godot_webxr_get_view_count() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(174, 1); + if (!GodotWebXR.session || !GodotWebXR.pose) { + return 1; + } + const view_count = GodotWebXR.pose.views.length; + return view_count > 0 ? view_count : 1; +} + +function _godot_webxr_get_visibility_state() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(175, 1); + if (!GodotWebXR.session || !GodotWebXR.session.visibilityState) { + return 0; + } + return GodotRuntime.allocString(GodotWebXR.session.visibilityState); +} + +function _godot_webxr_initialize(p_session_mode, p_required_features, p_optional_features, p_requested_reference_spaces, p_on_session_started, p_on_session_ended, p_on_session_failed, p_on_input_event, p_on_simple_event) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(176, 1, p_session_mode, p_required_features, p_optional_features, p_requested_reference_spaces, p_on_session_started, p_on_session_ended, p_on_session_failed, p_on_input_event, p_on_simple_event); + GodotWebXR.monkeyPatchRequestAnimationFrame(true); + const session_mode = GodotRuntime.parseString(p_session_mode); + const required_features = GodotRuntime.parseString(p_required_features).split(",").map(s => s.trim()).filter(s => s !== ""); + const optional_features = GodotRuntime.parseString(p_optional_features).split(",").map(s => s.trim()).filter(s => s !== ""); + const requested_reference_space_types = GodotRuntime.parseString(p_requested_reference_spaces).split(",").map(s => s.trim()); + const onstarted = GodotRuntime.get_func(p_on_session_started); + const onended = GodotRuntime.get_func(p_on_session_ended); + const onfailed = GodotRuntime.get_func(p_on_session_failed); + const oninputevent = GodotRuntime.get_func(p_on_input_event); + const onsimpleevent = GodotRuntime.get_func(p_on_simple_event); + const session_init = {}; + if (required_features.length > 0) { + session_init["requiredFeatures"] = required_features; + } + if (optional_features.length > 0) { + session_init["optionalFeatures"] = optional_features; + } + navigator.xr.requestSession(session_mode, session_init).then(function(session) { + GodotWebXR.session = session; + session.addEventListener("end", function(evt) { + onended(); + }); + session.addEventListener("inputsourceschange", function(evt) { + evt.added.forEach(GodotWebXR.addInputSource); + evt.removed.forEach(GodotWebXR.removeInputSource); + }); + [ "selectstart", "selectend", "squeezestart", "squeezeend" ].forEach((input_event, index) => { + session.addEventListener(input_event, function(evt) { + GodotWebXR.frame = evt.frame; + oninputevent(index, GodotWebXR.getInputSourceId(evt.inputSource)); + GodotWebXR.frame = null; + }); + }); + session.addEventListener("visibilitychange", function(evt) { + const c_str = GodotRuntime.allocString("visibility_state_changed"); + onsimpleevent(c_str); + GodotRuntime.free(c_str); + }); + GodotWebXR.onsimpleevent = onsimpleevent; + const gl_context_handle = _emscripten_webgl_get_current_context(); + const gl = GL.getContext(gl_context_handle).GLctx; + GodotWebXR.gl = gl; + gl.makeXRCompatible().then(function() { + GodotWebXR.gl_binding = new XRWebGLBinding(session, gl); + GodotWebXR.getLayer(); + function onReferenceSpaceSuccess(reference_space, reference_space_type) { + GodotWebXR.space = reference_space; + reference_space.onreset = function(evt) { + const c_str = GodotRuntime.allocString("reference_space_reset"); + onsimpleevent(c_str); + GodotRuntime.free(c_str); + }; + GodotWebXR.pauseResumeMainLoop(); + window.setTimeout(function() { + const c_str = GodotRuntime.allocString(reference_space_type); + onstarted(c_str); + GodotRuntime.free(c_str); + }, 0); + } + function requestReferenceSpace() { + const reference_space_type = requested_reference_space_types.shift(); + session.requestReferenceSpace(reference_space_type).then(refSpace => { + onReferenceSpaceSuccess(refSpace, reference_space_type); + }).catch(() => { + if (requested_reference_space_types.length === 0) { + const c_str = GodotRuntime.allocString("Unable to get any of the requested reference space types"); + onfailed(c_str); + GodotRuntime.free(c_str); + } else { + requestReferenceSpace(); + } + }); + } + requestReferenceSpace(); + }).catch(function(error) { + const c_str = GodotRuntime.allocString(`Unable to make WebGL context compatible with WebXR: ${error}`); + onfailed(c_str); + GodotRuntime.free(c_str); + }); + }).catch(function(error) { + const c_str = GodotRuntime.allocString(`Unable to start session: ${error}`); + onfailed(c_str); + GodotRuntime.free(c_str); + }); +} + +function _godot_webxr_is_session_supported(p_session_mode, p_callback) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(177, 1, p_session_mode, p_callback); + const session_mode = GodotRuntime.parseString(p_session_mode); + const cb = GodotRuntime.get_func(p_callback); + if (navigator.xr) { + navigator.xr.isSessionSupported(session_mode).then(function(supported) { + const c_str = GodotRuntime.allocString(session_mode); + cb(c_str, supported ? 1 : 0); + GodotRuntime.free(c_str); + }); + } else { + const c_str = GodotRuntime.allocString(session_mode); + cb(c_str, 0); + GodotRuntime.free(c_str); + } +} + +function _godot_webxr_is_supported() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(178, 1); + return !!navigator.xr; +} + +function _godot_webxr_uninitialize() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(179, 1); + if (GodotWebXR.session) { + GodotWebXR.session.end().catch(e => {}); + } + GodotWebXR.session = null; + GodotWebXR.gl_binding = null; + GodotWebXR.layer = null; + GodotWebXR.space = null; + GodotWebXR.frame = null; + GodotWebXR.pose = null; + GodotWebXR.view_count = 1; + GodotWebXR.input_sources = new Array(16); + GodotWebXR.touches = new Array(5); + GodotWebXR.onsimpleevent = null; + GodotWebXR.monkeyPatchRequestAnimationFrame(false); + GodotWebXR.pauseResumeMainLoop(); +} + +function _godot_webxr_update_input_source(p_input_source_id, r_target_pose, r_target_ray_mode, r_touch_index, r_has_grip_pose, r_grip_pose, r_has_standard_mapping, r_button_count, r_buttons, r_axes_count, r_axes) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(180, 1, p_input_source_id, r_target_pose, r_target_ray_mode, r_touch_index, r_has_grip_pose, r_grip_pose, r_has_standard_mapping, r_button_count, r_buttons, r_axes_count, r_axes); + if (!GodotWebXR.session || !GodotWebXR.frame) { + return 0; + } + if (p_input_source_id < 0 || p_input_source_id >= GodotWebXR.input_sources.length || !GodotWebXR.input_sources[p_input_source_id]) { + return false; + } + const input_source = GodotWebXR.input_sources[p_input_source_id]; + const frame = GodotWebXR.frame; + const space = GodotWebXR.space; + const target_pose = frame.getPose(input_source.targetRaySpace, space); + if (!target_pose) { + return false; + } + const target_pose_matrix = target_pose.transform.matrix; + for (let i = 0; i < 16; i++) { + GodotRuntime.setHeapValue(r_target_pose + i * 4, target_pose_matrix[i], "float"); + } + let target_ray_mode = 0; + switch (input_source.targetRayMode) { + case "gaze": + target_ray_mode = 1; + break; + + case "tracked-pointer": + target_ray_mode = 2; + break; + + case "screen": + target_ray_mode = 3; + break; + + default: + } + GodotRuntime.setHeapValue(r_target_ray_mode, target_ray_mode, "i32"); + GodotRuntime.setHeapValue(r_touch_index, GodotWebXR.getTouchIndex(input_source), "i32"); + let has_grip_pose = false; + if (input_source.gripSpace) { + const grip_pose = frame.getPose(input_source.gripSpace, space); + if (grip_pose) { + const grip_pose_matrix = grip_pose.transform.matrix; + for (let i = 0; i < 16; i++) { + GodotRuntime.setHeapValue(r_grip_pose + i * 4, grip_pose_matrix[i], "float"); + } + has_grip_pose = true; + } + } + GodotRuntime.setHeapValue(r_has_grip_pose, has_grip_pose ? 1 : 0, "i32"); + let has_standard_mapping = false; + let button_count = 0; + let axes_count = 0; + if (input_source.gamepad) { + if (input_source.gamepad.mapping === "xr-standard") { + has_standard_mapping = true; + } + button_count = Math.min(input_source.gamepad.buttons.length, 10); + for (let i = 0; i < button_count; i++) { + GodotRuntime.setHeapValue(r_buttons + i * 4, input_source.gamepad.buttons[i].value, "float"); + } + axes_count = Math.min(input_source.gamepad.axes.length, 10); + for (let i = 0; i < axes_count; i++) { + GodotRuntime.setHeapValue(r_axes + i * 4, input_source.gamepad.axes[i], "float"); + } + } + GodotRuntime.setHeapValue(r_has_standard_mapping, has_standard_mapping ? 1 : 0, "i32"); + GodotRuntime.setHeapValue(r_button_count, button_count, "i32"); + GodotRuntime.setHeapValue(r_axes_count, axes_count, "i32"); + return true; +} + +function _godot_webxr_update_target_frame_rate(p_frame_rate) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(181, 1, p_frame_rate); + if (!GodotWebXR.session || GodotWebXR.session.updateTargetFrameRate === undefined) { + return; + } + GodotWebXR.session.updateTargetFrameRate(p_frame_rate).then(() => { + const c_str = GodotRuntime.allocString("display_refresh_rate_changed"); + GodotWebXR.onsimpleevent(c_str); + GodotRuntime.free(c_str); + }); +} + +function arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) {} + return sum; +} + +var MONTH_DAYS_LEAP = [ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]; + +var MONTH_DAYS_REGULAR = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]; + +function addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[currentMonth]; + if (days > daysInCurrentMonth - newDate.getDate()) { + days -= daysInCurrentMonth - newDate.getDate() + 1; + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth + 1); + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear() + 1); + } + } else { + newDate.setDate(newDate.getDate() + days); + return newDate; + } + } + return newDate; +} + +function writeArrayToMemory(array, buffer) { + assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)"); + GROWABLE_HEAP_I8().set(array, buffer); +} + +function _strftime(s, maxsize, format, tm) { + var tm_zone = GROWABLE_HEAP_I32()[tm + 40 >> 2]; + var date = { + tm_sec: GROWABLE_HEAP_I32()[tm >> 2], + tm_min: GROWABLE_HEAP_I32()[tm + 4 >> 2], + tm_hour: GROWABLE_HEAP_I32()[tm + 8 >> 2], + tm_mday: GROWABLE_HEAP_I32()[tm + 12 >> 2], + tm_mon: GROWABLE_HEAP_I32()[tm + 16 >> 2], + tm_year: GROWABLE_HEAP_I32()[tm + 20 >> 2], + tm_wday: GROWABLE_HEAP_I32()[tm + 24 >> 2], + tm_yday: GROWABLE_HEAP_I32()[tm + 28 >> 2], + tm_isdst: GROWABLE_HEAP_I32()[tm + 32 >> 2], + tm_gmtoff: GROWABLE_HEAP_I32()[tm + 36 >> 2], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : "" + }; + var pattern = UTF8ToString(format); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]); + } + var WEEKDAYS = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ]; + var MONTHS = [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ]; + function leadingSomething(value, digits, character) { + var str = typeof value == "number" ? value.toString() : value || ""; + while (str.length < digits) { + str = character[0] + str; + } + return str; + } + function leadingNulls(value, digits) { + return leadingSomething(value, digits, "0"); + } + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : value > 0 ? 1 : 0; + } + var compare; + if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { + compare = sgn(date1.getDate() - date2.getDate()); + } + } + return compare; + } + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: + return new Date(janFourth.getFullYear() - 1, 11, 29); + + case 1: + return janFourth; + + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + + case 6: + return new Date(janFourth.getFullYear() - 1, 11, 30); + } + } + function getWeekBasedYear(date) { + var thisDate = addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear() + 1; + } + return thisDate.getFullYear(); + } + return thisDate.getFullYear() - 1; + } + var EXPANSION_RULES_2 = { + "%a": function(date) { + return WEEKDAYS[date.tm_wday].substring(0, 3); + }, + "%A": function(date) { + return WEEKDAYS[date.tm_wday]; + }, + "%b": function(date) { + return MONTHS[date.tm_mon].substring(0, 3); + }, + "%B": function(date) { + return MONTHS[date.tm_mon]; + }, + "%C": function(date) { + var year = date.tm_year + 1900; + return leadingNulls(year / 100 | 0, 2); + }, + "%d": function(date) { + return leadingNulls(date.tm_mday, 2); + }, + "%e": function(date) { + return leadingSomething(date.tm_mday, 2, " "); + }, + "%g": function(date) { + return getWeekBasedYear(date).toString().substring(2); + }, + "%G": function(date) { + return getWeekBasedYear(date); + }, + "%H": function(date) { + return leadingNulls(date.tm_hour, 2); + }, + "%I": function(date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + "%j": function(date) { + return leadingNulls(date.tm_mday + arraySum(isLeapYear(date.tm_year + 1900) ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR, date.tm_mon - 1), 3); + }, + "%m": function(date) { + return leadingNulls(date.tm_mon + 1, 2); + }, + "%M": function(date) { + return leadingNulls(date.tm_min, 2); + }, + "%n": function() { + return "\n"; + }, + "%p": function(date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return "AM"; + } + return "PM"; + }, + "%S": function(date) { + return leadingNulls(date.tm_sec, 2); + }, + "%t": function() { + return "\t"; + }, + "%u": function(date) { + return date.tm_wday || 7; + }, + "%U": function(date) { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2); + }, + "%V": function(date) { + var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7) / 7); + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++; + } + if (!val) { + val = 52; + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || dec31 == 5 && isLeapYear(date.tm_year % 400 - 1)) { + val++; + } + } else if (val == 53) { + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date.tm_year))) val = 1; + } + return leadingNulls(val, 2); + }, + "%w": function(date) { + return date.tm_wday; + }, + "%W": function(date) { + var days = date.tm_yday + 7 - (date.tm_wday + 6) % 7; + return leadingNulls(Math.floor(days / 7), 2); + }, + "%y": function(date) { + return (date.tm_year + 1900).toString().substring(2); + }, + "%Y": function(date) { + return date.tm_year + 1900; + }, + "%z": function(date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + off = off / 60 * 100 + off % 60; + return (ahead ? "+" : "-") + String("0000" + off).slice(-4); + }, + "%Z": function(date) { + return date.tm_zone; + }, + "%%": function() { + return "%"; + } + }; + pattern = pattern.replace(/%%/g, "\0\0"); + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date)); + } + } + pattern = pattern.replace(/\0\0/g, "%"); + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + writeArrayToMemory(bytes, s); + return bytes.length - 1; +} + +function _strftime_l(s, maxsize, format, tm, loc) { + return _strftime(s, maxsize, format, tm); +} + +function stringToUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8(str, ret, size); + return ret; +} + +function getCFunc(ident) { + var func = Module["_" + ident]; + assert(func, "Cannot call unknown function " + ident + ", make sure it is exported"); + return func; +} + +function ccall(ident, returnType, argTypes, args, opts) { + var toC = { + "string": str => { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { + ret = stringToUTF8OnStack(str); + } + return ret; + }, + "array": arr => { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + function convertReturnValue(ret) { + if (returnType === "string") { + return UTF8ToString(ret); + } + if (returnType === "boolean") return Boolean(ret); + return ret; + } + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + assert(returnType !== "array", 'Return type should not be "array".'); + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret); + } + ret = onDone(ret); + return ret; +} + +function cwrap(ident, returnType, argTypes, opts) { + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + }; +} + +PThread.init(); + +var FSNode = function(parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; +}; + +var readMode = 292 | 73; + +var writeMode = 146; + +Object.defineProperties(FSNode.prototype, { + read: { + get: function() { + return (this.mode & readMode) === readMode; + }, + set: function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: function() { + return (this.mode & writeMode) === writeMode; + }, + set: function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: function() { + return FS.isChrdev(this.mode); + } + } +}); + +FS.FSNode = FSNode; + +FS.createPreloadedFile = FS_createPreloadedFile; + +FS.staticInit(); + +ERRNO_CODES = { + "EPERM": 63, + "ENOENT": 44, + "ESRCH": 71, + "EINTR": 27, + "EIO": 29, + "ENXIO": 60, + "E2BIG": 1, + "ENOEXEC": 45, + "EBADF": 8, + "ECHILD": 12, + "EAGAIN": 6, + "EWOULDBLOCK": 6, + "ENOMEM": 48, + "EACCES": 2, + "EFAULT": 21, + "ENOTBLK": 105, + "EBUSY": 10, + "EEXIST": 20, + "EXDEV": 75, + "ENODEV": 43, + "ENOTDIR": 54, + "EISDIR": 31, + "EINVAL": 28, + "ENFILE": 41, + "EMFILE": 33, + "ENOTTY": 59, + "ETXTBSY": 74, + "EFBIG": 22, + "ENOSPC": 51, + "ESPIPE": 70, + "EROFS": 69, + "EMLINK": 34, + "EPIPE": 64, + "EDOM": 18, + "ERANGE": 68, + "ENOMSG": 49, + "EIDRM": 24, + "ECHRNG": 106, + "EL2NSYNC": 156, + "EL3HLT": 107, + "EL3RST": 108, + "ELNRNG": 109, + "EUNATCH": 110, + "ENOCSI": 111, + "EL2HLT": 112, + "EDEADLK": 16, + "ENOLCK": 46, + "EBADE": 113, + "EBADR": 114, + "EXFULL": 115, + "ENOANO": 104, + "EBADRQC": 103, + "EBADSLT": 102, + "EDEADLOCK": 16, + "EBFONT": 101, + "ENOSTR": 100, + "ENODATA": 116, + "ETIME": 117, + "ENOSR": 118, + "ENONET": 119, + "ENOPKG": 120, + "EREMOTE": 121, + "ENOLINK": 47, + "EADV": 122, + "ESRMNT": 123, + "ECOMM": 124, + "EPROTO": 65, + "EMULTIHOP": 36, + "EDOTDOT": 125, + "EBADMSG": 9, + "ENOTUNIQ": 126, + "EBADFD": 127, + "EREMCHG": 128, + "ELIBACC": 129, + "ELIBBAD": 130, + "ELIBSCN": 131, + "ELIBMAX": 132, + "ELIBEXEC": 133, + "ENOSYS": 52, + "ENOTEMPTY": 55, + "ENAMETOOLONG": 37, + "ELOOP": 32, + "EOPNOTSUPP": 138, + "EPFNOSUPPORT": 139, + "ECONNRESET": 15, + "ENOBUFS": 42, + "EAFNOSUPPORT": 5, + "EPROTOTYPE": 67, + "ENOTSOCK": 57, + "ENOPROTOOPT": 50, + "ESHUTDOWN": 140, + "ECONNREFUSED": 14, + "EADDRINUSE": 3, + "ECONNABORTED": 13, + "ENETUNREACH": 40, + "ENETDOWN": 38, + "ETIMEDOUT": 73, + "EHOSTDOWN": 142, + "EHOSTUNREACH": 23, + "EINPROGRESS": 26, + "EALREADY": 7, + "EDESTADDRREQ": 17, + "EMSGSIZE": 35, + "EPROTONOSUPPORT": 66, + "ESOCKTNOSUPPORT": 137, + "EADDRNOTAVAIL": 4, + "ENETRESET": 39, + "EISCONN": 30, + "ENOTCONN": 53, + "ETOOMANYREFS": 141, + "EUSERS": 136, + "EDQUOT": 19, + "ESTALE": 72, + "ENOTSUP": 138, + "ENOMEDIUM": 148, + "EILSEQ": 25, + "EOVERFLOW": 61, + "ECANCELED": 11, + "ENOTRECOVERABLE": 56, + "EOWNERDEAD": 62, + "ESTRPIPE": 135 +}; + +var GLctx; + +Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) { + Browser.requestFullscreen(lockPointer, resizeCanvas); +}; + +Module["requestFullScreen"] = function Module_requestFullScreen() { + Browser.requestFullScreen(); +}; + +Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { + Browser.requestAnimationFrame(func); +}; + +Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { + Browser.setCanvasSize(width, height, noUpdates); +}; + +Module["pauseMainLoop"] = function Module_pauseMainLoop() { + Browser.mainLoop.pause(); +}; + +Module["resumeMainLoop"] = function Module_resumeMainLoop() { + Browser.mainLoop.resume(); +}; + +Module["getUserMedia"] = function Module_getUserMedia() { + Browser.getUserMedia(); +}; + +Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) { + return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes); +}; + +var preloadedImages = {}; + +var preloadedAudios = {}; + +var miniTempWebGLIntBuffersStorage = new Int32Array(288); + +for (var i = 0; i < 288; ++i) { + miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i + 1); +} + +var miniTempWebGLFloatBuffersStorage = new Float32Array(288); + +for (var i = 0; i < 288; ++i) { + miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i + 1); +} + +Module["request_quit"] = function() { + GodotOS.request_quit(); +}; + +Module["onExit"] = GodotOS.cleanup; + +GodotOS._fs_sync_promise = Promise.resolve(); + +Module["initConfig"] = GodotConfig.init_config; + +Module["initFS"] = GodotFS.init; + +Module["copyToFS"] = GodotFS.copy_to_fs; + +GodotOS.atexit(function(resolve, reject) { + GodotDisplayCursor.clear(); + resolve(); +}); + +GodotOS.atexit(function(resolve, reject) { + GodotEventListeners.clear(); + resolve(); +}); + +GodotOS.atexit(function(resolve, reject) { + GodotDisplayVK.clear(); + resolve(); +}); + +GodotJSWrapper.proxies = new Map(); + +var proxiedFunctionTable = [ null, _proc_exit, exitOnMainThread, pthreadCreateProxied, ___syscall__newselect, ___syscall_accept4, ___syscall_bind, ___syscall_chdir, ___syscall_chmod, ___syscall_connect, ___syscall_faccessat, ___syscall_fchmod, ___syscall_fcntl64, ___syscall_getcwd, ___syscall_getdents64, ___syscall_getsockname, ___syscall_getsockopt, ___syscall_ioctl, ___syscall_listen, ___syscall_lstat64, ___syscall_mkdirat, ___syscall_newfstatat, ___syscall_openat, ___syscall_poll, ___syscall_readlinkat, ___syscall_recvfrom, ___syscall_renameat, ___syscall_rmdir, ___syscall_sendto, ___syscall_socket, ___syscall_stat64, ___syscall_statfs64, ___syscall_symlink, ___syscall_unlinkat, __setitimer_js, _emscripten_force_exit, setCanvasElementSizeMainThread, _emscripten_webgl_destroy_context, _emscripten_webgl_create_context_proxied, _emscripten_webgl_enable_extension, _environ_get, _environ_sizes_get, _fd_close, _fd_fdstat_get, _fd_read, _fd_seek, _fd_write, _getaddrinfo, _godot_audio_has_worklet, _godot_audio_init, _godot_audio_input_start, _godot_audio_input_stop, _godot_audio_is_available, _godot_audio_resume, _godot_audio_worklet_create, _godot_audio_worklet_start, _godot_js_config_canvas_id_get, _godot_js_config_locale_get, _godot_js_display_alert, _godot_js_display_canvas_focus, _godot_js_display_canvas_is_focused, _godot_js_display_clipboard_get, _godot_js_display_clipboard_set, _godot_js_display_cursor_is_hidden, _godot_js_display_cursor_is_locked, _godot_js_display_cursor_lock_set, _godot_js_display_cursor_set_custom_shape, _godot_js_display_cursor_set_shape, _godot_js_display_cursor_set_visible, _godot_js_display_desired_size_set, _godot_js_display_fullscreen_cb, _godot_js_display_fullscreen_exit, _godot_js_display_fullscreen_request, _godot_js_display_has_webgl, _godot_js_display_is_swap_ok_cancel, _godot_js_display_notification_cb, _godot_js_display_pixel_ratio_get, _godot_js_display_screen_dpi_get, _godot_js_display_screen_size_get, _godot_js_display_setup_canvas, _godot_js_display_size_update, _godot_js_display_touchscreen_is_available, _godot_js_display_tts_available, _godot_js_display_vk_available, _godot_js_display_vk_cb, _godot_js_display_vk_hide, _godot_js_display_vk_show, _godot_js_display_window_blur_cb, _godot_js_display_window_icon_set, _godot_js_display_window_size_get, _godot_js_display_window_title_set, _godot_js_fetch_create, _godot_js_fetch_free, _godot_js_fetch_http_status_get, _godot_js_fetch_is_chunked, _godot_js_fetch_read_chunk, _godot_js_fetch_read_headers, _godot_js_fetch_state_get, _godot_js_input_drop_files_cb, _godot_js_input_gamepad_cb, _godot_js_input_gamepad_sample, _godot_js_input_gamepad_sample_count, _godot_js_input_gamepad_sample_get, _godot_js_input_key_cb, _godot_js_input_mouse_button_cb, _godot_js_input_mouse_move_cb, _godot_js_input_mouse_wheel_cb, _godot_js_input_paste_cb, _godot_js_input_touch_cb, _godot_js_input_vibrate_handheld, _godot_js_os_download_buffer, _godot_js_os_execute, _godot_js_os_finish_async, _godot_js_os_fs_is_persistent, _godot_js_os_fs_sync, _godot_js_os_has_feature, _godot_js_os_hw_concurrency_get, _godot_js_os_request_quit_cb, _godot_js_os_shell_open, _godot_js_pwa_cb, _godot_js_pwa_update, _godot_js_rtc_datachannel_close, _godot_js_rtc_datachannel_connect, _godot_js_rtc_datachannel_destroy, _godot_js_rtc_datachannel_get_buffered_amount, _godot_js_rtc_datachannel_id_get, _godot_js_rtc_datachannel_is_negotiated, _godot_js_rtc_datachannel_is_ordered, _godot_js_rtc_datachannel_label_get, _godot_js_rtc_datachannel_max_packet_lifetime_get, _godot_js_rtc_datachannel_max_retransmits_get, _godot_js_rtc_datachannel_ready_state_get, _godot_js_rtc_datachannel_send, _godot_js_rtc_pc_close, _godot_js_rtc_pc_create, _godot_js_rtc_pc_datachannel_create, _godot_js_rtc_pc_destroy, _godot_js_rtc_pc_ice_candidate_add, _godot_js_rtc_pc_local_description_set, _godot_js_rtc_pc_offer_create, _godot_js_rtc_pc_remote_description_set, _godot_js_tts_get_voices, _godot_js_tts_is_paused, _godot_js_tts_is_speaking, _godot_js_tts_pause, _godot_js_tts_resume, _godot_js_tts_speak, _godot_js_tts_stop, _godot_js_websocket_buffered_amount, _godot_js_websocket_close, _godot_js_websocket_create, _godot_js_websocket_destroy, _godot_js_websocket_send, _godot_js_wrapper_create_cb, _godot_js_wrapper_create_object, _godot_js_wrapper_interface_get, _godot_js_wrapper_object_call, _godot_js_wrapper_object_get, _godot_js_wrapper_object_getvar, _godot_js_wrapper_object_set, _godot_js_wrapper_object_set_cb_ret, _godot_js_wrapper_object_setvar, _godot_js_wrapper_object_unref, _godot_webgl2_glFramebufferTextureMultiviewOVR, _godot_webgl2_glGetBufferSubData, _godot_webxr_get_bounds_geometry, _godot_webxr_get_color_texture, _godot_webxr_get_depth_texture, _godot_webxr_get_frame_rate, _godot_webxr_get_projection_for_view, _godot_webxr_get_render_target_size, _godot_webxr_get_supported_frame_rates, _godot_webxr_get_transform_for_view, _godot_webxr_get_velocity_texture, _godot_webxr_get_view_count, _godot_webxr_get_visibility_state, _godot_webxr_initialize, _godot_webxr_is_session_supported, _godot_webxr_is_supported, _godot_webxr_uninitialize, _godot_webxr_update_input_source, _godot_webxr_update_target_frame_rate ]; + +function checkIncomingModuleAPI() { + ignoredModuleProp("fetchSettings"); +} + +var wasmImports = { + "__assert_fail": ___assert_fail, + "__call_sighandler": ___call_sighandler, + "__dlsym": ___dlsym, + "__emscripten_init_main_thread_js": ___emscripten_init_main_thread_js, + "__emscripten_thread_cleanup": ___emscripten_thread_cleanup, + "__pthread_create_js": ___pthread_create_js, + "__syscall__newselect": ___syscall__newselect, + "__syscall_accept4": ___syscall_accept4, + "__syscall_bind": ___syscall_bind, + "__syscall_chdir": ___syscall_chdir, + "__syscall_chmod": ___syscall_chmod, + "__syscall_connect": ___syscall_connect, + "__syscall_faccessat": ___syscall_faccessat, + "__syscall_fchmod": ___syscall_fchmod, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_getcwd": ___syscall_getcwd, + "__syscall_getdents64": ___syscall_getdents64, + "__syscall_getsockname": ___syscall_getsockname, + "__syscall_getsockopt": ___syscall_getsockopt, + "__syscall_ioctl": ___syscall_ioctl, + "__syscall_listen": ___syscall_listen, + "__syscall_lstat64": ___syscall_lstat64, + "__syscall_mkdirat": ___syscall_mkdirat, + "__syscall_newfstatat": ___syscall_newfstatat, + "__syscall_openat": ___syscall_openat, + "__syscall_poll": ___syscall_poll, + "__syscall_readlinkat": ___syscall_readlinkat, + "__syscall_recvfrom": ___syscall_recvfrom, + "__syscall_renameat": ___syscall_renameat, + "__syscall_rmdir": ___syscall_rmdir, + "__syscall_sendto": ___syscall_sendto, + "__syscall_socket": ___syscall_socket, + "__syscall_stat64": ___syscall_stat64, + "__syscall_statfs64": ___syscall_statfs64, + "__syscall_symlink": ___syscall_symlink, + "__syscall_unlinkat": ___syscall_unlinkat, + "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic, + "_emscripten_notify_mailbox_postmessage": __emscripten_notify_mailbox_postmessage, + "_emscripten_proxied_gl_context_activated_from_main_browser_thread": __emscripten_proxied_gl_context_activated_from_main_browser_thread, + "_emscripten_set_offscreencanvas_size": __emscripten_set_offscreencanvas_size, + "_emscripten_thread_mailbox_await": __emscripten_thread_mailbox_await, + "_emscripten_thread_set_strongref": __emscripten_thread_set_strongref, + "_emscripten_throw_longjmp": __emscripten_throw_longjmp, + "_gmtime_js": __gmtime_js, + "_localtime_js": __localtime_js, + "_setitimer_js": __setitimer_js, + "_tzset_js": __tzset_js, + "abort": _abort, + "dlopen": _dlopen, + "emscripten_cancel_main_loop": _emscripten_cancel_main_loop, + "emscripten_check_blocking_allowed": _emscripten_check_blocking_allowed, + "emscripten_console_error": _emscripten_console_error, + "emscripten_date_now": _emscripten_date_now, + "emscripten_exit_with_live_runtime": _emscripten_exit_with_live_runtime, + "emscripten_force_exit": _emscripten_force_exit, + "emscripten_get_now": _emscripten_get_now, + "emscripten_glActiveTexture": _emscripten_glActiveTexture, + "emscripten_glAttachShader": _emscripten_glAttachShader, + "emscripten_glBeginTransformFeedback": _emscripten_glBeginTransformFeedback, + "emscripten_glBindBuffer": _emscripten_glBindBuffer, + "emscripten_glBindBufferBase": _emscripten_glBindBufferBase, + "emscripten_glBindBufferRange": _emscripten_glBindBufferRange, + "emscripten_glBindFramebuffer": _emscripten_glBindFramebuffer, + "emscripten_glBindRenderbuffer": _emscripten_glBindRenderbuffer, + "emscripten_glBindTexture": _emscripten_glBindTexture, + "emscripten_glBindVertexArray": _emscripten_glBindVertexArray, + "emscripten_glBlendColor": _emscripten_glBlendColor, + "emscripten_glBlendEquation": _emscripten_glBlendEquation, + "emscripten_glBlendFunc": _emscripten_glBlendFunc, + "emscripten_glBlendFuncSeparate": _emscripten_glBlendFuncSeparate, + "emscripten_glBlitFramebuffer": _emscripten_glBlitFramebuffer, + "emscripten_glBufferData": _emscripten_glBufferData, + "emscripten_glBufferSubData": _emscripten_glBufferSubData, + "emscripten_glCheckFramebufferStatus": _emscripten_glCheckFramebufferStatus, + "emscripten_glClear": _emscripten_glClear, + "emscripten_glClearBufferfv": _emscripten_glClearBufferfv, + "emscripten_glClearColor": _emscripten_glClearColor, + "emscripten_glClearDepthf": _emscripten_glClearDepthf, + "emscripten_glColorMask": _emscripten_glColorMask, + "emscripten_glCompileShader": _emscripten_glCompileShader, + "emscripten_glCompressedTexImage2D": _emscripten_glCompressedTexImage2D, + "emscripten_glCopyBufferSubData": _emscripten_glCopyBufferSubData, + "emscripten_glCreateProgram": _emscripten_glCreateProgram, + "emscripten_glCreateShader": _emscripten_glCreateShader, + "emscripten_glCullFace": _emscripten_glCullFace, + "emscripten_glDeleteBuffers": _emscripten_glDeleteBuffers, + "emscripten_glDeleteFramebuffers": _emscripten_glDeleteFramebuffers, + "emscripten_glDeleteProgram": _emscripten_glDeleteProgram, + "emscripten_glDeleteQueries": _emscripten_glDeleteQueries, + "emscripten_glDeleteRenderbuffers": _emscripten_glDeleteRenderbuffers, + "emscripten_glDeleteShader": _emscripten_glDeleteShader, + "emscripten_glDeleteSync": _emscripten_glDeleteSync, + "emscripten_glDeleteTextures": _emscripten_glDeleteTextures, + "emscripten_glDeleteVertexArrays": _emscripten_glDeleteVertexArrays, + "emscripten_glDepthFunc": _emscripten_glDepthFunc, + "emscripten_glDepthMask": _emscripten_glDepthMask, + "emscripten_glDisable": _emscripten_glDisable, + "emscripten_glDisableVertexAttribArray": _emscripten_glDisableVertexAttribArray, + "emscripten_glDrawArrays": _emscripten_glDrawArrays, + "emscripten_glDrawArraysInstanced": _emscripten_glDrawArraysInstanced, + "emscripten_glDrawElements": _emscripten_glDrawElements, + "emscripten_glDrawElementsInstanced": _emscripten_glDrawElementsInstanced, + "emscripten_glEnable": _emscripten_glEnable, + "emscripten_glEnableVertexAttribArray": _emscripten_glEnableVertexAttribArray, + "emscripten_glEndTransformFeedback": _emscripten_glEndTransformFeedback, + "emscripten_glFenceSync": _emscripten_glFenceSync, + "emscripten_glFinish": _emscripten_glFinish, + "emscripten_glFramebufferRenderbuffer": _emscripten_glFramebufferRenderbuffer, + "emscripten_glFramebufferTexture2D": _emscripten_glFramebufferTexture2D, + "emscripten_glFramebufferTextureLayer": _emscripten_glFramebufferTextureLayer, + "emscripten_glFrontFace": _emscripten_glFrontFace, + "emscripten_glGenBuffers": _emscripten_glGenBuffers, + "emscripten_glGenFramebuffers": _emscripten_glGenFramebuffers, + "emscripten_glGenQueries": _emscripten_glGenQueries, + "emscripten_glGenRenderbuffers": _emscripten_glGenRenderbuffers, + "emscripten_glGenTextures": _emscripten_glGenTextures, + "emscripten_glGenVertexArrays": _emscripten_glGenVertexArrays, + "emscripten_glGenerateMipmap": _emscripten_glGenerateMipmap, + "emscripten_glGetFloatv": _emscripten_glGetFloatv, + "emscripten_glGetInteger64v": _emscripten_glGetInteger64v, + "emscripten_glGetProgramInfoLog": _emscripten_glGetProgramInfoLog, + "emscripten_glGetProgramiv": _emscripten_glGetProgramiv, + "emscripten_glGetShaderInfoLog": _emscripten_glGetShaderInfoLog, + "emscripten_glGetShaderiv": _emscripten_glGetShaderiv, + "emscripten_glGetString": _emscripten_glGetString, + "emscripten_glGetStringi": _emscripten_glGetStringi, + "emscripten_glGetSynciv": _emscripten_glGetSynciv, + "emscripten_glGetUniformBlockIndex": _emscripten_glGetUniformBlockIndex, + "emscripten_glGetUniformLocation": _emscripten_glGetUniformLocation, + "emscripten_glLinkProgram": _emscripten_glLinkProgram, + "emscripten_glPixelStorei": _emscripten_glPixelStorei, + "emscripten_glReadBuffer": _emscripten_glReadBuffer, + "emscripten_glReadPixels": _emscripten_glReadPixels, + "emscripten_glRenderbufferStorage": _emscripten_glRenderbufferStorage, + "emscripten_glScissor": _emscripten_glScissor, + "emscripten_glShaderSource": _emscripten_glShaderSource, + "emscripten_glTexImage2D": _emscripten_glTexImage2D, + "emscripten_glTexImage3D": _emscripten_glTexImage3D, + "emscripten_glTexParameterf": _emscripten_glTexParameterf, + "emscripten_glTexParameteri": _emscripten_glTexParameteri, + "emscripten_glTexStorage2D": _emscripten_glTexStorage2D, + "emscripten_glTexSubImage3D": _emscripten_glTexSubImage3D, + "emscripten_glTransformFeedbackVaryings": _emscripten_glTransformFeedbackVaryings, + "emscripten_glUniform1f": _emscripten_glUniform1f, + "emscripten_glUniform1i": _emscripten_glUniform1i, + "emscripten_glUniform1iv": _emscripten_glUniform1iv, + "emscripten_glUniform1ui": _emscripten_glUniform1ui, + "emscripten_glUniform1uiv": _emscripten_glUniform1uiv, + "emscripten_glUniform2f": _emscripten_glUniform2f, + "emscripten_glUniform2fv": _emscripten_glUniform2fv, + "emscripten_glUniform2iv": _emscripten_glUniform2iv, + "emscripten_glUniform3fv": _emscripten_glUniform3fv, + "emscripten_glUniform4f": _emscripten_glUniform4f, + "emscripten_glUniform4fv": _emscripten_glUniform4fv, + "emscripten_glUniformBlockBinding": _emscripten_glUniformBlockBinding, + "emscripten_glUniformMatrix4fv": _emscripten_glUniformMatrix4fv, + "emscripten_glUseProgram": _emscripten_glUseProgram, + "emscripten_glVertexAttrib4f": _emscripten_glVertexAttrib4f, + "emscripten_glVertexAttribDivisor": _emscripten_glVertexAttribDivisor, + "emscripten_glVertexAttribI4ui": _emscripten_glVertexAttribI4ui, + "emscripten_glVertexAttribIPointer": _emscripten_glVertexAttribIPointer, + "emscripten_glVertexAttribPointer": _emscripten_glVertexAttribPointer, + "emscripten_glViewport": _emscripten_glViewport, + "emscripten_num_logical_cores": _emscripten_num_logical_cores, + "emscripten_receive_on_main_thread_js": _emscripten_receive_on_main_thread_js, + "emscripten_resize_heap": _emscripten_resize_heap, + "emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size, + "emscripten_set_main_loop": _emscripten_set_main_loop, + "emscripten_supports_offscreencanvas": _emscripten_supports_offscreencanvas, + "emscripten_webgl_destroy_context": _emscripten_webgl_destroy_context, + "emscripten_webgl_do_commit_frame": _emscripten_webgl_do_commit_frame, + "emscripten_webgl_do_create_context": _emscripten_webgl_do_create_context, + "emscripten_webgl_enable_extension": _emscripten_webgl_enable_extension, + "emscripten_webgl_init_context_attributes": _emscripten_webgl_init_context_attributes, + "emscripten_webgl_make_context_current_calling_thread": _emscripten_webgl_make_context_current_calling_thread, + "environ_get": _environ_get, + "environ_sizes_get": _environ_sizes_get, + "exit": _exit, + "fd_close": _fd_close, + "fd_fdstat_get": _fd_fdstat_get, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "getaddrinfo": _getaddrinfo, + "getnameinfo": _getnameinfo, + "godot_audio_has_worklet": _godot_audio_has_worklet, + "godot_audio_init": _godot_audio_init, + "godot_audio_input_start": _godot_audio_input_start, + "godot_audio_input_stop": _godot_audio_input_stop, + "godot_audio_is_available": _godot_audio_is_available, + "godot_audio_resume": _godot_audio_resume, + "godot_audio_worklet_create": _godot_audio_worklet_create, + "godot_audio_worklet_start": _godot_audio_worklet_start, + "godot_audio_worklet_state_add": _godot_audio_worklet_state_add, + "godot_audio_worklet_state_get": _godot_audio_worklet_state_get, + "godot_audio_worklet_state_wait": _godot_audio_worklet_state_wait, + "godot_js_config_canvas_id_get": _godot_js_config_canvas_id_get, + "godot_js_config_locale_get": _godot_js_config_locale_get, + "godot_js_display_alert": _godot_js_display_alert, + "godot_js_display_canvas_focus": _godot_js_display_canvas_focus, + "godot_js_display_canvas_is_focused": _godot_js_display_canvas_is_focused, + "godot_js_display_clipboard_get": _godot_js_display_clipboard_get, + "godot_js_display_clipboard_set": _godot_js_display_clipboard_set, + "godot_js_display_cursor_is_hidden": _godot_js_display_cursor_is_hidden, + "godot_js_display_cursor_is_locked": _godot_js_display_cursor_is_locked, + "godot_js_display_cursor_lock_set": _godot_js_display_cursor_lock_set, + "godot_js_display_cursor_set_custom_shape": _godot_js_display_cursor_set_custom_shape, + "godot_js_display_cursor_set_shape": _godot_js_display_cursor_set_shape, + "godot_js_display_cursor_set_visible": _godot_js_display_cursor_set_visible, + "godot_js_display_desired_size_set": _godot_js_display_desired_size_set, + "godot_js_display_fullscreen_cb": _godot_js_display_fullscreen_cb, + "godot_js_display_fullscreen_exit": _godot_js_display_fullscreen_exit, + "godot_js_display_fullscreen_request": _godot_js_display_fullscreen_request, + "godot_js_display_has_webgl": _godot_js_display_has_webgl, + "godot_js_display_is_swap_ok_cancel": _godot_js_display_is_swap_ok_cancel, + "godot_js_display_notification_cb": _godot_js_display_notification_cb, + "godot_js_display_pixel_ratio_get": _godot_js_display_pixel_ratio_get, + "godot_js_display_screen_dpi_get": _godot_js_display_screen_dpi_get, + "godot_js_display_screen_size_get": _godot_js_display_screen_size_get, + "godot_js_display_setup_canvas": _godot_js_display_setup_canvas, + "godot_js_display_size_update": _godot_js_display_size_update, + "godot_js_display_touchscreen_is_available": _godot_js_display_touchscreen_is_available, + "godot_js_display_tts_available": _godot_js_display_tts_available, + "godot_js_display_vk_available": _godot_js_display_vk_available, + "godot_js_display_vk_cb": _godot_js_display_vk_cb, + "godot_js_display_vk_hide": _godot_js_display_vk_hide, + "godot_js_display_vk_show": _godot_js_display_vk_show, + "godot_js_display_window_blur_cb": _godot_js_display_window_blur_cb, + "godot_js_display_window_icon_set": _godot_js_display_window_icon_set, + "godot_js_display_window_size_get": _godot_js_display_window_size_get, + "godot_js_display_window_title_set": _godot_js_display_window_title_set, + "godot_js_eval": _godot_js_eval, + "godot_js_fetch_create": _godot_js_fetch_create, + "godot_js_fetch_free": _godot_js_fetch_free, + "godot_js_fetch_http_status_get": _godot_js_fetch_http_status_get, + "godot_js_fetch_is_chunked": _godot_js_fetch_is_chunked, + "godot_js_fetch_read_chunk": _godot_js_fetch_read_chunk, + "godot_js_fetch_read_headers": _godot_js_fetch_read_headers, + "godot_js_fetch_state_get": _godot_js_fetch_state_get, + "godot_js_input_drop_files_cb": _godot_js_input_drop_files_cb, + "godot_js_input_gamepad_cb": _godot_js_input_gamepad_cb, + "godot_js_input_gamepad_sample": _godot_js_input_gamepad_sample, + "godot_js_input_gamepad_sample_count": _godot_js_input_gamepad_sample_count, + "godot_js_input_gamepad_sample_get": _godot_js_input_gamepad_sample_get, + "godot_js_input_key_cb": _godot_js_input_key_cb, + "godot_js_input_mouse_button_cb": _godot_js_input_mouse_button_cb, + "godot_js_input_mouse_move_cb": _godot_js_input_mouse_move_cb, + "godot_js_input_mouse_wheel_cb": _godot_js_input_mouse_wheel_cb, + "godot_js_input_paste_cb": _godot_js_input_paste_cb, + "godot_js_input_touch_cb": _godot_js_input_touch_cb, + "godot_js_input_vibrate_handheld": _godot_js_input_vibrate_handheld, + "godot_js_os_download_buffer": _godot_js_os_download_buffer, + "godot_js_os_execute": _godot_js_os_execute, + "godot_js_os_finish_async": _godot_js_os_finish_async, + "godot_js_os_fs_is_persistent": _godot_js_os_fs_is_persistent, + "godot_js_os_fs_sync": _godot_js_os_fs_sync, + "godot_js_os_has_feature": _godot_js_os_has_feature, + "godot_js_os_hw_concurrency_get": _godot_js_os_hw_concurrency_get, + "godot_js_os_request_quit_cb": _godot_js_os_request_quit_cb, + "godot_js_os_shell_open": _godot_js_os_shell_open, + "godot_js_pwa_cb": _godot_js_pwa_cb, + "godot_js_pwa_update": _godot_js_pwa_update, + "godot_js_rtc_datachannel_close": _godot_js_rtc_datachannel_close, + "godot_js_rtc_datachannel_connect": _godot_js_rtc_datachannel_connect, + "godot_js_rtc_datachannel_destroy": _godot_js_rtc_datachannel_destroy, + "godot_js_rtc_datachannel_get_buffered_amount": _godot_js_rtc_datachannel_get_buffered_amount, + "godot_js_rtc_datachannel_id_get": _godot_js_rtc_datachannel_id_get, + "godot_js_rtc_datachannel_is_negotiated": _godot_js_rtc_datachannel_is_negotiated, + "godot_js_rtc_datachannel_is_ordered": _godot_js_rtc_datachannel_is_ordered, + "godot_js_rtc_datachannel_label_get": _godot_js_rtc_datachannel_label_get, + "godot_js_rtc_datachannel_max_packet_lifetime_get": _godot_js_rtc_datachannel_max_packet_lifetime_get, + "godot_js_rtc_datachannel_max_retransmits_get": _godot_js_rtc_datachannel_max_retransmits_get, + "godot_js_rtc_datachannel_protocol_get": _godot_js_rtc_datachannel_protocol_get, + "godot_js_rtc_datachannel_ready_state_get": _godot_js_rtc_datachannel_ready_state_get, + "godot_js_rtc_datachannel_send": _godot_js_rtc_datachannel_send, + "godot_js_rtc_pc_close": _godot_js_rtc_pc_close, + "godot_js_rtc_pc_create": _godot_js_rtc_pc_create, + "godot_js_rtc_pc_datachannel_create": _godot_js_rtc_pc_datachannel_create, + "godot_js_rtc_pc_destroy": _godot_js_rtc_pc_destroy, + "godot_js_rtc_pc_ice_candidate_add": _godot_js_rtc_pc_ice_candidate_add, + "godot_js_rtc_pc_local_description_set": _godot_js_rtc_pc_local_description_set, + "godot_js_rtc_pc_offer_create": _godot_js_rtc_pc_offer_create, + "godot_js_rtc_pc_remote_description_set": _godot_js_rtc_pc_remote_description_set, + "godot_js_tts_get_voices": _godot_js_tts_get_voices, + "godot_js_tts_is_paused": _godot_js_tts_is_paused, + "godot_js_tts_is_speaking": _godot_js_tts_is_speaking, + "godot_js_tts_pause": _godot_js_tts_pause, + "godot_js_tts_resume": _godot_js_tts_resume, + "godot_js_tts_speak": _godot_js_tts_speak, + "godot_js_tts_stop": _godot_js_tts_stop, + "godot_js_websocket_buffered_amount": _godot_js_websocket_buffered_amount, + "godot_js_websocket_close": _godot_js_websocket_close, + "godot_js_websocket_create": _godot_js_websocket_create, + "godot_js_websocket_destroy": _godot_js_websocket_destroy, + "godot_js_websocket_send": _godot_js_websocket_send, + "godot_js_wrapper_create_cb": _godot_js_wrapper_create_cb, + "godot_js_wrapper_create_object": _godot_js_wrapper_create_object, + "godot_js_wrapper_interface_get": _godot_js_wrapper_interface_get, + "godot_js_wrapper_object_call": _godot_js_wrapper_object_call, + "godot_js_wrapper_object_get": _godot_js_wrapper_object_get, + "godot_js_wrapper_object_getvar": _godot_js_wrapper_object_getvar, + "godot_js_wrapper_object_set": _godot_js_wrapper_object_set, + "godot_js_wrapper_object_set_cb_ret": _godot_js_wrapper_object_set_cb_ret, + "godot_js_wrapper_object_setvar": _godot_js_wrapper_object_setvar, + "godot_js_wrapper_object_unref": _godot_js_wrapper_object_unref, + "godot_webgl2_glFramebufferTextureMultiviewOVR": _godot_webgl2_glFramebufferTextureMultiviewOVR, + "godot_webgl2_glGetBufferSubData": _godot_webgl2_glGetBufferSubData, + "godot_webxr_get_bounds_geometry": _godot_webxr_get_bounds_geometry, + "godot_webxr_get_color_texture": _godot_webxr_get_color_texture, + "godot_webxr_get_depth_texture": _godot_webxr_get_depth_texture, + "godot_webxr_get_frame_rate": _godot_webxr_get_frame_rate, + "godot_webxr_get_projection_for_view": _godot_webxr_get_projection_for_view, + "godot_webxr_get_render_target_size": _godot_webxr_get_render_target_size, + "godot_webxr_get_supported_frame_rates": _godot_webxr_get_supported_frame_rates, + "godot_webxr_get_transform_for_view": _godot_webxr_get_transform_for_view, + "godot_webxr_get_velocity_texture": _godot_webxr_get_velocity_texture, + "godot_webxr_get_view_count": _godot_webxr_get_view_count, + "godot_webxr_get_visibility_state": _godot_webxr_get_visibility_state, + "godot_webxr_initialize": _godot_webxr_initialize, + "godot_webxr_is_session_supported": _godot_webxr_is_session_supported, + "godot_webxr_is_supported": _godot_webxr_is_supported, + "godot_webxr_uninitialize": _godot_webxr_uninitialize, + "godot_webxr_update_input_source": _godot_webxr_update_input_source, + "godot_webxr_update_target_frame_rate": _godot_webxr_update_target_frame_rate, + "invoke_ii": invoke_ii, + "invoke_iii": invoke_iii, + "invoke_iiii": invoke_iiii, + "invoke_iiiii": invoke_iiiii, + "invoke_iiiiii": invoke_iiiiii, + "invoke_vi": invoke_vi, + "invoke_vii": invoke_vii, + "invoke_viii": invoke_viii, + "invoke_viiii": invoke_viiii, + "invoke_viiiiiii": invoke_viiiiiii, + "invoke_viiiiiiii": invoke_viiiiiiii, + "invoke_viiij": invoke_viiij, + "memory": wasmMemory || Module["wasmMemory"], + "strftime": _strftime, + "strftime_l": _strftime_l +}; + +var asm = createWasm(); + +var ___wasm_call_ctors = createExportWrapper("__wasm_call_ctors"); + +var _emscripten_webgl_commit_frame = createExportWrapper("emscripten_webgl_commit_frame"); + +var _free = createExportWrapper("free"); + +var __Z14godot_web_mainiPPc = Module["__Z14godot_web_mainiPPc"] = createExportWrapper("_Z14godot_web_mainiPPc"); + +var _main = Module["_main"] = createExportWrapper("__main_argc_argv"); + +var _malloc = createExportWrapper("malloc"); + +var ___errno_location = createExportWrapper("__errno_location"); + +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); + +var _htonl = createExportWrapper("htonl"); + +var _htons = createExportWrapper("htons"); + +var _ntohs = createExportWrapper("ntohs"); + +var __emwebxr_on_input_event = Module["__emwebxr_on_input_event"] = createExportWrapper("_emwebxr_on_input_event"); + +var __emwebxr_on_simple_event = Module["__emwebxr_on_simple_event"] = createExportWrapper("_emwebxr_on_simple_event"); + +var __emscripten_tls_init = Module["__emscripten_tls_init"] = createExportWrapper("_emscripten_tls_init"); + +var _pthread_self = Module["_pthread_self"] = function() { + return (_pthread_self = Module["_pthread_self"] = Module["asm"]["pthread_self"]).apply(null, arguments); +}; + +var _emscripten_webgl_get_current_context = createExportWrapper("emscripten_webgl_get_current_context"); + +var _emscripten_dispatch_to_thread_ = createExportWrapper("emscripten_dispatch_to_thread_"); + +var ___funcs_on_exit = createExportWrapper("__funcs_on_exit"); + +var __emscripten_thread_init = Module["__emscripten_thread_init"] = createExportWrapper("_emscripten_thread_init"); + +var __emscripten_thread_crashed = Module["__emscripten_thread_crashed"] = createExportWrapper("_emscripten_thread_crashed"); + +var _emscripten_main_thread_process_queued_calls = createExportWrapper("emscripten_main_thread_process_queued_calls"); + +var _emscripten_main_runtime_thread_id = createExportWrapper("emscripten_main_runtime_thread_id"); + +var __emscripten_run_in_main_runtime_thread_js = createExportWrapper("_emscripten_run_in_main_runtime_thread_js"); + +var _emscripten_stack_get_base = function() { + return (_emscripten_stack_get_base = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments); +}; + +var _emscripten_stack_get_end = function() { + return (_emscripten_stack_get_end = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments); +}; + +var __emscripten_thread_free_data = createExportWrapper("_emscripten_thread_free_data"); + +var __emscripten_thread_exit = Module["__emscripten_thread_exit"] = createExportWrapper("_emscripten_thread_exit"); + +var __emscripten_timeout = createExportWrapper("_emscripten_timeout"); + +var __emscripten_check_mailbox = Module["__emscripten_check_mailbox"] = createExportWrapper("_emscripten_check_mailbox"); + +var _setThrew = createExportWrapper("setThrew"); + +var _emscripten_stack_init = function() { + return (_emscripten_stack_init = Module["asm"]["emscripten_stack_init"]).apply(null, arguments); +}; + +var _emscripten_stack_set_limits = function() { + return (_emscripten_stack_set_limits = Module["asm"]["emscripten_stack_set_limits"]).apply(null, arguments); +}; + +var _emscripten_stack_get_free = function() { + return (_emscripten_stack_get_free = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments); +}; + +var stackSave = createExportWrapper("stackSave"); + +var stackRestore = createExportWrapper("stackRestore"); + +var stackAlloc = createExportWrapper("stackAlloc"); + +var _emscripten_stack_get_current = function() { + return (_emscripten_stack_get_current = Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments); +}; + +var ___cxa_increment_exception_refcount = createExportWrapper("__cxa_increment_exception_refcount"); + +var ___cxa_is_pointer_type = createExportWrapper("__cxa_is_pointer_type"); + +var dynCall_vjiii = Module["dynCall_vjiii"] = createExportWrapper("dynCall_vjiii"); + +var dynCall_viiiiji = Module["dynCall_viiiiji"] = createExportWrapper("dynCall_viiiiji"); + +var dynCall_viiiiij = Module["dynCall_viiiiij"] = createExportWrapper("dynCall_viiiiij"); + +var dynCall_viiiij = Module["dynCall_viiiij"] = createExportWrapper("dynCall_viiiij"); + +var dynCall_ji = Module["dynCall_ji"] = createExportWrapper("dynCall_ji"); + +var dynCall_viiijii = Module["dynCall_viiijii"] = createExportWrapper("dynCall_viiijii"); + +var dynCall_vijiii = Module["dynCall_vijiii"] = createExportWrapper("dynCall_vijiii"); + +var dynCall_jij = Module["dynCall_jij"] = createExportWrapper("dynCall_jij"); + +var dynCall_iiij = Module["dynCall_iiij"] = createExportWrapper("dynCall_iiij"); + +var dynCall_iij = Module["dynCall_iij"] = createExportWrapper("dynCall_iij"); + +var dynCall_viij = Module["dynCall_viij"] = createExportWrapper("dynCall_viij"); + +var dynCall_jiij = Module["dynCall_jiij"] = createExportWrapper("dynCall_jiij"); + +var dynCall_jiii = Module["dynCall_jiii"] = createExportWrapper("dynCall_jiii"); + +var dynCall_jiiiiiii = Module["dynCall_jiiiiiii"] = createExportWrapper("dynCall_jiiiiiii"); + +var dynCall_jiiiii = Module["dynCall_jiiiii"] = createExportWrapper("dynCall_jiiiii"); + +var dynCall_ij = Module["dynCall_ij"] = createExportWrapper("dynCall_ij"); + +var dynCall_jiiiiiiiiii = Module["dynCall_jiiiiiiiiii"] = createExportWrapper("dynCall_jiiiiiiiiii"); + +var dynCall_jiiiiii = Module["dynCall_jiiiiii"] = createExportWrapper("dynCall_jiiiiii"); + +var dynCall_jiiiiiiii = Module["dynCall_jiiiiiiii"] = createExportWrapper("dynCall_jiiiiiiii"); + +var dynCall_jii = Module["dynCall_jii"] = createExportWrapper("dynCall_jii"); + +var dynCall_vij = Module["dynCall_vij"] = createExportWrapper("dynCall_vij"); + +var dynCall_viiij = Module["dynCall_viiij"] = createExportWrapper("dynCall_viiij"); + +var dynCall_viiiiiiij = Module["dynCall_viiiiiiij"] = createExportWrapper("dynCall_viiiiiiij"); + +var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"); + +var dynCall_jiiifi = Module["dynCall_jiiifi"] = createExportWrapper("dynCall_jiiifi"); + +var dynCall_jiifff = Module["dynCall_jiifff"] = createExportWrapper("dynCall_jiifff"); + +var dynCall_vijf = Module["dynCall_vijf"] = createExportWrapper("dynCall_vijf"); + +var dynCall_viiiiifiijii = Module["dynCall_viiiiifiijii"] = createExportWrapper("dynCall_viiiiifiijii"); + +var dynCall_viiiiifiiijjii = Module["dynCall_viiiiifiiijjii"] = createExportWrapper("dynCall_viiiiifiiijjii"); + +var dynCall_viiiiifiiijii = Module["dynCall_viiiiifiiijii"] = createExportWrapper("dynCall_viiiiifiiijii"); + +var dynCall_viiiiifiiiijjii = Module["dynCall_viiiiifiiiijjii"] = createExportWrapper("dynCall_viiiiifiiiijjii"); + +var dynCall_vijiiii = Module["dynCall_vijiiii"] = createExportWrapper("dynCall_vijiiii"); + +var dynCall_vijii = Module["dynCall_vijii"] = createExportWrapper("dynCall_vijii"); + +var dynCall_viijiiiiiiiii = Module["dynCall_viijiiiiiiiii"] = createExportWrapper("dynCall_viijiiiiiiiii"); + +var dynCall_viiiiiji = Module["dynCall_viiiiiji"] = createExportWrapper("dynCall_viiiiiji"); + +var dynCall_vijj = Module["dynCall_vijj"] = createExportWrapper("dynCall_vijj"); + +var dynCall_vijiiiiiidddd = Module["dynCall_vijiiiiiidddd"] = createExportWrapper("dynCall_vijiiiiiidddd"); + +var dynCall_jiiii = Module["dynCall_jiiii"] = createExportWrapper("dynCall_jiiii"); + +var dynCall_jiijiiii = Module["dynCall_jiijiiii"] = createExportWrapper("dynCall_jiijiiii"); + +var dynCall_jiiji = Module["dynCall_jiiji"] = createExportWrapper("dynCall_jiiji"); + +var dynCall_jiiiji = Module["dynCall_jiiiji"] = createExportWrapper("dynCall_jiiiji"); + +var dynCall_jiijii = Module["dynCall_jiijii"] = createExportWrapper("dynCall_jiijii"); + +var dynCall_iijiiij = Module["dynCall_iijiiij"] = createExportWrapper("dynCall_iijiiij"); + +var dynCall_jijjjiiiiijii = Module["dynCall_jijjjiiiiijii"] = createExportWrapper("dynCall_jijjjiiiiijii"); + +var dynCall_jijiiiiifiii = Module["dynCall_jijiiiiifiii"] = createExportWrapper("dynCall_jijiiiiifiii"); + +var dynCall_viijiiiiiifiii = Module["dynCall_viijiiiiiifiii"] = createExportWrapper("dynCall_viijiiiiiifiii"); + +var dynCall_viji = Module["dynCall_viji"] = createExportWrapper("dynCall_viji"); + +var dynCall_viiji = Module["dynCall_viiji"] = createExportWrapper("dynCall_viiji"); + +var dynCall_vijji = Module["dynCall_vijji"] = createExportWrapper("dynCall_vijji"); + +var dynCall_vijjii = Module["dynCall_vijjii"] = createExportWrapper("dynCall_vijjii"); + +var dynCall_fij = Module["dynCall_fij"] = createExportWrapper("dynCall_fij"); + +var dynCall_vijiffifff = Module["dynCall_vijiffifff"] = createExportWrapper("dynCall_vijiffifff"); + +var dynCall_vijff = Module["dynCall_vijff"] = createExportWrapper("dynCall_vijff"); + +var dynCall_vijiffff = Module["dynCall_vijiffff"] = createExportWrapper("dynCall_vijiffff"); + +var dynCall_vijjf = Module["dynCall_vijjf"] = createExportWrapper("dynCall_vijjf"); + +var dynCall_vijij = Module["dynCall_vijij"] = createExportWrapper("dynCall_vijij"); + +var dynCall_vijif = Module["dynCall_vijif"] = createExportWrapper("dynCall_vijif"); + +var dynCall_vijiiifi = Module["dynCall_vijiiifi"] = createExportWrapper("dynCall_vijiiifi"); + +var dynCall_vijiifi = Module["dynCall_vijiifi"] = createExportWrapper("dynCall_vijiifi"); + +var dynCall_vijiif = Module["dynCall_vijiif"] = createExportWrapper("dynCall_vijiif"); + +var dynCall_vijifi = Module["dynCall_vijifi"] = createExportWrapper("dynCall_vijifi"); + +var dynCall_vijijiii = Module["dynCall_vijijiii"] = createExportWrapper("dynCall_vijijiii"); + +var dynCall_vijijiiii = Module["dynCall_vijijiiii"] = createExportWrapper("dynCall_vijijiiii"); + +var dynCall_vijijiiiff = Module["dynCall_vijijiiiff"] = createExportWrapper("dynCall_vijijiiiff"); + +var dynCall_vijijii = Module["dynCall_vijijii"] = createExportWrapper("dynCall_vijijii"); + +var dynCall_vijiijiiiiii = Module["dynCall_vijiijiiiiii"] = createExportWrapper("dynCall_vijiijiiiiii"); + +var dynCall_vijiiij = Module["dynCall_vijiiij"] = createExportWrapper("dynCall_vijiiij"); + +var dynCall_vijiiiiiiji = Module["dynCall_vijiiiiiiji"] = createExportWrapper("dynCall_vijiiiiiiji"); + +var dynCall_vijjj = Module["dynCall_vijjj"] = createExportWrapper("dynCall_vijjj"); + +var dynCall_vijdddd = Module["dynCall_vijdddd"] = createExportWrapper("dynCall_vijdddd"); + +var dynCall_vijififi = Module["dynCall_vijififi"] = createExportWrapper("dynCall_vijififi"); + +var dynCall_iijji = Module["dynCall_iijji"] = createExportWrapper("dynCall_iijji"); + +var dynCall_viijj = Module["dynCall_viijj"] = createExportWrapper("dynCall_viijj"); + +var dynCall_iiiij = Module["dynCall_iiiij"] = createExportWrapper("dynCall_iiiij"); + +var dynCall_dij = Module["dynCall_dij"] = createExportWrapper("dynCall_dij"); + +var dynCall_vijd = Module["dynCall_vijd"] = createExportWrapper("dynCall_vijd"); + +var dynCall_viijiiii = Module["dynCall_viijiiii"] = createExportWrapper("dynCall_viijiiii"); + +var dynCall_viijiii = Module["dynCall_viijiii"] = createExportWrapper("dynCall_viijiii"); + +var dynCall_iiji = Module["dynCall_iiji"] = createExportWrapper("dynCall_iiji"); + +var dynCall_iiiijf = Module["dynCall_iiiijf"] = createExportWrapper("dynCall_iiiijf"); + +var dynCall_vijiiiii = Module["dynCall_vijiiiii"] = createExportWrapper("dynCall_vijiiiii"); + +var dynCall_viijd = Module["dynCall_viijd"] = createExportWrapper("dynCall_viijd"); + +var dynCall_diij = Module["dynCall_diij"] = createExportWrapper("dynCall_diij"); + +var dynCall_viiiji = Module["dynCall_viiiji"] = createExportWrapper("dynCall_viiiji"); + +var dynCall_viiijj = Module["dynCall_viiijj"] = createExportWrapper("dynCall_viiijj"); + +var dynCall_viijji = Module["dynCall_viijji"] = createExportWrapper("dynCall_viijji"); + +var dynCall_jiiij = Module["dynCall_jiiij"] = createExportWrapper("dynCall_jiiij"); + +var dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii"); + +var dynCall_jiijjj = Module["dynCall_jiijjj"] = createExportWrapper("dynCall_jiijjj"); + +var dynCall_jiijj = Module["dynCall_jiijj"] = createExportWrapper("dynCall_jiijj"); + +var dynCall_viiijiji = Module["dynCall_viiijiji"] = createExportWrapper("dynCall_viiijiji"); + +var dynCall_viiijjiji = Module["dynCall_viiijjiji"] = createExportWrapper("dynCall_viiijjiji"); + +var dynCall_viijiji = Module["dynCall_viijiji"] = createExportWrapper("dynCall_viijiji"); + +var dynCall_iiiiijiii = Module["dynCall_iiiiijiii"] = createExportWrapper("dynCall_iiiiijiii"); + +var dynCall_iiiiiijd = Module["dynCall_iiiiiijd"] = createExportWrapper("dynCall_iiiiiijd"); + +var dynCall_diidj = Module["dynCall_diidj"] = createExportWrapper("dynCall_diidj"); + +var dynCall_viiiijij = Module["dynCall_viiiijij"] = createExportWrapper("dynCall_viiiijij"); + +var dynCall_viiidjj = Module["dynCall_viiidjj"] = createExportWrapper("dynCall_viiidjj"); + +var dynCall_viidj = Module["dynCall_viidj"] = createExportWrapper("dynCall_viidj"); + +var dynCall_iiijj = Module["dynCall_iiijj"] = createExportWrapper("dynCall_iiijj"); + +var dynCall_jiid = Module["dynCall_jiid"] = createExportWrapper("dynCall_jiid"); + +var dynCall_viiiiddji = Module["dynCall_viiiiddji"] = createExportWrapper("dynCall_viiiiddji"); + +var dynCall_vijiiiiiiiii = Module["dynCall_vijiiiiiiiii"] = createExportWrapper("dynCall_vijiiiiiiiii"); + +var dynCall_vijiiiffi = Module["dynCall_vijiiiffi"] = createExportWrapper("dynCall_vijiiiffi"); + +var dynCall_vijiiifii = Module["dynCall_vijiiifii"] = createExportWrapper("dynCall_vijiiifii"); + +var dynCall_viijfii = Module["dynCall_viijfii"] = createExportWrapper("dynCall_viijfii"); + +var dynCall_viiiiiiiiiiijjjjjjifiiiiii = Module["dynCall_viiiiiiiiiiijjjjjjifiiiiii"] = createExportWrapper("dynCall_viiiiiiiiiiijjjjjjifiiiiii"); + +var dynCall_vijifff = Module["dynCall_vijifff"] = createExportWrapper("dynCall_vijifff"); + +var dynCall_fiji = Module["dynCall_fiji"] = createExportWrapper("dynCall_fiji"); + +var dynCall_vijiiffifffi = Module["dynCall_vijiiffifffi"] = createExportWrapper("dynCall_vijiiffifffi"); + +var dynCall_iijj = Module["dynCall_iijj"] = createExportWrapper("dynCall_iijj"); + +var dynCall_iijjfj = Module["dynCall_iijjfj"] = createExportWrapper("dynCall_iijjfj"); + +var dynCall_vijiji = Module["dynCall_vijiji"] = createExportWrapper("dynCall_vijiji"); + +var dynCall_jijii = Module["dynCall_jijii"] = createExportWrapper("dynCall_jijii"); + +var dynCall_vijid = Module["dynCall_vijid"] = createExportWrapper("dynCall_vijid"); + +var dynCall_vijiiiiii = Module["dynCall_vijiiiiii"] = createExportWrapper("dynCall_vijiiiiii"); + +var dynCall_vijiff = Module["dynCall_vijiff"] = createExportWrapper("dynCall_vijiff"); + +var dynCall_vijjjj = Module["dynCall_vijjjj"] = createExportWrapper("dynCall_vijjjj"); + +var dynCall_vijiiiiiii = Module["dynCall_vijiiiiiii"] = createExportWrapper("dynCall_vijiiiiiii"); + +var dynCall_jiiifiiiii = Module["dynCall_jiiifiiiii"] = createExportWrapper("dynCall_jiiifiiiii"); + +var dynCall_viiiifijii = Module["dynCall_viiiifijii"] = createExportWrapper("dynCall_viiiifijii"); + +var dynCall_viiiifiijjii = Module["dynCall_viiiifiijjii"] = createExportWrapper("dynCall_viiiifiijjii"); + +var dynCall_vijiiifiijii = Module["dynCall_vijiiifiijii"] = createExportWrapper("dynCall_vijiiifiijii"); + +var dynCall_vijiiifiiijjii = Module["dynCall_vijiiifiiijjii"] = createExportWrapper("dynCall_vijiiifiiijjii"); + +var dynCall_vijiiifiiijii = Module["dynCall_vijiiifiiijii"] = createExportWrapper("dynCall_vijiiifiiijii"); + +var dynCall_vijiiifiiiijjii = Module["dynCall_vijiiifiiiijjii"] = createExportWrapper("dynCall_vijiiifiiiijjii"); + +var dynCall_fijiiii = Module["dynCall_fijiiii"] = createExportWrapper("dynCall_fijiiii"); + +var dynCall_fijiiiii = Module["dynCall_fijiiiii"] = createExportWrapper("dynCall_fijiiiii"); + +var dynCall_iijii = Module["dynCall_iijii"] = createExportWrapper("dynCall_iijii"); + +var dynCall_iijiijiiiii = Module["dynCall_iijiijiiiii"] = createExportWrapper("dynCall_iijiijiiiii"); + +var dynCall_iijijiiiii = Module["dynCall_iijijiiiii"] = createExportWrapper("dynCall_iijijiiiii"); + +var dynCall_vijijj = Module["dynCall_vijijj"] = createExportWrapper("dynCall_vijijj"); + +var dynCall_vijiiijj = Module["dynCall_vijiiijj"] = createExportWrapper("dynCall_vijiiijj"); + +var dynCall_vijiijj = Module["dynCall_vijiijj"] = createExportWrapper("dynCall_vijiijj"); + +var dynCall_vijjiji = Module["dynCall_vijjiji"] = createExportWrapper("dynCall_vijjiji"); + +var dynCall_vijjiijii = Module["dynCall_vijjiijii"] = createExportWrapper("dynCall_vijjiijii"); + +var dynCall_fijii = Module["dynCall_fijii"] = createExportWrapper("dynCall_fijii"); + +var dynCall_iiiiiiij = Module["dynCall_iiiiiiij"] = createExportWrapper("dynCall_iiiiiiij"); + +var dynCall_vijiiiij = Module["dynCall_vijiiiij"] = createExportWrapper("dynCall_vijiiiij"); + +var dynCall_jijj = Module["dynCall_jijj"] = createExportWrapper("dynCall_jijj"); + +var dynCall_jiiif = Module["dynCall_jiiif"] = createExportWrapper("dynCall_jiiif"); + +var dynCall_vijfff = Module["dynCall_vijfff"] = createExportWrapper("dynCall_vijfff"); + +var dynCall_vijfiff = Module["dynCall_vijfiff"] = createExportWrapper("dynCall_vijfiff"); + +var dynCall_vijfi = Module["dynCall_vijfi"] = createExportWrapper("dynCall_vijfi"); + +var dynCall_vijffffi = Module["dynCall_vijffffi"] = createExportWrapper("dynCall_vijffffi"); + +var dynCall_vijiiffi = Module["dynCall_vijiiffi"] = createExportWrapper("dynCall_vijiiffi"); + +var dynCall_vijiifffffff = Module["dynCall_vijiifffffff"] = createExportWrapper("dynCall_vijiifffffff"); + +var dynCall_vijifiifffffifff = Module["dynCall_vijifiifffffifff"] = createExportWrapper("dynCall_vijifiifffffifff"); + +var dynCall_vijiiffffiffffj = Module["dynCall_vijiiffffiffffj"] = createExportWrapper("dynCall_vijiiffffiffffj"); + +var dynCall_vijiifff = Module["dynCall_vijiifff"] = createExportWrapper("dynCall_vijiifff"); + +var dynCall_vijiffffffff = Module["dynCall_vijiffffffff"] = createExportWrapper("dynCall_vijiffffffff"); + +var dynCall_vijiifiififff = Module["dynCall_vijiifiififff"] = createExportWrapper("dynCall_vijiifiififff"); + +var dynCall_vijifffij = Module["dynCall_vijifffij"] = createExportWrapper("dynCall_vijifffij"); + +var dynCall_viijjjiifjii = Module["dynCall_viijjjiifjii"] = createExportWrapper("dynCall_viijjjiifjii"); + +var dynCall_vijjjii = Module["dynCall_vijjjii"] = createExportWrapper("dynCall_vijjjii"); + +var dynCall_fijj = Module["dynCall_fijj"] = createExportWrapper("dynCall_fijj"); + +var dynCall_iijjiii = Module["dynCall_iijjiii"] = createExportWrapper("dynCall_iijjiii"); + +var dynCall_iiiiij = Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij"); + +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj"); + +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj"); + +function invoke_vii(index, a1, a2) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index, a1) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index, a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiii(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iii(index, a1, a2) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index, a1, a2, a3) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiij(index, a1, a2, a3, a4, a5) { + var sp = stackSave(); + try { + dynCall_viiij(index, a1, a2, a3, a4, a5); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +Module["callMain"] = callMain; + +Module["keepRuntimeAlive"] = keepRuntimeAlive; + +Module["wasmMemory"] = wasmMemory; + +Module["cwrap"] = cwrap; + +Module["ExitStatus"] = ExitStatus; + +Module["PThread"] = PThread; + +var missingLibrarySymbols = [ "getHostByName", "traverseStack", "getCallstack", "emscriptenLog", "convertPCtoSourceLocation", "readEmAsmArgs", "jstoi_s", "listenOnce", "autoResumeAudioContext", "dynCallLegacy", "getDynCaller", "dynCall", "asmjsMangle", "HandleAllocator", "getNativeTypeSize", "STACK_SIZE", "STACK_ALIGN", "POINTER_SIZE", "ASSERTIONS", "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "convertI32PairToI53", "convertU32PairToI53", "uleb128Encode", "sigToWasmTypes", "generateFuncType", "convertJsFunctionToWasm", "getEmptyTableSlot", "updateTableMap", "getFunctionAddress", "addFunction", "removeFunction", "reallyNegative", "unSign", "strLen", "reSign", "formatString", "intArrayToString", "AsciiToString", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "registerKeyEventCallback", "getBoundingClientRect", "fillMouseEventData", "registerMouseEventCallback", "registerWheelEventCallback", "registerUiEventCallback", "registerFocusEventCallback", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "fillFullscreenChangeEventData", "registerFullscreenChangeEventCallback", "JSEvents_requestFullscreen", "JSEvents_resizeCanvasForFullscreen", "registerRestoreOldStyle", "hideEverythingExceptGivenElement", "restoreHiddenElements", "setLetterbox", "softFullscreenResizeWebGLRenderTarget", "doRequestFullscreen", "fillPointerlockChangeEventData", "registerPointerlockChangeEventCallback", "registerPointerlockErrorEventCallback", "requestPointerLock", "fillVisibilityChangeEventData", "registerVisibilityChangeEventCallback", "registerTouchEventCallback", "fillGamepadEventData", "registerGamepadEventCallback", "registerBeforeUnloadEventCallback", "fillBatteryEventData", "battery", "registerBatteryEventCallback", "setCanvasElementSize", "getCanvasSizeCallingThread", "getCanvasSizeMainThread", "getCanvasElementSize", "jsStackTrace", "stackTrace", "checkWasiClock", "wasiRightsToMuslOFlags", "wasiOFlagsToMuslOFlags", "createDyncallWrapper", "setImmediateWrapped", "clearImmediateWrapped", "polyfillSetImmediate", "getPromise", "makePromise", "idsToPromises", "makePromiseCallback", "ExceptionInfo", "_setNetworkCallback", "emscriptenWebGLGetUniform", "emscriptenWebGLGetVertexAttrib", "__glGetActiveAttribOrUniform", "writeGLArray", "emscripten_webgl_destroy_context_before_on_calling_thread", "registerWebGlEventCallback", "runAndAbortIfError", "SDL_unicode", "SDL_ttfContext", "SDL_audio", "GLFW_Window", "emscriptenWebGLGetIndexed", "ALLOC_NORMAL", "ALLOC_STACK", "allocate", "writeStringToMemory", "writeAsciiToMemory" ]; + +missingLibrarySymbols.forEach(missingLibrarySymbol); + +var unexportedSymbols = [ "run", "addOnPreRun", "addOnInit", "addOnPreMain", "addOnExit", "addOnPostRun", "addRunDependency", "removeRunDependency", "FS_createFolder", "FS_createPath", "FS_createDataFile", "FS_createLazyFile", "FS_createLink", "FS_createDevice", "FS_unlink", "out", "err", "abort", "stackAlloc", "stackSave", "stackRestore", "getTempRet0", "setTempRet0", "GROWABLE_HEAP_I8", "GROWABLE_HEAP_U8", "GROWABLE_HEAP_I16", "GROWABLE_HEAP_U16", "GROWABLE_HEAP_I32", "GROWABLE_HEAP_U32", "GROWABLE_HEAP_F32", "GROWABLE_HEAP_F64", "writeStackCookie", "checkStackCookie", "ptrToString", "zeroMemory", "exitJS", "getHeapMax", "emscripten_realloc_buffer", "ENV", "MONTH_DAYS_REGULAR", "MONTH_DAYS_LEAP", "MONTH_DAYS_REGULAR_CUMULATIVE", "MONTH_DAYS_LEAP_CUMULATIVE", "isLeapYear", "ydayFromDate", "arraySum", "addDays", "ERRNO_CODES", "ERRNO_MESSAGES", "setErrNo", "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "DNS", "Protocols", "Sockets", "initRandomFill", "randomFill", "timers", "warnOnce", "UNWIND_CACHE", "readEmAsmArgsArray", "jstoi_q", "getExecutableName", "handleException", "runtimeKeepalivePush", "runtimeKeepalivePop", "callUserCallback", "maybeExit", "safeSetTimeout", "asyncLoad", "alignMemory", "mmapAlloc", "writeI53ToI64", "readI53FromI64", "readI53FromU64", "convertI32PairToI53Checked", "getCFunc", "ccall", "freeTableIndexes", "functionsInTableMap", "setValue", "getValue", "PATH", "PATH_FS", "UTF8Decoder", "UTF8ArrayToString", "UTF8ToString", "stringToUTF8Array", "stringToUTF8", "lengthBytesUTF8", "intArrayFromString", "stringToAscii", "UTF16Decoder", "stringToNewUTF8", "stringToUTF8OnStack", "writeArrayToMemory", "SYSCALLS", "getSocketFromFD", "getSocketAddress", "JSEvents", "specialHTMLTargets", "maybeCStringToJsString", "findEventTarget", "findCanvasEventTarget", "currentFullscreenStrategy", "restoreOldWindowedStyle", "setCanvasElementSizeCallingThread", "setCanvasElementSizeMainThread", "demangle", "demangleAll", "getEnvStrings", "doReadv", "doWritev", "dlopenMissingError", "promiseMap", "uncaughtExceptionCount", "exceptionLast", "exceptionCaught", "Browser", "setMainLoop", "wget", "preloadPlugins", "FS_createPreloadedFile", "FS_modeStringToFlags", "FS_getMode", "FS", "MEMFS", "TTY", "PIPEFS", "SOCKFS", "tempFixedLengthArray", "miniTempWebGLFloatBuffers", "miniTempWebGLIntBuffers", "heapObjectForWebGLType", "heapAccessShiftForWebGLHeap", "webgl_enable_ANGLE_instanced_arrays", "webgl_enable_OES_vertex_array_object", "webgl_enable_WEBGL_draw_buffers", "webgl_enable_WEBGL_multi_draw", "GL", "emscriptenWebGLGet", "computeUnpackAlignedImageSize", "colorChannelsInGlTextureFormat", "emscriptenWebGLGetTexPixelData", "__glGenObject", "webglGetUniformLocation", "webglPrepareUniformLocationsBeforeFirstUse", "webglGetLeftBracePos", "emscripten_webgl_power_preferences", "AL", "GLUT", "EGL", "GLEW", "IDBStore", "SDL", "SDL_gfx", "GLFW", "webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance", "webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance", "allocateUTF8", "allocateUTF8OnStack", "terminateWorker", "killThread", "cleanupThread", "registerTLSInit", "cancelThread", "spawnThread", "exitOnMainThread", "proxyToMainThread", "emscripten_receive_on_main_thread_js_callArgs", "invokeEntryPoint", "checkMailbox", "GodotWebXR", "GodotWebSocket", "GodotRTCDataChannel", "GodotRTCPeerConnection", "GodotAudio", "GodotAudioWorklet", "GodotAudioScript", "GodotDisplayVK", "GodotDisplayCursor", "GodotDisplayScreen", "GodotDisplay", "GodotFetch", "IDHandler", "GodotConfig", "GodotFS", "GodotOS", "GodotEventListeners", "GodotPWA", "GodotRuntime", "GodotInputGamepads", "GodotInputDragDrop", "GodotInput", "GodotWebGL2", "GodotJSWrapper", "IDBFS" ]; + +unexportedSymbols.forEach(unexportedRuntimeSymbol); + +var calledRun; + +dependenciesFulfilled = function runCaller() { + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; +}; + +function callMain(args = []) { + assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])'); + assert(__ATPRERUN__.length == 0, "cannot call main when preRun functions remain to be called"); + var entryFunction = _main; + args.unshift(thisProgram); + var argc = args.length; + var argv = stackAlloc((argc + 1) * 4); + var argv_ptr = argv >> 2; + args.forEach(arg => { + GROWABLE_HEAP_I32()[argv_ptr++] = stringToUTF8OnStack(arg); + }); + GROWABLE_HEAP_I32()[argv_ptr] = 0; + try { + var ret = entryFunction(argc, argv); + exitJS(ret, true); + return ret; + } catch (e) { + return handleException(e); + } +} + +function stackCheckInit() { + assert(!ENVIRONMENT_IS_PTHREAD); + _emscripten_stack_init(); + writeStackCookie(); +} + +function run(args = arguments_) { + if (runDependencies > 0) { + return; + } + if (!ENVIRONMENT_IS_PTHREAD) stackCheckInit(); + if (ENVIRONMENT_IS_PTHREAD) { + readyPromiseResolve(Module); + initRuntime(); + startWorker(Module); + return; + } + preRun(); + if (runDependencies > 0) { + return; + } + function doRun() { + if (calledRun) return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + preMain(); + readyPromiseResolve(Module); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + if (shouldRunNow) callMain(args); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function() { + setTimeout(function() { + Module["setStatus"](""); + }, 1); + doRun(); + }, 1); + } else { + doRun(); + } + checkStackCookie(); +} + +if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()(); + } +} + +var shouldRunNow = false; + +if (Module["noInitialRun"]) shouldRunNow = false; + +run(); + + + return Godot.ready +} + +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = Godot; +else if (typeof define === 'function' && define['amd']) + define([], function() { return Godot; }); +else if (typeof exports === 'object') + exports["Godot"] = Godot; + +const Features = { // eslint-disable-line no-unused-vars + /** + * Check whether WebGL is available. Optionally, specify a particular version of WebGL to check for. + * + * @param {number=} [majorVersion=1] The major WebGL version to check for. + * @returns {boolean} If the given major version of WebGL is available. + * @function Engine.isWebGLAvailable + */ + isWebGLAvailable: function (majorVersion = 1) { + try { + return !!document.createElement('canvas').getContext(['webgl', 'webgl2'][majorVersion - 1]); + } catch (e) { /* Not available */ } + return false; + }, + + /** + * Check whether the Fetch API available and supports streaming responses. + * + * @returns {boolean} If the Fetch API is available and supports streaming responses. + * @function Engine.isFetchAvailable + */ + isFetchAvailable: function () { + return 'fetch' in window && 'Response' in window && 'body' in window.Response.prototype; + }, + + /** + * Check whether the engine is running in a Secure Context. + * + * @returns {boolean} If the engine is running in a Secure Context. + * @function Engine.isSecureContext + */ + isSecureContext: function () { + return window['isSecureContext'] === true; + }, + + /** + * Check whether the engine is cross origin isolated. + * This value is dependent on Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers sent by the server. + * + * @returns {boolean} If the engine is running in a Secure Context. + * @function Engine.isSecureContext + */ + isCrossOriginIsolated: function () { + return window['crossOriginIsolated'] === true; + }, + + /** + * Check whether SharedBufferArray is available. + * + * Most browsers require the page to be running in a secure context, and the + * the server to provide specific CORS headers for SharedArrayBuffer to be available. + * + * @returns {boolean} If SharedArrayBuffer is available. + * @function Engine.isSharedArrayBufferAvailable + */ + isSharedArrayBufferAvailable: function () { + return 'SharedArrayBuffer' in window; + }, + + /** + * Check whether the AudioContext supports AudioWorkletNodes. + * + * @returns {boolean} If AudioWorkletNode is available. + * @function Engine.isAudioWorkletAvailable + */ + isAudioWorkletAvailable: function () { + return 'AudioContext' in window && 'audioWorklet' in AudioContext.prototype; + }, + + /** + * Return an array of missing required features (as string). + * + * @returns {Array} A list of human-readable missing features. + * @function Engine.getMissingFeatures + */ + getMissingFeatures: function () { + const missing = []; + if (!Features.isWebGLAvailable(2)) { + missing.push('WebGL2 - Check web browser configuration and hardware support'); + } + if (!Features.isFetchAvailable()) { + missing.push('Fetch - Check web browser version'); + } + if (!Features.isSecureContext()) { + missing.push('Secure Context - Check web server configuration (use HTTPS)'); + } + if (!Features.isCrossOriginIsolated()) { + missing.push('Cross Origin Isolation - Check web server configuration (send correct headers)'); + } + if (!Features.isSharedArrayBufferAvailable()) { + missing.push('SharedArrayBuffer - Check web server configuration (send correct headers)'); + } + // Audio is normally optional since we have a dummy fallback. + return missing; + }, +}; + +const Preloader = /** @constructor */ function () { // eslint-disable-line no-unused-vars + function getTrackedResponse(response, load_status) { + function onloadprogress(reader, controller) { + return reader.read().then(function (result) { + if (load_status.done) { + return Promise.resolve(); + } + if (result.value) { + controller.enqueue(result.value); + load_status.loaded += result.value.length; + } + if (!result.done) { + return onloadprogress(reader, controller); + } + load_status.done = true; + return Promise.resolve(); + }); + } + const reader = response.body.getReader(); + return new Response(new ReadableStream({ + start: function (controller) { + onloadprogress(reader, controller).then(function () { + controller.close(); + }); + }, + }), { headers: response.headers }); + } + + function loadFetch(file, tracker, fileSize, raw) { + tracker[file] = { + total: fileSize || 0, + loaded: 0, + done: false, + }; + return fetch(file).then(function (response) { + if (!response.ok) { + return Promise.reject(new Error(`Failed loading file '${file}'`)); + } + const tr = getTrackedResponse(response, tracker[file]); + if (raw) { + return Promise.resolve(tr); + } + return tr.arrayBuffer(); + }); + } + + function retry(func, attempts = 1) { + function onerror(err) { + if (attempts <= 1) { + return Promise.reject(err); + } + return new Promise(function (resolve, reject) { + setTimeout(function () { + retry(func, attempts - 1).then(resolve).catch(reject); + }, 1000); + }); + } + return func().catch(onerror); + } + + const DOWNLOAD_ATTEMPTS_MAX = 4; + const loadingFiles = {}; + const lastProgress = { loaded: 0, total: 0 }; + let progressFunc = null; + + const animateProgress = function () { + let loaded = 0; + let total = 0; + let totalIsValid = true; + let progressIsFinal = true; + + Object.keys(loadingFiles).forEach(function (file) { + const stat = loadingFiles[file]; + if (!stat.done) { + progressIsFinal = false; + } + if (!totalIsValid || stat.total === 0) { + totalIsValid = false; + total = 0; + } else { + total += stat.total; + } + loaded += stat.loaded; + }); + if (loaded !== lastProgress.loaded || total !== lastProgress.total) { + lastProgress.loaded = loaded; + lastProgress.total = total; + if (typeof progressFunc === 'function') { + progressFunc(loaded, total); + } + } + if (!progressIsFinal) { + requestAnimationFrame(animateProgress); + } + }; + + this.animateProgress = animateProgress; + + this.setProgressFunc = function (callback) { + progressFunc = callback; + }; + + this.loadPromise = function (file, fileSize, raw = false) { + return retry(loadFetch.bind(null, file, loadingFiles, fileSize, raw), DOWNLOAD_ATTEMPTS_MAX); + }; + + this.preloadedFiles = []; + this.preload = function (pathOrBuffer, destPath, fileSize) { + let buffer = null; + if (typeof pathOrBuffer === 'string') { + const me = this; + return this.loadPromise(pathOrBuffer, fileSize).then(function (buf) { + me.preloadedFiles.push({ + path: destPath || pathOrBuffer, + buffer: buf, + }); + return Promise.resolve(); + }); + } else if (pathOrBuffer instanceof ArrayBuffer) { + buffer = new Uint8Array(pathOrBuffer); + } else if (ArrayBuffer.isView(pathOrBuffer)) { + buffer = new Uint8Array(pathOrBuffer.buffer); + } + if (buffer) { + this.preloadedFiles.push({ + path: destPath, + buffer: pathOrBuffer, + }); + return Promise.resolve(); + } + return Promise.reject(new Error('Invalid object for preloading')); + }; +}; + +/** + * An object used to configure the Engine instance based on godot export options, and to override those in custom HTML + * templates if needed. + * + * @header Engine configuration + * @summary The Engine configuration object. This is just a typedef, create it like a regular object, e.g.: + * + * ``const MyConfig = { executable: 'godot', unloadAfterInit: false }`` + * + * @typedef {Object} EngineConfig + */ +const EngineConfig = {}; // eslint-disable-line no-unused-vars + +/** + * @struct + * @constructor + * @ignore + */ +const InternalConfig = function (initConfig) { // eslint-disable-line no-unused-vars + const cfg = /** @lends {InternalConfig.prototype} */ { + /** + * Whether the unload the engine automatically after the instance is initialized. + * + * @memberof EngineConfig + * @default + * @type {boolean} + */ + unloadAfterInit: true, + /** + * The HTML DOM Canvas object to use. + * + * By default, the first canvas element in the document will be used is none is specified. + * + * @memberof EngineConfig + * @default + * @type {?HTMLCanvasElement} + */ + canvas: null, + /** + * The name of the WASM file without the extension. (Set by Godot Editor export process). + * + * @memberof EngineConfig + * @default + * @type {string} + */ + executable: '', + /** + * An alternative name for the game pck to load. The executable name is used otherwise. + * + * @memberof EngineConfig + * @default + * @type {?string} + */ + mainPack: null, + /** + * Specify a language code to select the proper localization for the game. + * + * The browser locale will be used if none is specified. See complete list of + * :ref:`supported locales `. + * + * @memberof EngineConfig + * @type {?string} + * @default + */ + locale: null, + /** + * The canvas resize policy determines how the canvas should be resized by Godot. + * + * ``0`` means Godot won't do any resizing. This is useful if you want to control the canvas size from + * javascript code in your template. + * + * ``1`` means Godot will resize the canvas on start, and when changing window size via engine functions. + * + * ``2`` means Godot will adapt the canvas size to match the whole browser window. + * + * @memberof EngineConfig + * @type {number} + * @default + */ + canvasResizePolicy: 2, + /** + * The arguments to be passed as command line arguments on startup. + * + * See :ref:`command line tutorial `. + * + * **Note**: :js:meth:`startGame ` will always add the ``--main-pack`` argument. + * + * @memberof EngineConfig + * @type {Array} + * @default + */ + args: [], + /** + * When enabled, the game canvas will automatically grab the focus when the engine starts. + * + * @memberof EngineConfig + * @type {boolean} + * @default + */ + focusCanvas: true, + /** + * When enabled, this will turn on experimental virtual keyboard support on mobile. + * + * @memberof EngineConfig + * @type {boolean} + * @default + */ + experimentalVK: false, + /** + * The progressive web app service worker to install. + * @memberof EngineConfig + * @default + * @type {string} + */ + serviceWorker: '', + /** + * @ignore + * @type {Array.} + */ + persistentPaths: ['/userfs'], + /** + * @ignore + * @type {boolean} + */ + persistentDrops: false, + /** + * @ignore + * @type {Array.} + */ + gdextensionLibs: [], + /** + * @ignore + * @type {Array.} + */ + fileSizes: [], + /** + * A callback function for handling Godot's ``OS.execute`` calls. + * + * This is for example used in the Web Editor template to switch between project manager and editor, and for running the game. + * + * @callback EngineConfig.onExecute + * @param {string} path The path that Godot's wants executed. + * @param {Array.} args The arguments of the "command" to execute. + */ + /** + * @ignore + * @type {?function(string, Array.)} + */ + onExecute: null, + /** + * A callback function for being notified when the Godot instance quits. + * + * **Note**: This function will not be called if the engine crashes or become unresponsive. + * + * @callback EngineConfig.onExit + * @param {number} status_code The status code returned by Godot on exit. + */ + /** + * @ignore + * @type {?function(number)} + */ + onExit: null, + /** + * A callback function for displaying download progress. + * + * The function is called once per frame while downloading files, so the usage of ``requestAnimationFrame()`` + * is not necessary. + * + * If the callback function receives a total amount of bytes as 0, this means that it is impossible to calculate. + * Possible reasons include: + * + * - Files are delivered with server-side chunked compression + * - Files are delivered with server-side compression on Chromium + * - Not all file downloads have started yet (usually on servers without multi-threading) + * + * @callback EngineConfig.onProgress + * @param {number} current The current amount of downloaded bytes so far. + * @param {number} total The total amount of bytes to be downloaded. + */ + /** + * @ignore + * @type {?function(number, number)} + */ + onProgress: null, + /** + * A callback function for handling the standard output stream. This method should usually only be used in debug pages. + * + * By default, ``console.log()`` is used. + * + * @callback EngineConfig.onPrint + * @param {...*} [var_args] A variadic number of arguments to be printed. + */ + /** + * @ignore + * @type {?function(...*)} + */ + onPrint: function () { + console.log.apply(console, Array.from(arguments)); // eslint-disable-line no-console + }, + /** + * A callback function for handling the standard error stream. This method should usually only be used in debug pages. + * + * By default, ``console.error()`` is used. + * + * @callback EngineConfig.onPrintError + * @param {...*} [var_args] A variadic number of arguments to be printed as errors. + */ + /** + * @ignore + * @type {?function(...*)} + */ + onPrintError: function (var_args) { + console.error.apply(console, Array.from(arguments)); // eslint-disable-line no-console + }, + }; + + /** + * @ignore + * @struct + * @constructor + * @param {EngineConfig} opts + */ + function Config(opts) { + this.update(opts); + } + + Config.prototype = cfg; + + /** + * @ignore + * @param {EngineConfig} opts + */ + Config.prototype.update = function (opts) { + const config = opts || {}; + // NOTE: We must explicitly pass the default, accessing it via + // the key will fail due to closure compiler renames. + function parse(key, def) { + if (typeof (config[key]) === 'undefined') { + return def; + } + return config[key]; + } + // Module config + this.unloadAfterInit = parse('unloadAfterInit', this.unloadAfterInit); + this.onPrintError = parse('onPrintError', this.onPrintError); + this.onPrint = parse('onPrint', this.onPrint); + this.onProgress = parse('onProgress', this.onProgress); + + // Godot config + this.canvas = parse('canvas', this.canvas); + this.executable = parse('executable', this.executable); + this.mainPack = parse('mainPack', this.mainPack); + this.locale = parse('locale', this.locale); + this.canvasResizePolicy = parse('canvasResizePolicy', this.canvasResizePolicy); + this.persistentPaths = parse('persistentPaths', this.persistentPaths); + this.persistentDrops = parse('persistentDrops', this.persistentDrops); + this.experimentalVK = parse('experimentalVK', this.experimentalVK); + this.focusCanvas = parse('focusCanvas', this.focusCanvas); + this.serviceWorker = parse('serviceWorker', this.serviceWorker); + this.gdextensionLibs = parse('gdextensionLibs', this.gdextensionLibs); + this.fileSizes = parse('fileSizes', this.fileSizes); + this.args = parse('args', this.args); + this.onExecute = parse('onExecute', this.onExecute); + this.onExit = parse('onExit', this.onExit); + }; + + /** + * @ignore + * @param {string} loadPath + * @param {Response} response + */ + Config.prototype.getModuleConfig = function (loadPath, response) { + let r = response; + return { + 'print': this.onPrint, + 'printErr': this.onPrintError, + 'thisProgram': this.executable, + 'noExitRuntime': false, + 'dynamicLibraries': [`${loadPath}.side.wasm`], + 'instantiateWasm': function (imports, onSuccess) { + function done(result) { + onSuccess(result['instance'], result['module']); + } + if (typeof (WebAssembly.instantiateStreaming) !== 'undefined') { + WebAssembly.instantiateStreaming(Promise.resolve(r), imports).then(done); + } else { + r.arrayBuffer().then(function (buffer) { + WebAssembly.instantiate(buffer, imports).then(done); + }); + } + r = null; + return {}; + }, + 'locateFile': function (path) { + if (!path.startsWith('godot.')) { + return path; + } else if (path.endsWith('.worker.js')) { + return `${loadPath}.worker.js`; + } else if (path.endsWith('.audio.worklet.js')) { + return `${loadPath}.audio.worklet.js`; + } else if (path.endsWith('.js')) { + return `${loadPath}.js`; + } else if (path.endsWith('.side.wasm')) { + return `${loadPath}.side.wasm`; + } else if (path.endsWith('.wasm')) { + return `${loadPath}.wasm`; + } + return path; + }, + }; + }; + + /** + * @ignore + * @param {function()} cleanup + */ + Config.prototype.getGodotConfig = function (cleanup) { + // Try to find a canvas + if (!(this.canvas instanceof HTMLCanvasElement)) { + const nodes = document.getElementsByTagName('canvas'); + if (nodes.length && nodes[0] instanceof HTMLCanvasElement) { + const first = nodes[0]; + this.canvas = /** @type {!HTMLCanvasElement} */ (first); + } + if (!this.canvas) { + throw new Error('No canvas found in page'); + } + } + // Canvas can grab focus on click, or key events won't work. + if (this.canvas.tabIndex < 0) { + this.canvas.tabIndex = 0; + } + + // Browser locale, or custom one if defined. + let locale = this.locale; + if (!locale) { + locale = navigator.languages ? navigator.languages[0] : navigator.language; + locale = locale.split('.')[0]; + } + locale = locale.replace('-', '_'); + const onExit = this.onExit; + + // Godot configuration. + return { + 'canvas': this.canvas, + 'canvasResizePolicy': this.canvasResizePolicy, + 'locale': locale, + 'persistentDrops': this.persistentDrops, + 'virtualKeyboard': this.experimentalVK, + 'focusCanvas': this.focusCanvas, + 'onExecute': this.onExecute, + 'onExit': function (p_code) { + cleanup(); // We always need to call the cleanup callback to free memory. + if (typeof (onExit) === 'function') { + onExit(p_code); + } + }, + }; + }; + return new Config(initConfig); +}; + +/** + * Projects exported for the Web expose the :js:class:`Engine` class to the JavaScript environment, that allows + * fine control over the engine's start-up process. + * + * This API is built in an asynchronous manner and requires basic understanding + * of `Promises `__. + * + * @module Engine + * @header Web export JavaScript reference + */ +const Engine = (function () { + const preloader = new Preloader(); + + let loadPromise = null; + let loadPath = ''; + let initPromise = null; + + /** + * @classdesc The ``Engine`` class provides methods for loading and starting exported projects on the Web. For default export + * settings, this is already part of the exported HTML page. To understand practical use of the ``Engine`` class, + * see :ref:`Custom HTML page for Web export `. + * + * @description Create a new Engine instance with the given configuration. + * + * @global + * @constructor + * @param {EngineConfig} initConfig The initial config for this instance. + */ + function Engine(initConfig) { // eslint-disable-line no-shadow + this.config = new InternalConfig(initConfig); + this.rtenv = null; + } + + /** + * Load the engine from the specified base path. + * + * @param {string} basePath Base path of the engine to load. + * @param {number=} [size=0] The file size if known. + * @returns {Promise} A Promise that resolves once the engine is loaded. + * + * @function Engine.load + */ + Engine.load = function (basePath, size) { + if (loadPromise == null) { + loadPath = basePath; + loadPromise = preloader.loadPromise(`${loadPath}.wasm`, size, true); + requestAnimationFrame(preloader.animateProgress); + } + return loadPromise; + }; + + /** + * Unload the engine to free memory. + * + * This method will be called automatically depending on the configuration. See :js:attr:`unloadAfterInit`. + * + * @function Engine.unload + */ + Engine.unload = function () { + loadPromise = null; + }; + + /** + * Safe Engine constructor, creates a new prototype for every new instance to avoid prototype pollution. + * @ignore + * @constructor + */ + function SafeEngine(initConfig) { + const proto = /** @lends Engine.prototype */ { + /** + * Initialize the engine instance. Optionally, pass the base path to the engine to load it, + * if it hasn't been loaded yet. See :js:meth:`Engine.load`. + * + * @param {string=} basePath Base path of the engine to load. + * @return {Promise} A ``Promise`` that resolves once the engine is loaded and initialized. + */ + init: function (basePath) { + if (initPromise) { + return initPromise; + } + if (loadPromise == null) { + if (!basePath) { + initPromise = Promise.reject(new Error('A base path must be provided when calling `init` and the engine is not loaded.')); + return initPromise; + } + Engine.load(basePath, this.config.fileSizes[`${basePath}.wasm`]); + } + const me = this; + function doInit(promise) { + // Care! Promise chaining is bogus with old emscripten versions. + // This caused a regression with the Mono build (which uses an older emscripten version). + // Make sure to test that when refactoring. + return new Promise(function (resolve, reject) { + promise.then(function (response) { + const cloned = new Response(response.clone().body, { 'headers': [['content-type', 'application/wasm']] }); + Godot(me.config.getModuleConfig(loadPath, cloned)).then(function (module) { + const paths = me.config.persistentPaths; + module['initFS'](paths).then(function (err) { + me.rtenv = module; + if (me.config.unloadAfterInit) { + Engine.unload(); + } + resolve(); + }); + }); + }); + }); + } + preloader.setProgressFunc(this.config.onProgress); + initPromise = doInit(loadPromise); + return initPromise; + }, + + /** + * Load a file so it is available in the instance's file system once it runs. Must be called **before** starting the + * instance. + * + * If not provided, the ``path`` is derived from the URL of the loaded file. + * + * @param {string|ArrayBuffer} file The file to preload. + * + * If a ``string`` the file will be loaded from that path. + * + * If an ``ArrayBuffer`` or a view on one, the buffer will used as the content of the file. + * + * @param {string=} path Path by which the file will be accessible. Required, if ``file`` is not a string. + * + * @returns {Promise} A Promise that resolves once the file is loaded. + */ + preloadFile: function (file, path) { + return preloader.preload(file, path, this.config.fileSizes[file]); + }, + + /** + * Start the engine instance using the given override configuration (if any). + * :js:meth:`startGame ` can be used in typical cases instead. + * + * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init `. + * The engine must be loaded beforehand. + * + * Fails if a canvas cannot be found on the page, or not specified in the configuration. + * + * @param {EngineConfig} override An optional configuration override. + * @return {Promise} Promise that resolves once the engine started. + */ + start: function (override) { + this.config.update(override); + const me = this; + return me.init().then(function () { + if (!me.rtenv) { + return Promise.reject(new Error('The engine must be initialized before it can be started')); + } + + let config = {}; + try { + config = me.config.getGodotConfig(function () { + me.rtenv = null; + }); + } catch (e) { + return Promise.reject(e); + } + // Godot configuration. + me.rtenv['initConfig'](config); + + // Preload GDExtension libraries. + const libs = []; + if (me.config.gdextensionLibs.length > 0 && !me.rtenv['loadDynamicLibrary']) { + return Promise.reject(new Error('GDExtension libraries are not supported by this engine version. ' + + 'Enable "Extensions Support" for your export preset and/or build your custom template with "dlink_enabled=yes".')); + } + me.config.gdextensionLibs.forEach(function (lib) { + libs.push(me.rtenv['loadDynamicLibrary'](lib, { 'loadAsync': true })); + }); + return Promise.all(libs).then(function () { + return new Promise(function (resolve, reject) { + preloader.preloadedFiles.forEach(function (file) { + me.rtenv['copyToFS'](file.path, file.buffer); + }); + preloader.preloadedFiles.length = 0; // Clear memory + me.rtenv['callMain'](me.config.args); + initPromise = null; + if (me.config.serviceWorker && 'serviceWorker' in navigator) { + navigator.serviceWorker.register(me.config.serviceWorker); + } + resolve(); + }); + }); + }); + }, + + /** + * Start the game instance using the given configuration override (if any). + * + * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init `. + * + * This will load the engine if it is not loaded, and preload the main pck. + * + * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack` + * properties set (normally done by the editor during export). + * + * @param {EngineConfig} override An optional configuration override. + * @return {Promise} Promise that resolves once the game started. + */ + startGame: function (override) { + this.config.update(override); + // Add main-pack argument. + const exe = this.config.executable; + const pack = this.config.mainPack || `${exe}.pck`; + this.config.args = ['--main-pack', pack].concat(this.config.args); + // Start and init with execName as loadPath if not inited. + const me = this; + return Promise.all([ + this.init(exe), + this.preloadFile(pack, pack), + ]).then(function () { + return me.start.apply(me); + }); + }, + + /** + * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system. + * + * @param {string} path The location where the file will be created. + * @param {ArrayBuffer} buffer The content of the file. + */ + copyToFS: function (path, buffer) { + if (this.rtenv == null) { + throw new Error('Engine must be inited before copying files'); + } + this.rtenv['copyToFS'](path, buffer); + }, + + /** + * Request that the current instance quit. + * + * This is akin the user pressing the close button in the window manager, and will + * have no effect if the engine has crashed, or is stuck in a loop. + * + */ + requestQuit: function () { + if (this.rtenv) { + this.rtenv['request_quit'](); + } + }, + }; + + Engine.prototype = proto; + // Closure compiler exported instance methods. + Engine.prototype['init'] = Engine.prototype.init; + Engine.prototype['preloadFile'] = Engine.prototype.preloadFile; + Engine.prototype['start'] = Engine.prototype.start; + Engine.prototype['startGame'] = Engine.prototype.startGame; + Engine.prototype['copyToFS'] = Engine.prototype.copyToFS; + Engine.prototype['requestQuit'] = Engine.prototype.requestQuit; + // Also expose static methods as instance methods + Engine.prototype['load'] = Engine.load; + Engine.prototype['unload'] = Engine.unload; + return new Engine(initConfig); + } + + // Closure compiler exported static methods. + SafeEngine['load'] = Engine.load; + SafeEngine['unload'] = Engine.unload; + + // Feature-detection utilities. + SafeEngine['isWebGLAvailable'] = Features.isWebGLAvailable; + SafeEngine['isFetchAvailable'] = Features.isFetchAvailable; + SafeEngine['isSecureContext'] = Features.isSecureContext; + SafeEngine['isCrossOriginIsolated'] = Features.isCrossOriginIsolated; + SafeEngine['isSharedArrayBufferAvailable'] = Features.isSharedArrayBufferAvailable; + SafeEngine['isAudioWorkletAvailable'] = Features.isAudioWorkletAvailable; + SafeEngine['getMissingFeatures'] = Features.getMissingFeatures; + + return SafeEngine; +}()); +if (typeof window !== 'undefined') { + window['Engine'] = Engine; +} diff --git a/index.pck b/index.pck new file mode 100644 index 0000000000000000000000000000000000000000..2b3b1530701fb91dafcc7185f91f714240f5ca9f GIT binary patch literal 6352 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
    +-ij9xPA7}5`PUD{SbP<{ZQg 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 =1Ged)V=?>%sizo`-!8haQeR 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