diff --git a/docs/assets/nmmo3/game.data b/docs/assets/nmmo3/game.data new file mode 100644 index 0000000..bb55ce6 Binary files /dev/null and b/docs/assets/nmmo3/game.data differ diff --git a/docs/assets/nmmo3/game.html b/docs/assets/nmmo3/game.html new file mode 100644 index 0000000..7d022ab --- /dev/null +++ b/docs/assets/nmmo3/game.html @@ -0,0 +1,89 @@ + + + + + + + raylib web game + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + diff --git a/docs/assets/nmmo3/game.js b/docs/assets/nmmo3/game.js new file mode 100644 index 0000000..f691991 --- /dev/null +++ b/docs/assets/nmmo3/game.js @@ -0,0 +1,11964 @@ +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(moduleArg) => Promise +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof Module != 'undefined' ? Module : {}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == 'object'; +var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != 'undefined'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string' && process.type != 'renderer'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (ENVIRONMENT_IS_NODE) { + // `require()` is no-op in an ESM module, use `createRequire()` to construct + // the require()` function. This is only necessary for multi-environment + // builds, `-sENVIRONMENT=node` emits a static import declaration instead. + // TODO: Swap all `require()`'s with `import()`'s? + +} + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +// include: /tmp/tmpyv5o0oz3.js + + Module['expectedDataFileDownloads'] ??= 0; + Module['expectedDataFileDownloads']++; + (() => { + // Do not attempt to redownload the virtual filesystem data when in a pthread or a Wasm Worker context. + var isPthread = typeof ENVIRONMENT_IS_PTHREAD != 'undefined' && ENVIRONMENT_IS_PTHREAD; + var isWasmWorker = typeof ENVIRONMENT_IS_WASM_WORKER != 'undefined' && ENVIRONMENT_IS_WASM_WORKER; + if (isPthread || isWasmWorker) return; + var isNode = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'; + function loadPackage(metadata) { + + var PACKAGE_PATH = ''; + if (typeof window === 'object') { + PACKAGE_PATH = window['encodeURIComponent'](window.location.pathname.substring(0, window.location.pathname.lastIndexOf('/')) + '/'); + } else if (typeof process === 'undefined' && typeof location !== 'undefined') { + // web worker + PACKAGE_PATH = encodeURIComponent(location.pathname.substring(0, location.pathname.lastIndexOf('/')) + '/'); + } + var PACKAGE_NAME = 'build_web/nmmo3/game.data'; + var REMOTE_PACKAGE_BASE = 'game.data'; + var REMOTE_PACKAGE_NAME = Module['locateFile'] ? Module['locateFile'](REMOTE_PACKAGE_BASE, '') : REMOTE_PACKAGE_BASE; +var REMOTE_PACKAGE_SIZE = metadata['remote_package_size']; + + function fetchRemotePackage(packageName, packageSize, callback, errback) { + if (isNode) { + require('fs').readFile(packageName, (err, contents) => { + if (err) { + errback(err); + } else { + callback(contents.buffer); + } + }); + return; + } + Module['dataFileDownloads'] ??= {}; + fetch(packageName) + .catch((cause) => Promise.reject(new Error(`Network Error: ${packageName}`, {cause}))) // If fetch fails, rewrite the error to include the failing URL & the cause. + .then((response) => { + if (!response.ok) { + return Promise.reject(new Error(`${response.status}: ${response.url}`)); + } + + if (!response.body && response.arrayBuffer) { // If we're using the polyfill, readers won't be available... + return response.arrayBuffer().then(callback); + } + + const reader = response.body.getReader(); + const iterate = () => reader.read().then(handleChunk).catch((cause) => { + return Promise.reject(new Error(`Unexpected error while handling : ${response.url} ${cause}`, {cause})); + }); + + const chunks = []; + const headers = response.headers; + const total = Number(headers.get('Content-Length') ?? packageSize); + let loaded = 0; + + const handleChunk = ({done, value}) => { + if (!done) { + chunks.push(value); + loaded += value.length; + Module['dataFileDownloads'][packageName] = {loaded, total}; + + let totalLoaded = 0; + let totalSize = 0; + + for (const download of Object.values(Module['dataFileDownloads'])) { + totalLoaded += download.loaded; + totalSize += download.total; + } + + Module['setStatus']?.(`Downloading data... (${totalLoaded}/${totalSize})`); + return iterate(); + } else { + const packageData = new Uint8Array(chunks.map((c) => c.length).reduce((a, b) => a + b, 0)); + let offset = 0; + for (const chunk of chunks) { + packageData.set(chunk, offset); + offset += chunk.length; + } + callback(packageData.buffer); + } + }; + + Module['setStatus']?.('Downloading data...'); + return iterate(); + }); + }; + + function handleError(error) { + console.error('package error:', error); + }; + + var fetchedCallback = null; + var fetched = Module['getPreloadedPackage'] ? Module['getPreloadedPackage'](REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE) : null; + + if (!fetched) fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, (data) => { + if (fetchedCallback) { + fetchedCallback(data); + fetchedCallback = null; + } else { + fetched = data; + } + }, handleError); + + function runWithFS(Module) { + + function assert(check, msg) { + if (!check) throw msg + new Error().stack; + } +Module['FS_createPath']("/", "resources", true, true); +Module['FS_createPath']("/resources", "moba", true, true); +Module['FS_createPath']("/resources", "nmmo3", true, true); +Module['FS_createPath']("/resources", "puffer_enduro", true, true); +Module['FS_createPath']("/resources", "robocode", true, true); + + /** @constructor */ + function DataRequest(start, end, audio) { + this.start = start; + this.end = end; + this.audio = audio; + } + DataRequest.prototype = { + requests: {}, + open: function(mode, name) { + this.name = name; + this.requests[name] = this; + Module['addRunDependency'](`fp ${this.name}`); + }, + send: function() {}, + onload: function() { + var byteArray = this.byteArray.subarray(this.start, this.end); + this.finish(byteArray); + }, + finish: function(byteArray) { + var that = this; + // canOwn this data in the filesystem, it is a slide into the heap that will never change + Module['FS_createDataFile'](this.name, null, byteArray, true, true, true); + Module['removeRunDependency'](`fp ${that.name}`); + this.requests[this.name] = null; + } + }; + + var files = metadata['files']; + for (var i = 0; i < files.length; ++i) { + new DataRequest(files[i]['start'], files[i]['end'], files[i]['audio'] || 0).open('GET', files[i]['filename']); + } + + function processPackageData(arrayBuffer) { + assert(arrayBuffer, 'Loading data file failed.'); + assert(arrayBuffer.constructor.name === ArrayBuffer.name, 'bad input to processPackageData'); + var byteArray = new Uint8Array(arrayBuffer); + var curr; + // Reuse the bytearray from the XHR as the source for file reads. + DataRequest.prototype.byteArray = byteArray; + var files = metadata['files']; + for (var i = 0; i < files.length; ++i) { + DataRequest.prototype.requests[files[i].filename].onload(); + } Module['removeRunDependency']('datafile_build_web/nmmo3/game.data'); + + }; + Module['addRunDependency']('datafile_build_web/nmmo3/game.data'); + + Module['preloadResults'] ??= {}; + + Module['preloadResults'][PACKAGE_NAME] = {fromCache: false}; + if (fetched) { + processPackageData(fetched); + fetched = null; + } else { + fetchedCallback = processPackageData; + } + + } + if (Module['calledRun']) { + runWithFS(Module); + } else { + (Module['preRun'] ??= []).push(runWithFS); // FS is not initialized yet, wait for it + } + + } + loadPackage({"files": [{"filename": "/resources/breakout_weights.bin", "start": 0, "end": 592404}, {"filename": "/resources/connect4.pt", "start": 592404, "end": 622798}, {"filename": "/resources/connect4_weights.bin", "start": 622798, "end": 1177326}, {"filename": "/resources/go_weights.bin", "start": 1177326, "end": 2196794}, {"filename": "/resources/moba/bloom_shader_100.fs", "start": 2196794, "end": 2197863}, {"filename": "/resources/moba/bloom_shader_330.fs", "start": 2197863, "end": 2198934}, {"filename": "/resources/moba/dota_map.png", "start": 2198934, "end": 2202630}, {"filename": "/resources/moba/game_map.npy", "start": 2202630, "end": 2219014}, {"filename": "/resources/moba/map_shader_100.fs", "start": 2219014, "end": 2222594}, {"filename": "/resources/moba/map_shader_330.fs", "start": 2222594, "end": 2229171}, {"filename": "/resources/moba/moba_assets.png", "start": 2229171, "end": 2342420}, {"filename": "/resources/moba/moba_weights.bin", "start": 2342420, "end": 3862644}, {"filename": "/resources/nmmo3/ASSETS_LICENSE.md", "start": 3862644, "end": 3863002}, {"filename": "/resources/nmmo3/air_0.png", "start": 3863002, "end": 4132896}, {"filename": "/resources/nmmo3/air_1.png", "start": 4132896, "end": 4403674}, {"filename": "/resources/nmmo3/air_2.png", "start": 4403674, "end": 4672771}, {"filename": "/resources/nmmo3/air_3.png", "start": 4672771, "end": 4944940}, {"filename": "/resources/nmmo3/air_4.png", "start": 4944940, "end": 5210611}, {"filename": "/resources/nmmo3/air_5.png", "start": 5210611, "end": 5476514}, {"filename": "/resources/nmmo3/air_6.png", "start": 5476514, "end": 5740760}, {"filename": "/resources/nmmo3/air_7.png", "start": 5740760, "end": 6005152}, {"filename": "/resources/nmmo3/air_8.png", "start": 6005152, "end": 6271292}, {"filename": "/resources/nmmo3/air_9.png", "start": 6271292, "end": 6536993}, {"filename": "/resources/nmmo3/earth_0.png", "start": 6536993, "end": 6805380}, {"filename": "/resources/nmmo3/earth_1.png", "start": 6805380, "end": 7074795}, {"filename": "/resources/nmmo3/earth_2.png", "start": 7074795, "end": 7342373}, {"filename": "/resources/nmmo3/earth_3.png", "start": 7342373, "end": 7612623}, {"filename": "/resources/nmmo3/earth_4.png", "start": 7612623, "end": 7877695}, {"filename": "/resources/nmmo3/earth_5.png", "start": 7877695, "end": 8143061}, {"filename": "/resources/nmmo3/earth_6.png", "start": 8143061, "end": 8406722}, {"filename": "/resources/nmmo3/earth_7.png", "start": 8406722, "end": 8670493}, {"filename": "/resources/nmmo3/earth_8.png", "start": 8670493, "end": 8935826}, {"filename": "/resources/nmmo3/earth_9.png", "start": 8935826, "end": 9201063}, {"filename": "/resources/nmmo3/fire_0.png", "start": 9201063, "end": 9468932}, {"filename": "/resources/nmmo3/fire_1.png", "start": 9468932, "end": 9738537}, {"filename": "/resources/nmmo3/fire_2.png", "start": 9738537, "end": 10006359}, {"filename": "/resources/nmmo3/fire_3.png", "start": 10006359, "end": 10277525}, {"filename": "/resources/nmmo3/fire_4.png", "start": 10277525, "end": 10542026}, {"filename": "/resources/nmmo3/fire_5.png", "start": 10542026, "end": 10806947}, {"filename": "/resources/nmmo3/fire_6.png", "start": 10806947, "end": 11069895}, {"filename": "/resources/nmmo3/fire_7.png", "start": 11069895, "end": 11333173}, {"filename": "/resources/nmmo3/fire_8.png", "start": 11333173, "end": 11598165}, {"filename": "/resources/nmmo3/fire_9.png", "start": 11598165, "end": 11862881}, {"filename": "/resources/nmmo3/inventory_64.png", "start": 11862881, "end": 11863332}, {"filename": "/resources/nmmo3/inventory_64_press.png", "start": 11863332, "end": 11863785}, {"filename": "/resources/nmmo3/inventory_64_selected.png", "start": 11863785, "end": 11864244}, {"filename": "/resources/nmmo3/items_condensed.png", "start": 11864244, "end": 11884118}, {"filename": "/resources/nmmo3/map_shader_100.fs", "start": 11884118, "end": 11885693}, {"filename": "/resources/nmmo3/map_shader_330.fs", "start": 11885693, "end": 11887371}, {"filename": "/resources/nmmo3/merged_sheet.png", "start": 11887371, "end": 18166704}, {"filename": "/resources/nmmo3/neutral_0.png", "start": 18166704, "end": 18433924}, {"filename": "/resources/nmmo3/neutral_1.png", "start": 18433924, "end": 18701896}, {"filename": "/resources/nmmo3/neutral_2.png", "start": 18701896, "end": 18968151}, {"filename": "/resources/nmmo3/neutral_3.png", "start": 18968151, "end": 19237736}, {"filename": "/resources/nmmo3/neutral_4.png", "start": 19237736, "end": 19501267}, {"filename": "/resources/nmmo3/neutral_5.png", "start": 19501267, "end": 19764999}, {"filename": "/resources/nmmo3/neutral_6.png", "start": 19764999, "end": 20027539}, {"filename": "/resources/nmmo3/neutral_7.png", "start": 20027539, "end": 20290071}, {"filename": "/resources/nmmo3/neutral_8.png", "start": 20290071, "end": 20554487}, {"filename": "/resources/nmmo3/neutral_9.png", "start": 20554487, "end": 20818132}, {"filename": "/resources/nmmo3/nmmo3_help.png", "start": 20818132, "end": 20882792}, {"filename": "/resources/nmmo3/nmmo_1500.bin", "start": 20882792, "end": 25288404}, {"filename": "/resources/nmmo3/nmmo_2025.bin", "start": 25288404, "end": 29694016}, {"filename": "/resources/nmmo3/water_0.png", "start": 29694016, "end": 29963677}, {"filename": "/resources/nmmo3/water_1.png", "start": 29963677, "end": 30234124}, {"filename": "/resources/nmmo3/water_2.png", "start": 30234124, "end": 30502654}, {"filename": "/resources/nmmo3/water_3.png", "start": 30502654, "end": 30774349}, {"filename": "/resources/nmmo3/water_4.png", "start": 30774349, "end": 31039726}, {"filename": "/resources/nmmo3/water_5.png", "start": 31039726, "end": 31305198}, {"filename": "/resources/nmmo3/water_6.png", "start": 31305198, "end": 31569003}, {"filename": "/resources/nmmo3/water_7.png", "start": 31569003, "end": 31833008}, {"filename": "/resources/nmmo3/water_8.png", "start": 31833008, "end": 32098476}, {"filename": "/resources/nmmo3/water_9.png", "start": 32098476, "end": 32363610}, {"filename": "/resources/pong_weights.bin", "start": 32363610, "end": 32898666}, {"filename": "/resources/puffer_enduro/enduro_spritesheet.png", "start": 32898666, "end": 32906151}, {"filename": "/resources/puffer_enduro/enduro_weights.bin", "start": 32906151, "end": 33475023}, {"filename": "/resources/puffers_128.png", "start": 33475023, "end": 33497929}, {"filename": "/resources/robocode/robocode.png", "start": 33497929, "end": 33529167}, {"filename": "/resources/rware_weights.bin", "start": 33529167, "end": 34074983}, {"filename": "/resources/snake_weights.bin", "start": 34074983, "end": 34668411}, {"filename": "/resources/tripletriad_weights.bin", "start": 34668411, "end": 35263931}], "remote_package_size": 35263931}); + + })(); + +// end include: /tmp/tmpyv5o0oz3.js +// include: /tmp/tmp7set6_6d.js + + // All the pre-js content up to here must remain later on, we need to run + // it. + if (Module['$ww'] || (typeof ENVIRONMENT_IS_PTHREAD != 'undefined' && ENVIRONMENT_IS_PTHREAD)) Module['preRun'] = []; + var necessaryPreJSTasks = Module['preRun'].slice(); + // end include: /tmp/tmp7set6_6d.js +// include: /tmp/tmpup0a09lw.js + + if (!Module['preRun']) throw 'Module.preRun should exist because file support used it; did a pre-js delete it?'; + necessaryPreJSTasks.forEach((task) => { + if (Module['preRun'].indexOf(task) < 0) throw 'All preRun tasks that exist before user pre-js code should remain after; did you replace Module or modify Module.preRun?'; + }); + // end include: /tmp/tmpup0a09lw.js + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var readAsync, readBinary; + +if (ENVIRONMENT_IS_NODE) { + if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + var nodeVersion = process.versions.node; + var numericVersion = nodeVersion.split('.').slice(0, 3); + numericVersion = (numericVersion[0] * 10000) + (numericVersion[1] * 100) + (numericVersion[2].split('-')[0] * 1); + var minVersion = 160000; + if (numericVersion < 160000) { + throw new Error('This emscripten-generated code requires node v16.0.0 (detected v' + nodeVersion + ')'); + } + + // These modules will usually be used on Node.js. Load them eagerly to avoid + // the complexity of lazy-loading. + var fs = require('fs'); + var nodePath = require('path'); + + scriptDirectory = __dirname + '/'; + +// include: node_shell_read.js +readBinary = (filename) => { + // We need to re-wrap `file://` strings to URLs. Normalizing isn't + // necessary in that case, the path should already be absolute. + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + var ret = fs.readFileSync(filename); + assert(ret.buffer); + return ret; +}; + +readAsync = (filename, binary = true) => { + // See the comment in the `readBinary` function. + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + return new Promise((resolve, reject) => { + fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => { + if (err) reject(err); + else resolve(binary ? data.buffer : data); + }); + }); +}; +// end include: node_shell_read.js + if (!Module['thisProgram'] && process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, '/'); + } + + arguments_ = process.argv.slice(2); + + if (typeof module != 'undefined') { + module['exports'] = Module; + } + + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow; + }; + +} else +if (ENVIRONMENT_IS_SHELL) { + + if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof WorkerGlobalScope != 'undefined') 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?)'); + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.startsWith('blob:')) { + scriptDirectory = ''; + } else { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/')+1); + } + + if (!(typeof window == 'object' || typeof WorkerGlobalScope != 'undefined')) 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?)'); + + { +// include: web_or_worker_shell_read.js +if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = (url) => { + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use XHR on webview if URL is a file URL. + if (isFileURI(url)) { + return new Promise((resolve, reject) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + resolve(xhr.response); + return; + } + reject(xhr.status); + }; + xhr.onerror = reject; + xhr.send(null); + }); + } + return fetch(url, { credentials: 'same-origin' }) + .then((response) => { + if (response.ok) { + return response.arrayBuffer(); + } + return Promise.reject(new Error(response.status + ' : ' + response.url)); + }) + }; +// end include: web_or_worker_shell_read.js + } +} else +{ + throw new Error('environment detection error'); +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.error.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used. +moduleOverrides = null; +checkIncomingModuleAPI(); + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_'); + +if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram'); + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +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'); +assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)'); +assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); +legacyModuleProp('asm', 'wasmExports'); +legacyModuleProp('readAsync', 'readAsync'); +legacyModuleProp('readBinary', 'readBinary'); +legacyModuleProp('setWindowTitle', 'setWindowTitle'); +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +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 FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js'; +var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js'; +var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js'; +var OPFS = 'OPFS is no longer included by default; build with -lopfs.js'; + +var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js'; + +assert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.'); + +// end include: shell.js + +// include: preamble.js +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary'); + +if (typeof WebAssembly != 'object') { + err('no native wasm support detected'); +} + +// include: base64Utils.js +// Converts a string of base64 into a byte array (Uint8Array). +function intArrayFromBase64(s) { + if (typeof ENVIRONMENT_IS_NODE != 'undefined' && ENVIRONMENT_IS_NODE) { + var buf = Buffer.from(s, 'base64'); + return new Uint8Array(buf.buffer, buf.byteOffset, buf.length); + } + + var decoded = atob(s); + var bytes = new Uint8Array(decoded.length); + for (var i = 0 ; i < decoded.length ; ++i) { + bytes[i] = decoded.charCodeAt(i); + } + return bytes; +} + +// If filename is a base64 data URI, parses and returns data (Buffer on node, +// Uint8Array otherwise). If filename is not a base64 data URI, returns undefined. +function tryParseAsDataURI(filename) { + if (!isDataURI(filename)) { + return; + } + + return intArrayFromBase64(filename.slice(dataURIPrefix.length)); +} +// end include: base64Utils.js +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we +// don't define it at all in release modes. This matches the behaviour of +// MINIMAL_RUNTIME. +// TODO(sbc): Make this the default even without STRICT enabled. +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed' + (text ? ': ' + text : '')); + } +} + +// We used to include malloc/free by default in the past. Show a helpful error in +// builds with assertions. + +// Memory management + +var HEAP, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +// include: runtime_shared.js +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module['HEAP8'] = HEAP8 = new Int8Array(b); + Module['HEAP16'] = HEAP16 = new Int16Array(b); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(b); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(b); + Module['HEAP32'] = HEAP32 = new Int32Array(b); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(b); + Module['HEAPF32'] = HEAPF32 = new Float32Array(b); + Module['HEAPF64'] = HEAPF64 = new Float64Array(b); +} + +// end include: runtime_shared.js +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'); + +// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY +assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'); +assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'); + +// include: runtime_stack_check.js +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + // If the stack ends at address zero we write our cookies 4 bytes into the + // stack. This prevents interference with SAFE_HEAP and ASAN which also + // monitor writes to address zero. + if (max == 0) { + max += 4; + } + // The stack grow downwards towards _emscripten_stack_get_end. + // We write cookies to the final two words in the stack and detect if they are + // ever overwritten. + HEAPU32[((max)>>2)] = 0x02135467;checkInt32(0x02135467); + HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;checkInt32(0x89BACDFE); + // Also test the global address 0 for integrity. + HEAPU32[((0)>>2)] = 1668509029;checkInt32(1668509029); +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + // See writeStackCookie(). + if (max == 0) { + max += 4; + } + var cookie1 = HEAPU32[((max)>>2)]; + var cookie2 = HEAPU32[(((max)+(4))>>2)]; + if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) { + abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`); + } + // Also test the global address 0 for integrity. + if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) { + abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); + } +} +// end include: runtime_stack_check.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +function preRun() { + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + + checkStackCookie(); + + setStackLimits(); + + +if (!Module['noFSInit'] && !FS.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + checkStackCookie(); + + callRuntimeCallbacks(__ATMAIN__); +} + +function postRun() { + checkStackCookie(); + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +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'); +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + + Module['monitorRunDependencies']?.(runDependencies); + + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != 'undefined') { + // Check for missing dependencies every few seconds + 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)'); + } + }, 10000); + } + } else { + err('warning: run dependency added without ID'); + } +} + +function removeRunDependency(id) { + runDependencies--; + + 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(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + Module['onAbort']?.(what); + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + + if (what.indexOf('RuntimeError: unreachable') >= 0) { + what += '. "unreachable" may be due to ASYNCIFY_STACK_SIZE not being large enough (try increasing it)'; + } + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // definition for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// include: URIUtils.js +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +/** + * Indicates whether filename is a base64 data URI. + * @noinline + */ +var isDataURI = (filename) => filename.startsWith(dataURIPrefix); + +/** + * Indicates whether filename is delivered via file protocol (as opposed to http/https) + * @noinline + */ +var isFileURI = (filename) => filename.startsWith('file://'); +// end include: URIUtils.js +function createExportWrapper(name, nargs) { + return (...args) => { + assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`); + var f = wasmExports[name]; + assert(f, `exported native function \`${name}\` not found`); + // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled. + assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`); + return f(...args); + }; +} + +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +function findWasmBinary() { + var f = 'game.wasm'; + if (!isDataURI(f)) { + return locateFile(f); + } + return f; +} + +var wasmBinaryFile; + +function getBinarySync(file) { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw 'both async and sync fetching of the wasm failed'; +} + +function getBinaryPromise(binaryFile) { + // If we don't have the binary yet, load it asynchronously using readAsync. + if (!wasmBinary + ) { + // Fetch the binary using readAsync + return readAsync(binaryFile).then( + (response) => new Uint8Array(/** @type{!ArrayBuffer} */(response)), + // Fall back to getBinarySync if readAsync fails + () => getBinarySync(binaryFile) + ); + } + + // Otherwise, getBinarySync should be able to get it synchronously + return Promise.resolve().then(() => getBinarySync(binaryFile)); +} + +function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then((binary) => { + return WebAssembly.instantiate(binary, imports); + }).then(receiver, (reason) => { + err(`failed to asynchronously prepare wasm: ${reason}`); + + // Warn on some common problems. + 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) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(binaryFile) && + // Avoid instantiateStreaming() on Node.js environment for now, as while + // Node.js v18.1.0 implements it, it does not have a full fetch() + // implementation yet. + // + // Reference: + // https://github.com/emscripten-core/emscripten/pull/16917 + !ENVIRONMENT_IS_NODE && + typeof fetch == 'function') { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, imports); + + return result.then( + callback, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err(`wasm streaming compile failed: ${reason}`); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(binaryFile, imports, callback); + }); + }); + } + return instantiateArrayBuffer(binaryFile, imports, callback); +} + +function getWasmImports() { + // instrumenting imports is used in asyncify in two ways: to add assertions + // that check for proper import use, and for ASYNCIFY=2 we use them to set up + // the Promise API on the import side. + Asyncify.instrumentWasmImports(wasmImports); + // prepare imports + return { + 'env': wasmImports, + 'wasi_snapshot_preview1': wasmImports, + } +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + wasmExports = instance.exports; + + wasmExports = Asyncify.instrumentWasmExports(wasmExports); + + + + wasmMemory = wasmExports['memory']; + + assert(wasmMemory, 'memory not found in wasm exports'); + updateMemoryViews(); + + addOnInit(wasmExports['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + var info = getWasmImports(); + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module['instantiateWasm']) { + try { + return Module['instantiateWasm'](info, receiveInstance); + } catch(e) { + err(`Module.instantiateWasm callback failed with error: ${e}`); + return false; + } + } + + wasmBinaryFile ??= findWasmBinary(); + + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// include: runtime_debug.js +// Endianness check +(() => { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 0x6373; + if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)'; +})(); + +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)'); +} + +function legacyModuleProp(prop, newName, incoming=true) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get() { + let extra = incoming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : ''; + abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra); + + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`); + } +} + +// forcing the filesystem exports a few things by default +function isExportedByForceFilesystem(name) { + return name === 'FS_createPath' || + name === 'FS_createDataFile' || + name === 'FS_createPreloadedFile' || + name === 'FS_unlink' || + name === 'addRunDependency' || + // The old FS has some functionality that WasmFS lacks. + name === 'FS_createLazyFile' || + name === 'FS_createDevice' || + name === 'removeRunDependency'; +} + +/** + * Intercept access to a global symbol. This enables us to give informative + * warnings/errors when folks attempt to use symbols they did not include in + * their build, or no symbols that no longer exist. + */ +function hookGlobalSymbolAccess(sym, func) { + if (typeof globalThis != 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get() { + func(); + return undefined; + } + }); + } +} + +function missingGlobal(sym, msg) { + hookGlobalSymbolAccess(sym, () => { + warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`); + }); +} + +missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer'); +missingGlobal('asm', 'Please use wasmExports instead'); + +function missingLibrarySymbol(sym) { + hookGlobalSymbolAccess(sym, () => { + // Can't `abort()` here because it would break code that does runtime + // checks. e.g. `if (typeof SDL === 'undefined')`. + 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`; + // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in + // library.js, which means $name for a JS name with no prefix, or name + // for a JS name like _name. + 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); + }); + + // Any symbol that is not included from the JS library is also (by definition) + // not exported on the Module object. + unexportedRuntimeSymbol(sym); +} + +function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get() { + var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + abort(msg); + } + }); + } +} + +var MAX_UINT8 = (2 ** 8) - 1; +var MAX_UINT16 = (2 ** 16) - 1; +var MAX_UINT32 = (2 ** 32) - 1; +var MAX_UINT53 = (2 ** 53) - 1; +var MAX_UINT64 = (2 ** 64) - 1; + +var MIN_INT8 = - (2 ** ( 8 - 1)); +var MIN_INT16 = - (2 ** (16 - 1)); +var MIN_INT32 = - (2 ** (32 - 1)); +var MIN_INT53 = - (2 ** (53 - 1)); +var MIN_INT64 = - (2 ** (64 - 1)); + +function checkInt(value, bits, min, max) { + assert(Number.isInteger(Number(value)), `attempt to write non-integer (${value}) into integer heap`); + assert(value <= max, `value (${value}) too large to write as ${bits}-bit value`); + assert(value >= min, `value (${value}) too small to write as ${bits}-bit value`); +} + +var checkInt1 = (value) => checkInt(value, 1, 1); +var checkInt8 = (value) => checkInt(value, 8, MIN_INT8, MAX_UINT8); +var checkInt16 = (value) => checkInt(value, 16, MIN_INT16, MAX_UINT16); +var checkInt32 = (value) => checkInt(value, 32, MIN_INT32, MAX_UINT32); +var checkInt53 = (value) => checkInt(value, 53, MIN_INT53, MAX_UINT53); +var checkInt64 = (value) => checkInt(value, 64, MIN_INT64, MAX_UINT64); + +// Used by XXXXX_DEBUG settings to output debug messages. +function dbg(...args) { + // TODO(sbc): Make this configurable somehow. Its not always convenient for + // logging to show up as warnings. + console.warn(...args); +} +// end include: runtime_debug.js +// === Body === + +function GetWindowInnerWidth() { return window.innerWidth; } +function GetWindowInnerHeight() { return window.innerHeight; } + +// end include: preamble.js + + + class ExitStatus { + name = 'ExitStatus'; + constructor(status) { + this.message = `Program terminated with exit(${status})`; + this.status = status; + } + } + + var callRuntimeCallbacks = (callbacks) => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } + }; + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': return HEAP8[ptr]; + case 'i8': return HEAP8[ptr]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': abort('to do getValue(i64) use WASM_BIGINT'); + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + case '*': return HEAPU32[((ptr)>>2)]; + default: abort(`invalid type for getValue: ${type}`); + } + } + + var noExitRuntime = Module['noExitRuntime'] || true; + + var ptrToString = (ptr) => { + assert(typeof ptr === 'number'); + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + ptr >>>= 0; + return '0x' + ptr.toString(16).padStart(8, '0'); + }; + + var setStackLimits = () => { + var stackLow = _emscripten_stack_get_base(); + var stackHigh = _emscripten_stack_get_end(); + ___set_stack_limits(stackLow, stackHigh); + }; + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': HEAP8[ptr] = value;checkInt8(value); break; + case 'i8': HEAP8[ptr] = value;checkInt8(value); break; + case 'i16': HEAP16[((ptr)>>1)] = value;checkInt16(value); break; + case 'i32': HEAP32[((ptr)>>2)] = value;checkInt32(value); break; + case 'i64': abort('to do setValue(i64) use WASM_BIGINT'); + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + case '*': HEAPU32[((ptr)>>2)] = value; break; + default: abort(`invalid type for setValue: ${type}`); + } + } + + var stackRestore = (val) => __emscripten_stack_restore(val); + + var stackSave = () => _emscripten_stack_get_current(); + + var warnOnce = (text) => { + warnOnce.shown ||= {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text; + err(text); + } + }; + + var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder() : undefined; + + /** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number=} idx + * @param {number=} maxBytesToRead + * @return {string} + */ + var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. Also, use the length info to avoid running tiny + // strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, + // so that undefined/NaN means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ''; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) 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 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + return str; + }; + + /** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index (i.e. maxBytesToRead will not + * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing + * frequent uses of UTF8ToString() with and without maxBytesToRead may throw + * JS JIT optimizations off, so it is worth to consider consistently using one + * @return {string} + */ + var UTF8ToString = (ptr, maxBytesToRead) => { + assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`); + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; + }; + var ___assert_fail = (condition, filename, line, func) => { + abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + }; + + + + var ___handle_stack_overflow = (requested) => { + var base = _emscripten_stack_get_base(); + var end = _emscripten_stack_get_end(); + abort(`stack overflow (Attempt to set SP to ${ptrToString(requested)}` + + `, with stack limits [${ptrToString(end)} - ${ptrToString(base)}` + + ']). If you require more stack space build with -sSTACK_SIZE='); + }; + + var PATH = { + isAbs:(path) => path.charAt(0) === '/', + splitPath:(filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray:(parts, allowAboveRoot) => { + // if the path tries to go above the root, `up` ends up > 0 + 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 the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + }, + normalize:(path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + 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) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename:(path) => { + // EMSCRIPTEN return '/'' for '/', not an empty string + 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:(...paths) => PATH.normalize(paths.join('/')), + join2:(l, r) => PATH.normalize(l + '/' + r), + }; + + var initRandomFill = () => { + if (typeof crypto == 'object' && typeof crypto['getRandomValues'] == 'function') { + // for modern web browsers + return (view) => crypto.getRandomValues(view); + } else + if (ENVIRONMENT_IS_NODE) { + // for nodejs with or without crypto support included + try { + var crypto_module = require('crypto'); + var randomFillSync = crypto_module['randomFillSync']; + if (randomFillSync) { + // nodejs with LTS crypto support + return (view) => crypto_module['randomFillSync'](view); + } + // very old nodejs with the original crypto API + var randomBytes = crypto_module['randomBytes']; + return (view) => ( + view.set(randomBytes(view.byteLength)), + // Return the original view to match modern native implementations. + view + ); + } catch (e) { + // nodejs doesn't have crypto support + } + } + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + abort('no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: (array) => { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };'); + }; + var randomFill = (view) => { + // Lazily init on the first invocation. + return (randomFill = initRandomFill())(view); + }; + + + + var PATH_FS = { + resolve:(...args) => { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? args[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path != 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter((p) => !!p), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + }, + relative:(from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }, + }; + + + + var FS_stdin_getChar_buffer = []; + + var lengthBytesUTF8 = (str) => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); // possibly a lead surrogate + if (c <= 0x7F) { + len++; + } else if (c <= 0x7FF) { + len += 2; + } else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; ++i; + } else { + len += 3; + } + } + return len; + }; + + var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`); + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 0x10FFFF) 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++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; + }; + /** @type {function(string, boolean=, number=)} */ + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + var FS_stdin_getChar = () => { + if (!FS_stdin_getChar_buffer.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + + // For some reason we must suppress a closure warning here, even though + // fd definitely exists on process.stdin, and is even the proper way to + // get the fd of stdin, + // https://github.com/nodejs/help/issues/2136#issuecomment-523649904 + // This started to happen after moving this logic out of library_tty.js, + // so it is related to the surrounding code in some unclear manner. + /** @suppress {missingProperties} */ + var fd = process.stdin.fd; + + try { + bytesRead = fs.readSync(fd, buf, 0, BUFSIZE); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an + // exception, but on other OSes, reading EOF returns 0. Uniformize + // behavior by treating the EOF exception to return 0. + if (e.toString().includes('EOF')) bytesRead = 0; + else throw e; + } + + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString('utf-8'); + } + } else + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else + {} + if (!result) { + return null; + } + FS_stdin_getChar_buffer = intArrayFromString(result, true); + } + return FS_stdin_getChar_buffer.shift(); + }; + var TTY = { + ttys:[], + init() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process.stdin.setEncoding('utf8'); + // } + }, + shutdown() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process.stdin.pause(); + // } + }, + register(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + }, + stream_ops:{ + open(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + }, + close(stream) { + // flush any pending line data + stream.tty.ops.fsync(stream.tty); + }, + fsync(stream) { + stream.tty.ops.fsync(stream.tty); + }, + read(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }, + }, + default_tty_ops:{ + get_char(tty) { + return FS_stdin_getChar(); + }, + put_char(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + }, + fsync(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output)); + tty.output = []; + } + }, + ioctl_tcgets(tty) { + // typical setting + return { + c_iflag: 25856, + c_oflag: 5, + c_cflag: 191, + c_lflag: 35387, + c_cc: [ + 0x03, 0x1c, 0x7f, 0x15, 0x04, 0x00, 0x01, 0x00, 0x11, 0x13, 0x1a, 0x00, + 0x12, 0x0f, 0x17, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + ] + }; + }, + ioctl_tcsets(tty, optional_actions, data) { + // currently just ignore + return 0; + }, + ioctl_tiocgwinsz(tty) { + return [24, 80]; + }, + }, + default_tty1_ops:{ + put_char(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output)); + tty.output = []; + } + }, + }, + }; + + + var zeroMemory = (address, size) => { + HEAPU8.fill(0, address, address + size); + }; + + var alignMemory = (size, alignment) => { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; + }; + var mmapAlloc = (size) => { + abort('internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported'); + }; + var MEMFS = { + ops_table:null, + mount(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + }, + createNode(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + 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; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + 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(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + }, + getFileDataAsTypedArray(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + }, + expandFileStorage(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + }, + resizeFileStorage(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + } + }, + node_ops:{ + getattr(node) { + var attr = {}; + // device numbers reuse inode numbers. + 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); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + }, + setattr(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + }, + lookup(parent, name) { + throw new FS.ErrnoError(44); + }, + mknod(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + }, + rename(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + 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); + } + } + } + // do the internal rewiring + 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; + }, + unlink(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + rmdir(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(node) { + var entries = ['.', '..']; + for (var key of Object.keys(node.contents)) { + entries.push(key); + } + return entries; + }, + symlink(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + }, + readlink(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }, + }, + stream_ops:{ + read(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) { // non-trivial, and typed array + 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(stream, buffer, offset, length, position, canOwn) { + // The data buffer should be a typed array view + assert(!(buffer instanceof ArrayBuffer)); + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + 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) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) { + // Use typed array write which is available. + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek(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(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + }, + mmap(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; + // Only make a new copy when MAP_PRIVATE is specified. + if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) { + // We can't emulate MAP_SHARED when the file is not backed by the + // buffer we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + if (contents) { + // Try to avoid unnecessary slices. + 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); + } + } + HEAP8.set(contents, ptr); + } + } + return { ptr, allocated }; + }, + msync(stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }, + }, + }; + + /** @param {boolean=} noRunDep */ + var asyncLoad = (url, onload, onerror, noRunDep) => { + var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : ''; + readAsync(url).then( + (arrayBuffer) => { + assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, + (err) => { + if (onerror) { + onerror(); + } else { + throw `Loading data file "${url}" failed.`; + } + } + ); + if (dep) addRunDependency(dep); + }; + + + var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => { + FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn); + }; + + var preloadPlugins = Module['preloadPlugins'] || []; + var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => { + // Ensure plugins are ready. + if (typeof Browser != 'undefined') Browser.init(); + + var handled = false; + preloadPlugins.forEach((plugin) => { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, onerror); + handled = true; + } + }); + return handled; + }; + var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency(`cp ${fullname}`); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + preFinish?.(); + if (!dontCreateFile) { + FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + onload?.(); + removeRunDependency(dep); + } + if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => { + onerror?.(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, processData, onerror); + } else { + processData(url); + } + }; + + var 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; + }; + + var FS_getMode = (canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + }; + + + + + + + var strError = (errno) => { + return UTF8ToString(_strerror(errno)); + }; + + var 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 FS = { + root:null, + mounts:[], + devices:{ + }, + streams:[], + nextInode:1, + nameTable:null, + currentPath:"/", + initialized:false, + ignorePermissions:true, + ErrnoError:class extends Error { + name = 'ErrnoError'; + // We set the `name` property to be able to identify `FS.ErrnoError` + // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway. + // - when using PROXYFS, an error can come from an underlying FS + // as different FS objects have their own FS.ErrnoError each, + // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs. + // we'll use the reliable test `err.name == "ErrnoError"` instead + constructor(errno) { + super(runtimeInitialized ? strError(errno) : ''); + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + } + }, + filesystems:null, + syncFSRequests:0, + readFiles:{ + }, + FSStream:class { + shared = {}; + get object() { + return this.node; + } + set object(val) { + this.node = val; + } + get isRead() { + return (this.flags & 2097155) !== 1; + } + get isWrite() { + return (this.flags & 2097155) !== 0; + } + get isAppend() { + return (this.flags & 1024); + } + get flags() { + return this.shared.flags; + } + set flags(val) { + this.shared.flags = val; + } + get position() { + return this.shared.position; + } + set position(val) { + this.shared.position = val; + } + }, + FSNode:class { + node_ops = {}; + stream_ops = {}; + readMode = 292 | 73; + writeMode = 146; + mounted = null; + constructor(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + this.parent = parent; + this.mount = parent.mount; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.rdev = rdev; + } + get read() { + return (this.mode & this.readMode) === this.readMode; + } + set read(val) { + val ? this.mode |= this.readMode : this.mode &= ~this.readMode; + } + get write() { + return (this.mode & this.writeMode) === this.writeMode; + } + set write(val) { + val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode; + } + get isFolder() { + return FS.isDir(this.mode); + } + get isDevice() { + return FS.isChrdev(this.mode); + } + }, + 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) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the absolute path + var parts = path.split('/').filter((p) => !!p); + + // start at the root + 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) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + 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) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + 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); + } + 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; + } + } + // if we failed to find it in the cache, call into the VFS + 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; + } + // return 0 if any user, group or owner bits are set. + 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) { + if (!FS.isDir(dir.mode)) return 54; + 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' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + }, + MAX_OPEN_FDS:4096, + nextfd() { + for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + }, + getStreamChecked(fd) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + return stream; + }, + getStream:(fd) => FS.streams[fd], + createStream(stream, fd = -1) { + assert(fd >= -1); + + // clone it, so we can return an instance of FSStream + stream = Object.assign(new FS.FSStream(), stream); + if (fd == -1) { + fd = FS.nextfd(); + } + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + }, + closeStream(fd) { + FS.streams[fd] = null; + }, + dupStream(origStream, fd = -1) { + var stream = FS.createStream(origStream, fd); + stream.stream_ops?.dup?.(stream); + return stream; + }, + chrdev_stream_ops:{ + open(stream) { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + stream.stream_ops.open?.(stream); + }, + llseek() { + throw new FS.ErrnoError(70); + }, + }, + major:(dev) => ((dev) >> 8), + minor:(dev) => ((dev) & 0xff), + 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(...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); + } + }; + + // sync all mounts + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, + mount(type, opts, mountpoint) { + if (typeof type == 'string') { + // The filesystem was not included, and instead we have an error + // message stored in the variable. + 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; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type, + opts, + mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + 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); + } + + // destroy the nodes for this mount, and all its child mounts + 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; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + 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 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir(path, mode) { + mode = mode !== undefined ? mode : 511 /* 0777 */; + 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 /* 0666 */; + } + 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); + // parents must exist + var lookup, old_dir, new_dir; + + // let the errors from non existent directories percolate up + 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); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + 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 we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + // update old node (we do this here to avoid each backend + // needing to) + old_node.parent = new_dir; + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + 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) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + 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.getStreamChecked(fd); + 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() + // we ignore the uid / gid for now + }); + }, + lchown(path, uid, gid) { + FS.chown(path, uid, gid, true); + }, + fchown(fd, uid, gid) { + var stream = FS.getStreamChecked(fd); + 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.getStreamChecked(fd); + 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; + if ((flags & 64)) { + mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode; + 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) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512) && !created) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node, + path: FS.getPath(node), // we want the absolute path to the node + flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + 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; // free readdir state + 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) { + assert(offset >= 0); + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + }, + write(stream, buffer, offset, length, position, canOwn) { + assert(offset >= 0); + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + 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) { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + 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); + } + if (!length) { + throw new FS.ErrnoError(28); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + }, + msync(stream, buffer, offset, length, mmapFlags) { + assert(offset >= 0); + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + }, + 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); + } 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() { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + llseek: () => 0, + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using err() rather than out() + // so we register a second tty just for it. + 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)); + // setup /dev/[u]random + // use a buffer to avoid overhead of individual crypto calls per byte + 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); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + }, + createSpecialDirectories() { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + 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 /* 0777 */, 73); + node.node_ops = { + lookup(parent, name) { + var fd = +name; + var stream = FS.getStreamChecked(fd); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: () => stream.path }, + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + }, + createStandardStreams(input, output, error) { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (input) { + FS.createDevice('/dev', 'stdin', input); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (output) { + FS.createDevice('/dev', 'stdout', null, output); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (error) { + FS.createDevice('/dev', 'stderr', null, error); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + 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})`); + }, + staticInit() { + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + }, + init(input, output, error) { + assert(!FS.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.initialized = true; + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + input ??= Module['stdin']; + output ??= Module['stdout']; + error ??= Module['stderr']; + + FS.createStandardStreams(input, output, error); + }, + quit() { + FS.initialized = false; + // force-flush all streams, so we get musl std streams printed out + _fflush(0); + // close all of our streams + 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) { + // operate from within the context of the symlink's target + 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) { + // ignore EEXIST + } + 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; + } + // make sure we can write to the file + 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); + } + }, + createDevice(parent, name, input, output) { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS_getMode(!!input, !!output); + FS.createDevice.major ??= 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open(stream) { + stream.seekable = false; + }, + close(stream) { + // flush any pending line data + if (output?.buffer?.length) { + output(10); + } + }, + read(stream, buffer, offset, length, pos /* ignored */) { + 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 { // Command-line. + try { + obj.contents = readBinary(obj.url); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } + }, + createLazyFile(parent, name, url, canRead, canWrite) { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). + // Actual getting is abstracted away for eventual reuse. + class LazyUint8Array { + lengthKnown = false; + chunks = []; // Loaded chunks. Index is the chunk number + 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]; + } + setDataGetter(getter) { + this.getter = getter; + } + cacheLength() { + // Find length + 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; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + 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!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + 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(/** @type{Array} */(xhr.response || [])); + } + return intArrayFromString(xhr.responseText || '', true); + }; + var lazyArray = this; + lazyArray.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + 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) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + 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; + } + get length() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + get chunkSize() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + + 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(); + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = (...args) => { + FS.forceLoadFile(node); + return fn(...args); + }; + }); + 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) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + // use a custom read function + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position) + }; + // use a custom mmap function + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, HEAP8, ptr, length, position); + return { ptr, allocated: true }; + }; + node.stream_ops = stream_ops; + return node; + }, + 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'); + }, + }; + + var SYSCALLS = { + DEFAULT_POLLMASK:5, + calculateAt(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + // relative 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(func, path, buf) { + var stat = func(path); + HEAP32[((buf)>>2)] = stat.dev;checkInt32(stat.dev); + HEAP32[(((buf)+(4))>>2)] = stat.mode;checkInt32(stat.mode); + HEAPU32[(((buf)+(8))>>2)] = stat.nlink;checkInt32(stat.nlink); + HEAP32[(((buf)+(12))>>2)] = stat.uid;checkInt32(stat.uid); + HEAP32[(((buf)+(16))>>2)] = stat.gid;checkInt32(stat.gid); + HEAP32[(((buf)+(20))>>2)] = stat.rdev;checkInt32(stat.rdev); + (tempI64 = [stat.size>>>0,(tempDouble = stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(24))>>2)] = tempI64[0],HEAP32[(((buf)+(28))>>2)] = tempI64[1]);checkInt64(stat.size); + HEAP32[(((buf)+(32))>>2)] = 4096;checkInt32(4096); + HEAP32[(((buf)+(36))>>2)] = stat.blocks;checkInt32(stat.blocks); + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + (tempI64 = [Math.floor(atime / 1000)>>>0,(tempDouble = Math.floor(atime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]);checkInt64(Math.floor(atime / 1000)); + HEAPU32[(((buf)+(48))>>2)] = (atime % 1000) * 1000 * 1000;checkInt32((atime % 1000) * 1000 * 1000); + (tempI64 = [Math.floor(mtime / 1000)>>>0,(tempDouble = Math.floor(mtime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(56))>>2)] = tempI64[0],HEAP32[(((buf)+(60))>>2)] = tempI64[1]);checkInt64(Math.floor(mtime / 1000)); + HEAPU32[(((buf)+(64))>>2)] = (mtime % 1000) * 1000 * 1000;checkInt32((mtime % 1000) * 1000 * 1000); + (tempI64 = [Math.floor(ctime / 1000)>>>0,(tempDouble = Math.floor(ctime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(72))>>2)] = tempI64[0],HEAP32[(((buf)+(76))>>2)] = tempI64[1]);checkInt64(Math.floor(ctime / 1000)); + HEAPU32[(((buf)+(80))>>2)] = (ctime % 1000) * 1000 * 1000;checkInt32((ctime % 1000) * 1000 * 1000); + (tempI64 = [stat.ino>>>0,(tempDouble = stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(88))>>2)] = tempI64[0],HEAP32[(((buf)+(92))>>2)] = tempI64[1]);checkInt64(stat.ino); + return 0; + }, + doMsync(addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + }, + getStreamFromFD(fd) { + var stream = FS.getStreamChecked(fd); + return stream; + }, + varargs:undefined, + getStr(ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, + }; + function ___syscall_faccessat(dirfd, path, amode, flags) { + try { + + path = SYSCALLS.getStr(path); + assert(flags === 0 || flags == 512); + path = SYSCALLS.calculateAt(dirfd, path); + if (amode & ~7) { + // need a valid mode + 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 /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + /** @suppress {duplicate } */ + var syscallGetVarargI = () => { + assert(SYSCALLS.varargs != undefined); + // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number. + var ret = HEAP32[((+SYSCALLS.varargs)>>2)]; + SYSCALLS.varargs += 4; + return ret; + }; + var syscallGetVarargP = syscallGetVarargI; + + + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = syscallGetVarargI(); + if (arg < 0) { + return -28; + } + while (FS.streams[arg]) { + arg++; + } + var newStream; + newStream = FS.dupStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; // FD_CLOEXEC makes no sense for a single process. + case 3: + return stream.flags; + case 4: { + var arg = syscallGetVarargI(); + stream.flags |= arg; + return 0; + } + case 12: { + var arg = syscallGetVarargP(); + var offset = 0; + // We're always unlocked. + HEAP16[(((arg)+(offset))>>1)] = 2;checkInt16(2); + return 0; + } + case 13: + case 14: + return 0; // Pretend that the locking is successful. + } + return -28; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + var 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, HEAPU8, outPtr, maxBytesToWrite); + }; + function ___syscall_getcwd(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_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: { + if (!stream.tty) return -59; + return 0; + } + case 21505: { + if (!stream.tty) return -59; + if (stream.tty.ops.ioctl_tcgets) { + var termios = stream.tty.ops.ioctl_tcgets(stream); + var argp = syscallGetVarargP(); + HEAP32[((argp)>>2)] = termios.c_iflag || 0;checkInt32(termios.c_iflag || 0); + HEAP32[(((argp)+(4))>>2)] = termios.c_oflag || 0;checkInt32(termios.c_oflag || 0); + HEAP32[(((argp)+(8))>>2)] = termios.c_cflag || 0;checkInt32(termios.c_cflag || 0); + HEAP32[(((argp)+(12))>>2)] = termios.c_lflag || 0;checkInt32(termios.c_lflag || 0); + for (var i = 0; i < 32; i++) { + HEAP8[(argp + i)+(17)] = termios.c_cc[i] || 0;checkInt8(termios.c_cc[i] || 0); + } + return 0; + } + return 0; + } + case 21510: + case 21511: + case 21512: { + if (!stream.tty) return -59; + return 0; // no-op, not actually adjusting terminal settings + } + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + if (stream.tty.ops.ioctl_tcsets) { + var argp = syscallGetVarargP(); + var c_iflag = HEAP32[((argp)>>2)]; + var c_oflag = HEAP32[(((argp)+(4))>>2)]; + var c_cflag = HEAP32[(((argp)+(8))>>2)]; + var c_lflag = HEAP32[(((argp)+(12))>>2)]; + var c_cc = [] + for (var i = 0; i < 32; i++) { + c_cc.push(HEAP8[(argp + i)+(17)]); + } + return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc }); + } + return 0; // no-op, not actually adjusting terminal settings + } + case 21519: { + if (!stream.tty) return -59; + var argp = syscallGetVarargP(); + HEAP32[((argp)>>2)] = 0;checkInt32(0); + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; // not supported + } + case 21531: { + var argp = syscallGetVarargP(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + // TODO: in theory we should write to the winsize struct that gets + // passed in, but for now musl doesn't read anything on it + if (!stream.tty) return -59; + if (stream.tty.ops.ioctl_tiocgwinsz) { + var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty); + var argp = syscallGetVarargP(); + HEAP16[((argp)>>1)] = winsize[0];checkInt16(winsize[0]); + HEAP16[(((argp)+(2))>>1)] = winsize[1];checkInt16(winsize[1]); + } + return 0; + } + case 21524: { + // TODO: technically, this ioctl call should change the window size. + // but, since emscripten doesn't have any concept of a terminal window + // yet, we'll just silently throw it away as we do TIOCGWINSZ + if (!stream.tty) return -59; + return 0; + } + case 21515: { + if (!stream.tty) return -59; + return 0; + } + default: return -28; // not supported + } + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? syscallGetVarargI() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return -e.errno; + } + } + + var __abort_js = () => { + abort('native code called abort()'); + }; + + var nowIsMonotonic = 1; + var __emscripten_get_now_is_monotonic = () => nowIsMonotonic; + + var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num); + + var _emscripten_date_now = () => Date.now(); + + var JSEvents = { + memcpy(target, src, size) { + HEAP8.set(HEAP8.subarray(src, src + size), target); + }, + removeAllEventListeners() { + while (JSEvents.eventHandlers.length) { + JSEvents._removeHandler(JSEvents.eventHandlers.length - 1); + } + JSEvents.deferredCalls = []; + }, + inEventHandler:0, + deferredCalls:[], + deferCall(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; + } + // Test if the given call was already queued, and if so, don't add it again. + for (var call of JSEvents.deferredCalls) { + if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) { + return; + } + } + JSEvents.deferredCalls.push({ + targetFunction, + precedence, + argsList + }); + + JSEvents.deferredCalls.sort((x,y) => x.precedence < y.precedence); + }, + removeDeferredCalls(targetFunction) { + JSEvents.deferredCalls = JSEvents.deferredCalls.filter((call) => call.targetFunction != targetFunction); + }, + canPerformEventHandlerRequests() { + if (navigator.userActivation) { + // Verify against transient activation status from UserActivation API + // whether it is possible to perform a request here without needing to defer. See + // https://developer.mozilla.org/en-US/docs/Web/Security/User_activation#transient_activation + // and https://caniuse.com/mdn-api_useractivation + // At the time of writing, Firefox does not support this API: https://bugzilla.mozilla.org/show_bug.cgi?id=1791079 + return navigator.userActivation.isActive; + } + + return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls; + }, + runDeferredCalls() { + if (!JSEvents.canPerformEventHandlerRequests()) { + return; + } + var deferredCalls = JSEvents.deferredCalls; + JSEvents.deferredCalls = []; + for (var call of deferredCalls) { + call.targetFunction(...call.argsList); + } + }, + eventHandlers:[], + removeAllHandlersOnTarget:(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(i) { + var h = JSEvents.eventHandlers[i]; + h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture); + JSEvents.eventHandlers.splice(i, 1); + }, + registerOrRemoveHandler(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; + } + if (eventHandler.callbackfunc) { + eventHandler.eventListenerFunc = function(event) { + // Increment nesting count for the event handler. + ++JSEvents.inEventHandler; + JSEvents.currentEventHandler = eventHandler; + // Process any old deferred calls the user has placed. + JSEvents.runDeferredCalls(); + // Process the actual event, calls back to user C code handler. + eventHandler.handlerFunc(event); + // Process any new deferred calls that were placed right now from this event handler. + JSEvents.runDeferredCalls(); + // Out of event handler - restore nesting count. + --JSEvents.inEventHandler; + }; + + eventHandler.target.addEventListener(eventHandler.eventTypeString, + eventHandler.eventListenerFunc, + eventHandler.useCapture); + JSEvents.eventHandlers.push(eventHandler); + } 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; + }, + getNodeNameForTarget(target) { + if (!target) return ''; + if (target == window) return '#window'; + if (target == screen) return '#screen'; + return target?.nodeName || ''; + }, + fullscreenEnabled() { + return document.fullscreenEnabled + // Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitFullscreenEnabled. + // TODO: If Safari at some point ships with unprefixed version, update the version check above. + || document.webkitFullscreenEnabled + ; + }, + }; + + var maybeCStringToJsString = (cString) => { + // "cString > 2" checks if the input is a number, and isn't of the special + // values we accept here, EMSCRIPTEN_EVENT_TARGET_* (which map to 0, 1, 2). + // In other words, if cString > 2 then it's a pointer to a valid place in + // memory, and points to a C string. + return cString > 2 ? UTF8ToString(cString) : cString; + }; + + /** @type {Object} */ + var specialHTMLTargets = [0, typeof document != 'undefined' ? document : 0, typeof window != 'undefined' ? window : 0]; + var findEventTarget = (target) => { + target = maybeCStringToJsString(target); + var domElement = specialHTMLTargets[target] || (typeof document != 'undefined' ? document.querySelector(target) : undefined); + return domElement; + }; + + var getBoundingClientRect = (e) => specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : {'left':0,'top':0}; + var _emscripten_get_element_css_size = (target, width, height) => { + target = findEventTarget(target); + if (!target) return -4; + + var rect = getBoundingClientRect(target); + HEAPF64[((width)>>3)] = rect.width; + HEAPF64[((height)>>3)] = rect.height; + + return 0; + }; + + + var fillGamepadEventData = (eventStruct, e) => { + HEAPF64[((eventStruct)>>3)] = e.timestamp; + for (var i = 0; i < e.axes.length; ++i) { + HEAPF64[(((eventStruct+i*8)+(16))>>3)] = e.axes[i]; + } + for (var i = 0; i < e.buttons.length; ++i) { + if (typeof e.buttons[i] == 'object') { + HEAPF64[(((eventStruct+i*8)+(528))>>3)] = e.buttons[i].value; + } else { + HEAPF64[(((eventStruct+i*8)+(528))>>3)] = e.buttons[i]; + } + } + for (var i = 0; i < e.buttons.length; ++i) { + if (typeof e.buttons[i] == 'object') { + HEAP8[(eventStruct+i)+(1040)] = e.buttons[i].pressed;checkInt8(e.buttons[i].pressed); + } else { + // Assigning a boolean to HEAP32, that's ok, but Closure would like to warn about it: + /** @suppress {checkTypes} */ + HEAP8[(eventStruct+i)+(1040)] = e.buttons[i] == 1;checkInt8(e.buttons[i] == 1); + } + } + HEAP8[(eventStruct)+(1104)] = e.connected;checkInt8(e.connected); + HEAP32[(((eventStruct)+(1108))>>2)] = e.index;checkInt32(e.index); + HEAP32[(((eventStruct)+(8))>>2)] = e.axes.length;checkInt32(e.axes.length); + HEAP32[(((eventStruct)+(12))>>2)] = e.buttons.length;checkInt32(e.buttons.length); + stringToUTF8(e.id, eventStruct + 1112, 64); + stringToUTF8(e.mapping, eventStruct + 1176, 64); + }; + var _emscripten_get_gamepad_status = (index, gamepadState) => { + if (!JSEvents.lastGamepadState) throw 'emscripten_get_gamepad_status() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!'; + // INVALID_PARAM is returned on a Gamepad index that never was there. + if (index < 0 || index >= JSEvents.lastGamepadState.length) return -5; + + // NO_DATA is returned on a Gamepad index that was removed. + // For previously disconnected gamepads there should be an empty slot (null/undefined/false) at the index. + // This is because gamepads must keep their original position in the array. + // For example, removing the first of two gamepads produces [null/undefined/false, gamepad]. + if (!JSEvents.lastGamepadState[index]) return -7; + + fillGamepadEventData(gamepadState, JSEvents.lastGamepadState[index]); + return 0; + }; + + var _emscripten_get_now = () => performance.now(); + + var _emscripten_get_num_gamepads = () => { + if (!JSEvents.lastGamepadState) throw 'emscripten_get_num_gamepads() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!'; + // N.B. Do not call emscripten_get_num_gamepads() unless having first called emscripten_sample_gamepad_data(), and that has returned EMSCRIPTEN_RESULT_SUCCESS. + // Otherwise the following line will throw an exception. + return JSEvents.lastGamepadState.length; + }; + + var GLctx; + + var webgl_enable_ANGLE_instanced_arrays = (ctx) => { + // Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2. + var ext = ctx.getExtension('ANGLE_instanced_arrays'); + // Because this extension is a core function in WebGL 2, assign the extension entry points in place of + // where the core functions will reside in WebGL 2. This way the calling code can call these without + // having to dynamically branch depending if running against WebGL 1 or WebGL 2. + if (ext) { + ctx['vertexAttribDivisor'] = (index, divisor) => ext['vertexAttribDivisorANGLE'](index, divisor); + ctx['drawArraysInstanced'] = (mode, first, count, primcount) => ext['drawArraysInstancedANGLE'](mode, first, count, primcount); + ctx['drawElementsInstanced'] = (mode, count, type, indices, primcount) => ext['drawElementsInstancedANGLE'](mode, count, type, indices, primcount); + return 1; + } + }; + + var webgl_enable_OES_vertex_array_object = (ctx) => { + // Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2. + var ext = ctx.getExtension('OES_vertex_array_object'); + if (ext) { + ctx['createVertexArray'] = () => ext['createVertexArrayOES'](); + ctx['deleteVertexArray'] = (vao) => ext['deleteVertexArrayOES'](vao); + ctx['bindVertexArray'] = (vao) => ext['bindVertexArrayOES'](vao); + ctx['isVertexArray'] = (vao) => ext['isVertexArrayOES'](vao); + return 1; + } + }; + + var webgl_enable_WEBGL_draw_buffers = (ctx) => { + // Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2. + var ext = ctx.getExtension('WEBGL_draw_buffers'); + if (ext) { + ctx['drawBuffers'] = (n, bufs) => ext['drawBuffersWEBGL'](n, bufs); + return 1; + } + }; + + var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance = (ctx) => + // Closure is expected to be allowed to minify the '.dibvbi' property, so not accessing it quoted. + !!(ctx.dibvbi = ctx.getExtension('WEBGL_draw_instanced_base_vertex_base_instance')); + + var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance = (ctx) => { + // Closure is expected to be allowed to minify the '.mdibvbi' property, so not accessing it quoted. + return !!(ctx.mdibvbi = ctx.getExtension('WEBGL_multi_draw_instanced_base_vertex_base_instance')); + }; + + var webgl_enable_EXT_polygon_offset_clamp = (ctx) => { + return !!(ctx.extPolygonOffsetClamp = ctx.getExtension('EXT_polygon_offset_clamp')); + }; + + var webgl_enable_EXT_clip_control = (ctx) => { + return !!(ctx.extClipControl = ctx.getExtension('EXT_clip_control')); + }; + + var webgl_enable_WEBGL_polygon_mode = (ctx) => { + return !!(ctx.webglPolygonMode = ctx.getExtension('WEBGL_polygon_mode')); + }; + + var webgl_enable_WEBGL_multi_draw = (ctx) => { + // Closure is expected to be allowed to minify the '.multiDrawWebgl' property, so not accessing it quoted. + return !!(ctx.multiDrawWebgl = ctx.getExtension('WEBGL_multi_draw')); + }; + + var getEmscriptenSupportedExtensions = (ctx) => { + // Restrict the list of advertised extensions to those that we actually + // support. + var supportedExtensions = [ + // WebGL 1 extensions + 'ANGLE_instanced_arrays', + 'EXT_blend_minmax', + 'EXT_disjoint_timer_query', + 'EXT_frag_depth', + 'EXT_shader_texture_lod', + 'EXT_sRGB', + 'OES_element_index_uint', + 'OES_fbo_render_mipmap', + 'OES_standard_derivatives', + 'OES_texture_float', + 'OES_texture_half_float', + 'OES_texture_half_float_linear', + 'OES_vertex_array_object', + 'WEBGL_color_buffer_float', + 'WEBGL_depth_texture', + 'WEBGL_draw_buffers', + // WebGL 2 extensions + 'EXT_color_buffer_float', + 'EXT_conservative_depth', + 'EXT_disjoint_timer_query_webgl2', + 'EXT_texture_norm16', + 'NV_shader_noperspective_interpolation', + 'WEBGL_clip_cull_distance', + // WebGL 1 and WebGL 2 extensions + 'EXT_clip_control', + 'EXT_color_buffer_half_float', + 'EXT_depth_clamp', + 'EXT_float_blend', + 'EXT_polygon_offset_clamp', + 'EXT_texture_compression_bptc', + 'EXT_texture_compression_rgtc', + 'EXT_texture_filter_anisotropic', + 'KHR_parallel_shader_compile', + 'OES_texture_float_linear', + 'WEBGL_blend_func_extended', + 'WEBGL_compressed_texture_astc', + 'WEBGL_compressed_texture_etc', + 'WEBGL_compressed_texture_etc1', + 'WEBGL_compressed_texture_s3tc', + 'WEBGL_compressed_texture_s3tc_srgb', + 'WEBGL_debug_renderer_info', + 'WEBGL_debug_shaders', + 'WEBGL_lose_context', + 'WEBGL_multi_draw', + 'WEBGL_polygon_mode' + ]; + // .getSupportedExtensions() can return null if context is lost, so coerce to empty array. + return (ctx.getSupportedExtensions() || []).filter(ext => supportedExtensions.includes(ext)); + }; + + + var GL = { + counter:1, + buffers:[], + programs:[], + framebuffers:[], + renderbuffers:[], + textures:[], + shaders:[], + vaos:[], + contexts:[], + offscreenCanvases:{ + }, + queries:[], + samplers:[], + transformFeedbacks:[], + syncs:[], + stringCache:{ + }, + stringiCache:{ + }, + unpackAlignment:4, + unpackRowLength:0, + recordError:(errorCode) => { + if (!GL.lastError) { + GL.lastError = errorCode; + } + }, + getNewId:(table) => { + var ret = GL.counter++; + for (var i = table.length; i < ret; i++) { + table[i] = null; + } + return ret; + }, + genObject:(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(0x502 /* GL_INVALID_OPERATION */); + } + HEAP32[(((buffers)+(i*4))>>2)] = id;checkInt32(id); + } + }, + getSource:(shader, count, string, length) => { + var source = ''; + for (var i = 0; i < count; ++i) { + var len = length ? HEAPU32[(((length)+(i*4))>>2)] : undefined; + source += UTF8ToString(HEAPU32[(((string)+(i*4))>>2)], len); + } + return source; + }, + createContext:(/** @type {HTMLCanvasElement} */ canvas, webGLContextAttributes) => { + + // BUG: Workaround Safari WebGL issue: After successfully acquiring WebGL + // context on a canvas, calling .getContext() will always return that + // context independent of which 'webgl' or 'webgl2' + // context version was passed. See: + // https://bugs.webkit.org/show_bug.cgi?id=222758 + // and: + // https://github.com/emscripten-core/emscripten/issues/13295. + // TODO: Once the bug is fixed and shipped in Safari, adjust the Safari + // version field in above check. + if (!canvas.getContextSafariWebGL2Fixed) { + canvas.getContextSafariWebGL2Fixed = canvas.getContext; + /** @type {function(this:HTMLCanvasElement, string, (Object|null)=): (Object|null)} */ + function fixedGetContext(ver, attrs) { + var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs); + return ((ver == 'webgl') == (gl instanceof WebGLRenderingContext)) ? gl : null; + } + canvas.getContext = fixedGetContext; + } + + var ctx = + (webGLContextAttributes.majorVersion > 1) + ? + canvas.getContext("webgl2", webGLContextAttributes) + : + (canvas.getContext("webgl", webGLContextAttributes) + // https://caniuse.com/#feat=webgl + ); + + if (!ctx) return 0; + + var handle = GL.registerContext(ctx, webGLContextAttributes); + + return handle; + }, + registerContext:(ctx, webGLContextAttributes) => { + // without pthreads a context is just an integer ID + var handle = GL.getNewId(GL.contexts); + + var context = { + handle, + attributes: webGLContextAttributes, + version: webGLContextAttributes.majorVersion, + GLctx: ctx + }; + + // Store the created context object so that we can access the context + // given a canvas without having to pass the parameters again. + if (ctx.canvas) ctx.canvas.GLctxObject = context; + GL.contexts[handle] = context; + if (typeof webGLContextAttributes.enableExtensionsByDefault == 'undefined' || webGLContextAttributes.enableExtensionsByDefault) { + GL.initExtensions(context); + } + + return handle; + }, + makeContextCurrent:(contextHandle) => { + + // Active Emscripten GL layer context object. + GL.currentContext = GL.contexts[contextHandle]; + // Active WebGL context object. + Module.ctx = GLctx = GL.currentContext?.GLctx; + return !(contextHandle && !GLctx); + }, + getContext:(contextHandle) => { + return GL.contexts[contextHandle]; + }, + deleteContext:(contextHandle) => { + if (GL.currentContext === GL.contexts[contextHandle]) { + GL.currentContext = null; + } + if (typeof JSEvents == 'object') { + // Release all JS event handlers on the DOM element that the GL context is + // associated with since the context is now deleted. + JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); + } + // Make sure the canvas object no longer refers to the context object so + // there are no GC surprises. + if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) { + GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; + } + GL.contexts[contextHandle] = null; + }, + initExtensions:(context) => { + // If this function is called without a specific context object, init the + // extensions of the currently active context. + context ||= GL.currentContext; + + if (context.initExtensionsDone) return; + context.initExtensionsDone = true; + + var GLctx = context.GLctx; + + // Detect the presence of a few extensions manually, ction GL interop + // layer itself will need to know if they exist. + + // Extensions that are available in both WebGL 1 and WebGL 2 + webgl_enable_WEBGL_multi_draw(GLctx); + webgl_enable_EXT_polygon_offset_clamp(GLctx); + webgl_enable_EXT_clip_control(GLctx); + webgl_enable_WEBGL_polygon_mode(GLctx); + // Extensions that are only available in WebGL 1 (the calls will be no-ops + // if called on a WebGL 2 context active) + webgl_enable_ANGLE_instanced_arrays(GLctx); + webgl_enable_OES_vertex_array_object(GLctx); + webgl_enable_WEBGL_draw_buffers(GLctx); + // Extensions that are available from WebGL >= 2 (no-op if called on a WebGL 1 context active) + webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx); + webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx); + + // On WebGL 2, EXT_disjoint_timer_query is replaced with an alternative + // that's based on core APIs, and exposes only the queryCounterEXT() + // entrypoint. + if (context.version >= 2) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2"); + } + + // However, Firefox exposes the WebGL 1 version on WebGL 2 as well and + // thus we look for the WebGL 1 version again if the WebGL 2 version + // isn't present. https://bugzilla.mozilla.org/show_bug.cgi?id=1328882 + if (context.version < 2 || !GLctx.disjointTimerQueryExt) + { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query"); + } + + getEmscriptenSupportedExtensions(GLctx).forEach((ext) => { + // WEBGL_lose_context, WEBGL_debug_renderer_info and WEBGL_debug_shaders + // are not enabled by default. + if (!ext.includes('lose_context') && !ext.includes('debug')) { + // Call .getExtension() to enable that extension permanently. + GLctx.getExtension(ext); + } + }); + }, + }; + /** @suppress {duplicate } */ + var _glActiveTexture = (x0) => GLctx.activeTexture(x0); + var _emscripten_glActiveTexture = _glActiveTexture; + + /** @suppress {duplicate } */ + var _glAttachShader = (program, shader) => { + GLctx.attachShader(GL.programs[program], GL.shaders[shader]); + }; + var _emscripten_glAttachShader = _glAttachShader; + + /** @suppress {duplicate } */ + var _glBeginQuery = (target, id) => { + GLctx.beginQuery(target, GL.queries[id]); + }; + var _emscripten_glBeginQuery = _glBeginQuery; + + /** @suppress {duplicate } */ + var _glBeginQueryEXT = (target, id) => { + GLctx.disjointTimerQueryExt['beginQueryEXT'](target, GL.queries[id]); + }; + var _emscripten_glBeginQueryEXT = _glBeginQueryEXT; + + /** @suppress {duplicate } */ + var _glBeginTransformFeedback = (x0) => GLctx.beginTransformFeedback(x0); + var _emscripten_glBeginTransformFeedback = _glBeginTransformFeedback; + + + /** @suppress {duplicate } */ + var _glBindAttribLocation = (program, index, name) => { + GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name)); + }; + var _emscripten_glBindAttribLocation = _glBindAttribLocation; + + /** @suppress {duplicate } */ + var _glBindBuffer = (target, buffer) => { + + if (target == 0x88EB /*GL_PIXEL_PACK_BUFFER*/) { + // In WebGL 2 glReadPixels entry point, we need to use a different WebGL 2 + // API function call when a buffer is bound to + // GL_PIXEL_PACK_BUFFER_BINDING point, so must keep track whether that + // binding point is non-null to know what is the proper API function to + // call. + GLctx.currentPixelPackBufferBinding = buffer; + } else if (target == 0x88EC /*GL_PIXEL_UNPACK_BUFFER*/) { + // In WebGL 2 gl(Compressed)Tex(Sub)Image[23]D entry points, we need to + // use a different WebGL 2 API function call when a buffer is bound to + // GL_PIXEL_UNPACK_BUFFER_BINDING point, so must keep track whether that + // binding point is non-null to know what is the proper API function to + // call. + GLctx.currentPixelUnpackBufferBinding = buffer; + } + GLctx.bindBuffer(target, GL.buffers[buffer]); + }; + var _emscripten_glBindBuffer = _glBindBuffer; + + /** @suppress {duplicate } */ + var _glBindBufferBase = (target, index, buffer) => { + GLctx.bindBufferBase(target, index, GL.buffers[buffer]); + }; + var _emscripten_glBindBufferBase = _glBindBufferBase; + + /** @suppress {duplicate } */ + var _glBindBufferRange = (target, index, buffer, offset, ptrsize) => { + GLctx.bindBufferRange(target, index, GL.buffers[buffer], offset, ptrsize); + }; + var _emscripten_glBindBufferRange = _glBindBufferRange; + + /** @suppress {duplicate } */ + var _glBindFramebuffer = (target, framebuffer) => { + + GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]); + + }; + var _emscripten_glBindFramebuffer = _glBindFramebuffer; + + /** @suppress {duplicate } */ + var _glBindRenderbuffer = (target, renderbuffer) => { + GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]); + }; + var _emscripten_glBindRenderbuffer = _glBindRenderbuffer; + + /** @suppress {duplicate } */ + var _glBindSampler = (unit, sampler) => { + GLctx.bindSampler(unit, GL.samplers[sampler]); + }; + var _emscripten_glBindSampler = _glBindSampler; + + /** @suppress {duplicate } */ + var _glBindTexture = (target, texture) => { + GLctx.bindTexture(target, GL.textures[texture]); + }; + var _emscripten_glBindTexture = _glBindTexture; + + /** @suppress {duplicate } */ + var _glBindTransformFeedback = (target, id) => { + GLctx.bindTransformFeedback(target, GL.transformFeedbacks[id]); + }; + var _emscripten_glBindTransformFeedback = _glBindTransformFeedback; + + /** @suppress {duplicate } */ + var _glBindVertexArray = (vao) => { + GLctx.bindVertexArray(GL.vaos[vao]); + }; + var _emscripten_glBindVertexArray = _glBindVertexArray; + + + /** @suppress {duplicate } */ + var _glBindVertexArrayOES = _glBindVertexArray; + var _emscripten_glBindVertexArrayOES = _glBindVertexArrayOES; + + /** @suppress {duplicate } */ + var _glBlendColor = (x0, x1, x2, x3) => GLctx.blendColor(x0, x1, x2, x3); + var _emscripten_glBlendColor = _glBlendColor; + + /** @suppress {duplicate } */ + var _glBlendEquation = (x0) => GLctx.blendEquation(x0); + var _emscripten_glBlendEquation = _glBlendEquation; + + /** @suppress {duplicate } */ + var _glBlendEquationSeparate = (x0, x1) => GLctx.blendEquationSeparate(x0, x1); + var _emscripten_glBlendEquationSeparate = _glBlendEquationSeparate; + + /** @suppress {duplicate } */ + var _glBlendFunc = (x0, x1) => GLctx.blendFunc(x0, x1); + var _emscripten_glBlendFunc = _glBlendFunc; + + /** @suppress {duplicate } */ + var _glBlendFuncSeparate = (x0, x1, x2, x3) => GLctx.blendFuncSeparate(x0, x1, x2, x3); + var _emscripten_glBlendFuncSeparate = _glBlendFuncSeparate; + + /** @suppress {duplicate } */ + var _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; + + /** @suppress {duplicate } */ + var _glBufferData = (target, size, data, usage) => { + + if (GL.currentContext.version >= 2) { + // If size is zero, WebGL would interpret uploading the whole input + // arraybuffer (starting from given offset), which would not make sense in + // WebAssembly, so avoid uploading if size is zero. However we must still + // call bufferData to establish a backing storage of zero bytes. + if (data && size) { + GLctx.bufferData(target, HEAPU8, usage, data, size); + } else { + GLctx.bufferData(target, size, usage); + } + return; + } + // N.b. here first form specifies a heap subarray, second form an integer + // size, so the ?: code here is polymorphic. It is advised to avoid + // randomly mixing both uses in calling code, to avoid any potential JS + // engine JIT issues. + GLctx.bufferData(target, data ? HEAPU8.subarray(data, data+size) : size, usage); + }; + var _emscripten_glBufferData = _glBufferData; + + /** @suppress {duplicate } */ + var _glBufferSubData = (target, offset, size, data) => { + if (GL.currentContext.version >= 2) { + size && GLctx.bufferSubData(target, offset, HEAPU8, data, size); + return; + } + GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data+size)); + }; + var _emscripten_glBufferSubData = _glBufferSubData; + + /** @suppress {duplicate } */ + var _glCheckFramebufferStatus = (x0) => GLctx.checkFramebufferStatus(x0); + var _emscripten_glCheckFramebufferStatus = _glCheckFramebufferStatus; + + /** @suppress {duplicate } */ + var _glClear = (x0) => GLctx.clear(x0); + var _emscripten_glClear = _glClear; + + /** @suppress {duplicate } */ + var _glClearBufferfi = (x0, x1, x2, x3) => GLctx.clearBufferfi(x0, x1, x2, x3); + var _emscripten_glClearBufferfi = _glClearBufferfi; + + /** @suppress {duplicate } */ + var _glClearBufferfv = (buffer, drawbuffer, value) => { + + GLctx.clearBufferfv(buffer, drawbuffer, HEAPF32, ((value)>>2)); + }; + var _emscripten_glClearBufferfv = _glClearBufferfv; + + /** @suppress {duplicate } */ + var _glClearBufferiv = (buffer, drawbuffer, value) => { + + GLctx.clearBufferiv(buffer, drawbuffer, HEAP32, ((value)>>2)); + }; + var _emscripten_glClearBufferiv = _glClearBufferiv; + + /** @suppress {duplicate } */ + var _glClearBufferuiv = (buffer, drawbuffer, value) => { + + GLctx.clearBufferuiv(buffer, drawbuffer, HEAPU32, ((value)>>2)); + }; + var _emscripten_glClearBufferuiv = _glClearBufferuiv; + + /** @suppress {duplicate } */ + var _glClearColor = (x0, x1, x2, x3) => GLctx.clearColor(x0, x1, x2, x3); + var _emscripten_glClearColor = _glClearColor; + + /** @suppress {duplicate } */ + var _glClearDepthf = (x0) => GLctx.clearDepth(x0); + var _emscripten_glClearDepthf = _glClearDepthf; + + /** @suppress {duplicate } */ + var _glClearStencil = (x0) => GLctx.clearStencil(x0); + var _emscripten_glClearStencil = _glClearStencil; + + var convertI32PairToI53 = (lo, hi) => { + // This function should not be getting called with too large unsigned numbers + // in high part (if hi >= 0x7FFFFFFFF, one should have been calling + // convertU32PairToI53()) + assert(hi === (hi|0)); + return (lo >>> 0) + hi * 4294967296; + }; + /** @suppress {duplicate } */ + var _glClientWaitSync = (sync, flags, timeout_low, timeout_high) => { + // WebGL2 vs GLES3 differences: in GLES3, the timeout parameter is a uint64, where 0xFFFFFFFFFFFFFFFFULL means GL_TIMEOUT_IGNORED. + // In JS, there's no 64-bit value types, so instead timeout is taken to be signed, and GL_TIMEOUT_IGNORED is given value -1. + // Inherently the value accepted in the timeout is lossy, and can't take in arbitrary u64 bit pattern (but most likely doesn't matter) + // See https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15 + var timeout = convertI32PairToI53(timeout_low, timeout_high); + return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout); + }; + var _emscripten_glClientWaitSync = _glClientWaitSync; + + /** @suppress {duplicate } */ + var _glClipControlEXT = (origin, depth) => { + GLctx.extClipControl['clipControlEXT'](origin, depth); + }; + var _emscripten_glClipControlEXT = _glClipControlEXT; + + /** @suppress {duplicate } */ + var _glColorMask = (red, green, blue, alpha) => { + GLctx.colorMask(!!red, !!green, !!blue, !!alpha); + }; + var _emscripten_glColorMask = _glColorMask; + + /** @suppress {duplicate } */ + var _glCompileShader = (shader) => { + GLctx.compileShader(GL.shaders[shader]); + }; + var _emscripten_glCompileShader = _glCompileShader; + + /** @suppress {duplicate } */ + var _glCompressedTexImage2D = (target, level, internalFormat, width, height, border, imageSize, data) => { + // `data` may be null here, which means "allocate uniniitalized space but + // don't upload" in GLES parlance, but `compressedTexImage2D` requires the + // final data parameter, so we simply pass a heap view starting at zero + // effectively uploading whatever happens to be near address zero. See + // https://github.com/emscripten-core/emscripten/issues/19300. + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding || !imageSize) { + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); + return; + } + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8, data, imageSize); + return; + } + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8.subarray((data), data+imageSize)); + }; + var _emscripten_glCompressedTexImage2D = _glCompressedTexImage2D; + + /** @suppress {duplicate } */ + var _glCompressedTexImage3D = (target, level, internalFormat, width, height, depth, border, imageSize, data) => { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.compressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); + } else { + GLctx.compressedTexImage3D(target, level, internalFormat, width, height, depth, border, HEAPU8, data, imageSize); + } + }; + var _emscripten_glCompressedTexImage3D = _glCompressedTexImage3D; + + /** @suppress {duplicate } */ + var _glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding || !imageSize) { + GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); + return; + } + GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize); + return; + } + GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8.subarray((data), data+imageSize)); + }; + var _emscripten_glCompressedTexSubImage2D = _glCompressedTexSubImage2D; + + /** @suppress {duplicate } */ + var _glCompressedTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) => { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + } else { + GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize); + } + }; + var _emscripten_glCompressedTexSubImage3D = _glCompressedTexSubImage3D; + + /** @suppress {duplicate } */ + var _glCopyBufferSubData = (x0, x1, x2, x3, x4) => GLctx.copyBufferSubData(x0, x1, x2, x3, x4); + var _emscripten_glCopyBufferSubData = _glCopyBufferSubData; + + /** @suppress {duplicate } */ + var _glCopyTexImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7); + var _emscripten_glCopyTexImage2D = _glCopyTexImage2D; + + /** @suppress {duplicate } */ + var _glCopyTexSubImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7); + var _emscripten_glCopyTexSubImage2D = _glCopyTexSubImage2D; + + /** @suppress {duplicate } */ + var _glCopyTexSubImage3D = (x0, x1, x2, x3, x4, x5, x6, x7, x8) => GLctx.copyTexSubImage3D(x0, x1, x2, x3, x4, x5, x6, x7, x8); + var _emscripten_glCopyTexSubImage3D = _glCopyTexSubImage3D; + + /** @suppress {duplicate } */ + var _glCreateProgram = () => { + var id = GL.getNewId(GL.programs); + var program = GLctx.createProgram(); + // Store additional information needed for each shader program: + program.name = id; + // Lazy cache results of + // glGetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH/GL_ACTIVE_ATTRIBUTE_MAX_LENGTH/GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH) + program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0; + program.uniformIdCounter = 1; + GL.programs[id] = program; + return id; + }; + var _emscripten_glCreateProgram = _glCreateProgram; + + /** @suppress {duplicate } */ + var _glCreateShader = (shaderType) => { + var id = GL.getNewId(GL.shaders); + GL.shaders[id] = GLctx.createShader(shaderType); + + return id; + }; + var _emscripten_glCreateShader = _glCreateShader; + + /** @suppress {duplicate } */ + var _glCullFace = (x0) => GLctx.cullFace(x0); + var _emscripten_glCullFace = _glCullFace; + + /** @suppress {duplicate } */ + var _glDeleteBuffers = (n, buffers) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((buffers)+(i*4))>>2)]; + var buffer = GL.buffers[id]; + + // From spec: "glDeleteBuffers silently ignores 0's and names that do not + // correspond to existing buffer objects." + 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; + + /** @suppress {duplicate } */ + var _glDeleteFramebuffers = (n, framebuffers) => { + for (var i = 0; i < n; ++i) { + var id = HEAP32[(((framebuffers)+(i*4))>>2)]; + var framebuffer = GL.framebuffers[id]; + if (!framebuffer) continue; // GL spec: "glDeleteFramebuffers silently ignores 0s and names that do not correspond to existing framebuffer objects". + GLctx.deleteFramebuffer(framebuffer); + framebuffer.name = 0; + GL.framebuffers[id] = null; + } + }; + var _emscripten_glDeleteFramebuffers = _glDeleteFramebuffers; + + /** @suppress {duplicate } */ + var _glDeleteProgram = (id) => { + if (!id) return; + var program = GL.programs[id]; + if (!program) { + // glDeleteProgram actually signals an error when deleting a nonexisting + // object, unlike some other GL delete functions. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + GLctx.deleteProgram(program); + program.name = 0; + GL.programs[id] = null; + }; + var _emscripten_glDeleteProgram = _glDeleteProgram; + + /** @suppress {duplicate } */ + var _glDeleteQueries = (n, ids) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((ids)+(i*4))>>2)]; + var query = GL.queries[id]; + if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero." + GLctx.deleteQuery(query); + GL.queries[id] = null; + } + }; + var _emscripten_glDeleteQueries = _glDeleteQueries; + + /** @suppress {duplicate } */ + var _glDeleteQueriesEXT = (n, ids) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((ids)+(i*4))>>2)]; + var query = GL.queries[id]; + if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero." + GLctx.disjointTimerQueryExt['deleteQueryEXT'](query); + GL.queries[id] = null; + } + }; + var _emscripten_glDeleteQueriesEXT = _glDeleteQueriesEXT; + + /** @suppress {duplicate } */ + var _glDeleteRenderbuffers = (n, renderbuffers) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((renderbuffers)+(i*4))>>2)]; + var renderbuffer = GL.renderbuffers[id]; + if (!renderbuffer) continue; // GL spec: "glDeleteRenderbuffers silently ignores 0s and names that do not correspond to existing renderbuffer objects". + GLctx.deleteRenderbuffer(renderbuffer); + renderbuffer.name = 0; + GL.renderbuffers[id] = null; + } + }; + var _emscripten_glDeleteRenderbuffers = _glDeleteRenderbuffers; + + /** @suppress {duplicate } */ + var _glDeleteSamplers = (n, samplers) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((samplers)+(i*4))>>2)]; + var sampler = GL.samplers[id]; + if (!sampler) continue; + GLctx.deleteSampler(sampler); + sampler.name = 0; + GL.samplers[id] = null; + } + }; + var _emscripten_glDeleteSamplers = _glDeleteSamplers; + + /** @suppress {duplicate } */ + var _glDeleteShader = (id) => { + if (!id) return; + var shader = GL.shaders[id]; + if (!shader) { + // glDeleteShader actually signals an error when deleting a nonexisting + // object, unlike some other GL delete functions. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + GLctx.deleteShader(shader); + GL.shaders[id] = null; + }; + var _emscripten_glDeleteShader = _glDeleteShader; + + /** @suppress {duplicate } */ + var _glDeleteSync = (id) => { + if (!id) return; + var sync = GL.syncs[id]; + if (!sync) { // glDeleteSync signals an error when deleting a nonexisting object, unlike some other GL delete functions. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + GLctx.deleteSync(sync); + sync.name = 0; + GL.syncs[id] = null; + }; + var _emscripten_glDeleteSync = _glDeleteSync; + + /** @suppress {duplicate } */ + var _glDeleteTextures = (n, textures) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((textures)+(i*4))>>2)]; + var texture = GL.textures[id]; + // GL spec: "glDeleteTextures silently ignores 0s and names that do not + // correspond to existing textures". + if (!texture) continue; + GLctx.deleteTexture(texture); + texture.name = 0; + GL.textures[id] = null; + } + }; + var _emscripten_glDeleteTextures = _glDeleteTextures; + + /** @suppress {duplicate } */ + var _glDeleteTransformFeedbacks = (n, ids) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((ids)+(i*4))>>2)]; + var transformFeedback = GL.transformFeedbacks[id]; + if (!transformFeedback) continue; // GL spec: "unused names in ids are ignored, as is the name zero." + GLctx.deleteTransformFeedback(transformFeedback); + transformFeedback.name = 0; + GL.transformFeedbacks[id] = null; + } + }; + var _emscripten_glDeleteTransformFeedbacks = _glDeleteTransformFeedbacks; + + /** @suppress {duplicate } */ + var _glDeleteVertexArrays = (n, vaos) => { + for (var i = 0; i < n; i++) { + var id = HEAP32[(((vaos)+(i*4))>>2)]; + GLctx.deleteVertexArray(GL.vaos[id]); + GL.vaos[id] = null; + } + }; + var _emscripten_glDeleteVertexArrays = _glDeleteVertexArrays; + + + /** @suppress {duplicate } */ + var _glDeleteVertexArraysOES = _glDeleteVertexArrays; + var _emscripten_glDeleteVertexArraysOES = _glDeleteVertexArraysOES; + + /** @suppress {duplicate } */ + var _glDepthFunc = (x0) => GLctx.depthFunc(x0); + var _emscripten_glDepthFunc = _glDepthFunc; + + /** @suppress {duplicate } */ + var _glDepthMask = (flag) => { + GLctx.depthMask(!!flag); + }; + var _emscripten_glDepthMask = _glDepthMask; + + /** @suppress {duplicate } */ + var _glDepthRangef = (x0, x1) => GLctx.depthRange(x0, x1); + var _emscripten_glDepthRangef = _glDepthRangef; + + /** @suppress {duplicate } */ + var _glDetachShader = (program, shader) => { + GLctx.detachShader(GL.programs[program], GL.shaders[shader]); + }; + var _emscripten_glDetachShader = _glDetachShader; + + /** @suppress {duplicate } */ + var _glDisable = (x0) => GLctx.disable(x0); + var _emscripten_glDisable = _glDisable; + + /** @suppress {duplicate } */ + var _glDisableVertexAttribArray = (index) => { + GLctx.disableVertexAttribArray(index); + }; + var _emscripten_glDisableVertexAttribArray = _glDisableVertexAttribArray; + + /** @suppress {duplicate } */ + var _glDrawArrays = (mode, first, count) => { + + GLctx.drawArrays(mode, first, count); + + }; + var _emscripten_glDrawArrays = _glDrawArrays; + + /** @suppress {duplicate } */ + var _glDrawArraysInstanced = (mode, first, count, primcount) => { + GLctx.drawArraysInstanced(mode, first, count, primcount); + }; + var _emscripten_glDrawArraysInstanced = _glDrawArraysInstanced; + + + /** @suppress {duplicate } */ + var _glDrawArraysInstancedANGLE = _glDrawArraysInstanced; + var _emscripten_glDrawArraysInstancedANGLE = _glDrawArraysInstancedANGLE; + + + /** @suppress {duplicate } */ + var _glDrawArraysInstancedARB = _glDrawArraysInstanced; + var _emscripten_glDrawArraysInstancedARB = _glDrawArraysInstancedARB; + + + /** @suppress {duplicate } */ + var _glDrawArraysInstancedEXT = _glDrawArraysInstanced; + var _emscripten_glDrawArraysInstancedEXT = _glDrawArraysInstancedEXT; + + + /** @suppress {duplicate } */ + var _glDrawArraysInstancedNV = _glDrawArraysInstanced; + var _emscripten_glDrawArraysInstancedNV = _glDrawArraysInstancedNV; + + var tempFixedLengthArray = []; + + /** @suppress {duplicate } */ + var _glDrawBuffers = (n, bufs) => { + + var bufArray = tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[(((bufs)+(i*4))>>2)]; + } + + GLctx.drawBuffers(bufArray); + }; + var _emscripten_glDrawBuffers = _glDrawBuffers; + + + /** @suppress {duplicate } */ + var _glDrawBuffersEXT = _glDrawBuffers; + var _emscripten_glDrawBuffersEXT = _glDrawBuffersEXT; + + + /** @suppress {duplicate } */ + var _glDrawBuffersWEBGL = _glDrawBuffers; + var _emscripten_glDrawBuffersWEBGL = _glDrawBuffersWEBGL; + + /** @suppress {duplicate } */ + var _glDrawElements = (mode, count, type, indices) => { + + GLctx.drawElements(mode, count, type, indices); + + }; + var _emscripten_glDrawElements = _glDrawElements; + + /** @suppress {duplicate } */ + var _glDrawElementsInstanced = (mode, count, type, indices, primcount) => { + GLctx.drawElementsInstanced(mode, count, type, indices, primcount); + }; + var _emscripten_glDrawElementsInstanced = _glDrawElementsInstanced; + + + /** @suppress {duplicate } */ + var _glDrawElementsInstancedANGLE = _glDrawElementsInstanced; + var _emscripten_glDrawElementsInstancedANGLE = _glDrawElementsInstancedANGLE; + + + /** @suppress {duplicate } */ + var _glDrawElementsInstancedARB = _glDrawElementsInstanced; + var _emscripten_glDrawElementsInstancedARB = _glDrawElementsInstancedARB; + + + /** @suppress {duplicate } */ + var _glDrawElementsInstancedEXT = _glDrawElementsInstanced; + var _emscripten_glDrawElementsInstancedEXT = _glDrawElementsInstancedEXT; + + + /** @suppress {duplicate } */ + var _glDrawElementsInstancedNV = _glDrawElementsInstanced; + var _emscripten_glDrawElementsInstancedNV = _glDrawElementsInstancedNV; + + /** @suppress {duplicate } */ + var _glDrawRangeElements = (mode, start, end, count, type, indices) => { + // TODO: This should be a trivial pass-though function registered at the bottom of this page as + // glFuncs[6][1] += ' drawRangeElements'; + // but due to https://bugzilla.mozilla.org/show_bug.cgi?id=1202427, + // we work around by ignoring the range. + _glDrawElements(mode, count, type, indices); + }; + var _emscripten_glDrawRangeElements = _glDrawRangeElements; + + /** @suppress {duplicate } */ + var _glEnable = (x0) => GLctx.enable(x0); + var _emscripten_glEnable = _glEnable; + + /** @suppress {duplicate } */ + var _glEnableVertexAttribArray = (index) => { + GLctx.enableVertexAttribArray(index); + }; + var _emscripten_glEnableVertexAttribArray = _glEnableVertexAttribArray; + + /** @suppress {duplicate } */ + var _glEndQuery = (x0) => GLctx.endQuery(x0); + var _emscripten_glEndQuery = _glEndQuery; + + /** @suppress {duplicate } */ + var _glEndQueryEXT = (target) => { + GLctx.disjointTimerQueryExt['endQueryEXT'](target); + }; + var _emscripten_glEndQueryEXT = _glEndQueryEXT; + + /** @suppress {duplicate } */ + var _glEndTransformFeedback = () => GLctx.endTransformFeedback(); + var _emscripten_glEndTransformFeedback = _glEndTransformFeedback; + + /** @suppress {duplicate } */ + var _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; // Failed to create a sync object + }; + var _emscripten_glFenceSync = _glFenceSync; + + /** @suppress {duplicate } */ + var _glFinish = () => GLctx.finish(); + var _emscripten_glFinish = _glFinish; + + /** @suppress {duplicate } */ + var _glFlush = () => GLctx.flush(); + var _emscripten_glFlush = _glFlush; + + /** @suppress {duplicate } */ + var _glFramebufferRenderbuffer = (target, attachment, renderbuffertarget, renderbuffer) => { + GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, + GL.renderbuffers[renderbuffer]); + }; + var _emscripten_glFramebufferRenderbuffer = _glFramebufferRenderbuffer; + + /** @suppress {duplicate } */ + var _glFramebufferTexture2D = (target, attachment, textarget, texture, level) => { + GLctx.framebufferTexture2D(target, attachment, textarget, + GL.textures[texture], level); + }; + var _emscripten_glFramebufferTexture2D = _glFramebufferTexture2D; + + /** @suppress {duplicate } */ + var _glFramebufferTextureLayer = (target, attachment, texture, level, layer) => { + GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer); + }; + var _emscripten_glFramebufferTextureLayer = _glFramebufferTextureLayer; + + /** @suppress {duplicate } */ + var _glFrontFace = (x0) => GLctx.frontFace(x0); + var _emscripten_glFrontFace = _glFrontFace; + + /** @suppress {duplicate } */ + var _glGenBuffers = (n, buffers) => { + GL.genObject(n, buffers, 'createBuffer', GL.buffers + ); + }; + var _emscripten_glGenBuffers = _glGenBuffers; + + /** @suppress {duplicate } */ + var _glGenFramebuffers = (n, ids) => { + GL.genObject(n, ids, 'createFramebuffer', GL.framebuffers + ); + }; + var _emscripten_glGenFramebuffers = _glGenFramebuffers; + + /** @suppress {duplicate } */ + var _glGenQueries = (n, ids) => { + GL.genObject(n, ids, 'createQuery', GL.queries + ); + }; + var _emscripten_glGenQueries = _glGenQueries; + + /** @suppress {duplicate } */ + var _glGenQueriesEXT = (n, ids) => { + for (var i = 0; i < n; i++) { + var query = GLctx.disjointTimerQueryExt['createQueryEXT'](); + if (!query) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + while (i < n) HEAP32[(((ids)+(i++*4))>>2)] = 0;checkInt32(0); + return; + } + var id = GL.getNewId(GL.queries); + query.name = id; + GL.queries[id] = query; + HEAP32[(((ids)+(i*4))>>2)] = id;checkInt32(id); + } + }; + var _emscripten_glGenQueriesEXT = _glGenQueriesEXT; + + /** @suppress {duplicate } */ + var _glGenRenderbuffers = (n, renderbuffers) => { + GL.genObject(n, renderbuffers, 'createRenderbuffer', GL.renderbuffers + ); + }; + var _emscripten_glGenRenderbuffers = _glGenRenderbuffers; + + /** @suppress {duplicate } */ + var _glGenSamplers = (n, samplers) => { + GL.genObject(n, samplers, 'createSampler', GL.samplers + ); + }; + var _emscripten_glGenSamplers = _glGenSamplers; + + /** @suppress {duplicate } */ + var _glGenTextures = (n, textures) => { + GL.genObject(n, textures, 'createTexture', GL.textures + ); + }; + var _emscripten_glGenTextures = _glGenTextures; + + /** @suppress {duplicate } */ + var _glGenTransformFeedbacks = (n, ids) => { + GL.genObject(n, ids, 'createTransformFeedback', GL.transformFeedbacks + ); + }; + var _emscripten_glGenTransformFeedbacks = _glGenTransformFeedbacks; + + /** @suppress {duplicate } */ + var _glGenVertexArrays = (n, arrays) => { + GL.genObject(n, arrays, 'createVertexArray', GL.vaos + ); + }; + var _emscripten_glGenVertexArrays = _glGenVertexArrays; + + + /** @suppress {duplicate } */ + var _glGenVertexArraysOES = _glGenVertexArrays; + var _emscripten_glGenVertexArraysOES = _glGenVertexArraysOES; + + /** @suppress {duplicate } */ + var _glGenerateMipmap = (x0) => GLctx.generateMipmap(x0); + var _emscripten_glGenerateMipmap = _glGenerateMipmap; + + + var __glGetActiveAttribOrUniform = (funcName, program, index, bufSize, length, size, type, name) => { + program = GL.programs[program]; + var info = GLctx[funcName](program, index); + if (info) { + // If an error occurs, nothing will be written to length, size and type and name. + var numBytesWrittenExclNull = name && stringToUTF8(info.name, name, bufSize); + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull); + if (size) HEAP32[((size)>>2)] = info.size;checkInt32(info.size); + if (type) HEAP32[((type)>>2)] = info.type;checkInt32(info.type); + } + }; + + /** @suppress {duplicate } */ + var _glGetActiveAttrib = (program, index, bufSize, length, size, type, name) => { + __glGetActiveAttribOrUniform('getActiveAttrib', program, index, bufSize, length, size, type, name); + }; + var _emscripten_glGetActiveAttrib = _glGetActiveAttrib; + + + /** @suppress {duplicate } */ + var _glGetActiveUniform = (program, index, bufSize, length, size, type, name) => { + __glGetActiveAttribOrUniform('getActiveUniform', program, index, bufSize, length, size, type, name); + }; + var _emscripten_glGetActiveUniform = _glGetActiveUniform; + + /** @suppress {duplicate } */ + var _glGetActiveUniformBlockName = (program, uniformBlockIndex, bufSize, length, uniformBlockName) => { + program = GL.programs[program]; + + var result = GLctx.getActiveUniformBlockName(program, uniformBlockIndex); + if (!result) return; // If an error occurs, nothing will be written to uniformBlockName or length. + if (uniformBlockName && bufSize > 0) { + var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize); + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull); + } else { + if (length) HEAP32[((length)>>2)] = 0;checkInt32(0); + } + }; + var _emscripten_glGetActiveUniformBlockName = _glGetActiveUniformBlockName; + + /** @suppress {duplicate } */ + var _glGetActiveUniformBlockiv = (program, uniformBlockIndex, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + + if (pname == 0x8A41 /* GL_UNIFORM_BLOCK_NAME_LENGTH */) { + var name = GLctx.getActiveUniformBlockName(program, uniformBlockIndex); + HEAP32[((params)>>2)] = name.length+1;checkInt32(name.length+1); + return; + } + + var result = GLctx.getActiveUniformBlockParameter(program, uniformBlockIndex, pname); + if (result === null) return; // If an error occurs, nothing should be written to params. + if (pname == 0x8A43 /*GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES*/) { + for (var i = 0; i < result.length; i++) { + HEAP32[(((params)+(i*4))>>2)] = result[i];checkInt32(result[i]); + } + } else { + HEAP32[((params)>>2)] = result;checkInt32(result); + } + }; + var _emscripten_glGetActiveUniformBlockiv = _glGetActiveUniformBlockiv; + + /** @suppress {duplicate } */ + var _glGetActiveUniformsiv = (program, uniformCount, uniformIndices, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (uniformCount > 0 && uniformIndices == 0) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + var ids = []; + for (var i = 0; i < uniformCount; i++) { + ids.push(HEAP32[(((uniformIndices)+(i*4))>>2)]); + } + + var result = GLctx.getActiveUniforms(program, ids, pname); + if (!result) return; // GL spec: If an error is generated, nothing is written out to params. + + var len = result.length; + for (var i = 0; i < len; i++) { + HEAP32[(((params)+(i*4))>>2)] = result[i];checkInt32(result[i]); + } + }; + var _emscripten_glGetActiveUniformsiv = _glGetActiveUniformsiv; + + /** @suppress {duplicate } */ + var _glGetAttachedShaders = (program, maxCount, count, shaders) => { + var result = GLctx.getAttachedShaders(GL.programs[program]); + var len = result.length; + if (len > maxCount) { + len = maxCount; + } + HEAP32[((count)>>2)] = len;checkInt32(len); + for (var i = 0; i < len; ++i) { + var id = GL.shaders.indexOf(result[i]); + HEAP32[(((shaders)+(i*4))>>2)] = id;checkInt32(id); + } + }; + var _emscripten_glGetAttachedShaders = _glGetAttachedShaders; + + + /** @suppress {duplicate } */ + var _glGetAttribLocation = (program, name) => { + return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name)); + }; + var _emscripten_glGetAttribLocation = _glGetAttribLocation; + + var readI53FromI64 = (ptr) => { + return HEAPU32[((ptr)>>2)] + HEAP32[(((ptr)+(4))>>2)] * 4294967296; + }; + + var readI53FromU64 = (ptr) => { + return HEAPU32[((ptr)>>2)] + HEAPU32[(((ptr)+(4))>>2)] * 4294967296; + }; + var writeI53ToI64 = (ptr, num) => { + HEAPU32[((ptr)>>2)] = num;checkInt32(num); + var lower = HEAPU32[((ptr)>>2)]; + HEAPU32[(((ptr)+(4))>>2)] = (num - lower)/4294967296;checkInt32((num - lower)/4294967296); + var deserialized = (num >= 0) ? readI53FromU64(ptr) : readI53FromI64(ptr); + var offset = ((ptr)>>2); + if (deserialized != num) warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(HEAPU32[offset])}, hi=${ptrToString(HEAPU32[offset+1])}, which deserializes back to ${deserialized} instead!`); + }; + + + var webglGetExtensions = function $webglGetExtensions() { + var exts = getEmscriptenSupportedExtensions(GLctx); + exts = exts.concat(exts.map((e) => "GL_" + e)); + return exts; + }; + + var emscriptenWebGLGet = (name_, p, type) => { + // Guard against user passing a null pointer. + // Note that GLES2 spec does not say anything about how passing a null + // pointer should be treated. Testing on desktop core GL 3, the application + // crashes on glGetIntegerv to a null pointer, but better to report an error + // instead of doing anything random. + if (!p) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var ret = undefined; + switch (name_) { // Handle a few trivial GLES values + case 0x8DFA: // GL_SHADER_COMPILER + ret = 1; + break; + case 0x8DF8: // GL_SHADER_BINARY_FORMATS + if (type != 0 && type != 1) { + GL.recordError(0x500); // GL_INVALID_ENUM + } + // Do not write anything to the out pointer, since no binary formats are + // supported. + return; + case 0x87FE: // GL_NUM_PROGRAM_BINARY_FORMATS + case 0x8DF9: // GL_NUM_SHADER_BINARY_FORMATS + ret = 0; + break; + case 0x86A2: // GL_NUM_COMPRESSED_TEXTURE_FORMATS + // WebGL doesn't have GL_NUM_COMPRESSED_TEXTURE_FORMATS (it's obsolete + // since GL_COMPRESSED_TEXTURE_FORMATS returns a JS array that can be + // queried for length), so implement it ourselves to allow C++ GLES2 + // code get the length. + var formats = GLctx.getParameter(0x86A3 /*GL_COMPRESSED_TEXTURE_FORMATS*/); + ret = formats ? formats.length : 0; + break; + + case 0x821D: // GL_NUM_EXTENSIONS + if (GL.currentContext.version < 2) { + // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context + GL.recordError(0x502 /* GL_INVALID_OPERATION */); + return; + } + ret = webglGetExtensions().length; + break; + case 0x821B: // GL_MAJOR_VERSION + case 0x821C: // GL_MINOR_VERSION + if (GL.currentContext.version < 2) { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + ret = name_ == 0x821B ? 3 : 0; // return version 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(0x500); // GL_INVALID_ENUM + return; + case "object": + if (result === null) { + // null is a valid result for some (e.g., which buffer is bound - + // perhaps nothing is bound), but otherwise can mean an invalid + // name_, which we need to report as an error + switch (name_) { + case 0x8894: // ARRAY_BUFFER_BINDING + case 0x8B8D: // CURRENT_PROGRAM + case 0x8895: // ELEMENT_ARRAY_BUFFER_BINDING + case 0x8CA6: // FRAMEBUFFER_BINDING or DRAW_FRAMEBUFFER_BINDING + case 0x8CA7: // RENDERBUFFER_BINDING + case 0x8069: // TEXTURE_BINDING_2D + case 0x85B5: // WebGL 2 GL_VERTEX_ARRAY_BINDING, or WebGL 1 extension OES_vertex_array_object GL_VERTEX_ARRAY_BINDING_OES + case 0x8F36: // COPY_READ_BUFFER_BINDING or COPY_READ_BUFFER + case 0x8F37: // COPY_WRITE_BUFFER_BINDING or COPY_WRITE_BUFFER + case 0x88ED: // PIXEL_PACK_BUFFER_BINDING + case 0x88EF: // PIXEL_UNPACK_BUFFER_BINDING + case 0x8CAA: // READ_FRAMEBUFFER_BINDING + case 0x8919: // SAMPLER_BINDING + case 0x8C1D: // TEXTURE_BINDING_2D_ARRAY + case 0x806A: // TEXTURE_BINDING_3D + case 0x8E25: // TRANSFORM_FEEDBACK_BINDING + case 0x8C8F: // TRANSFORM_FEEDBACK_BUFFER_BINDING + case 0x8A28: // UNIFORM_BUFFER_BINDING + case 0x8514: { // TEXTURE_BINDING_CUBE_MAP + ret = 0; + break; + } + default: { + GL.recordError(0x500); // GL_INVALID_ENUM + 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: HEAP32[(((p)+(i*4))>>2)] = result[i];checkInt32(result[i]); break; + case 2: HEAPF32[(((p)+(i*4))>>2)] = result[i]; break; + case 4: HEAP8[(p)+(i)] = result[i] ? 1 : 0;checkInt8(result[i] ? 1 : 0); break; + } + } + return; + } else { + try { + ret = result.name | 0; + } catch(e) { + GL.recordError(0x500); // GL_INVALID_ENUM + err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`); + return; + } + } + break; + default: + GL.recordError(0x500); // GL_INVALID_ENUM + 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: HEAP32[((p)>>2)] = ret;checkInt32(ret); break; + case 2: HEAPF32[((p)>>2)] = ret; break; + case 4: HEAP8[p] = ret ? 1 : 0;checkInt8(ret ? 1 : 0); break; + } + }; + + /** @suppress {duplicate } */ + var _glGetBooleanv = (name_, p) => emscriptenWebGLGet(name_, p, 4); + var _emscripten_glGetBooleanv = _glGetBooleanv; + + /** @suppress {duplicate } */ + var _glGetBufferParameteri64v = (target, value, data) => { + if (!data) { + // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense + // if data == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + writeI53ToI64(data, GLctx.getBufferParameter(target, value)); + }; + var _emscripten_glGetBufferParameteri64v = _glGetBufferParameteri64v; + + /** @suppress {duplicate } */ + var _glGetBufferParameteriv = (target, value, data) => { + if (!data) { + // GLES2 specification does not specify how to behave if data is a null + // pointer. Since calling this function does not make sense if data == + // null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((data)>>2)] = GLctx.getBufferParameter(target, value);checkInt32(GLctx.getBufferParameter(target, value)); + }; + var _emscripten_glGetBufferParameteriv = _glGetBufferParameteriv; + + /** @suppress {duplicate } */ + var _glGetError = () => { + var error = GLctx.getError() || GL.lastError; + GL.lastError = 0/*GL_NO_ERROR*/; + return error; + }; + var _emscripten_glGetError = _glGetError; + + + /** @suppress {duplicate } */ + var _glGetFloatv = (name_, p) => emscriptenWebGLGet(name_, p, 2); + var _emscripten_glGetFloatv = _glGetFloatv; + + /** @suppress {duplicate } */ + var _glGetFragDataLocation = (program, name) => { + return GLctx.getFragDataLocation(GL.programs[program], UTF8ToString(name)); + }; + var _emscripten_glGetFragDataLocation = _glGetFragDataLocation; + + /** @suppress {duplicate } */ + var _glGetFramebufferAttachmentParameteriv = (target, attachment, pname, params) => { + var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname); + if (result instanceof WebGLRenderbuffer || + result instanceof WebGLTexture) { + result = result.name | 0; + } + HEAP32[((params)>>2)] = result;checkInt32(result); + }; + var _emscripten_glGetFramebufferAttachmentParameteriv = _glGetFramebufferAttachmentParameteriv; + + var emscriptenWebGLGetIndexed = (target, index, data, type) => { + if (!data) { + // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense + // if data == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var result = GLctx.getIndexedParameter(target, index); + var ret; + switch (typeof result) { + case 'boolean': + ret = result ? 1 : 0; + break; + case 'number': + ret = result; + break; + case 'object': + if (result === null) { + switch (target) { + case 0x8C8F: // TRANSFORM_FEEDBACK_BUFFER_BINDING + case 0x8A28: // UNIFORM_BUFFER_BINDING + ret = 0; + break; + default: { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + } + } else if (result instanceof WebGLBuffer) { + ret = result.name | 0; + } else { + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + break; + default: + GL.recordError(0x500); // GL_INVALID_ENUM + return; + } + + switch (type) { + case 1: writeI53ToI64(data, ret); break; + case 0: HEAP32[((data)>>2)] = ret;checkInt32(ret); break; + case 2: HEAPF32[((data)>>2)] = ret; break; + case 4: HEAP8[data] = ret ? 1 : 0;checkInt8(ret ? 1 : 0); break; + default: throw 'internal emscriptenWebGLGetIndexed() error, bad type: ' + type; + } + }; + /** @suppress {duplicate } */ + var _glGetInteger64i_v = (target, index, data) => + emscriptenWebGLGetIndexed(target, index, data, 1); + var _emscripten_glGetInteger64i_v = _glGetInteger64i_v; + + /** @suppress {duplicate } */ + var _glGetInteger64v = (name_, p) => { + emscriptenWebGLGet(name_, p, 1); + }; + var _emscripten_glGetInteger64v = _glGetInteger64v; + + /** @suppress {duplicate } */ + var _glGetIntegeri_v = (target, index, data) => + emscriptenWebGLGetIndexed(target, index, data, 0); + var _emscripten_glGetIntegeri_v = _glGetIntegeri_v; + + + /** @suppress {duplicate } */ + var _glGetIntegerv = (name_, p) => emscriptenWebGLGet(name_, p, 0); + var _emscripten_glGetIntegerv = _glGetIntegerv; + + /** @suppress {duplicate } */ + var _glGetInternalformativ = (target, internalformat, pname, bufSize, params) => { + if (bufSize < 0) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (!params) { + // GLES3 specification does not specify how to behave if values is a null pointer. Since calling this function does not make sense + // if values == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var ret = GLctx.getInternalformatParameter(target, internalformat, pname); + if (ret === null) return; + for (var i = 0; i < ret.length && i < bufSize; ++i) { + HEAP32[(((params)+(i*4))>>2)] = ret[i];checkInt32(ret[i]); + } + }; + var _emscripten_glGetInternalformativ = _glGetInternalformativ; + + /** @suppress {duplicate } */ + var _glGetProgramBinary = (program, bufSize, length, binaryFormat, binary) => { + GL.recordError(0x502/*GL_INVALID_OPERATION*/); + }; + var _emscripten_glGetProgramBinary = _glGetProgramBinary; + + /** @suppress {duplicate } */ + var _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) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull); + }; + var _emscripten_glGetProgramInfoLog = _glGetProgramInfoLog; + + /** @suppress {duplicate } */ + var _glGetProgramiv = (program, pname, p) => { + if (!p) { + // GLES2 specification does not specify how to behave if p is a null + // pointer. Since calling this function does not make sense if p == null, + // issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + + if (program >= GL.counter) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + + program = GL.programs[program]; + + if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH + var log = GLctx.getProgramInfoLog(program); + if (log === null) log = '(unknown error)'; + HEAP32[((p)>>2)] = log.length + 1;checkInt32(log.length + 1); + } else if (pname == 0x8B87 /* GL_ACTIVE_UNIFORM_MAX_LENGTH */) { + if (!program.maxUniformLength) { + var numActiveUniforms = GLctx.getProgramParameter(program, 0x8B86/*GL_ACTIVE_UNIFORMS*/); + for (var i = 0; i < numActiveUniforms; ++i) { + program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length+1); + } + } + HEAP32[((p)>>2)] = program.maxUniformLength;checkInt32(program.maxUniformLength); + } else if (pname == 0x8B8A /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */) { + if (!program.maxAttributeLength) { + var numActiveAttributes = GLctx.getProgramParameter(program, 0x8B89/*GL_ACTIVE_ATTRIBUTES*/); + for (var i = 0; i < numActiveAttributes; ++i) { + program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length+1); + } + } + HEAP32[((p)>>2)] = program.maxAttributeLength;checkInt32(program.maxAttributeLength); + } else if (pname == 0x8A35 /* GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH */) { + if (!program.maxUniformBlockNameLength) { + var numActiveUniformBlocks = GLctx.getProgramParameter(program, 0x8A36/*GL_ACTIVE_UNIFORM_BLOCKS*/); + for (var i = 0; i < numActiveUniformBlocks; ++i) { + program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length+1); + } + } + HEAP32[((p)>>2)] = program.maxUniformBlockNameLength;checkInt32(program.maxUniformBlockNameLength); + } else { + HEAP32[((p)>>2)] = GLctx.getProgramParameter(program, pname);checkInt32(GLctx.getProgramParameter(program, pname)); + } + }; + var _emscripten_glGetProgramiv = _glGetProgramiv; + + + /** @suppress {duplicate } */ + var _glGetQueryObjecti64vEXT = (id, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param; + if (GL.currentContext.version < 2) + { + param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname); + } + else { + param = GLctx.getQueryParameter(query, pname); + } + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + writeI53ToI64(params, ret); + }; + var _emscripten_glGetQueryObjecti64vEXT = _glGetQueryObjecti64vEXT; + + /** @suppress {duplicate } */ + var _glGetQueryObjectivEXT = (id, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname); + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + HEAP32[((params)>>2)] = ret;checkInt32(ret); + }; + var _emscripten_glGetQueryObjectivEXT = _glGetQueryObjectivEXT; + + + /** @suppress {duplicate } */ + var _glGetQueryObjectui64vEXT = _glGetQueryObjecti64vEXT; + var _emscripten_glGetQueryObjectui64vEXT = _glGetQueryObjectui64vEXT; + + /** @suppress {duplicate } */ + var _glGetQueryObjectuiv = (id, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var query = GL.queries[id]; + var param = GLctx.getQueryParameter(query, pname); + var ret; + if (typeof param == 'boolean') { + ret = param ? 1 : 0; + } else { + ret = param; + } + HEAP32[((params)>>2)] = ret;checkInt32(ret); + }; + var _emscripten_glGetQueryObjectuiv = _glGetQueryObjectuiv; + + + /** @suppress {duplicate } */ + var _glGetQueryObjectuivEXT = _glGetQueryObjectivEXT; + var _emscripten_glGetQueryObjectuivEXT = _glGetQueryObjectuivEXT; + + /** @suppress {duplicate } */ + var _glGetQueryiv = (target, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.getQuery(target, pname);checkInt32(GLctx.getQuery(target, pname)); + }; + var _emscripten_glGetQueryiv = _glGetQueryiv; + + /** @suppress {duplicate } */ + var _glGetQueryivEXT = (target, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.disjointTimerQueryExt['getQueryEXT'](target, pname);checkInt32(GLctx.disjointTimerQueryExt['getQueryEXT'](target, pname)); + }; + var _emscripten_glGetQueryivEXT = _glGetQueryivEXT; + + /** @suppress {duplicate } */ + var _glGetRenderbufferParameteriv = (target, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if params == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.getRenderbufferParameter(target, pname);checkInt32(GLctx.getRenderbufferParameter(target, pname)); + }; + var _emscripten_glGetRenderbufferParameteriv = _glGetRenderbufferParameteriv; + + /** @suppress {duplicate } */ + var _glGetSamplerParameterfv = (sampler, pname, params) => { + if (!params) { + // GLES3 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAPF32[((params)>>2)] = GLctx.getSamplerParameter(GL.samplers[sampler], pname); + }; + var _emscripten_glGetSamplerParameterfv = _glGetSamplerParameterfv; + + /** @suppress {duplicate } */ + var _glGetSamplerParameteriv = (sampler, pname, params) => { + if (!params) { + // GLES3 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense + // if p == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.getSamplerParameter(GL.samplers[sampler], pname);checkInt32(GLctx.getSamplerParameter(GL.samplers[sampler], pname)); + }; + var _emscripten_glGetSamplerParameteriv = _glGetSamplerParameteriv; + + + /** @suppress {duplicate } */ + var _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) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull); + }; + var _emscripten_glGetShaderInfoLog = _glGetShaderInfoLog; + + /** @suppress {duplicate } */ + var _glGetShaderPrecisionFormat = (shaderType, precisionType, range, precision) => { + var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType); + HEAP32[((range)>>2)] = result.rangeMin;checkInt32(result.rangeMin); + HEAP32[(((range)+(4))>>2)] = result.rangeMax;checkInt32(result.rangeMax); + HEAP32[((precision)>>2)] = result.precision;checkInt32(result.precision); + }; + var _emscripten_glGetShaderPrecisionFormat = _glGetShaderPrecisionFormat; + + /** @suppress {duplicate } */ + var _glGetShaderSource = (shader, bufSize, length, source) => { + var result = GLctx.getShaderSource(GL.shaders[shader]); + if (!result) return; // If an error occurs, nothing will be written to length or source. + var numBytesWrittenExclNull = (bufSize > 0 && source) ? stringToUTF8(result, source, bufSize) : 0; + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull); + }; + var _emscripten_glGetShaderSource = _glGetShaderSource; + + /** @suppress {duplicate } */ + var _glGetShaderiv = (shader, pname, p) => { + if (!p) { + // GLES2 specification does not specify how to behave if p is a null + // pointer. Since calling this function does not make sense if p == null, + // issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = '(unknown error)'; + // The GLES2 specification says that if the shader has an empty info log, + // a value of 0 is returned. Otherwise the log has a null char appended. + // (An empty string is falsey, so we can just check that instead of + // looking at log.length.) + var logLength = log ? log.length + 1 : 0; + HEAP32[((p)>>2)] = logLength;checkInt32(logLength); + } else if (pname == 0x8B88) { // GL_SHADER_SOURCE_LENGTH + var source = GLctx.getShaderSource(GL.shaders[shader]); + // source may be a null, or the empty string, both of which are falsey + // values that we report a 0 length for. + var sourceLength = source ? source.length + 1 : 0; + HEAP32[((p)>>2)] = sourceLength;checkInt32(sourceLength); + } else { + HEAP32[((p)>>2)] = GLctx.getShaderParameter(GL.shaders[shader], pname);checkInt32(GLctx.getShaderParameter(GL.shaders[shader], pname)); + } + }; + var _emscripten_glGetShaderiv = _glGetShaderiv; + + + + var stringToNewUTF8 = (str) => { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8(str, ret, size); + return ret; + }; + + + /** @suppress {duplicate } */ + var _glGetString = (name_) => { + var ret = GL.stringCache[name_]; + if (!ret) { + switch (name_) { + case 0x1F03 /* GL_EXTENSIONS */: + ret = stringToNewUTF8(webglGetExtensions().join(' ')); + break; + case 0x1F00 /* GL_VENDOR */: + case 0x1F01 /* GL_RENDERER */: + case 0x9245 /* UNMASKED_VENDOR_WEBGL */: + case 0x9246 /* UNMASKED_RENDERER_WEBGL */: + var s = GLctx.getParameter(name_); + if (!s) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + } + ret = s ? stringToNewUTF8(s) : 0; + break; + + case 0x1F02 /* GL_VERSION */: + var webGLVersion = GLctx.getParameter(0x1F02 /*GL_VERSION*/); + // return GLES version string corresponding to the version of the WebGL context + var glVersion = `OpenGL ES 2.0 (${webGLVersion})`; + if (GL.currentContext.version >= 2) glVersion = `OpenGL ES 3.0 (${webGLVersion})`; + ret = stringToNewUTF8(glVersion); + break; + case 0x8B8C /* GL_SHADING_LANGUAGE_VERSION */: + var glslVersion = GLctx.getParameter(0x8B8C /*GL_SHADING_LANGUAGE_VERSION*/); + // extract the version number 'N.M' from the string 'WebGL GLSL ES N.M ...' + 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'; // ensure minor version has 2 digits + glslVersion = `OpenGL ES GLSL ES ${ver_num[1]} (${glslVersion})`; + } + ret = stringToNewUTF8(glslVersion); + break; + default: + GL.recordError(0x500/*GL_INVALID_ENUM*/); + // fall through + } + GL.stringCache[name_] = ret; + } + return ret; + }; + var _emscripten_glGetString = _glGetString; + + + /** @suppress {duplicate } */ + var _glGetStringi = (name, index) => { + if (GL.currentContext.version < 2) { + GL.recordError(0x502 /* GL_INVALID_OPERATION */); // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context + return 0; + } + var stringiCache = GL.stringiCache[name]; + if (stringiCache) { + if (index < 0 || index >= stringiCache.length) { + GL.recordError(0x501/*GL_INVALID_VALUE*/); + return 0; + } + return stringiCache[index]; + } + switch (name) { + case 0x1F03 /* GL_EXTENSIONS */: + var exts = webglGetExtensions().map(stringToNewUTF8); + stringiCache = GL.stringiCache[name] = exts; + if (index < 0 || index >= stringiCache.length) { + GL.recordError(0x501/*GL_INVALID_VALUE*/); + return 0; + } + return stringiCache[index]; + default: + GL.recordError(0x500/*GL_INVALID_ENUM*/); + return 0; + } + }; + var _emscripten_glGetStringi = _glGetStringi; + + /** @suppress {duplicate } */ + var _glGetSynciv = (sync, pname, bufSize, length, values) => { + if (bufSize < 0) { + // GLES3 specification does not specify how to behave if bufSize < 0, however in the spec wording for glGetInternalformativ, it does say that GL_INVALID_VALUE should be raised, + // so raise GL_INVALID_VALUE here as well. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (!values) { + // GLES3 specification does not specify how to behave if values is a null pointer. Since calling this function does not make sense + // if values == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var ret = GLctx.getSyncParameter(GL.syncs[sync], pname); + if (ret !== null) { + HEAP32[((values)>>2)] = ret;checkInt32(ret); + if (length) HEAP32[((length)>>2)] = 1;checkInt32(1); // Report a single value outputted. + } + }; + var _emscripten_glGetSynciv = _glGetSynciv; + + /** @suppress {duplicate } */ + var _glGetTexParameterfv = (target, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null + // pointer. Since calling this function does not make sense if p == null, + // issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAPF32[((params)>>2)] = GLctx.getTexParameter(target, pname); + }; + var _emscripten_glGetTexParameterfv = _glGetTexParameterfv; + + /** @suppress {duplicate } */ + var _glGetTexParameteriv = (target, pname, params) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null + // pointer. Since calling this function does not make sense if p == null, + // issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((params)>>2)] = GLctx.getTexParameter(target, pname);checkInt32(GLctx.getTexParameter(target, pname)); + }; + var _emscripten_glGetTexParameteriv = _glGetTexParameteriv; + + /** @suppress {duplicate } */ + var _glGetTransformFeedbackVarying = (program, index, bufSize, length, size, type, name) => { + program = GL.programs[program]; + var info = GLctx.getTransformFeedbackVarying(program, index); + if (!info) return; // If an error occurred, the return parameters length, size, type and name will be unmodified. + + if (name && bufSize > 0) { + var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize); + if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull); + } else { + if (length) HEAP32[((length)>>2)] = 0;checkInt32(0); + } + + if (size) HEAP32[((size)>>2)] = info.size;checkInt32(info.size); + if (type) HEAP32[((type)>>2)] = info.type;checkInt32(info.type); + }; + var _emscripten_glGetTransformFeedbackVarying = _glGetTransformFeedbackVarying; + + /** @suppress {duplicate } */ + var _glGetUniformBlockIndex = (program, uniformBlockName) => { + return GLctx.getUniformBlockIndex(GL.programs[program], UTF8ToString(uniformBlockName)); + }; + var _emscripten_glGetUniformBlockIndex = _glGetUniformBlockIndex; + + /** @suppress {duplicate } */ + var _glGetUniformIndices = (program, uniformCount, uniformNames, uniformIndices) => { + if (!uniformIndices) { + // GLES2 specification does not specify how to behave if uniformIndices is a null pointer. Since calling this function does not make sense + // if uniformIndices == null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) { + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + var names = []; + for (var i = 0; i < uniformCount; i++) + names.push(UTF8ToString(HEAP32[(((uniformNames)+(i*4))>>2)])); + + var result = GLctx.getUniformIndices(program, names); + if (!result) return; // GL spec: If an error is generated, nothing is written out to uniformIndices. + + var len = result.length; + for (var i = 0; i < len; i++) { + HEAP32[(((uniformIndices)+(i*4))>>2)] = result[i];checkInt32(result[i]); + } + }; + var _emscripten_glGetUniformIndices = _glGetUniformIndices; + + /** @suppress {checkTypes} */ + var jstoi_q = (str) => parseInt(str); + + /** @noinline */ + var webglGetLeftBracePos = (name) => name.slice(-1) == ']' && name.lastIndexOf('['); + + var webglPrepareUniformLocationsBeforeFirstUse = (program) => { + var uniformLocsById = program.uniformLocsById, // Maps GLuint -> WebGLUniformLocation + uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, // Maps name -> [uniform array length, GLuint] + i, j; + + // On the first time invocation of glGetUniformLocation on this shader program: + // initialize cache data structures and discover which uniforms are arrays. + if (!uniformLocsById) { + // maps GLint integer locations to WebGLUniformLocations + program.uniformLocsById = uniformLocsById = {}; + // maps integer locations back to uniform name strings, so that we can lazily fetch uniform array locations + program.uniformArrayNamesById = {}; + + var numActiveUniforms = GLctx.getProgramParameter(program, 0x8B86/*GL_ACTIVE_UNIFORMS*/); + for (i = 0; i < numActiveUniforms; ++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; + + // Assign a new location. + var id = program.uniformIdCounter; + program.uniformIdCounter += sz; + // Eagerly get the location of the uniformArray[0] base element. + // The remaining indices >0 will be left for lazy evaluation to + // improve performance. Those may never be needed to fetch, if the + // application fills arrays always in full starting from the first + // element of the array. + uniformSizeAndIdsByName[arrayName] = [sz, id]; + + // Store placeholder integers in place that highlight that these + // >0 index locations are array indices pending population. + for (j = 0; j < sz; ++j) { + uniformLocsById[id] = j; + program.uniformArrayNamesById[id++] = arrayName; + } + } + } + }; + + + + /** @suppress {duplicate } */ + var _glGetUniformLocation = (program, name) => { + + name = UTF8ToString(name); + + if (program = GL.programs[program]) { + webglPrepareUniformLocationsBeforeFirstUse(program); + var uniformLocsById = program.uniformLocsById; // Maps GLuint -> WebGLUniformLocation + var arrayIndex = 0; + var uniformBaseName = name; + + // Invariant: when populating integer IDs for uniform locations, we must + // maintain the precondition that arrays reside in contiguous addresses, + // i.e. for a 'vec4 colors[10];', colors[4] must be at location + // colors[0]+4. However, user might call glGetUniformLocation(program, + // "colors") for an array, so we cannot discover based on the user input + // arguments whether the uniform we are dealing with is an array. The only + // way to discover which uniforms are arrays is to enumerate over all the + // active uniforms in the program. + var leftBrace = webglGetLeftBracePos(name); + + // If user passed an array accessor "[index]", parse the array index off the accessor. + if (leftBrace > 0) { + arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0; // "index]", coerce parseInt(']') with >>>0 to treat "foo[]" as "foo[0]" and foo[-1] as unsigned out-of-bounds. + uniformBaseName = name.slice(0, leftBrace); + } + + // Have we cached the location of this uniform before? + // A pair [array length, GLint of the uniform location] + var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName]; + + // If an uniform with this name exists, and if its index is within the + // array limits (if it's even an array), query the WebGLlocation, or + // return an existing cached location. + if (sizeAndId && arrayIndex < sizeAndId[0]) { + arrayIndex += sizeAndId[1]; // Add the base location of the uniform to the array index offset. + if ((uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name))) { + return arrayIndex; + } + } + } + else { + // N.b. we are currently unable to distinguish between GL program IDs that + // never existed vs GL program IDs that have been deleted, so report + // GL_INVALID_VALUE in both cases. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + } + return -1; + }; + var _emscripten_glGetUniformLocation = _glGetUniformLocation; + + var webglGetUniformLocation = (location) => { + var p = GLctx.currentProgram; + + if (p) { + var webglLoc = p.uniformLocsById[location]; + // p.uniformLocsById[location] stores either an integer, or a + // WebGLUniformLocation. + // If an integer, we have not yet bound the location, so do it now. The + // integer value specifies the array index we should bind to. + if (typeof webglLoc == 'number') { + p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? `[${webglLoc}]` : '')); + } + // Else an already cached WebGLUniformLocation, return it. + return webglLoc; + } else { + GL.recordError(0x502/*GL_INVALID_OPERATION*/); + } + }; + + + /** @suppress{checkTypes} */ + var emscriptenWebGLGetUniform = (program, location, params, type) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null + // pointer. Since calling this function does not make sense if params == + // null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + program = GL.programs[program]; + webglPrepareUniformLocationsBeforeFirstUse(program); + var data = GLctx.getUniform(program, webglGetUniformLocation(location)); + if (typeof data == 'number' || typeof data == 'boolean') { + switch (type) { + case 0: HEAP32[((params)>>2)] = data;checkInt32(data); break; + case 2: HEAPF32[((params)>>2)] = data; break; + } + } else { + for (var i = 0; i < data.length; i++) { + switch (type) { + case 0: HEAP32[(((params)+(i*4))>>2)] = data[i];checkInt32(data[i]); break; + case 2: HEAPF32[(((params)+(i*4))>>2)] = data[i]; break; + } + } + } + }; + + /** @suppress {duplicate } */ + var _glGetUniformfv = (program, location, params) => { + emscriptenWebGLGetUniform(program, location, params, 2); + }; + var _emscripten_glGetUniformfv = _glGetUniformfv; + + + /** @suppress {duplicate } */ + var _glGetUniformiv = (program, location, params) => { + emscriptenWebGLGetUniform(program, location, params, 0); + }; + var _emscripten_glGetUniformiv = _glGetUniformiv; + + /** @suppress {duplicate } */ + var _glGetUniformuiv = (program, location, params) => + emscriptenWebGLGetUniform(program, location, params, 0); + var _emscripten_glGetUniformuiv = _glGetUniformuiv; + + /** @suppress{checkTypes} */ + var emscriptenWebGLGetVertexAttrib = (index, pname, params, type) => { + if (!params) { + // GLES2 specification does not specify how to behave if params is a null + // pointer. Since calling this function does not make sense if params == + // null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + var data = GLctx.getVertexAttrib(index, pname); + if (pname == 0x889F/*VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/) { + HEAP32[((params)>>2)] = data && data["name"];checkInt32(data && data["name"]); + } else if (typeof data == 'number' || typeof data == 'boolean') { + switch (type) { + case 0: HEAP32[((params)>>2)] = data;checkInt32(data); break; + case 2: HEAPF32[((params)>>2)] = data; break; + case 5: HEAP32[((params)>>2)] = Math.fround(data);checkInt32(Math.fround(data)); break; + } + } else { + for (var i = 0; i < data.length; i++) { + switch (type) { + case 0: HEAP32[(((params)+(i*4))>>2)] = data[i];checkInt32(data[i]); break; + case 2: HEAPF32[(((params)+(i*4))>>2)] = data[i]; break; + case 5: HEAP32[(((params)+(i*4))>>2)] = Math.fround(data[i]);checkInt32(Math.fround(data[i])); break; + } + } + } + }; + /** @suppress {duplicate } */ + var _glGetVertexAttribIiv = (index, pname, params) => { + // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttribI4iv(), + // otherwise the results are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 0); + }; + var _emscripten_glGetVertexAttribIiv = _glGetVertexAttribIiv; + + + /** @suppress {duplicate } */ + var _glGetVertexAttribIuiv = _glGetVertexAttribIiv; + var _emscripten_glGetVertexAttribIuiv = _glGetVertexAttribIuiv; + + /** @suppress {duplicate } */ + var _glGetVertexAttribPointerv = (index, pname, pointer) => { + if (!pointer) { + // GLES2 specification does not specify how to behave if pointer is a null + // pointer. Since calling this function does not make sense if pointer == + // null, issue a GL error to notify user about it. + GL.recordError(0x501 /* GL_INVALID_VALUE */); + return; + } + HEAP32[((pointer)>>2)] = GLctx.getVertexAttribOffset(index, pname);checkInt32(GLctx.getVertexAttribOffset(index, pname)); + }; + var _emscripten_glGetVertexAttribPointerv = _glGetVertexAttribPointerv; + + + /** @suppress {duplicate } */ + var _glGetVertexAttribfv = (index, pname, params) => { + // N.B. This function may only be called if the vertex attribute was + // specified using the function glVertexAttrib*f(), otherwise the results + // are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 2); + }; + var _emscripten_glGetVertexAttribfv = _glGetVertexAttribfv; + + + /** @suppress {duplicate } */ + var _glGetVertexAttribiv = (index, pname, params) => { + // N.B. This function may only be called if the vertex attribute was + // specified using the function glVertexAttrib*f(), otherwise the results + // are undefined. (GLES3 spec 6.1.12) + emscriptenWebGLGetVertexAttrib(index, pname, params, 5); + }; + var _emscripten_glGetVertexAttribiv = _glGetVertexAttribiv; + + /** @suppress {duplicate } */ + var _glHint = (x0, x1) => GLctx.hint(x0, x1); + var _emscripten_glHint = _glHint; + + /** @suppress {duplicate } */ + var _glInvalidateFramebuffer = (target, numAttachments, attachments) => { + var list = tempFixedLengthArray[numAttachments]; + for (var i = 0; i < numAttachments; i++) { + list[i] = HEAP32[(((attachments)+(i*4))>>2)]; + } + + GLctx.invalidateFramebuffer(target, list); + }; + var _emscripten_glInvalidateFramebuffer = _glInvalidateFramebuffer; + + /** @suppress {duplicate } */ + var _glInvalidateSubFramebuffer = (target, numAttachments, attachments, x, y, width, height) => { + var list = tempFixedLengthArray[numAttachments]; + for (var i = 0; i < numAttachments; i++) { + list[i] = HEAP32[(((attachments)+(i*4))>>2)]; + } + + GLctx.invalidateSubFramebuffer(target, list, x, y, width, height); + }; + var _emscripten_glInvalidateSubFramebuffer = _glInvalidateSubFramebuffer; + + /** @suppress {duplicate } */ + var _glIsBuffer = (buffer) => { + var b = GL.buffers[buffer]; + if (!b) return 0; + return GLctx.isBuffer(b); + }; + var _emscripten_glIsBuffer = _glIsBuffer; + + /** @suppress {duplicate } */ + var _glIsEnabled = (x0) => GLctx.isEnabled(x0); + var _emscripten_glIsEnabled = _glIsEnabled; + + /** @suppress {duplicate } */ + var _glIsFramebuffer = (framebuffer) => { + var fb = GL.framebuffers[framebuffer]; + if (!fb) return 0; + return GLctx.isFramebuffer(fb); + }; + var _emscripten_glIsFramebuffer = _glIsFramebuffer; + + /** @suppress {duplicate } */ + var _glIsProgram = (program) => { + program = GL.programs[program]; + if (!program) return 0; + return GLctx.isProgram(program); + }; + var _emscripten_glIsProgram = _glIsProgram; + + /** @suppress {duplicate } */ + var _glIsQuery = (id) => { + var query = GL.queries[id]; + if (!query) return 0; + return GLctx.isQuery(query); + }; + var _emscripten_glIsQuery = _glIsQuery; + + /** @suppress {duplicate } */ + var _glIsQueryEXT = (id) => { + var query = GL.queries[id]; + if (!query) return 0; + return GLctx.disjointTimerQueryExt['isQueryEXT'](query); + }; + var _emscripten_glIsQueryEXT = _glIsQueryEXT; + + /** @suppress {duplicate } */ + var _glIsRenderbuffer = (renderbuffer) => { + var rb = GL.renderbuffers[renderbuffer]; + if (!rb) return 0; + return GLctx.isRenderbuffer(rb); + }; + var _emscripten_glIsRenderbuffer = _glIsRenderbuffer; + + /** @suppress {duplicate } */ + var _glIsSampler = (id) => { + var sampler = GL.samplers[id]; + if (!sampler) return 0; + return GLctx.isSampler(sampler); + }; + var _emscripten_glIsSampler = _glIsSampler; + + /** @suppress {duplicate } */ + var _glIsShader = (shader) => { + var s = GL.shaders[shader]; + if (!s) return 0; + return GLctx.isShader(s); + }; + var _emscripten_glIsShader = _glIsShader; + + /** @suppress {duplicate } */ + var _glIsSync = (sync) => GLctx.isSync(GL.syncs[sync]); + var _emscripten_glIsSync = _glIsSync; + + /** @suppress {duplicate } */ + var _glIsTexture = (id) => { + var texture = GL.textures[id]; + if (!texture) return 0; + return GLctx.isTexture(texture); + }; + var _emscripten_glIsTexture = _glIsTexture; + + /** @suppress {duplicate } */ + var _glIsTransformFeedback = (id) => GLctx.isTransformFeedback(GL.transformFeedbacks[id]); + var _emscripten_glIsTransformFeedback = _glIsTransformFeedback; + + /** @suppress {duplicate } */ + var _glIsVertexArray = (array) => { + + var vao = GL.vaos[array]; + if (!vao) return 0; + return GLctx.isVertexArray(vao); + }; + var _emscripten_glIsVertexArray = _glIsVertexArray; + + + /** @suppress {duplicate } */ + var _glIsVertexArrayOES = _glIsVertexArray; + var _emscripten_glIsVertexArrayOES = _glIsVertexArrayOES; + + /** @suppress {duplicate } */ + var _glLineWidth = (x0) => GLctx.lineWidth(x0); + var _emscripten_glLineWidth = _glLineWidth; + + /** @suppress {duplicate } */ + var _glLinkProgram = (program) => { + program = GL.programs[program]; + GLctx.linkProgram(program); + // Invalidate earlier computed uniform->ID mappings, those have now become stale + program.uniformLocsById = 0; // Mark as null-like so that glGetUniformLocation() knows to populate this again. + program.uniformSizeAndIdsByName = {}; + + }; + var _emscripten_glLinkProgram = _glLinkProgram; + + /** @suppress {duplicate } */ + var _glPauseTransformFeedback = () => GLctx.pauseTransformFeedback(); + var _emscripten_glPauseTransformFeedback = _glPauseTransformFeedback; + + /** @suppress {duplicate } */ + var _glPixelStorei = (pname, param) => { + if (pname == 3317) { + GL.unpackAlignment = param; + } else if (pname == 3314) { + GL.unpackRowLength = param; + } + GLctx.pixelStorei(pname, param); + }; + var _emscripten_glPixelStorei = _glPixelStorei; + + /** @suppress {duplicate } */ + var _glPolygonModeWEBGL = (face, mode) => { + GLctx.webglPolygonMode['polygonModeWEBGL'](face, mode); + }; + var _emscripten_glPolygonModeWEBGL = _glPolygonModeWEBGL; + + /** @suppress {duplicate } */ + var _glPolygonOffset = (x0, x1) => GLctx.polygonOffset(x0, x1); + var _emscripten_glPolygonOffset = _glPolygonOffset; + + /** @suppress {duplicate } */ + var _glPolygonOffsetClampEXT = (factor, units, clamp) => { + GLctx.extPolygonOffsetClamp['polygonOffsetClampEXT'](factor, units, clamp); + }; + var _emscripten_glPolygonOffsetClampEXT = _glPolygonOffsetClampEXT; + + /** @suppress {duplicate } */ + var _glProgramBinary = (program, binaryFormat, binary, length) => { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + }; + var _emscripten_glProgramBinary = _glProgramBinary; + + /** @suppress {duplicate } */ + var _glProgramParameteri = (program, pname, value) => { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + }; + var _emscripten_glProgramParameteri = _glProgramParameteri; + + /** @suppress {duplicate } */ + var _glQueryCounterEXT = (id, target) => { + GLctx.disjointTimerQueryExt['queryCounterEXT'](GL.queries[id], target); + }; + var _emscripten_glQueryCounterEXT = _glQueryCounterEXT; + + /** @suppress {duplicate } */ + var _glReadBuffer = (x0) => GLctx.readBuffer(x0); + var _emscripten_glReadBuffer = _glReadBuffer; + + var computeUnpackAlignedImageSize = (width, height, sizePerPixel) => { + function roundedToNextMultipleOf(x, y) { + return (x + y - 1) & -y; + } + var plainRowSize = (GL.unpackRowLength || width) * sizePerPixel; + var alignedRowSize = roundedToNextMultipleOf(plainRowSize, GL.unpackAlignment); + return height * alignedRowSize; + }; + + var colorChannelsInGlTextureFormat = (format) => { + // Micro-optimizations for size: map format to size by subtracting smallest + // enum value (0x1902) from all values first. Also omit the most common + // size value (1) from the list, which is assumed by formats not on the + // list. + var colorChannels = { + // 0x1902 /* GL_DEPTH_COMPONENT */ - 0x1902: 1, + // 0x1906 /* GL_ALPHA */ - 0x1902: 1, + 5: 3, + 6: 4, + // 0x1909 /* GL_LUMINANCE */ - 0x1902: 1, + 8: 2, + 29502: 3, + 29504: 4, + // 0x1903 /* GL_RED */ - 0x1902: 1, + 26917: 2, + 26918: 2, + // 0x8D94 /* GL_RED_INTEGER */ - 0x1902: 1, + 29846: 3, + 29847: 4 + }; + return colorChannels[format - 0x1902]||1; + }; + + var heapObjectForWebGLType = (type) => { + // Micro-optimization for size: Subtract lowest GL enum number (0x1400/* GL_BYTE */) from type to compare + // smaller values for the heap, for shorter generated code size. + // Also the type HEAPU16 is not tested for explicitly, but any unrecognized type will return out HEAPU16. + // (since most types are HEAPU16) + type -= 0x1400; + if (type == 0) return HEAP8; + + if (type == 1) return HEAPU8; + + if (type == 2) return HEAP16; + + if (type == 4) return HEAP32; + + if (type == 6) return HEAPF32; + + if (type == 5 + || type == 28922 + || type == 28520 + || type == 30779 + || type == 30782 + ) + return HEAPU32; + + return HEAPU16; + }; + + var toTypedArrayIndex = (pointer, heap) => + pointer >>> (31 - Math.clz32(heap.BYTES_PER_ELEMENT)); + + var emscriptenWebGLGetTexPixelData = (type, format, width, height, pixels, internalFormat) => { + var heap = heapObjectForWebGLType(type); + var sizePerPixel = colorChannelsInGlTextureFormat(format) * heap.BYTES_PER_ELEMENT; + var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel); + return heap.subarray(toTypedArrayIndex(pixels, heap), toTypedArrayIndex(pixels + bytes, heap)); + }; + + + + /** @suppress {duplicate } */ + var _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); + return; + } + var heap = heapObjectForWebGLType(type); + var target = toTypedArrayIndex(pixels, heap); + GLctx.readPixels(x, y, width, height, format, type, heap, target); + return; + } + var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format); + if (!pixelData) { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + return; + } + GLctx.readPixels(x, y, width, height, format, type, pixelData); + }; + var _emscripten_glReadPixels = _glReadPixels; + + /** @suppress {duplicate } */ + var _glReleaseShaderCompiler = () => { + // NOP (as allowed by GLES 2.0 spec) + }; + var _emscripten_glReleaseShaderCompiler = _glReleaseShaderCompiler; + + /** @suppress {duplicate } */ + var _glRenderbufferStorage = (x0, x1, x2, x3) => GLctx.renderbufferStorage(x0, x1, x2, x3); + var _emscripten_glRenderbufferStorage = _glRenderbufferStorage; + + /** @suppress {duplicate } */ + var _glRenderbufferStorageMultisample = (x0, x1, x2, x3, x4) => GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4); + var _emscripten_glRenderbufferStorageMultisample = _glRenderbufferStorageMultisample; + + /** @suppress {duplicate } */ + var _glResumeTransformFeedback = () => GLctx.resumeTransformFeedback(); + var _emscripten_glResumeTransformFeedback = _glResumeTransformFeedback; + + /** @suppress {duplicate } */ + var _glSampleCoverage = (value, invert) => { + GLctx.sampleCoverage(value, !!invert); + }; + var _emscripten_glSampleCoverage = _glSampleCoverage; + + /** @suppress {duplicate } */ + var _glSamplerParameterf = (sampler, pname, param) => { + GLctx.samplerParameterf(GL.samplers[sampler], pname, param); + }; + var _emscripten_glSamplerParameterf = _glSamplerParameterf; + + /** @suppress {duplicate } */ + var _glSamplerParameterfv = (sampler, pname, params) => { + var param = HEAPF32[((params)>>2)]; + GLctx.samplerParameterf(GL.samplers[sampler], pname, param); + }; + var _emscripten_glSamplerParameterfv = _glSamplerParameterfv; + + /** @suppress {duplicate } */ + var _glSamplerParameteri = (sampler, pname, param) => { + GLctx.samplerParameteri(GL.samplers[sampler], pname, param); + }; + var _emscripten_glSamplerParameteri = _glSamplerParameteri; + + /** @suppress {duplicate } */ + var _glSamplerParameteriv = (sampler, pname, params) => { + var param = HEAP32[((params)>>2)]; + GLctx.samplerParameteri(GL.samplers[sampler], pname, param); + }; + var _emscripten_glSamplerParameteriv = _glSamplerParameteriv; + + /** @suppress {duplicate } */ + var _glScissor = (x0, x1, x2, x3) => GLctx.scissor(x0, x1, x2, x3); + var _emscripten_glScissor = _glScissor; + + /** @suppress {duplicate } */ + var _glShaderBinary = (count, shaders, binaryformat, binary, length) => { + GL.recordError(0x500/*GL_INVALID_ENUM*/); + }; + var _emscripten_glShaderBinary = _glShaderBinary; + + /** @suppress {duplicate } */ + var _glShaderSource = (shader, count, string, length) => { + var source = GL.getSource(shader, count, string, length); + + GLctx.shaderSource(GL.shaders[shader], source); + }; + var _emscripten_glShaderSource = _glShaderSource; + + /** @suppress {duplicate } */ + var _glStencilFunc = (x0, x1, x2) => GLctx.stencilFunc(x0, x1, x2); + var _emscripten_glStencilFunc = _glStencilFunc; + + /** @suppress {duplicate } */ + var _glStencilFuncSeparate = (x0, x1, x2, x3) => GLctx.stencilFuncSeparate(x0, x1, x2, x3); + var _emscripten_glStencilFuncSeparate = _glStencilFuncSeparate; + + /** @suppress {duplicate } */ + var _glStencilMask = (x0) => GLctx.stencilMask(x0); + var _emscripten_glStencilMask = _glStencilMask; + + /** @suppress {duplicate } */ + var _glStencilMaskSeparate = (x0, x1) => GLctx.stencilMaskSeparate(x0, x1); + var _emscripten_glStencilMaskSeparate = _glStencilMaskSeparate; + + /** @suppress {duplicate } */ + var _glStencilOp = (x0, x1, x2) => GLctx.stencilOp(x0, x1, x2); + var _emscripten_glStencilOp = _glStencilOp; + + /** @suppress {duplicate } */ + var _glStencilOpSeparate = (x0, x1, x2, x3) => GLctx.stencilOpSeparate(x0, x1, x2, x3); + var _emscripten_glStencilOpSeparate = _glStencilOpSeparate; + + + + + /** @suppress {duplicate } */ + var _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); + return; + } + if (pixels) { + var heap = heapObjectForWebGLType(type); + var index = toTypedArrayIndex(pixels, heap); + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, index); + return; + } + } + var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null; + GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixelData); + }; + var _emscripten_glTexImage2D = _glTexImage2D; + + + /** @suppress {duplicate } */ + var _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, toTypedArrayIndex(pixels, heap)); + } else { + GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, null); + } + }; + var _emscripten_glTexImage3D = _glTexImage3D; + + /** @suppress {duplicate } */ + var _glTexParameterf = (x0, x1, x2) => GLctx.texParameterf(x0, x1, x2); + var _emscripten_glTexParameterf = _glTexParameterf; + + /** @suppress {duplicate } */ + var _glTexParameterfv = (target, pname, params) => { + var param = HEAPF32[((params)>>2)]; + GLctx.texParameterf(target, pname, param); + }; + var _emscripten_glTexParameterfv = _glTexParameterfv; + + /** @suppress {duplicate } */ + var _glTexParameteri = (x0, x1, x2) => GLctx.texParameteri(x0, x1, x2); + var _emscripten_glTexParameteri = _glTexParameteri; + + /** @suppress {duplicate } */ + var _glTexParameteriv = (target, pname, params) => { + var param = HEAP32[((params)>>2)]; + GLctx.texParameteri(target, pname, param); + }; + var _emscripten_glTexParameteriv = _glTexParameteriv; + + /** @suppress {duplicate } */ + var _glTexStorage2D = (x0, x1, x2, x3, x4) => GLctx.texStorage2D(x0, x1, x2, x3, x4); + var _emscripten_glTexStorage2D = _glTexStorage2D; + + /** @suppress {duplicate } */ + var _glTexStorage3D = (x0, x1, x2, x3, x4, x5) => GLctx.texStorage3D(x0, x1, x2, x3, x4, x5); + var _emscripten_glTexStorage3D = _glTexStorage3D; + + + + + /** @suppress {duplicate } */ + var _glTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, type, pixels) => { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + return; + } + if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, toTypedArrayIndex(pixels, heap)); + return; + } + } + var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0) : null; + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData); + }; + var _emscripten_glTexSubImage2D = _glTexSubImage2D; + + + /** @suppress {duplicate } */ + var _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, toTypedArrayIndex(pixels, heap)); + } else { + GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null); + } + }; + var _emscripten_glTexSubImage3D = _glTexSubImage3D; + + /** @suppress {duplicate } */ + var _glTransformFeedbackVaryings = (program, count, varyings, bufferMode) => { + program = GL.programs[program]; + var vars = []; + for (var i = 0; i < count; i++) + vars.push(UTF8ToString(HEAP32[(((varyings)+(i*4))>>2)])); + + GLctx.transformFeedbackVaryings(program, vars, bufferMode); + }; + var _emscripten_glTransformFeedbackVaryings = _glTransformFeedbackVaryings; + + + /** @suppress {duplicate } */ + var _glUniform1f = (location, v0) => { + GLctx.uniform1f(webglGetUniformLocation(location), v0); + }; + var _emscripten_glUniform1f = _glUniform1f; + + + var miniTempWebGLFloatBuffers = []; + + /** @suppress {duplicate } */ + var _glUniform1fv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count); + return; + } + + if (count <= 288) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[count]; + for (var i = 0; i < count; ++i) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + } + } else + { + var view = HEAPF32.subarray((((value)>>2)), ((value+count*4)>>2)); + } + GLctx.uniform1fv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform1fv = _glUniform1fv; + + + /** @suppress {duplicate } */ + var _glUniform1i = (location, v0) => { + GLctx.uniform1i(webglGetUniformLocation(location), v0); + }; + var _emscripten_glUniform1i = _glUniform1i; + + + var miniTempWebGLIntBuffers = []; + + /** @suppress {duplicate } */ + var _glUniform1iv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count); + return; + } + + if (count <= 288) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLIntBuffers[count]; + for (var i = 0; i < count; ++i) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + } + } else + { + var view = HEAP32.subarray((((value)>>2)), ((value+count*4)>>2)); + } + GLctx.uniform1iv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform1iv = _glUniform1iv; + + /** @suppress {duplicate } */ + var _glUniform1ui = (location, v0) => { + GLctx.uniform1ui(webglGetUniformLocation(location), v0); + }; + var _emscripten_glUniform1ui = _glUniform1ui; + + /** @suppress {duplicate } */ + var _glUniform1uiv = (location, count, value) => { + count && GLctx.uniform1uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count); + }; + var _emscripten_glUniform1uiv = _glUniform1uiv; + + + /** @suppress {duplicate } */ + var _glUniform2f = (location, v0, v1) => { + GLctx.uniform2f(webglGetUniformLocation(location), v0, v1); + }; + var _emscripten_glUniform2f = _glUniform2f; + + + + /** @suppress {duplicate } */ + var _glUniform2fv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count*2); + return; + } + + if (count <= 144) { + // avoid allocation when uploading few enough uniforms + count *= 2; + var view = miniTempWebGLFloatBuffers[count]; + for (var i = 0; i < count; i += 2) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + } + } else + { + var view = HEAPF32.subarray((((value)>>2)), ((value+count*8)>>2)); + } + GLctx.uniform2fv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform2fv = _glUniform2fv; + + + /** @suppress {duplicate } */ + var _glUniform2i = (location, v0, v1) => { + GLctx.uniform2i(webglGetUniformLocation(location), v0, v1); + }; + var _emscripten_glUniform2i = _glUniform2i; + + + + /** @suppress {duplicate } */ + var _glUniform2iv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count*2); + return; + } + + if (count <= 144) { + // avoid allocation when uploading few enough uniforms + count *= 2; + var view = miniTempWebGLIntBuffers[count]; + for (var i = 0; i < count; i += 2) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + view[i+1] = HEAP32[(((value)+(4*i+4))>>2)]; + } + } else + { + var view = HEAP32.subarray((((value)>>2)), ((value+count*8)>>2)); + } + GLctx.uniform2iv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform2iv = _glUniform2iv; + + /** @suppress {duplicate } */ + var _glUniform2ui = (location, v0, v1) => { + GLctx.uniform2ui(webglGetUniformLocation(location), v0, v1); + }; + var _emscripten_glUniform2ui = _glUniform2ui; + + /** @suppress {duplicate } */ + var _glUniform2uiv = (location, count, value) => { + count && GLctx.uniform2uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count*2); + }; + var _emscripten_glUniform2uiv = _glUniform2uiv; + + + /** @suppress {duplicate } */ + var _glUniform3f = (location, v0, v1, v2) => { + GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2); + }; + var _emscripten_glUniform3f = _glUniform3f; + + + + /** @suppress {duplicate } */ + var _glUniform3fv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count*3); + return; + } + + if (count <= 96) { + // avoid allocation when uploading few enough uniforms + count *= 3; + var view = miniTempWebGLFloatBuffers[count]; + for (var i = 0; i < count; i += 3) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)]; + } + } else + { + var view = HEAPF32.subarray((((value)>>2)), ((value+count*12)>>2)); + } + GLctx.uniform3fv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform3fv = _glUniform3fv; + + + /** @suppress {duplicate } */ + var _glUniform3i = (location, v0, v1, v2) => { + GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2); + }; + var _emscripten_glUniform3i = _glUniform3i; + + + + /** @suppress {duplicate } */ + var _glUniform3iv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count*3); + return; + } + + if (count <= 96) { + // avoid allocation when uploading few enough uniforms + count *= 3; + var view = miniTempWebGLIntBuffers[count]; + for (var i = 0; i < count; i += 3) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + view[i+1] = HEAP32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAP32[(((value)+(4*i+8))>>2)]; + } + } else + { + var view = HEAP32.subarray((((value)>>2)), ((value+count*12)>>2)); + } + GLctx.uniform3iv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform3iv = _glUniform3iv; + + /** @suppress {duplicate } */ + var _glUniform3ui = (location, v0, v1, v2) => { + GLctx.uniform3ui(webglGetUniformLocation(location), v0, v1, v2); + }; + var _emscripten_glUniform3ui = _glUniform3ui; + + /** @suppress {duplicate } */ + var _glUniform3uiv = (location, count, value) => { + count && GLctx.uniform3uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count*3); + }; + var _emscripten_glUniform3uiv = _glUniform3uiv; + + + /** @suppress {duplicate } */ + var _glUniform4f = (location, v0, v1, v2, v3) => { + GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3); + }; + var _emscripten_glUniform4f = _glUniform4f; + + + + /** @suppress {duplicate } */ + var _glUniform4fv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count*4); + return; + } + + if (count <= 72) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[4*count]; + // hoist the heap out of the loop for size and for pthreads+growth. + var heap = HEAPF32; + value = ((value)>>2); + count *= 4; + for (var i = 0; i < 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 = HEAPF32.subarray((((value)>>2)), ((value+count*16)>>2)); + } + GLctx.uniform4fv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform4fv = _glUniform4fv; + + + /** @suppress {duplicate } */ + var _glUniform4i = (location, v0, v1, v2, v3) => { + GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3); + }; + var _emscripten_glUniform4i = _glUniform4i; + + + + /** @suppress {duplicate } */ + var _glUniform4iv = (location, count, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count*4); + return; + } + + if (count <= 72) { + // avoid allocation when uploading few enough uniforms + count *= 4; + var view = miniTempWebGLIntBuffers[count]; + for (var i = 0; i < count; i += 4) { + view[i] = HEAP32[(((value)+(4*i))>>2)]; + view[i+1] = HEAP32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAP32[(((value)+(4*i+8))>>2)]; + view[i+3] = HEAP32[(((value)+(4*i+12))>>2)]; + } + } else + { + var view = HEAP32.subarray((((value)>>2)), ((value+count*16)>>2)); + } + GLctx.uniform4iv(webglGetUniformLocation(location), view); + }; + var _emscripten_glUniform4iv = _glUniform4iv; + + /** @suppress {duplicate } */ + var _glUniform4ui = (location, v0, v1, v2, v3) => { + GLctx.uniform4ui(webglGetUniformLocation(location), v0, v1, v2, v3); + }; + var _emscripten_glUniform4ui = _glUniform4ui; + + /** @suppress {duplicate } */ + var _glUniform4uiv = (location, count, value) => { + count && GLctx.uniform4uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count*4); + }; + var _emscripten_glUniform4uiv = _glUniform4uiv; + + /** @suppress {duplicate } */ + var _glUniformBlockBinding = (program, uniformBlockIndex, uniformBlockBinding) => { + program = GL.programs[program]; + + GLctx.uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); + }; + var _emscripten_glUniformBlockBinding = _glUniformBlockBinding; + + + + /** @suppress {duplicate } */ + var _glUniformMatrix2fv = (location, count, transpose, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*4); + return; + } + + if (count <= 72) { + // avoid allocation when uploading few enough uniforms + count *= 4; + var view = miniTempWebGLFloatBuffers[count]; + for (var i = 0; i < count; i += 4) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)]; + view[i+3] = HEAPF32[(((value)+(4*i+12))>>2)]; + } + } else + { + var view = HEAPF32.subarray((((value)>>2)), ((value+count*16)>>2)); + } + GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view); + }; + var _emscripten_glUniformMatrix2fv = _glUniformMatrix2fv; + + /** @suppress {duplicate } */ + var _glUniformMatrix2x3fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix2x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*6); + }; + var _emscripten_glUniformMatrix2x3fv = _glUniformMatrix2x3fv; + + /** @suppress {duplicate } */ + var _glUniformMatrix2x4fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix2x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*8); + }; + var _emscripten_glUniformMatrix2x4fv = _glUniformMatrix2x4fv; + + + + /** @suppress {duplicate } */ + var _glUniformMatrix3fv = (location, count, transpose, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*9); + return; + } + + if (count <= 32) { + // avoid allocation when uploading few enough uniforms + count *= 9; + var view = miniTempWebGLFloatBuffers[count]; + for (var i = 0; i < count; i += 9) { + view[i] = HEAPF32[(((value)+(4*i))>>2)]; + view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)]; + view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)]; + view[i+3] = HEAPF32[(((value)+(4*i+12))>>2)]; + view[i+4] = HEAPF32[(((value)+(4*i+16))>>2)]; + view[i+5] = HEAPF32[(((value)+(4*i+20))>>2)]; + view[i+6] = HEAPF32[(((value)+(4*i+24))>>2)]; + view[i+7] = HEAPF32[(((value)+(4*i+28))>>2)]; + view[i+8] = HEAPF32[(((value)+(4*i+32))>>2)]; + } + } else + { + var view = HEAPF32.subarray((((value)>>2)), ((value+count*36)>>2)); + } + GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view); + }; + var _emscripten_glUniformMatrix3fv = _glUniformMatrix3fv; + + /** @suppress {duplicate } */ + var _glUniformMatrix3x2fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix3x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*6); + }; + var _emscripten_glUniformMatrix3x2fv = _glUniformMatrix3x2fv; + + /** @suppress {duplicate } */ + var _glUniformMatrix3x4fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix3x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*12); + }; + var _emscripten_glUniformMatrix3x4fv = _glUniformMatrix3x4fv; + + + + /** @suppress {duplicate } */ + var _glUniformMatrix4fv = (location, count, transpose, value) => { + + if (GL.currentContext.version >= 2) { + count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*16); + return; + } + + if (count <= 18) { + // avoid allocation when uploading few enough uniforms + var view = miniTempWebGLFloatBuffers[16*count]; + // hoist the heap out of the loop for size and for pthreads+growth. + var heap = HEAPF32; + value = ((value)>>2); + count *= 16; + for (var i = 0; i < 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 = HEAPF32.subarray((((value)>>2)), ((value+count*64)>>2)); + } + GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view); + }; + var _emscripten_glUniformMatrix4fv = _glUniformMatrix4fv; + + /** @suppress {duplicate } */ + var _glUniformMatrix4x2fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix4x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*8); + }; + var _emscripten_glUniformMatrix4x2fv = _glUniformMatrix4x2fv; + + /** @suppress {duplicate } */ + var _glUniformMatrix4x3fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix4x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*12); + }; + var _emscripten_glUniformMatrix4x3fv = _glUniformMatrix4x3fv; + + /** @suppress {duplicate } */ + var _glUseProgram = (program) => { + program = GL.programs[program]; + GLctx.useProgram(program); + // Record the currently active program so that we can access the uniform + // mapping table of that program. + GLctx.currentProgram = program; + }; + var _emscripten_glUseProgram = _glUseProgram; + + /** @suppress {duplicate } */ + var _glValidateProgram = (program) => { + GLctx.validateProgram(GL.programs[program]); + }; + var _emscripten_glValidateProgram = _glValidateProgram; + + /** @suppress {duplicate } */ + var _glVertexAttrib1f = (x0, x1) => GLctx.vertexAttrib1f(x0, x1); + var _emscripten_glVertexAttrib1f = _glVertexAttrib1f; + + /** @suppress {duplicate } */ + var _glVertexAttrib1fv = (index, v) => { + + GLctx.vertexAttrib1f(index, HEAPF32[v>>2]); + }; + var _emscripten_glVertexAttrib1fv = _glVertexAttrib1fv; + + /** @suppress {duplicate } */ + var _glVertexAttrib2f = (x0, x1, x2) => GLctx.vertexAttrib2f(x0, x1, x2); + var _emscripten_glVertexAttrib2f = _glVertexAttrib2f; + + /** @suppress {duplicate } */ + var _glVertexAttrib2fv = (index, v) => { + + GLctx.vertexAttrib2f(index, HEAPF32[v>>2], HEAPF32[v+4>>2]); + }; + var _emscripten_glVertexAttrib2fv = _glVertexAttrib2fv; + + /** @suppress {duplicate } */ + var _glVertexAttrib3f = (x0, x1, x2, x3) => GLctx.vertexAttrib3f(x0, x1, x2, x3); + var _emscripten_glVertexAttrib3f = _glVertexAttrib3f; + + /** @suppress {duplicate } */ + var _glVertexAttrib3fv = (index, v) => { + + GLctx.vertexAttrib3f(index, HEAPF32[v>>2], HEAPF32[v+4>>2], HEAPF32[v+8>>2]); + }; + var _emscripten_glVertexAttrib3fv = _glVertexAttrib3fv; + + /** @suppress {duplicate } */ + var _glVertexAttrib4f = (x0, x1, x2, x3, x4) => GLctx.vertexAttrib4f(x0, x1, x2, x3, x4); + var _emscripten_glVertexAttrib4f = _glVertexAttrib4f; + + /** @suppress {duplicate } */ + var _glVertexAttrib4fv = (index, v) => { + + GLctx.vertexAttrib4f(index, HEAPF32[v>>2], HEAPF32[v+4>>2], HEAPF32[v+8>>2], HEAPF32[v+12>>2]); + }; + var _emscripten_glVertexAttrib4fv = _glVertexAttrib4fv; + + /** @suppress {duplicate } */ + var _glVertexAttribDivisor = (index, divisor) => { + GLctx.vertexAttribDivisor(index, divisor); + }; + var _emscripten_glVertexAttribDivisor = _glVertexAttribDivisor; + + + /** @suppress {duplicate } */ + var _glVertexAttribDivisorANGLE = _glVertexAttribDivisor; + var _emscripten_glVertexAttribDivisorANGLE = _glVertexAttribDivisorANGLE; + + + /** @suppress {duplicate } */ + var _glVertexAttribDivisorARB = _glVertexAttribDivisor; + var _emscripten_glVertexAttribDivisorARB = _glVertexAttribDivisorARB; + + + /** @suppress {duplicate } */ + var _glVertexAttribDivisorEXT = _glVertexAttribDivisor; + var _emscripten_glVertexAttribDivisorEXT = _glVertexAttribDivisorEXT; + + + /** @suppress {duplicate } */ + var _glVertexAttribDivisorNV = _glVertexAttribDivisor; + var _emscripten_glVertexAttribDivisorNV = _glVertexAttribDivisorNV; + + /** @suppress {duplicate } */ + var _glVertexAttribI4i = (x0, x1, x2, x3, x4) => GLctx.vertexAttribI4i(x0, x1, x2, x3, x4); + var _emscripten_glVertexAttribI4i = _glVertexAttribI4i; + + /** @suppress {duplicate } */ + var _glVertexAttribI4iv = (index, v) => { + GLctx.vertexAttribI4i(index, HEAP32[v>>2], HEAP32[v+4>>2], HEAP32[v+8>>2], HEAP32[v+12>>2]); + }; + var _emscripten_glVertexAttribI4iv = _glVertexAttribI4iv; + + /** @suppress {duplicate } */ + var _glVertexAttribI4ui = (x0, x1, x2, x3, x4) => GLctx.vertexAttribI4ui(x0, x1, x2, x3, x4); + var _emscripten_glVertexAttribI4ui = _glVertexAttribI4ui; + + /** @suppress {duplicate } */ + var _glVertexAttribI4uiv = (index, v) => { + GLctx.vertexAttribI4ui(index, HEAPU32[v>>2], HEAPU32[v+4>>2], HEAPU32[v+8>>2], HEAPU32[v+12>>2]); + }; + var _emscripten_glVertexAttribI4uiv = _glVertexAttribI4uiv; + + /** @suppress {duplicate } */ + var _glVertexAttribIPointer = (index, size, type, stride, ptr) => { + GLctx.vertexAttribIPointer(index, size, type, stride, ptr); + }; + var _emscripten_glVertexAttribIPointer = _glVertexAttribIPointer; + + /** @suppress {duplicate } */ + var _glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => { + GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + }; + var _emscripten_glVertexAttribPointer = _glVertexAttribPointer; + + /** @suppress {duplicate } */ + var _glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3); + var _emscripten_glViewport = _glViewport; + + /** @suppress {duplicate } */ + var _glWaitSync = (sync, flags, timeout_low, timeout_high) => { + // See WebGL2 vs GLES3 difference on GL_TIMEOUT_IGNORED above (https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15) + var timeout = convertI32PairToI53(timeout_low, timeout_high); + GLctx.waitSync(GL.syncs[sync], flags, timeout); + }; + var _emscripten_glWaitSync = _glWaitSync; + + var getHeapMax = () => + HEAPU8.length; + + + + var abortOnCannotGrowMemory = (requestedSize) => { + abort(`Cannot enlarge memory arrays to size ${requestedSize} bytes (OOM). Either (1) compile with -sINITIAL_MEMORY=X with X higher than the current value ${HEAP8.length}, (2) compile with -sALLOW_MEMORY_GROWTH which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -sABORTING_MALLOC=0`); + }; + var _emscripten_resize_heap = (requestedSize) => { + var oldSize = HEAPU8.length; + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + requestedSize >>>= 0; + abortOnCannotGrowMemory(requestedSize); + }; + + /** @suppress {checkTypes} */ + var _emscripten_sample_gamepad_data = () => { + try { + if (navigator.getGamepads) return (JSEvents.lastGamepadState = navigator.getGamepads()) + ? 0 : -1; + } catch(e) { + err(`navigator.getGamepads() exists, but failed to execute with exception ${e}. Disabling Gamepad access.`); + navigator.getGamepads = null; // Disable getGamepads() so that it won't be attempted to be used again. + } + return -1; + }; + + + var findCanvasEventTarget = findEventTarget; + var _emscripten_set_canvas_element_size = (target, width, height) => { + var canvas = findCanvasEventTarget(target); + if (!canvas) return -4; + canvas.width = width; + canvas.height = height; + return 0; + }; + + + + + var fillMouseEventData = (eventStruct, e, target) => { + assert(eventStruct % 4 == 0); + HEAPF64[((eventStruct)>>3)] = e.timeStamp; + var idx = ((eventStruct)>>2); + HEAP32[idx + 2] = e.screenX; + HEAP32[idx + 3] = e.screenY; + HEAP32[idx + 4] = e.clientX; + HEAP32[idx + 5] = e.clientY; + HEAP8[eventStruct + 24] = e.ctrlKey; + HEAP8[eventStruct + 25] = e.shiftKey; + HEAP8[eventStruct + 26] = e.altKey; + HEAP8[eventStruct + 27] = e.metaKey; + HEAP16[idx*2 + 14] = e.button; + HEAP16[idx*2 + 15] = e.buttons; + + HEAP32[idx + 8] = e["movementX"] + ; + + HEAP32[idx + 9] = e["movementY"] + ; + + // Note: rect contains doubles (truncated to placate SAFE_HEAP, which is the same behaviour when writing to HEAP32 anyway) + var rect = getBoundingClientRect(target); + HEAP32[idx + 10] = e.clientX - (rect.left | 0); + HEAP32[idx + 11] = e.clientY - (rect.top | 0); + + }; + + + var registerMouseEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => { + JSEvents.mouseEvent ||= _malloc(64); + target = findEventTarget(target); + + var mouseEventHandlerFunc = (e = event) => { + // TODO: Make this access thread safe, or this could update live while app is reading it. + fillMouseEventData(JSEvents.mouseEvent, e, target); + + if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, JSEvents.mouseEvent, userData)) e.preventDefault(); + }; + + var eventHandler = { + target, + allowsDeferredCalls: eventTypeString != 'mousemove' && eventTypeString != 'mouseenter' && eventTypeString != 'mouseleave', // Mouse move events do not allow fullscreen/pointer lock requests to be handled in them! + eventTypeString, + callbackfunc, + handlerFunc: mouseEventHandlerFunc, + useCapture + }; + return JSEvents.registerOrRemoveHandler(eventHandler); + }; + var _emscripten_set_click_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => + registerMouseEventCallback(target, userData, useCapture, callbackfunc, 4, "click", targetThread); + + + + + var fillFullscreenChangeEventData = (eventStruct) => { + var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement; + var isFullscreen = !!fullscreenElement; + // Assigning a boolean to HEAP32 with expected type coercion. + /** @suppress{checkTypes} */ + HEAP8[eventStruct] = isFullscreen;checkInt8(isFullscreen); + HEAP8[(eventStruct)+(1)] = JSEvents.fullscreenEnabled();checkInt8(JSEvents.fullscreenEnabled()); + // If transitioning to fullscreen, report info about the element that is now fullscreen. + // If transitioning to windowed mode, report info about the element that just was fullscreen. + var reportedElement = isFullscreen ? fullscreenElement : JSEvents.previousFullscreenElement; + var nodeName = JSEvents.getNodeNameForTarget(reportedElement); + var id = reportedElement?.id || ''; + stringToUTF8(nodeName, eventStruct + 2, 128); + stringToUTF8(id, eventStruct + 130, 128); + HEAP32[(((eventStruct)+(260))>>2)] = reportedElement ? reportedElement.clientWidth : 0;checkInt32(reportedElement ? reportedElement.clientWidth : 0); + HEAP32[(((eventStruct)+(264))>>2)] = reportedElement ? reportedElement.clientHeight : 0;checkInt32(reportedElement ? reportedElement.clientHeight : 0); + HEAP32[(((eventStruct)+(268))>>2)] = screen.width;checkInt32(screen.width); + HEAP32[(((eventStruct)+(272))>>2)] = screen.height;checkInt32(screen.height); + if (isFullscreen) { + JSEvents.previousFullscreenElement = fullscreenElement; + } + }; + + + var registerFullscreenChangeEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => { + JSEvents.fullscreenChangeEvent ||= _malloc(276); + + var fullscreenChangeEventhandlerFunc = (e = event) => { + var fullscreenChangeEvent = JSEvents.fullscreenChangeEvent; + + fillFullscreenChangeEventData(fullscreenChangeEvent); + + if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, fullscreenChangeEvent, userData)) e.preventDefault(); + }; + + var eventHandler = { + target, + eventTypeString, + callbackfunc, + handlerFunc: fullscreenChangeEventhandlerFunc, + useCapture + }; + return JSEvents.registerOrRemoveHandler(eventHandler); + }; + + + var _emscripten_set_fullscreenchange_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => { + if (!JSEvents.fullscreenEnabled()) return -1; + target = findEventTarget(target); + if (!target) return -4; + + // Unprefixed Fullscreen API shipped in Chromium 71 (https://bugs.chromium.org/p/chromium/issues/detail?id=383813) + // As of Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitfullscreenchange. TODO: revisit this check once Safari ships unprefixed version. + registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "webkitfullscreenchange", targetThread); + + return registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "fullscreenchange", targetThread); + }; + + + + + var registerGamepadEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => { + JSEvents.gamepadEvent ||= _malloc(1240); + + var gamepadEventHandlerFunc = (e = event) => { + var gamepadEvent = JSEvents.gamepadEvent; + fillGamepadEventData(gamepadEvent, e["gamepad"]); + + if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, gamepadEvent, userData)) e.preventDefault(); + }; + + var eventHandler = { + target: findEventTarget(target), + allowsDeferredCalls: true, + eventTypeString, + callbackfunc, + handlerFunc: gamepadEventHandlerFunc, + useCapture + }; + return JSEvents.registerOrRemoveHandler(eventHandler); + }; + + var _emscripten_set_gamepadconnected_callback_on_thread = (userData, useCapture, callbackfunc, targetThread) => { + if (_emscripten_sample_gamepad_data()) return -1; + return registerGamepadEventCallback(2, userData, useCapture, callbackfunc, 26, "gamepadconnected", targetThread); + }; + + + var _emscripten_set_gamepaddisconnected_callback_on_thread = (userData, useCapture, callbackfunc, targetThread) => { + if (_emscripten_sample_gamepad_data()) return -1; + return registerGamepadEventCallback(2, userData, useCapture, callbackfunc, 27, "gamepaddisconnected", targetThread); + }; + + + + var registerUiEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => { + JSEvents.uiEvent ||= _malloc(36); + + target = findEventTarget(target); + + var uiEventHandlerFunc = (e = event) => { + if (e.target != target) { + // Never take ui events such as scroll via a 'bubbled' route, but always from the direct element that + // was targeted. Otherwise e.g. if app logs a message in response to a page scroll, the Emscripten log + // message box could cause to scroll, generating a new (bubbled) scroll message, causing a new log print, + // causing a new scroll, etc.. + return; + } + var b = document.body; // Take document.body to a variable, Closure compiler does not outline access to it on its own. + if (!b) { + // During a page unload 'body' can be null, with "Cannot read property 'clientWidth' of null" being thrown + return; + } + var uiEvent = JSEvents.uiEvent; + HEAP32[((uiEvent)>>2)] = 0;checkInt32(0); // always zero for resize and scroll + HEAP32[(((uiEvent)+(4))>>2)] = b.clientWidth;checkInt32(b.clientWidth); + HEAP32[(((uiEvent)+(8))>>2)] = b.clientHeight;checkInt32(b.clientHeight); + HEAP32[(((uiEvent)+(12))>>2)] = innerWidth;checkInt32(innerWidth); + HEAP32[(((uiEvent)+(16))>>2)] = innerHeight;checkInt32(innerHeight); + HEAP32[(((uiEvent)+(20))>>2)] = outerWidth;checkInt32(outerWidth); + HEAP32[(((uiEvent)+(24))>>2)] = outerHeight;checkInt32(outerHeight); + HEAP32[(((uiEvent)+(28))>>2)] = pageXOffset | 0;checkInt32(pageXOffset | 0); // scroll offsets are float + HEAP32[(((uiEvent)+(32))>>2)] = pageYOffset | 0;checkInt32(pageYOffset | 0); + if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, uiEvent, userData)) e.preventDefault(); + }; + + var eventHandler = { + target, + eventTypeString, + callbackfunc, + handlerFunc: uiEventHandlerFunc, + useCapture + }; + return JSEvents.registerOrRemoveHandler(eventHandler); + }; + var _emscripten_set_resize_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => + registerUiEventCallback(target, userData, useCapture, callbackfunc, 10, "resize", targetThread); + + + + + var registerTouchEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => { + JSEvents.touchEvent ||= _malloc(1552); + + target = findEventTarget(target); + + var touchEventHandlerFunc = (e) => { + assert(e); + var t, touches = {}, et = e.touches; + // To ease marshalling different kinds of touches that browser reports (all touches are listed in e.touches, + // only changed touches in e.changedTouches, and touches on target at a.targetTouches), mark a boolean in + // each Touch object so that we can later loop only once over all touches we see to marshall over to Wasm. + + for (let t of et) { + // Browser might recycle the generated Touch objects between each frame (Firefox on Android), so reset any + // changed/target states we may have set from previous frame. + t.isChanged = t.onTarget = 0; + touches[t.identifier] = t; + } + // Mark which touches are part of the changedTouches list. + for (let t of e.changedTouches) { + t.isChanged = 1; + touches[t.identifier] = t; + } + // Mark which touches are part of the targetTouches list. + for (let t of e.targetTouches) { + touches[t.identifier].onTarget = 1; + } + + var touchEvent = JSEvents.touchEvent; + HEAPF64[((touchEvent)>>3)] = e.timeStamp; + HEAP8[touchEvent + 12] = e.ctrlKey; + HEAP8[touchEvent + 13] = e.shiftKey; + HEAP8[touchEvent + 14] = e.altKey; + HEAP8[touchEvent + 15] = e.metaKey; + var idx = touchEvent + 16; + var targetRect = getBoundingClientRect(target); + var numTouches = 0; + for (let t of Object.values(touches)) { + var idx32 = ((idx)>>2); // Pre-shift the ptr to index to HEAP32 to save code size + HEAP32[idx32 + 0] = t.identifier; + HEAP32[idx32 + 1] = t.screenX; + HEAP32[idx32 + 2] = t.screenY; + HEAP32[idx32 + 3] = t.clientX; + HEAP32[idx32 + 4] = t.clientY; + HEAP32[idx32 + 5] = t.pageX; + HEAP32[idx32 + 6] = t.pageY; + HEAP8[idx + 28] = t.isChanged; + HEAP8[idx + 29] = t.onTarget; + HEAP32[idx32 + 8] = t.clientX - (targetRect.left | 0); + HEAP32[idx32 + 9] = t.clientY - (targetRect.top | 0); + + idx += 48; + + if (++numTouches > 31) { + break; + } + } + HEAP32[(((touchEvent)+(8))>>2)] = numTouches;checkInt32(numTouches); + + if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, touchEvent, userData)) e.preventDefault(); + }; + + var eventHandler = { + target, + allowsDeferredCalls: eventTypeString == 'touchstart' || eventTypeString == 'touchend', + eventTypeString, + callbackfunc, + handlerFunc: touchEventHandlerFunc, + useCapture + }; + return JSEvents.registerOrRemoveHandler(eventHandler); + }; + var _emscripten_set_touchcancel_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => + registerTouchEventCallback(target, userData, useCapture, callbackfunc, 25, "touchcancel", targetThread); + + var _emscripten_set_touchend_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => + registerTouchEventCallback(target, userData, useCapture, callbackfunc, 23, "touchend", targetThread); + + var _emscripten_set_touchmove_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => + registerTouchEventCallback(target, userData, useCapture, callbackfunc, 24, "touchmove", targetThread); + + var _emscripten_set_touchstart_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => + registerTouchEventCallback(target, userData, useCapture, callbackfunc, 22, "touchstart", targetThread); + + var handleException = (e) => { + // Certain exception types we do not treat as errors since they are used for + // internal control flow. + // 1. ExitStatus, which is thrown by exit() + // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others + // that wish to return to JS event loop. + 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 524288)'); + } + } + quit_(1, e); + }; + + + var runtimeKeepaliveCounter = 0; + var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0; + var _proc_exit = (code) => { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + Module['onExit']?.(code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); + }; + + + /** @suppress {duplicate } */ + /** @param {boolean|number=} implicit */ + var exitJS = (status, implicit) => { + EXITSTATUS = status; + + checkUnflushedContent(); + + // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down + 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)`; + err(msg); + } + + _proc_exit(status); + }; + var _exit = exitJS; + + + var maybeExit = () => { + if (!keepRuntimeAlive()) { + try { + _exit(EXITSTATUS); + } catch (e) { + handleException(e); + } + } + }; + var callUserCallback = (func) => { + if (ABORT) { + err('user callback triggered after runtime exited or application aborted. Ignoring.'); + return; + } + try { + func(); + maybeExit(); + } catch (e) { + handleException(e); + } + }; + + /** @param {number=} timeout */ + var safeSetTimeout = (func, timeout) => { + + return setTimeout(() => { + + callUserCallback(func); + }, timeout); + }; + + + + var Browser = { + useWebGL:false, + isFullscreen:false, + pointerLock:false, + moduleContextCreatedCallbacks:[], + workers:[], + preloadedImages:{ + }, + preloadedAudios:{ + }, + init() { + if (Browser.initted) return; + Browser.initted = true; + + // Support for plugins that can process preloaded files. You can add more of these to + // your app by creating and appending to preloadPlugins. + // + // Each plugin is asked if it can handle a file based on the file's name. If it can, + // it is given the file's raw data. When it is done, it calls a callback with the file's + // (possibly modified) data. For example, a plugin might decompress a file, or it + // might create some side data structure for use later (like an Image element, etc.). + + var imagePlugin = {}; + imagePlugin['canHandle'] = function imagePlugin_canHandle(name) { + return !Module['noImageDecoding'] && /\.(jpg|jpeg|png|bmp|webp)$/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) { // Safari bug #118630 + // Safari's Blob can only take an ArrayBuffer + 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 = /** @type {!HTMLCanvasElement} */ (document.createElement('canvas')); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext('2d'); + ctx.drawImage(img, 0, 0); + Browser.preloadedImages[name] = canvas; + URL.revokeObjectURL(url); + onload?.(byteArray); + }; + img.onerror = (event) => { + err(`Image ${url} could not be decoded`); + 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; + Browser.preloadedAudios[name] = audio; + onload?.(byteArray); + } + function fail() { + if (done) return; + done = true; + Browser.preloadedAudios[name] = new Audio(); // empty shim + onerror?.(); + } + var b = new Blob([byteArray], { type: Browser.getMimetype(name) }); + var url = URL.createObjectURL(b); // XXX we never revoke this! + assert(typeof url == 'string', 'createObjectURL must return a url as a string'); + var audio = new Audio(); + audio.addEventListener('canplaythrough', () => finish(audio), false); // use addEventListener due to chromium bug 124926 + 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)) & 0x3f; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar&3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar&0xf) << 2]; + ret += PAD; + } + return ret; + } + audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray); + finish(audio); // we don't wait for confirmation this worked - but it's worth trying + }; + audio.src = url; + // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror + safeSetTimeout(() => { + finish(audio); // try to use it even though it is not necessarily ready to play + }, 10000); + }; + preloadPlugins.push(audioPlugin); + + // Canvas event setup + + 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) { + // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module + // Module['forcedAspectRatio'] = 4 / 3; + + canvas.requestPointerLock = canvas['requestPointerLock'] || + canvas['mozRequestPointerLock'] || + canvas['webkitRequestPointerLock'] || + canvas['msRequestPointerLock'] || + (() => {}); + canvas.exitPointerLock = document['exitPointerLock'] || + document['mozExitPointerLock'] || + document['webkitExitPointerLock'] || + document['msExitPointerLock'] || + (() => {}); // no-op if function does not exist + 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(/** @type {HTMLCanvasElement} */ canvas, useWebGL, setInModule, webGLContextAttributes) { + if (useWebGL && Module.ctx && canvas == Module['canvas']) return Module.ctx; // no need to recreate GL context if it's already been created for this canvas. + + var ctx; + var contextHandle; + if (useWebGL) { + // For GLES2/desktop GL compatibility, adjust a few defaults to be different to WebGL defaults, so that they align better with the desktop defaults. + var contextAttributes = { + antialias: false, + alpha: false, + majorVersion: (typeof WebGL2RenderingContext != 'undefined') ? 2 : 1, + }; + + if (webGLContextAttributes) { + for (var attribute in webGLContextAttributes) { + contextAttributes[attribute] = webGLContextAttributes[attribute]; + } + } + + // This check of existence of GL is here to satisfy Closure compiler, which yells if variable GL is referenced below but GL object is not + // actually compiled in because application is not doing any GL operations. TODO: Ideally if GL is not being used, this function + // Browser.createContext() should not even be emitted. + 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); + Browser.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach((callback) => callback()); + Browser.init(); + } + return ctx; + }, + fullscreenHandlersInstalled:false, + lockPointer:undefined, + resizeCanvas:undefined, + requestFullscreen(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 { + // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + + if (Browser.resizeCanvas) { + Browser.setWindowedCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } + Module['onFullScreen']?.(Browser.isFullscreen); + 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); + } + + // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + + // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size) + 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() { + abort('Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)'); + }, + exitFullscreen() { + // This is workaround for chrome. Trying to exit from fullscreen + // not in fullscreen state will cause "TypeError: Document not active" + // in chrome. See https://github.com/emscripten-core/emscripten/pull/8236 + if (!Browser.isFullscreen) { + return false; + } + + var CFS = document['exitFullscreen'] || + document['cancelFullScreen'] || + document['mozCancelFullScreen'] || + document['msExitFullscreen'] || + document['webkitCancelFullScreen'] || + (() => {}); + CFS.apply(document, []); + return true; + }, + safeSetTimeout(func, timeout) { + // Legacy function, this is used by the SDL2 port so we need to keep it + // around at least until that is updated. + // See https://github.com/libsdl-org/SDL/pull/6304 + return safeSetTimeout(func, timeout); + }, + getMimetype(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(func) { + window.getUserMedia ||= navigator['getUserMedia'] || + navigator['mozGetUserMedia']; + window.getUserMedia(func); + }, + getMovementX(event) { + return event['movementX'] || + event['mozMovementX'] || + event['webkitMovementX'] || + 0; + }, + getMovementY(event) { + return event['movementY'] || + event['mozMovementY'] || + event['webkitMovementY'] || + 0; + }, + getMouseWheelDelta(event) { + var delta = 0; + switch (event.type) { + case 'DOMMouseScroll': + // 3 lines make up a step + delta = event.detail / 3; + break; + case 'mousewheel': + // 120 units make up a step + delta = event.wheelDelta / 120; + break; + case 'wheel': + delta = event.deltaY + switch (event.deltaMode) { + case 0: + // DOM_DELTA_PIXEL: 100 pixels make up a step + delta /= 100; + break; + case 1: + // DOM_DELTA_LINE: 3 lines make up a step + delta /= 3; + break; + case 2: + // DOM_DELTA_PAGE: A page makes up 80 steps + 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:{ + }, + calculateMouseCoords(pageX, pageY) { + // Calculate the movement based on the changes + // in the coordinates. + var rect = Module["canvas"].getBoundingClientRect(); + var cw = Module["canvas"].width; + var ch = Module["canvas"].height; + + // Neither .scrollX or .pageXOffset are defined in a spec, but + // we prefer .scrollX because it is currently in a spec draft. + // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/) + var scrollX = ((typeof window.scrollX != 'undefined') ? window.scrollX : window.pageXOffset); + var scrollY = ((typeof window.scrollY != 'undefined') ? window.scrollY : window.pageYOffset); + // If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset + // and we have no viable fallback. + assert((typeof scrollX != 'undefined') && (typeof scrollY != 'undefined'), 'Unable to retrieve scroll position, mouse positions likely broken.'); + var adjustedX = pageX - (scrollX + rect.left); + var adjustedY = pageY - (scrollY + rect.top); + + // the canvas might be CSS-scaled compared to its backbuffer; + // SDL-using content will want mouse coordinates in terms + // of backbuffer units. + adjustedX = adjustedX * (cw / rect.width); + adjustedY = adjustedY * (ch / rect.height); + + return { x: adjustedX, y: adjustedY }; + }, + setMouseCoords(pageX, pageY) { + const {x, y} = Browser.calculateMouseCoords(pageX, pageY); + Browser.mouseMovementX = x - Browser.mouseX; + Browser.mouseMovementY = y - Browser.mouseY; + Browser.mouseX = x; + Browser.mouseY = y; + }, + calculateMouseEvent(event) { // event should be mousemove, mousedown or mouseup + if (Browser.pointerLock) { + // When the pointer is locked, calculate the coordinates + // based on the movement of the mouse. + // Workaround for Firefox bug 764498 + if (event.type != 'mousemove' && + ('mozMovementX' in event)) { + Browser.mouseMovementX = Browser.mouseMovementY = 0; + } else { + Browser.mouseMovementX = Browser.getMovementX(event); + Browser.mouseMovementY = Browser.getMovementY(event); + } + + // add the mouse delta to the current absolute mouse position + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY; + } else { + if (event.type === 'touchstart' || event.type === 'touchend' || event.type === 'touchmove') { + var touch = event.touch; + if (touch === undefined) { + return; // the "touch" property is only defined in SDL + + } + var coords = Browser.calculateMouseCoords(touch.pageX, touch.pageY); + + 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]; + last ||= coords; + Browser.lastTouches[touch.identifier] = last; + Browser.touches[touch.identifier] = coords; + } + return; + } + + Browser.setMouseCoords(event.pageX, event.pageY); + } + }, + resizeListeners:[], + updateResizeListeners() { + var canvas = Module['canvas']; + Browser.resizeListeners.forEach((listener) => listener(canvas.width, canvas.height)); + }, + setCanvasSize(width, height, noUpdates) { + var canvas = Module['canvas']; + Browser.updateCanvasDimensions(canvas, width, height); + if (!noUpdates) Browser.updateResizeListeners(); + }, + windowedWidth:0, + windowedHeight:0, + setFullscreenCanvasSize() { + // check if SDL is available + if (typeof SDL != "undefined") { + var flags = HEAPU32[((SDL.screen)>>2)]; + flags = flags | 0x00800000; // set SDL_FULLSCREEN flag + HEAP32[((SDL.screen)>>2)] = flags;checkInt32(flags); + } + Browser.updateCanvasDimensions(Module['canvas']); + Browser.updateResizeListeners(); + }, + setWindowedCanvasSize() { + // check if SDL is available + if (typeof SDL != "undefined") { + var flags = HEAPU32[((SDL.screen)>>2)]; + flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag + HEAP32[((SDL.screen)>>2)] = flags;checkInt32(flags); + } + Browser.updateCanvasDimensions(Module['canvas']); + Browser.updateResizeListeners(); + }, + updateCanvasDimensions(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"); + } + } + } + }, + }; + + var _emscripten_set_window_title = (title) => document.title = UTF8ToString(title); + + var _emscripten_sleep = (ms) => { + // emscripten_sleep() does not return a value, but we still need a |return| + // here for stack switching support (ASYNCIFY=2). In that mode this function + // returns a Promise instead of nothing, and that Promise is what tells the + // wasm VM to pause the stack. + return Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms)); + }; + _emscripten_sleep.isAsync = true; + + + function _fd_close(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; + } + } + + /** @param {number=} offset */ + var doReadv = (stream, iov, iovcnt, offset) => { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + if (typeof offset != 'undefined') { + offset += curr; + } + } + return ret; + }; + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num;checkInt32(num); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + + var convertI32PairToI53Checked = (lo, hi) => { + assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32 + assert(hi === (hi|0)); // hi should be a i32 + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + }; + function _fd_seek(fd,offset_low, offset_high,whence,newOffset) { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + + + try { + + 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.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]);checkInt64(stream.position); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + ; + } + + /** @param {number=} offset */ + var doWritev = (stream, iov, iovcnt, offset) => { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) { + // No more space to write. + break; + } + if (typeof offset != 'undefined') { + offset += curr; + } + } + return ret; + }; + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num;checkInt32(num); + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e; + return e.errno; + } + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** @constructor */ + function GLFW_Window(id, width, height, framebufferWidth, framebufferHeight, title, monitor, share) { + this.id = id; + this.x = 0; + this.y = 0; + this.fullscreen = false; // Used to determine if app in fullscreen mode + this.storedX = 0; // Used to store X before fullscreen + this.storedY = 0; // Used to store Y before fullscreen + this.width = width; + this.height = height; + this.framebufferWidth = framebufferWidth; + this.framebufferHeight = framebufferHeight; + this.storedWidth = width; // Used to store width before fullscreen + this.storedHeight = height; // Used to store height before fullscreen + this.title = title; + this.monitor = monitor; + this.share = share; + this.attributes = Object.assign({}, GLFW.hints); + this.inputModes = { + 0x00033001:0x00034001, // GLFW_CURSOR (GLFW_CURSOR_NORMAL) + 0x00033002:0, // GLFW_STICKY_KEYS + 0x00033003:0, // GLFW_STICKY_MOUSE_BUTTONS + }; + this.buttons = 0; + this.keys = new Array(); + this.domKeys = new Array(); + this.shouldClose = 0; + this.title = null; + this.windowPosFunc = 0; // GLFWwindowposfun + this.windowSizeFunc = 0; // GLFWwindowsizefun + this.windowCloseFunc = 0; // GLFWwindowclosefun + this.windowRefreshFunc = 0; // GLFWwindowrefreshfun + this.windowFocusFunc = 0; // GLFWwindowfocusfun + this.windowIconifyFunc = 0; // GLFWwindowiconifyfun + this.windowMaximizeFunc = 0; // GLFWwindowmaximizefun + this.framebufferSizeFunc = 0; // GLFWframebuffersizefun + this.windowContentScaleFunc = 0; // GLFWwindowcontentscalefun + this.mouseButtonFunc = 0; // GLFWmousebuttonfun + this.cursorPosFunc = 0; // GLFWcursorposfun + this.cursorEnterFunc = 0; // GLFWcursorenterfun + this.scrollFunc = 0; // GLFWscrollfun + this.dropFunc = 0; // GLFWdropfun + this.keyFunc = 0; // GLFWkeyfun + this.charFunc = 0; // GLFWcharfun + this.userptr = 0; + } + + + var _emscripten_set_main_loop_timing = (mode, value) => { + MainLoop.timingMode = mode; + MainLoop.timingValue = value; + + if (!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; // Return non-zero on failure, can't set timing mode when there is no main loop. + } + + if (!MainLoop.running) { + + MainLoop.running = true; + } + if (mode == 0) { + MainLoop.scheduler = function MainLoop_scheduler_setTimeout() { + var timeUntilNextTick = Math.max(0, MainLoop.tickStartTime + value - _emscripten_get_now())|0; + setTimeout(MainLoop.runner, timeUntilNextTick); // doing this each time means that on exception, we stop + }; + MainLoop.method = 'timeout'; + } else if (mode == 1) { + MainLoop.scheduler = function MainLoop_scheduler_rAF() { + MainLoop.requestAnimationFrame(MainLoop.runner); + }; + MainLoop.method = 'rAF'; + } else if (mode == 2) { + if (typeof MainLoop.setImmediate == 'undefined') { + if (typeof setImmediate == 'undefined') { + // Emulate setImmediate. (note: not a complete polyfill, we don't emulate clearImmediate() to keep code size to minimum, since not needed) + var setImmediates = []; + var emscriptenMainLoopMessageId = 'setimmediate'; + /** @param {Event} event */ + var MainLoop_setImmediate_messageHandler = (event) => { + // When called in current thread or Worker, the main loop ID is structured slightly different to accommodate for --proxy-to-worker runtime listening to Worker events, + // so check for both cases. + if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) { + event.stopPropagation(); + setImmediates.shift()(); + } + }; + addEventListener("message", MainLoop_setImmediate_messageHandler, true); + MainLoop.setImmediate = /** @type{function(function(): ?, ...?): number} */((func) => { + setImmediates.push(func); + if (ENVIRONMENT_IS_WORKER) { + Module['setImmediates'] ??= []; + Module['setImmediates'].push(func); + postMessage({target: emscriptenMainLoopMessageId}); // In --proxy-to-worker, route the message via proxyClient.js + } else postMessage(emscriptenMainLoopMessageId, "*"); // On the main thread, can just send the message to itself. + }); + } else { + MainLoop.setImmediate = setImmediate; + } + } + MainLoop.scheduler = function MainLoop_scheduler_setImmediate() { + MainLoop.setImmediate(MainLoop.runner); + }; + MainLoop.method = 'immediate'; + } + return 0; + }; + + + + /** + * @param {number=} arg + * @param {boolean=} noSetTiming + */ + var setMainLoop = (iterFunc, fps, simulateInfiniteLoop, arg, noSetTiming) => { + assert(!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.'); + MainLoop.func = iterFunc; + MainLoop.arg = arg; + + var thisMainLoopId = MainLoop.currentlyRunningMainloop; + function checkIsRunning() { + if (thisMainLoopId < MainLoop.currentlyRunningMainloop) { + + maybeExit(); + return false; + } + return true; + } + + // We create the loop runner here but it is not actually running until + // _emscripten_set_main_loop_timing is called (which might happen a + // later time). This member signifies that the current runner has not + // yet been started so that we can call runtimeKeepalivePush when it + // gets it timing set for the first time. + MainLoop.running = false; + MainLoop.runner = function MainLoop_runner() { + if (ABORT) return; + if (MainLoop.queue.length > 0) { + var start = Date.now(); + var blocker = MainLoop.queue.shift(); + blocker.func(blocker.arg); + if (MainLoop.remainingBlockers) { + var remaining = MainLoop.remainingBlockers; + var next = remaining%1 == 0 ? remaining-1 : Math.floor(remaining); + if (blocker.counted) { + MainLoop.remainingBlockers = next; + } else { + // not counted, but move the progress along a tiny bit + next = next + 0.5; // do not steal all the next one's progress + MainLoop.remainingBlockers = (8*remaining + next)/9; + } + } + MainLoop.updateStatus(); + + // catches pause/resume main loop from blocker execution + if (!checkIsRunning()) return; + + setTimeout(MainLoop.runner, 0); + return; + } + + // catch pauses from non-main loop sources + if (!checkIsRunning()) return; + + // Implement very basic swap interval control + MainLoop.currentFrameNumber = MainLoop.currentFrameNumber + 1 | 0; + if (MainLoop.timingMode == 1 && MainLoop.timingValue > 1 && MainLoop.currentFrameNumber % MainLoop.timingValue != 0) { + // Not the scheduled time to render this frame - skip. + MainLoop.scheduler(); + return; + } else if (MainLoop.timingMode == 0) { + MainLoop.tickStartTime = _emscripten_get_now(); + } + + if (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!'); + MainLoop.method = ''; // just warn once per call to set main loop + } + + MainLoop.runIter(iterFunc); + + // catch pauses from the main loop itself + if (!checkIsRunning()) return; + + MainLoop.scheduler(); + } + + if (!noSetTiming) { + if (fps && fps > 0) { + _emscripten_set_main_loop_timing(0, 1000.0 / fps); + } else { + // Do rAF by rendering each frame (no decimating) + _emscripten_set_main_loop_timing(1, 1); + } + + MainLoop.scheduler(); + } + + if (simulateInfiniteLoop) { + throw 'unwind'; + } + }; + + + var MainLoop = { + running:false, + scheduler:null, + method:"", + currentlyRunningMainloop:0, + func:null, + arg:0, + timingMode:0, + timingValue:0, + currentFrameNumber:0, + queue:[], + preMainLoop:[], + postMainLoop:[], + pause() { + MainLoop.scheduler = null; + // Incrementing this signals the previous main loop that it's now become old, and it must return. + MainLoop.currentlyRunningMainloop++; + }, + resume() { + MainLoop.currentlyRunningMainloop++; + var timingMode = MainLoop.timingMode; + var timingValue = MainLoop.timingValue; + var func = MainLoop.func; + MainLoop.func = null; + // do not set timing and call scheduler, we will do it on the next lines + setMainLoop(func, 0, false, MainLoop.arg, true); + _emscripten_set_main_loop_timing(timingMode, timingValue); + MainLoop.scheduler(); + }, + updateStatus() { + if (Module['setStatus']) { + var message = Module['statusMessage'] || 'Please wait...'; + var remaining = MainLoop.remainingBlockers ?? 0; + var expected = MainLoop.expectedBlockers ?? 0; + if (remaining) { + if (remaining < expected) { + Module['setStatus'](`{message} ({expected - remaining}/{expected})`); + } else { + Module['setStatus'](message); + } + } else { + Module['setStatus'](''); + } + } + }, + init() { + Module['preMainLoop'] && MainLoop.preMainLoop.push(Module['preMainLoop']); + Module['postMainLoop'] && MainLoop.postMainLoop.push(Module['postMainLoop']); + }, + runIter(func) { + if (ABORT) return; + for (var pre of MainLoop.preMainLoop) { + if (pre() === false) { + return; // |return false| skips a frame + } + } + callUserCallback(func); + for (var post of MainLoop.postMainLoop) { + post(); + } + checkStackCookie(); + }, + nextRAF:0, + fakeRequestAnimationFrame(func) { + // try to keep 60fps between calls to here + var now = Date.now(); + if (MainLoop.nextRAF === 0) { + MainLoop.nextRAF = now + 1000/60; + } else { + while (now + 2 >= MainLoop.nextRAF) { // fudge a little, to avoid timer jitter causing us to do lots of delay:0 + MainLoop.nextRAF += 1000/60; + } + } + var delay = Math.max(MainLoop.nextRAF - now, 0); + setTimeout(func, delay); + }, + requestAnimationFrame(func) { + if (typeof requestAnimationFrame == 'function') { + requestAnimationFrame(func); + return; + } + var RAF = MainLoop.fakeRequestAnimationFrame; + RAF(func); + }, + }; + + + + + var GLFW = { + WindowFromId:(id) => { + if (id <= 0 || !GLFW.windows) return null; + return GLFW.windows[id - 1]; + }, + joystickFunc:0, + errorFunc:0, + monitorFunc:0, + active:null, + scale:null, + windows:null, + monitors:null, + monitorString:null, + versionString:null, + initialTime:null, + extensions:null, + devicePixelRatioMQL:null, + hints:null, + primaryTouchId:null, + defaultHints:{ + 131073:0, + 131074:0, + 131075:1, + 131076:1, + 131077:1, + 131082:0, + 135169:8, + 135170:8, + 135171:8, + 135172:8, + 135173:24, + 135174:8, + 135175:0, + 135176:0, + 135177:0, + 135178:0, + 135179:0, + 135180:0, + 135181:0, + 135182:0, + 135183:0, + 139265:196609, + 139266:1, + 139267:0, + 139268:0, + 139269:0, + 139270:0, + 139271:0, + 139272:0, + 139276:0, + }, + DOMToGLFWKeyCode:(keycode) => { + switch (keycode) { + // these keycodes are only defined for GLFW3, assume they are the same for GLFW2 + case 0x20:return 32; // DOM_VK_SPACE -> GLFW_KEY_SPACE + case 0xDE:return 39; // DOM_VK_QUOTE -> GLFW_KEY_APOSTROPHE + case 0xBC:return 44; // DOM_VK_COMMA -> GLFW_KEY_COMMA + case 0xAD:return 45; // DOM_VK_HYPHEN_MINUS -> GLFW_KEY_MINUS + case 0xBD:return 45; // DOM_VK_MINUS -> GLFW_KEY_MINUS + case 0xBE:return 46; // DOM_VK_PERIOD -> GLFW_KEY_PERIOD + case 0xBF:return 47; // DOM_VK_SLASH -> GLFW_KEY_SLASH + case 0x30:return 48; // DOM_VK_0 -> GLFW_KEY_0 + case 0x31:return 49; // DOM_VK_1 -> GLFW_KEY_1 + case 0x32:return 50; // DOM_VK_2 -> GLFW_KEY_2 + case 0x33:return 51; // DOM_VK_3 -> GLFW_KEY_3 + case 0x34:return 52; // DOM_VK_4 -> GLFW_KEY_4 + case 0x35:return 53; // DOM_VK_5 -> GLFW_KEY_5 + case 0x36:return 54; // DOM_VK_6 -> GLFW_KEY_6 + case 0x37:return 55; // DOM_VK_7 -> GLFW_KEY_7 + case 0x38:return 56; // DOM_VK_8 -> GLFW_KEY_8 + case 0x39:return 57; // DOM_VK_9 -> GLFW_KEY_9 + case 0x3B:return 59; // DOM_VK_SEMICOLON -> GLFW_KEY_SEMICOLON + case 0x3D:return 61; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL + case 0xBB:return 61; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL + case 0x41:return 65; // DOM_VK_A -> GLFW_KEY_A + case 0x42:return 66; // DOM_VK_B -> GLFW_KEY_B + case 0x43:return 67; // DOM_VK_C -> GLFW_KEY_C + case 0x44:return 68; // DOM_VK_D -> GLFW_KEY_D + case 0x45:return 69; // DOM_VK_E -> GLFW_KEY_E + case 0x46:return 70; // DOM_VK_F -> GLFW_KEY_F + case 0x47:return 71; // DOM_VK_G -> GLFW_KEY_G + case 0x48:return 72; // DOM_VK_H -> GLFW_KEY_H + case 0x49:return 73; // DOM_VK_I -> GLFW_KEY_I + case 0x4A:return 74; // DOM_VK_J -> GLFW_KEY_J + case 0x4B:return 75; // DOM_VK_K -> GLFW_KEY_K + case 0x4C:return 76; // DOM_VK_L -> GLFW_KEY_L + case 0x4D:return 77; // DOM_VK_M -> GLFW_KEY_M + case 0x4E:return 78; // DOM_VK_N -> GLFW_KEY_N + case 0x4F:return 79; // DOM_VK_O -> GLFW_KEY_O + case 0x50:return 80; // DOM_VK_P -> GLFW_KEY_P + case 0x51:return 81; // DOM_VK_Q -> GLFW_KEY_Q + case 0x52:return 82; // DOM_VK_R -> GLFW_KEY_R + case 0x53:return 83; // DOM_VK_S -> GLFW_KEY_S + case 0x54:return 84; // DOM_VK_T -> GLFW_KEY_T + case 0x55:return 85; // DOM_VK_U -> GLFW_KEY_U + case 0x56:return 86; // DOM_VK_V -> GLFW_KEY_V + case 0x57:return 87; // DOM_VK_W -> GLFW_KEY_W + case 0x58:return 88; // DOM_VK_X -> GLFW_KEY_X + case 0x59:return 89; // DOM_VK_Y -> GLFW_KEY_Y + case 0x5a:return 90; // DOM_VK_Z -> GLFW_KEY_Z + case 0xDB:return 91; // DOM_VK_OPEN_BRACKET -> GLFW_KEY_LEFT_BRACKET + case 0xDC:return 92; // DOM_VK_BACKSLASH -> GLFW_KEY_BACKSLASH + case 0xDD:return 93; // DOM_VK_CLOSE_BRACKET -> GLFW_KEY_RIGHT_BRACKET + case 0xC0:return 96; // DOM_VK_BACK_QUOTE -> GLFW_KEY_GRAVE_ACCENT + + case 0x1B:return 256; // DOM_VK_ESCAPE -> GLFW_KEY_ESCAPE + case 0x0D:return 257; // DOM_VK_RETURN -> GLFW_KEY_ENTER + case 0x09:return 258; // DOM_VK_TAB -> GLFW_KEY_TAB + case 0x08:return 259; // DOM_VK_BACK -> GLFW_KEY_BACKSPACE + case 0x2D:return 260; // DOM_VK_INSERT -> GLFW_KEY_INSERT + case 0x2E:return 261; // DOM_VK_DELETE -> GLFW_KEY_DELETE + case 0x27:return 262; // DOM_VK_RIGHT -> GLFW_KEY_RIGHT + case 0x25:return 263; // DOM_VK_LEFT -> GLFW_KEY_LEFT + case 0x28:return 264; // DOM_VK_DOWN -> GLFW_KEY_DOWN + case 0x26:return 265; // DOM_VK_UP -> GLFW_KEY_UP + case 0x21:return 266; // DOM_VK_PAGE_UP -> GLFW_KEY_PAGE_UP + case 0x22:return 267; // DOM_VK_PAGE_DOWN -> GLFW_KEY_PAGE_DOWN + case 0x24:return 268; // DOM_VK_HOME -> GLFW_KEY_HOME + case 0x23:return 269; // DOM_VK_END -> GLFW_KEY_END + case 0x14:return 280; // DOM_VK_CAPS_LOCK -> GLFW_KEY_CAPS_LOCK + case 0x91:return 281; // DOM_VK_SCROLL_LOCK -> GLFW_KEY_SCROLL_LOCK + case 0x90:return 282; // DOM_VK_NUM_LOCK -> GLFW_KEY_NUM_LOCK + case 0x2C:return 283; // DOM_VK_SNAPSHOT -> GLFW_KEY_PRINT_SCREEN + case 0x13:return 284; // DOM_VK_PAUSE -> GLFW_KEY_PAUSE + case 0x70:return 290; // DOM_VK_F1 -> GLFW_KEY_F1 + case 0x71:return 291; // DOM_VK_F2 -> GLFW_KEY_F2 + case 0x72:return 292; // DOM_VK_F3 -> GLFW_KEY_F3 + case 0x73:return 293; // DOM_VK_F4 -> GLFW_KEY_F4 + case 0x74:return 294; // DOM_VK_F5 -> GLFW_KEY_F5 + case 0x75:return 295; // DOM_VK_F6 -> GLFW_KEY_F6 + case 0x76:return 296; // DOM_VK_F7 -> GLFW_KEY_F7 + case 0x77:return 297; // DOM_VK_F8 -> GLFW_KEY_F8 + case 0x78:return 298; // DOM_VK_F9 -> GLFW_KEY_F9 + case 0x79:return 299; // DOM_VK_F10 -> GLFW_KEY_F10 + case 0x7A:return 300; // DOM_VK_F11 -> GLFW_KEY_F11 + case 0x7B:return 301; // DOM_VK_F12 -> GLFW_KEY_F12 + case 0x7C:return 302; // DOM_VK_F13 -> GLFW_KEY_F13 + case 0x7D:return 303; // DOM_VK_F14 -> GLFW_KEY_F14 + case 0x7E:return 304; // DOM_VK_F15 -> GLFW_KEY_F15 + case 0x7F:return 305; // DOM_VK_F16 -> GLFW_KEY_F16 + case 0x80:return 306; // DOM_VK_F17 -> GLFW_KEY_F17 + case 0x81:return 307; // DOM_VK_F18 -> GLFW_KEY_F18 + case 0x82:return 308; // DOM_VK_F19 -> GLFW_KEY_F19 + case 0x83:return 309; // DOM_VK_F20 -> GLFW_KEY_F20 + case 0x84:return 310; // DOM_VK_F21 -> GLFW_KEY_F21 + case 0x85:return 311; // DOM_VK_F22 -> GLFW_KEY_F22 + case 0x86:return 312; // DOM_VK_F23 -> GLFW_KEY_F23 + case 0x87:return 313; // DOM_VK_F24 -> GLFW_KEY_F24 + case 0x88:return 314; // 0x88 (not used?) -> GLFW_KEY_F25 + case 0x60:return 320; // DOM_VK_NUMPAD0 -> GLFW_KEY_KP_0 + case 0x61:return 321; // DOM_VK_NUMPAD1 -> GLFW_KEY_KP_1 + case 0x62:return 322; // DOM_VK_NUMPAD2 -> GLFW_KEY_KP_2 + case 0x63:return 323; // DOM_VK_NUMPAD3 -> GLFW_KEY_KP_3 + case 0x64:return 324; // DOM_VK_NUMPAD4 -> GLFW_KEY_KP_4 + case 0x65:return 325; // DOM_VK_NUMPAD5 -> GLFW_KEY_KP_5 + case 0x66:return 326; // DOM_VK_NUMPAD6 -> GLFW_KEY_KP_6 + case 0x67:return 327; // DOM_VK_NUMPAD7 -> GLFW_KEY_KP_7 + case 0x68:return 328; // DOM_VK_NUMPAD8 -> GLFW_KEY_KP_8 + case 0x69:return 329; // DOM_VK_NUMPAD9 -> GLFW_KEY_KP_9 + case 0x6E:return 330; // DOM_VK_DECIMAL -> GLFW_KEY_KP_DECIMAL + case 0x6F:return 331; // DOM_VK_DIVIDE -> GLFW_KEY_KP_DIVIDE + case 0x6A:return 332; // DOM_VK_MULTIPLY -> GLFW_KEY_KP_MULTIPLY + case 0x6D:return 333; // DOM_VK_SUBTRACT -> GLFW_KEY_KP_SUBTRACT + case 0x6B:return 334; // DOM_VK_ADD -> GLFW_KEY_KP_ADD + // case 0x0D:return 335; // DOM_VK_RETURN -> GLFW_KEY_KP_ENTER (DOM_KEY_LOCATION_RIGHT) + // case 0x61:return 336; // DOM_VK_EQUALS -> GLFW_KEY_KP_EQUAL (DOM_KEY_LOCATION_RIGHT) + case 0x10:return 340; // DOM_VK_SHIFT -> GLFW_KEY_LEFT_SHIFT + case 0x11:return 341; // DOM_VK_CONTROL -> GLFW_KEY_LEFT_CONTROL + case 0x12:return 342; // DOM_VK_ALT -> GLFW_KEY_LEFT_ALT + case 0x5B:return 343; // DOM_VK_WIN -> GLFW_KEY_LEFT_SUPER + case 0xE0:return 343; // DOM_VK_META -> GLFW_KEY_LEFT_SUPER + // case 0x10:return 344; // DOM_VK_SHIFT -> GLFW_KEY_RIGHT_SHIFT (DOM_KEY_LOCATION_RIGHT) + // case 0x11:return 345; // DOM_VK_CONTROL -> GLFW_KEY_RIGHT_CONTROL (DOM_KEY_LOCATION_RIGHT) + // case 0x12:return 346; // DOM_VK_ALT -> GLFW_KEY_RIGHT_ALT (DOM_KEY_LOCATION_RIGHT) + // case 0x5B:return 347; // DOM_VK_WIN -> GLFW_KEY_RIGHT_SUPER (DOM_KEY_LOCATION_RIGHT) + case 0x5D:return 348; // DOM_VK_CONTEXT_MENU -> GLFW_KEY_MENU + // XXX: GLFW_KEY_WORLD_1, GLFW_KEY_WORLD_2 what are these? + default:return -1; // GLFW_KEY_UNKNOWN + }; + }, + getModBits:(win) => { + var mod = 0; + if (win.keys[340]) mod |= 0x0001; // GLFW_MOD_SHIFT + if (win.keys[341]) mod |= 0x0002; // GLFW_MOD_CONTROL + if (win.keys[342]) mod |= 0x0004; // GLFW_MOD_ALT + if (win.keys[343] || win.keys[348]) mod |= 0x0008; // GLFW_MOD_SUPER + // add caps and num lock keys? only if lock_key_mod is set + return mod; + }, + onKeyPress:(event) => { + if (!GLFW.active || !GLFW.active.charFunc) return; + if (event.ctrlKey || event.metaKey) return; + + // correct unicode charCode is only available with onKeyPress event + var charCode = event.charCode; + if (charCode == 0 || (charCode >= 0x00 && charCode <= 0x1F)) return; + + ((a1, a2) => dynCall_vii(GLFW.active.charFunc, a1, a2))(GLFW.active.id, charCode); + }, + onKeyChanged:(keyCode, status) => { + if (!GLFW.active) return; + + var key = GLFW.DOMToGLFWKeyCode(keyCode); + if (key == -1) return; + + var repeat = status && GLFW.active.keys[key]; + GLFW.active.keys[key] = status; + GLFW.active.domKeys[keyCode] = status; + + if (GLFW.active.keyFunc) { + if (repeat) status = 2; // GLFW_REPEAT + ((a1, a2, a3, a4, a5) => dynCall_viiiii(GLFW.active.keyFunc, a1, a2, a3, a4, a5))(GLFW.active.id, key, keyCode, status, GLFW.getModBits(GLFW.active)); + } + }, + onGamepadConnected:(event) => { + GLFW.refreshJoysticks(); + }, + onGamepadDisconnected:(event) => { + GLFW.refreshJoysticks(); + }, + onKeydown:(event) => { + GLFW.onKeyChanged(event.keyCode, 1); // GLFW_PRESS or GLFW_REPEAT + + // This logic comes directly from the sdl implementation. We cannot + // call preventDefault on all keydown events otherwise onKeyPress will + // not get called + if (event.key == 'Backspace' || event.key == 'Tab') { + event.preventDefault(); + } + }, + onKeyup:(event) => { + GLFW.onKeyChanged(event.keyCode, 0); // GLFW_RELEASE + }, + onBlur:(event) => { + if (!GLFW.active) return; + + for (var i = 0; i < GLFW.active.domKeys.length; ++i) { + if (GLFW.active.domKeys[i]) { + GLFW.onKeyChanged(i, 0); // GLFW_RELEASE + } + } + }, + onMousemove:(event) => { + if (!GLFW.active) return; + + if (event.type === 'touchmove') { + // Handling for touch events that are being converted to mouse input. + + // Don't let the browser fire a duplicate mouse event. + event.preventDefault(); + + let primaryChanged = false; + for (let i of event.changedTouches) { + // If our chosen primary touch moved, update Browser mouse coords + if (GLFW.primaryTouchId === i.identifier) { + Browser.setMouseCoords(i.pageX, i.pageY); + primaryChanged = true; + break; + } + } + + if (!primaryChanged) { + // Do not send mouse events if some touch other than the primary triggered this. + return; + } + + } else { + // Handling for non-touch mouse input events. + Browser.calculateMouseEvent(event); + } + + if (event.target != Module["canvas"] || !GLFW.active.cursorPosFunc) return; + + if (GLFW.active.cursorPosFunc) { + ((a1, a2, a3) => dynCall_vidd(GLFW.active.cursorPosFunc, a1, a2, a3))(GLFW.active.id, Browser.mouseX, Browser.mouseY); + } + }, + DOMToGLFWMouseButton:(event) => { + // DOM and glfw have different button codes. + // See http://www.w3schools.com/jsref/event_button.asp. + var eventButton = event['button']; + if (eventButton > 0) { + if (eventButton == 1) { + eventButton = 2; + } else { + eventButton = 1; + } + } + return eventButton; + }, + onMouseenter:(event) => { + if (!GLFW.active) return; + + if (event.target != Module["canvas"]) return; + + if (GLFW.active.cursorEnterFunc) { + ((a1, a2) => dynCall_vii(GLFW.active.cursorEnterFunc, a1, a2))(GLFW.active.id, 1); + } + }, + onMouseleave:(event) => { + if (!GLFW.active) return; + + if (event.target != Module["canvas"]) return; + + if (GLFW.active.cursorEnterFunc) { + ((a1, a2) => dynCall_vii(GLFW.active.cursorEnterFunc, a1, a2))(GLFW.active.id, 0); + } + }, + onMouseButtonChanged:(event, status) => { + if (!GLFW.active) return; + + if (event.target != Module["canvas"]) return; + + // Is this from a touch event? + const isTouchType = event.type === 'touchstart' || event.type === 'touchend' || event.type === 'touchcancel'; + + // Only emulating mouse left-click behavior for touches. + let eventButton = 0; + if (isTouchType) { + // Handling for touch events that are being converted to mouse input. + + // Don't let the browser fire a duplicate mouse event. + event.preventDefault(); + + let primaryChanged = false; + + // Set a primary touch if we have none. + if (GLFW.primaryTouchId === null && event.type === 'touchstart' && event.targetTouches.length > 0) { + // Pick the first touch that started in the canvas and treat it as primary. + const chosenTouch = event.targetTouches[0]; + GLFW.primaryTouchId = chosenTouch.identifier; + + Browser.setMouseCoords(chosenTouch.pageX, chosenTouch.pageY); + primaryChanged = true; + } else if (event.type === 'touchend' || event.type === 'touchcancel') { + // Clear the primary touch if it ended. + for (let i of event.changedTouches) { + // If our chosen primary touch ended, remove it. + if (GLFW.primaryTouchId === i.identifier) { + GLFW.primaryTouchId = null; + primaryChanged = true; + break; + } + } + } + + if (!primaryChanged) { + // Do not send mouse events if some touch other than the primary triggered this. + return; + } + + } else { + // Handling for non-touch mouse input events. + Browser.calculateMouseEvent(event); + eventButton = GLFW.DOMToGLFWMouseButton(event); + } + + if (status == 1) { // GLFW_PRESS + GLFW.active.buttons |= (1 << eventButton); + try { + event.target.setCapture(); + } catch (e) {} + } else { // GLFW_RELEASE + GLFW.active.buttons &= ~(1 << eventButton); + } + + // Send mouse event to GLFW. + if (GLFW.active.mouseButtonFunc) { + ((a1, a2, a3, a4) => dynCall_viiii(GLFW.active.mouseButtonFunc, a1, a2, a3, a4))(GLFW.active.id, eventButton, status, GLFW.getModBits(GLFW.active)); + } + }, + onMouseButtonDown:(event) => { + if (!GLFW.active) return; + GLFW.onMouseButtonChanged(event, 1); // GLFW_PRESS + }, + onMouseButtonUp:(event) => { + if (!GLFW.active) return; + GLFW.onMouseButtonChanged(event, 0); // GLFW_RELEASE + }, + onMouseWheel:(event) => { + // Note the minus sign that flips browser wheel direction (positive direction scrolls page down) to native wheel direction (positive direction is mouse wheel up) + var delta = -Browser.getMouseWheelDelta(event); + delta = (delta == 0) ? 0 : (delta > 0 ? Math.max(delta, 1) : Math.min(delta, -1)); // Quantize to integer so that minimum scroll is at least +/- 1. + GLFW.wheelPos += delta; + + if (!GLFW.active || !GLFW.active.scrollFunc || event.target != Module['canvas']) return; + var sx = 0; + var sy = delta; + if (event.type == 'mousewheel') { + sx = event.wheelDeltaX; + } else { + sx = event.deltaX; + } + + ((a1, a2, a3) => dynCall_vidd(GLFW.active.scrollFunc, a1, a2, a3))(GLFW.active.id, sx, sy); + + event.preventDefault(); + }, + onCanvasResize:(width, height, framebufferWidth, framebufferHeight) => { + if (!GLFW.active) return; + + var resizeNeeded = false; + + // If the client is requesting fullscreen mode + if (document["fullscreen"] || document["fullScreen"] || document["mozFullScreen"] || document["webkitIsFullScreen"]) { + if (!GLFW.active.fullscreen) { + resizeNeeded = width != screen.width || height != screen.height; + GLFW.active.storedX = GLFW.active.x; + GLFW.active.storedY = GLFW.active.y; + GLFW.active.storedWidth = GLFW.active.width; + GLFW.active.storedHeight = GLFW.active.height; + GLFW.active.x = GLFW.active.y = 0; + GLFW.active.width = screen.width; + GLFW.active.height = screen.height; + GLFW.active.fullscreen = true; + } + // If the client is reverting from fullscreen mode + } else if (GLFW.active.fullscreen == true) { + resizeNeeded = width != GLFW.active.storedWidth || height != GLFW.active.storedHeight; + GLFW.active.x = GLFW.active.storedX; + GLFW.active.y = GLFW.active.storedY; + GLFW.active.width = GLFW.active.storedWidth; + GLFW.active.height = GLFW.active.storedHeight; + GLFW.active.fullscreen = false; + } + + if (resizeNeeded) { + // width or height is changed (fullscreen / exit fullscreen) which will call this listener back + // with proper framebufferWidth/framebufferHeight + Browser.setCanvasSize(GLFW.active.width, GLFW.active.height); + } else if (GLFW.active.width != width || + GLFW.active.height != height || + GLFW.active.framebufferWidth != framebufferWidth || + GLFW.active.framebufferHeight != framebufferHeight) { + GLFW.active.width = width; + GLFW.active.height = height; + GLFW.active.framebufferWidth = framebufferWidth; + GLFW.active.framebufferHeight = framebufferHeight; + GLFW.onWindowSizeChanged(); + GLFW.onFramebufferSizeChanged(); + } + }, + onWindowSizeChanged:() => { + if (!GLFW.active) return; + + if (GLFW.active.windowSizeFunc) { + ((a1, a2, a3) => dynCall_viii(GLFW.active.windowSizeFunc, a1, a2, a3))(GLFW.active.id, GLFW.active.width, GLFW.active.height); + } + }, + onFramebufferSizeChanged:() => { + if (!GLFW.active) return; + + if (GLFW.active.framebufferSizeFunc) { + ((a1, a2, a3) => dynCall_viii(GLFW.active.framebufferSizeFunc, a1, a2, a3))(GLFW.active.id, GLFW.active.framebufferWidth, GLFW.active.framebufferHeight); + } + }, + onWindowContentScaleChanged:(scale) => { + GLFW.scale = scale; + if (!GLFW.active) return; + + if (GLFW.active.windowContentScaleFunc) { + ((a1, a2, a3) => dynCall_viff(GLFW.active.windowContentScaleFunc, a1, a2, a3))(GLFW.active.id, GLFW.scale, GLFW.scale); + } + }, + getTime:() => _emscripten_get_now() / 1000, + setWindowTitle:(winid, title) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + + win.title = title; + if (GLFW.active.id == win.id) { + _emscripten_set_window_title(title); + } + }, + setJoystickCallback:(cbfun) => { + var prevcbfun = GLFW.joystickFunc; + GLFW.joystickFunc = cbfun; + GLFW.refreshJoysticks(); + return prevcbfun; + }, + joys:{ + }, + lastGamepadState:[], + lastGamepadStateFrame:null, + refreshJoysticks:() => { + // Produce a new Gamepad API sample if we are ticking a new game frame, or if not using emscripten_set_main_loop() at all to drive animation. + if (MainLoop.currentFrameNumber !== GLFW.lastGamepadStateFrame || !MainLoop.currentFrameNumber) { + GLFW.lastGamepadState = navigator.getGamepads ? navigator.getGamepads() : (navigator.webkitGetGamepads || []); + GLFW.lastGamepadStateFrame = MainLoop.currentFrameNumber; + + for (var joy = 0; joy < GLFW.lastGamepadState.length; ++joy) { + var gamepad = GLFW.lastGamepadState[joy]; + + if (gamepad) { + if (!GLFW.joys[joy]) { + out('glfw joystick connected:',joy); + GLFW.joys[joy] = { + id: stringToNewUTF8(gamepad.id), + buttonsCount: gamepad.buttons.length, + axesCount: gamepad.axes.length, + buttons: _malloc(gamepad.buttons.length), + axes: _malloc(gamepad.axes.length*4), + }; + + if (GLFW.joystickFunc) { + ((a1, a2) => dynCall_vii(GLFW.joystickFunc, a1, a2))(joy, 0x00040001); // GLFW_CONNECTED + } + } + + var data = GLFW.joys[joy]; + + for (var i = 0; i < gamepad.buttons.length; ++i) { + HEAP8[data.buttons + i] = gamepad.buttons[i].pressed;checkInt8(gamepad.buttons[i].pressed); + } + + for (var i = 0; i < gamepad.axes.length; ++i) { + HEAPF32[((data.axes + i*4)>>2)] = gamepad.axes[i]; + } + } else { + if (GLFW.joys[joy]) { + out('glfw joystick disconnected',joy); + + if (GLFW.joystickFunc) { + ((a1, a2) => dynCall_vii(GLFW.joystickFunc, a1, a2))(joy, 0x00040002); // GLFW_DISCONNECTED + } + + _free(GLFW.joys[joy].id); + _free(GLFW.joys[joy].buttons); + _free(GLFW.joys[joy].axes); + + delete GLFW.joys[joy]; + } + } + } + } + }, + setKeyCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.keyFunc; + win.keyFunc = cbfun; + return prevcbfun; + }, + setCharCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.charFunc; + win.charFunc = cbfun; + return prevcbfun; + }, + setMouseButtonCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.mouseButtonFunc; + win.mouseButtonFunc = cbfun; + return prevcbfun; + }, + setCursorPosCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.cursorPosFunc; + win.cursorPosFunc = cbfun; + return prevcbfun; + }, + setScrollCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.scrollFunc; + win.scrollFunc = cbfun; + return prevcbfun; + }, + setDropCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.dropFunc; + win.dropFunc = cbfun; + return prevcbfun; + }, + onDrop:(event) => { + if (!GLFW.active || !GLFW.active.dropFunc) return; + if (!event.dataTransfer || !event.dataTransfer.files || event.dataTransfer.files.length == 0) return; + + event.preventDefault(); + + var filenames = _malloc(event.dataTransfer.files.length*4); + var filenamesArray = []; + var count = event.dataTransfer.files.length; + + // Read and save the files to emscripten's FS + var written = 0; + var drop_dir = '.glfw_dropped_files'; + FS.createPath('/', drop_dir); + + function save(file) { + var path = '/' + drop_dir + '/' + file.name.replace(/\//g, '_'); + var reader = new FileReader(); + reader.onloadend = (e) => { + if (reader.readyState != 2) { // not DONE + ++written; + out('failed to read dropped file: '+file.name+': '+reader.error); + return; + } + + var data = e.target.result; + FS.writeFile(path, new Uint8Array(data)); + if (++written === count) { + ((a1, a2, a3) => dynCall_viii(GLFW.active.dropFunc, a1, a2, a3))(GLFW.active.id, count, filenames); + + for (var i = 0; i < filenamesArray.length; ++i) { + _free(filenamesArray[i]); + } + _free(filenames); + } + }; + reader.readAsArrayBuffer(file); + + var filename = stringToNewUTF8(path); + filenamesArray.push(filename); + HEAPU32[((filenames + i*4)>>2)] = filename;checkInt32(filename); + } + + for (var i = 0; i < count; ++i) { + save(event.dataTransfer.files[i]); + } + + return false; + }, + onDragover:(event) => { + if (!GLFW.active || !GLFW.active.dropFunc) return; + + event.preventDefault(); + return false; + }, + setWindowSizeCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.windowSizeFunc; + win.windowSizeFunc = cbfun; + + return prevcbfun; + }, + setWindowCloseCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.windowCloseFunc; + win.windowCloseFunc = cbfun; + return prevcbfun; + }, + setWindowRefreshCallback:(winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.windowRefreshFunc; + win.windowRefreshFunc = cbfun; + return prevcbfun; + }, + onClickRequestPointerLock:(e) => { + if (!Browser.pointerLock && Module['canvas'].requestPointerLock) { + Module['canvas'].requestPointerLock(); + e.preventDefault(); + } + }, + setInputMode:(winid, mode, value) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + + switch (mode) { + case 0x00033001: { // GLFW_CURSOR + switch (value) { + case 0x00034001: { // GLFW_CURSOR_NORMAL + win.inputModes[mode] = value; + Module['canvas'].removeEventListener('click', GLFW.onClickRequestPointerLock, true); + Module['canvas'].exitPointerLock(); + break; + } + case 0x00034002: { // GLFW_CURSOR_HIDDEN + err('glfwSetInputMode called with GLFW_CURSOR_HIDDEN value not implemented'); + break; + } + case 0x00034003: { // GLFW_CURSOR_DISABLED + win.inputModes[mode] = value; + Module['canvas'].addEventListener('click', GLFW.onClickRequestPointerLock, true); + Module['canvas'].requestPointerLock(); + break; + } + default: { + err(`glfwSetInputMode called with unknown value parameter value: ${value}`); + break; + } + } + break; + } + case 0x00033002: { // GLFW_STICKY_KEYS + err('glfwSetInputMode called with GLFW_STICKY_KEYS mode not implemented'); + break; + } + case 0x00033003: { // GLFW_STICKY_MOUSE_BUTTONS + err('glfwSetInputMode called with GLFW_STICKY_MOUSE_BUTTONS mode not implemented'); + break; + } + case 0x00033004: { // GLFW_LOCK_KEY_MODS + err('glfwSetInputMode called with GLFW_LOCK_KEY_MODS mode not implemented'); + break; + } + case 0x000330005: { // GLFW_RAW_MOUSE_MOTION + err('glfwSetInputMode called with GLFW_RAW_MOUSE_MOTION mode not implemented'); + break; + } + default: { + err(`glfwSetInputMode called with unknown mode parameter value: ${mode}`); + break; + } + } + }, + getKey:(winid, key) => { + var win = GLFW.WindowFromId(winid); + if (!win) return 0; + return win.keys[key]; + }, + getMouseButton:(winid, button) => { + var win = GLFW.WindowFromId(winid); + if (!win) return 0; + return (win.buttons & (1 << button)) > 0; + }, + getCursorPos:(winid, x, y) => { + HEAPF64[((x)>>3)] = Browser.mouseX; + HEAPF64[((y)>>3)] = Browser.mouseY; + }, + getMousePos:(winid, x, y) => { + HEAP32[((x)>>2)] = Browser.mouseX;checkInt32(Browser.mouseX); + HEAP32[((y)>>2)] = Browser.mouseY;checkInt32(Browser.mouseY); + }, + setCursorPos:(winid, x, y) => { + }, + getWindowPos:(winid, x, y) => { + var wx = 0; + var wy = 0; + + var win = GLFW.WindowFromId(winid); + if (win) { + wx = win.x; + wy = win.y; + } + + if (x) { + HEAP32[((x)>>2)] = wx;checkInt32(wx); + } + + if (y) { + HEAP32[((y)>>2)] = wy;checkInt32(wy); + } + }, + setWindowPos:(winid, x, y) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + win.x = x; + win.y = y; + }, + getWindowSize:(winid, width, height) => { + var ww = 0; + var wh = 0; + + var win = GLFW.WindowFromId(winid); + if (win) { + ww = win.width; + wh = win.height; + } + + if (width) { + HEAP32[((width)>>2)] = ww;checkInt32(ww); + } + + if (height) { + HEAP32[((height)>>2)] = wh;checkInt32(wh); + } + }, + setWindowSize:(winid, width, height) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + + if (GLFW.active.id == win.id) { + Browser.setCanvasSize(width, height); // triggers the listener (onCanvasResize) + windowSizeFunc + } + }, + defaultWindowHints:() => { + GLFW.hints = Object.assign({}, GLFW.defaultHints); + }, + createWindow:(width, height, title, monitor, share) => { + var i, id; + for (i = 0; i < GLFW.windows.length && GLFW.windows[i] !== null; i++) { + // no-op + } + if (i > 0) throw "glfwCreateWindow only supports one window at time currently"; + + // id for window + id = i + 1; + + // not valid + if (width <= 0 || height <= 0) return 0; + + if (monitor) { + Browser.requestFullscreen(); + } else { + Browser.setCanvasSize(width, height); + } + + // Create context when there are no existing alive windows + for (i = 0; i < GLFW.windows.length && GLFW.windows[i] == null; i++) { + // no-op + } + var useWebGL = GLFW.hints[0x00022001] > 0; // Use WebGL when we are told to based on GLFW_CLIENT_API + if (i == GLFW.windows.length) { + if (useWebGL) { + var contextAttributes = { + antialias: (GLFW.hints[0x0002100D] > 1), // GLFW_SAMPLES + depth: (GLFW.hints[0x00021005] > 0), // GLFW_DEPTH_BITS + stencil: (GLFW.hints[0x00021006] > 0), // GLFW_STENCIL_BITS + alpha: (GLFW.hints[0x00021004] > 0) // GLFW_ALPHA_BITS + } + Browser.createContext(Module['canvas'], /*useWebGL=*/true, /*setInModule=*/true, contextAttributes); + } else { + Browser.init(); + } + } + + // If context creation failed, do not return a valid window + if (!Module.ctx && useWebGL) return 0; + + // Initializes the framebuffer size from the canvas + const canvas = Module['canvas']; + var win = new GLFW_Window(id, width, height, canvas.width, canvas.height, title, monitor, share); + + // Set window to array + if (id - 1 == GLFW.windows.length) { + GLFW.windows.push(win); + } else { + GLFW.windows[id - 1] = win; + } + + GLFW.active = win; + GLFW.adjustCanvasDimensions(); + return win.id; + }, + destroyWindow:(winid) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + + if (win.windowCloseFunc) { + ((a1) => dynCall_vi(win.windowCloseFunc, a1))(win.id); + } + + GLFW.windows[win.id - 1] = null; + if (GLFW.active.id == win.id) + GLFW.active = null; + + // Destroy context when no alive windows + for (var i = 0; i < GLFW.windows.length; i++) + if (GLFW.windows[i] !== null) return; + + delete Module.ctx; + }, + swapBuffers:(winid) => { + }, + requestFullscreen(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); + Browser.updateResizeListeners(); + } + } else { + // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + + if (Browser.resizeCanvas) { + Browser.setWindowedCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + Browser.updateResizeListeners(); + } + } + Module['onFullScreen']?.(Browser.isFullscreen); + 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); + } + + // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + + // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size) + 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(); + }, + updateCanvasDimensions(canvas, wNative, hNative) { + const scale = GLFW.getHiDPIScale(); + + 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) { + wNative = w; + hNative = h; + } + const wNativeScaled = Math.floor(wNative * scale); + const hNativeScaled = Math.floor(hNative * scale); + if (canvas.width != wNativeScaled) canvas.width = wNativeScaled; + if (canvas.height != hNativeScaled) canvas.height = hNativeScaled; + if (typeof canvas.style != 'undefined') { + if (!GLFW.isCSSScalingEnabled()) { + canvas.style.setProperty( "width", wNative + "px", "important"); + canvas.style.setProperty("height", hNative + "px", "important"); + } else { + canvas.style.removeProperty( "width"); + canvas.style.removeProperty("height"); + } + } + }, + calculateMouseCoords(pageX, pageY) { + // Calculate the movement based on the changes + // in the coordinates. + const rect = Module["canvas"].getBoundingClientRect(); + + // Neither .scrollX or .pageXOffset are defined in a spec, but + // we prefer .scrollX because it is currently in a spec draft. + // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/) + var scrollX = ((typeof window.scrollX != 'undefined') ? window.scrollX : window.pageXOffset); + var scrollY = ((typeof window.scrollY != 'undefined') ? window.scrollY : window.pageYOffset); + // If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset + // and we have no viable fallback. + assert((typeof scrollX != 'undefined') && (typeof scrollY != 'undefined'), 'Unable to retrieve scroll position, mouse positions likely broken.'); + var adjustedX = pageX - (scrollX + rect.left); + var adjustedY = pageY - (scrollY + rect.top); + + // getBoundingClientRect() returns dimension affected by CSS, so as a result: + // - when CSS scaling is enabled, this will fix the mouse coordinates to match the width/height of the window + // - otherwise the CSS width/height are forced to the width/height of the GLFW window (see updateCanvasDimensions), + // so there is no need to adjust the position + if (GLFW.isCSSScalingEnabled() && GLFW.active) { + adjustedX = adjustedX * (GLFW.active.width / rect.width); + adjustedY = adjustedY * (GLFW.active.height / rect.height); + } + + return { x: adjustedX, y: adjustedY }; + }, + setWindowAttrib:(winid, attrib, value) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + const isHiDPIAware = GLFW.isHiDPIAware(); + win.attributes[attrib] = value; + if (isHiDPIAware !== GLFW.isHiDPIAware()) + GLFW.adjustCanvasDimensions(); + }, + getDevicePixelRatio() { + return (typeof devicePixelRatio == 'number' && devicePixelRatio) || 1.0; + }, + isHiDPIAware() { + if (GLFW.active) + return GLFW.active.attributes[0x0002200C] > 0; // GLFW_SCALE_TO_MONITOR + else + return false; + }, + isCSSScalingEnabled() { + return !GLFW.isHiDPIAware(); + }, + adjustCanvasDimensions() { + if (GLFW.active) { + Browser.updateCanvasDimensions(Module['canvas'], GLFW.active.width, GLFW.active.height); + Browser.updateResizeListeners(); + } + }, + getHiDPIScale() { + return GLFW.isHiDPIAware() ? GLFW.scale : 1.0; + }, + onDevicePixelRatioChange() { + GLFW.onWindowContentScaleChanged(GLFW.getDevicePixelRatio()); + GLFW.adjustCanvasDimensions(); + }, + GLFW2ParamToGLFW3Param:(param) => { + var table = { + 0x00030001:0, // GLFW_MOUSE_CURSOR + 0x00030002:0, // GLFW_STICKY_KEYS + 0x00030003:0, // GLFW_STICKY_MOUSE_BUTTONS + 0x00030004:0, // GLFW_SYSTEM_KEYS + 0x00030005:0, // GLFW_KEY_REPEAT + 0x00030006:0, // GLFW_AUTO_POLL_EVENTS + 0x00020001:0, // GLFW_OPENED + 0x00020002:0, // GLFW_ACTIVE + 0x00020003:0, // GLFW_ICONIFIED + 0x00020004:0, // GLFW_ACCELERATED + 0x00020005:0x00021001, // GLFW_RED_BITS + 0x00020006:0x00021002, // GLFW_GREEN_BITS + 0x00020007:0x00021003, // GLFW_BLUE_BITS + 0x00020008:0x00021004, // GLFW_ALPHA_BITS + 0x00020009:0x00021005, // GLFW_DEPTH_BITS + 0x0002000A:0x00021006, // GLFW_STENCIL_BITS + 0x0002000B:0x0002100F, // GLFW_REFRESH_RATE + 0x0002000C:0x00021007, // GLFW_ACCUM_RED_BITS + 0x0002000D:0x00021008, // GLFW_ACCUM_GREEN_BITS + 0x0002000E:0x00021009, // GLFW_ACCUM_BLUE_BITS + 0x0002000F:0x0002100A, // GLFW_ACCUM_ALPHA_BITS + 0x00020010:0x0002100B, // GLFW_AUX_BUFFERS + 0x00020011:0x0002100C, // GLFW_STEREO + 0x00020012:0, // GLFW_WINDOW_NO_RESIZE + 0x00020013:0x0002100D, // GLFW_FSAA_SAMPLES + 0x00020014:0x00022002, // GLFW_OPENGL_VERSION_MAJOR + 0x00020015:0x00022003, // GLFW_OPENGL_VERSION_MINOR + 0x00020016:0x00022006, // GLFW_OPENGL_FORWARD_COMPAT + 0x00020017:0x00022007, // GLFW_OPENGL_DEBUG_CONTEXT + 0x00020018:0x00022008, // GLFW_OPENGL_PROFILE + }; + return table[param]; + }, + }; + var _glfwCreateWindow = (width, height, title, monitor, share) => GLFW.createWindow(width, height, title, monitor, share); + + var _glfwDefaultWindowHints = () => GLFW.defaultWindowHints(); + + var _glfwDestroyWindow = (winid) => GLFW.destroyWindow(winid); + + var _glfwGetPrimaryMonitor = () => 1; + + var _glfwGetTime = () => GLFW.getTime() - GLFW.initialTime; + + var _glfwGetVideoModes = (monitor, count) => { + HEAP32[((count)>>2)] = 0;checkInt32(0); + return 0; + }; + + + + var _glfwInit = () => { + if (GLFW.windows) return 1; // GL_TRUE + + GLFW.initialTime = GLFW.getTime(); + GLFW.defaultWindowHints(); + GLFW.windows = new Array() + GLFW.active = null; + GLFW.scale = GLFW.getDevicePixelRatio(); + + window.addEventListener("gamepadconnected", GLFW.onGamepadConnected, true); + window.addEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true); + window.addEventListener("keydown", GLFW.onKeydown, true); + window.addEventListener("keypress", GLFW.onKeyPress, true); + window.addEventListener("keyup", GLFW.onKeyup, true); + window.addEventListener("blur", GLFW.onBlur, true); + + // watch for devicePixelRatio changes + GLFW.devicePixelRatioMQL = window.matchMedia('(resolution: ' + GLFW.getDevicePixelRatio() + 'dppx)'); + GLFW.devicePixelRatioMQL.addEventListener('change', GLFW.onDevicePixelRatioChange); + + Module["canvas"].addEventListener("touchmove", GLFW.onMousemove, true); + Module["canvas"].addEventListener("touchstart", GLFW.onMouseButtonDown, true); + Module["canvas"].addEventListener("touchcancel", GLFW.onMouseButtonUp, true); + Module["canvas"].addEventListener("touchend", GLFW.onMouseButtonUp, true); + Module["canvas"].addEventListener("mousemove", GLFW.onMousemove, true); + Module["canvas"].addEventListener("mousedown", GLFW.onMouseButtonDown, true); + Module["canvas"].addEventListener("mouseup", GLFW.onMouseButtonUp, true); + Module["canvas"].addEventListener('wheel', GLFW.onMouseWheel, true); + Module["canvas"].addEventListener('mousewheel', GLFW.onMouseWheel, true); + Module["canvas"].addEventListener('mouseenter', GLFW.onMouseenter, true); + Module["canvas"].addEventListener('mouseleave', GLFW.onMouseleave, true); + Module["canvas"].addEventListener('drop', GLFW.onDrop, true); + Module["canvas"].addEventListener('dragover', GLFW.onDragover, true); + + // Overriding implementation to account for HiDPI + Browser.requestFullscreen = GLFW.requestFullscreen; + Browser.calculateMouseCoords = GLFW.calculateMouseCoords; + Browser.updateCanvasDimensions = GLFW.updateCanvasDimensions; + + Browser.resizeListeners.push((width, height) => { + if (GLFW.isHiDPIAware()) { + var canvas = Module['canvas']; + GLFW.onCanvasResize(canvas.clientWidth, canvas.clientHeight, width, height); + } else { + GLFW.onCanvasResize(width, height, width, height); + } + }); + + return 1; // GL_TRUE + }; + + var _glfwMakeContextCurrent = (winid) => {}; + + var _glfwSetCharCallback = (winid, cbfun) => GLFW.setCharCallback(winid, cbfun); + + var _glfwSetCursorEnterCallback = (winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.cursorEnterFunc; + win.cursorEnterFunc = cbfun; + return prevcbfun; + }; + + var _glfwSetCursorPosCallback = (winid, cbfun) => GLFW.setCursorPosCallback(winid, cbfun); + + var _glfwSetDropCallback = (winid, cbfun) => GLFW.setDropCallback(winid, cbfun); + + var _glfwSetErrorCallback = (cbfun) => { + var prevcbfun = GLFW.errorFunc; + GLFW.errorFunc = cbfun; + return prevcbfun; + }; + + var _glfwSetKeyCallback = (winid, cbfun) => GLFW.setKeyCallback(winid, cbfun); + + var _glfwSetMouseButtonCallback = (winid, cbfun) => GLFW.setMouseButtonCallback(winid, cbfun); + + var _glfwSetScrollCallback = (winid, cbfun) => GLFW.setScrollCallback(winid, cbfun); + + var _glfwSetWindowFocusCallback = (winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.windowFocusFunc; + win.windowFocusFunc = cbfun; + return prevcbfun; + }; + + var _glfwSetWindowIconifyCallback = (winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.windowIconifyFunc; + win.windowIconifyFunc = cbfun; + return prevcbfun; + }; + + var _glfwSetWindowShouldClose = (winid, value) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + win.shouldClose = value; + }; + + var _glfwSetWindowSizeCallback = (winid, cbfun) => GLFW.setWindowSizeCallback(winid, cbfun); + + var _glfwSwapBuffers = (winid) => GLFW.swapBuffers(winid); + + var _glfwTerminate = () => { + window.removeEventListener("gamepadconnected", GLFW.onGamepadConnected, true); + window.removeEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true); + window.removeEventListener("keydown", GLFW.onKeydown, true); + window.removeEventListener("keypress", GLFW.onKeyPress, true); + window.removeEventListener("keyup", GLFW.onKeyup, true); + window.removeEventListener("blur", GLFW.onBlur, true); + Module["canvas"].removeEventListener("touchmove", GLFW.onMousemove, true); + Module["canvas"].removeEventListener("touchstart", GLFW.onMouseButtonDown, true); + Module["canvas"].removeEventListener("touchcancel", GLFW.onMouseButtonUp, true); + Module["canvas"].removeEventListener("touchend", GLFW.onMouseButtonUp, true); + Module["canvas"].removeEventListener("mousemove", GLFW.onMousemove, true); + Module["canvas"].removeEventListener("mousedown", GLFW.onMouseButtonDown, true); + Module["canvas"].removeEventListener("mouseup", GLFW.onMouseButtonUp, true); + Module["canvas"].removeEventListener('wheel', GLFW.onMouseWheel, true); + Module["canvas"].removeEventListener('mousewheel', GLFW.onMouseWheel, true); + Module["canvas"].removeEventListener('mouseenter', GLFW.onMouseenter, true); + Module["canvas"].removeEventListener('mouseleave', GLFW.onMouseleave, true); + Module["canvas"].removeEventListener('drop', GLFW.onDrop, true); + Module["canvas"].removeEventListener('dragover', GLFW.onDragover, true); + + if (GLFW.devicePixelRatioMQL) + GLFW.devicePixelRatioMQL.removeEventListener('change', GLFW.onDevicePixelRatioChange); + + Module["canvas"].width = Module["canvas"].height = 1; + GLFW.windows = null; + GLFW.active = null; + }; + + var _glfwWindowHint = (target, hint) => { + GLFW.hints[target] = hint; + }; + + + + + var runAndAbortIfError = (func) => { + try { + return func(); + } catch (e) { + abort(e); + } + }; + + + var sigToWasmTypes = (sig) => { + assert(!sig.includes('j'), 'i64 not permitted in function signatures when WASM_BIGINT is disabled'); + var typeNames = { + 'i': 'i32', + 'j': 'i64', + 'f': 'f32', + 'd': 'f64', + 'e': 'externref', + 'p': 'i32', + }; + var type = { + parameters: [], + results: sig[0] == 'v' ? [] : [typeNames[sig[0]]] + }; + for (var i = 1; i < sig.length; ++i) { + assert(sig[i] in typeNames, 'invalid signature char: ' + sig[i]); + type.parameters.push(typeNames[sig[i]]); + } + return type; + }; + + var runtimeKeepalivePush = () => { + runtimeKeepaliveCounter += 1; + }; + + var runtimeKeepalivePop = () => { + assert(runtimeKeepaliveCounter > 0); + runtimeKeepaliveCounter -= 1; + }; + + + var Asyncify = { + instrumentWasmImports(imports) { + var importPattern = /^(invoke_.*|__asyncjs__.*)$/; + + for (let [x, original] of Object.entries(imports)) { + if (typeof original == 'function') { + let isAsyncifyImport = original.isAsync || importPattern.test(x); + imports[x] = (...args) => { + var originalAsyncifyState = Asyncify.state; + try { + return original(...args); + } finally { + // Only asyncify-declared imports are allowed to change the + // state. + // Changing the state from normal to disabled is allowed (in any + // function) as that is what shutdown does (and we don't have an + // explicit list of shutdown imports). + var changedToDisabled = + originalAsyncifyState === Asyncify.State.Normal && + Asyncify.state === Asyncify.State.Disabled; + // invoke_* functions are allowed to change the state if we do + // not ignore indirect calls. + var ignoredInvoke = x.startsWith('invoke_') && + true; + if (Asyncify.state !== originalAsyncifyState && + !isAsyncifyImport && + !changedToDisabled && + !ignoredInvoke) { + throw new Error(`import ${x} was not in ASYNCIFY_IMPORTS, but changed the state`); + } + } + }; + } + } + }, + instrumentWasmExports(exports) { + var ret = {}; + for (let [x, original] of Object.entries(exports)) { + if (typeof original == 'function') { + ret[x] = (...args) => { + Asyncify.exportCallStack.push(x); + try { + return original(...args); + } finally { + if (!ABORT) { + var y = Asyncify.exportCallStack.pop(); + assert(y === x); + Asyncify.maybeStopUnwind(); + } + } + }; + } else { + ret[x] = original; + } + } + return ret; + }, + State:{ + Normal:0, + Unwinding:1, + Rewinding:2, + Disabled:3, + }, + state:0, + StackSize:4096, + currData:null, + handleSleepReturnValue:0, + exportCallStack:[], + callStackNameToId:{ + }, + callStackIdToName:{ + }, + callStackId:0, + asyncPromiseHandlers:null, + sleepCallbacks:[], + getCallStackId(funcName) { + var id = Asyncify.callStackNameToId[funcName]; + if (id === undefined) { + id = Asyncify.callStackId++; + Asyncify.callStackNameToId[funcName] = id; + Asyncify.callStackIdToName[id] = funcName; + } + return id; + }, + maybeStopUnwind() { + if (Asyncify.currData && + Asyncify.state === Asyncify.State.Unwinding && + Asyncify.exportCallStack.length === 0) { + // We just finished unwinding. + // Be sure to set the state before calling any other functions to avoid + // possible infinite recursion here (For example in debug pthread builds + // the dbg() function itself can call back into WebAssembly to get the + // current pthread_self() pointer). + Asyncify.state = Asyncify.State.Normal; + + // Keep the runtime alive so that a re-wind can be done later. + runAndAbortIfError(_asyncify_stop_unwind); + if (typeof Fibers != 'undefined') { + Fibers.trampoline(); + } + } + }, + whenDone() { + assert(Asyncify.currData, 'Tried to wait for an async operation when none is in progress.'); + assert(!Asyncify.asyncPromiseHandlers, 'Cannot have multiple async operations in flight at once'); + return new Promise((resolve, reject) => { + Asyncify.asyncPromiseHandlers = { resolve, reject }; + }); + }, + allocateData() { + // An asyncify data structure has three fields: + // 0 current stack pos + // 4 max stack pos + // 8 id of function at bottom of the call stack (callStackIdToName[id] == name of js function) + // + // The Asyncify ABI only interprets the first two fields, the rest is for the runtime. + // We also embed a stack in the same memory region here, right next to the structure. + // This struct is also defined as asyncify_data_t in emscripten/fiber.h + var ptr = _malloc(12 + Asyncify.StackSize); + Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize); + Asyncify.setDataRewindFunc(ptr); + return ptr; + }, + setDataHeader(ptr, stack, stackSize) { + HEAPU32[((ptr)>>2)] = stack; + HEAPU32[(((ptr)+(4))>>2)] = stack + stackSize; + }, + setDataRewindFunc(ptr) { + var bottomOfCallStack = Asyncify.exportCallStack[0]; + var rewindId = Asyncify.getCallStackId(bottomOfCallStack); + HEAP32[(((ptr)+(8))>>2)] = rewindId;checkInt32(rewindId); + }, + getDataRewindFuncName(ptr) { + var id = HEAP32[(((ptr)+(8))>>2)]; + var name = Asyncify.callStackIdToName[id]; + return name; + }, + getDataRewindFunc(name) { + var func = wasmExports[name]; + return func; + }, + doRewind(ptr) { + var name = Asyncify.getDataRewindFuncName(ptr); + var func = Asyncify.getDataRewindFunc(name); + // Once we have rewound and the stack we no longer need to artificially + // keep the runtime alive. + + return func(); + }, + handleSleep(startAsync) { + assert(Asyncify.state !== Asyncify.State.Disabled, 'Asyncify cannot be done during or after the runtime exits'); + if (ABORT) return; + if (Asyncify.state === Asyncify.State.Normal) { + // Prepare to sleep. Call startAsync, and see what happens: + // if the code decided to call our callback synchronously, + // then no async operation was in fact begun, and we don't + // need to do anything. + var reachedCallback = false; + var reachedAfterCallback = false; + startAsync((handleSleepReturnValue = 0) => { + assert(!handleSleepReturnValue || typeof handleSleepReturnValue == 'number' || typeof handleSleepReturnValue == 'boolean'); // old emterpretify API supported other stuff + if (ABORT) return; + Asyncify.handleSleepReturnValue = handleSleepReturnValue; + reachedCallback = true; + if (!reachedAfterCallback) { + // We are happening synchronously, so no need for async. + return; + } + // This async operation did not happen synchronously, so we did + // unwind. In that case there can be no compiled code on the stack, + // as it might break later operations (we can rewind ok now, but if + // we unwind again, we would unwind through the extra compiled code + // too). + assert(!Asyncify.exportCallStack.length, 'Waking up (starting to rewind) must be done from JS, without compiled code on the stack.'); + Asyncify.state = Asyncify.State.Rewinding; + runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData)); + if (typeof MainLoop != 'undefined' && MainLoop.func) { + MainLoop.resume(); + } + var asyncWasmReturnValue, isError = false; + try { + asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData); + } catch (err) { + asyncWasmReturnValue = err; + isError = true; + } + // Track whether the return value was handled by any promise handlers. + var handled = false; + if (!Asyncify.currData) { + // All asynchronous execution has finished. + // `asyncWasmReturnValue` now contains the final + // return value of the exported async WASM function. + // + // Note: `asyncWasmReturnValue` is distinct from + // `Asyncify.handleSleepReturnValue`. + // `Asyncify.handleSleepReturnValue` contains the return + // value of the last C function to have executed + // `Asyncify.handleSleep()`, where as `asyncWasmReturnValue` + // contains the return value of the exported WASM function + // that may have called C functions that + // call `Asyncify.handleSleep()`. + var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers; + if (asyncPromiseHandlers) { + Asyncify.asyncPromiseHandlers = null; + (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue); + handled = true; + } + } + if (isError && !handled) { + // If there was an error and it was not handled by now, we have no choice but to + // rethrow that error into the global scope where it can be caught only by + // `onerror` or `onunhandledpromiserejection`. + throw asyncWasmReturnValue; + } + }); + reachedAfterCallback = true; + if (!reachedCallback) { + // A true async operation was begun; start a sleep. + Asyncify.state = Asyncify.State.Unwinding; + // TODO: reuse, don't alloc/free every sleep + Asyncify.currData = Asyncify.allocateData(); + if (typeof MainLoop != 'undefined' && MainLoop.func) { + MainLoop.pause(); + } + runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData)); + } + } else if (Asyncify.state === Asyncify.State.Rewinding) { + // Stop a resume. + Asyncify.state = Asyncify.State.Normal; + runAndAbortIfError(_asyncify_stop_rewind); + _free(Asyncify.currData); + Asyncify.currData = null; + // Call all sleep callbacks now that the sleep-resume is all done. + Asyncify.sleepCallbacks.forEach(callUserCallback); + } else { + abort(`invalid state: ${Asyncify.state}`); + } + return Asyncify.handleSleepReturnValue; + }, + handleAsync(startAsync) { + return Asyncify.handleSleep((wakeUp) => { + // TODO: add error handling as a second param when handleSleep implements it. + startAsync().then(wakeUp); + }); + }, + }; + + var FS_createPath = FS.createPath; + + + + var FS_unlink = (path) => FS.unlink(path); + + var FS_createLazyFile = FS.createLazyFile; + + var FS_createDevice = FS.createDevice; + + FS.createPreloadedFile = FS_createPreloadedFile; + FS.staticInit(); + // Set module methods based on EXPORTED_RUNTIME_METHODS + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_unlink"] = FS.unlink; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + ; +for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));; +var miniTempWebGLFloatBuffersStorage = new Float32Array(288); + // Create GL_POOL_TEMP_BUFFERS_SIZE+1 temporary buffers, for uploads of size 0 through GL_POOL_TEMP_BUFFERS_SIZE inclusive + for (/**@suppress{duplicate}*/var i = 0; i <= 288; ++i) { + miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i); + }; +var miniTempWebGLIntBuffersStorage = new Int32Array(288); + // Create GL_POOL_TEMP_BUFFERS_SIZE+1 temporary buffers, for uploads of size 0 through GL_POOL_TEMP_BUFFERS_SIZE inclusive + for (/**@suppress{duplicate}*/var i = 0; i <= 288; ++i) { + miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i); + }; + + // exports + Module["requestFullscreen"] = Browser.requestFullscreen; + Module["requestFullScreen"] = Browser.requestFullScreen; + Module["setCanvasSize"] = Browser.setCanvasSize; + Module["getUserMedia"] = Browser.getUserMedia; + Module["createContext"] = Browser.createContext; + ; + + Module["requestAnimationFrame"] = MainLoop.requestAnimationFrame; + Module["pauseMainLoop"] = MainLoop.pause; + Module["resumeMainLoop"] = MainLoop.resume; + MainLoop.init();; +function checkIncomingModuleAPI() { + ignoredModuleProp('fetchSettings'); +} +var wasmImports = { + /** @export */ + GetWindowInnerHeight, + /** @export */ + GetWindowInnerWidth, + /** @export */ + __assert_fail: ___assert_fail, + /** @export */ + __handle_stack_overflow: ___handle_stack_overflow, + /** @export */ + __syscall_faccessat: ___syscall_faccessat, + /** @export */ + __syscall_fcntl64: ___syscall_fcntl64, + /** @export */ + __syscall_getcwd: ___syscall_getcwd, + /** @export */ + __syscall_ioctl: ___syscall_ioctl, + /** @export */ + __syscall_openat: ___syscall_openat, + /** @export */ + _abort_js: __abort_js, + /** @export */ + _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic, + /** @export */ + _emscripten_memcpy_js: __emscripten_memcpy_js, + /** @export */ + emscripten_date_now: _emscripten_date_now, + /** @export */ + emscripten_get_element_css_size: _emscripten_get_element_css_size, + /** @export */ + emscripten_get_gamepad_status: _emscripten_get_gamepad_status, + /** @export */ + emscripten_get_now: _emscripten_get_now, + /** @export */ + emscripten_get_num_gamepads: _emscripten_get_num_gamepads, + /** @export */ + emscripten_glActiveTexture: _emscripten_glActiveTexture, + /** @export */ + emscripten_glAttachShader: _emscripten_glAttachShader, + /** @export */ + emscripten_glBeginQuery: _emscripten_glBeginQuery, + /** @export */ + emscripten_glBeginQueryEXT: _emscripten_glBeginQueryEXT, + /** @export */ + emscripten_glBeginTransformFeedback: _emscripten_glBeginTransformFeedback, + /** @export */ + emscripten_glBindAttribLocation: _emscripten_glBindAttribLocation, + /** @export */ + emscripten_glBindBuffer: _emscripten_glBindBuffer, + /** @export */ + emscripten_glBindBufferBase: _emscripten_glBindBufferBase, + /** @export */ + emscripten_glBindBufferRange: _emscripten_glBindBufferRange, + /** @export */ + emscripten_glBindFramebuffer: _emscripten_glBindFramebuffer, + /** @export */ + emscripten_glBindRenderbuffer: _emscripten_glBindRenderbuffer, + /** @export */ + emscripten_glBindSampler: _emscripten_glBindSampler, + /** @export */ + emscripten_glBindTexture: _emscripten_glBindTexture, + /** @export */ + emscripten_glBindTransformFeedback: _emscripten_glBindTransformFeedback, + /** @export */ + emscripten_glBindVertexArray: _emscripten_glBindVertexArray, + /** @export */ + emscripten_glBindVertexArrayOES: _emscripten_glBindVertexArrayOES, + /** @export */ + emscripten_glBlendColor: _emscripten_glBlendColor, + /** @export */ + emscripten_glBlendEquation: _emscripten_glBlendEquation, + /** @export */ + emscripten_glBlendEquationSeparate: _emscripten_glBlendEquationSeparate, + /** @export */ + emscripten_glBlendFunc: _emscripten_glBlendFunc, + /** @export */ + emscripten_glBlendFuncSeparate: _emscripten_glBlendFuncSeparate, + /** @export */ + emscripten_glBlitFramebuffer: _emscripten_glBlitFramebuffer, + /** @export */ + emscripten_glBufferData: _emscripten_glBufferData, + /** @export */ + emscripten_glBufferSubData: _emscripten_glBufferSubData, + /** @export */ + emscripten_glCheckFramebufferStatus: _emscripten_glCheckFramebufferStatus, + /** @export */ + emscripten_glClear: _emscripten_glClear, + /** @export */ + emscripten_glClearBufferfi: _emscripten_glClearBufferfi, + /** @export */ + emscripten_glClearBufferfv: _emscripten_glClearBufferfv, + /** @export */ + emscripten_glClearBufferiv: _emscripten_glClearBufferiv, + /** @export */ + emscripten_glClearBufferuiv: _emscripten_glClearBufferuiv, + /** @export */ + emscripten_glClearColor: _emscripten_glClearColor, + /** @export */ + emscripten_glClearDepthf: _emscripten_glClearDepthf, + /** @export */ + emscripten_glClearStencil: _emscripten_glClearStencil, + /** @export */ + emscripten_glClientWaitSync: _emscripten_glClientWaitSync, + /** @export */ + emscripten_glClipControlEXT: _emscripten_glClipControlEXT, + /** @export */ + emscripten_glColorMask: _emscripten_glColorMask, + /** @export */ + emscripten_glCompileShader: _emscripten_glCompileShader, + /** @export */ + emscripten_glCompressedTexImage2D: _emscripten_glCompressedTexImage2D, + /** @export */ + emscripten_glCompressedTexImage3D: _emscripten_glCompressedTexImage3D, + /** @export */ + emscripten_glCompressedTexSubImage2D: _emscripten_glCompressedTexSubImage2D, + /** @export */ + emscripten_glCompressedTexSubImage3D: _emscripten_glCompressedTexSubImage3D, + /** @export */ + emscripten_glCopyBufferSubData: _emscripten_glCopyBufferSubData, + /** @export */ + emscripten_glCopyTexImage2D: _emscripten_glCopyTexImage2D, + /** @export */ + emscripten_glCopyTexSubImage2D: _emscripten_glCopyTexSubImage2D, + /** @export */ + emscripten_glCopyTexSubImage3D: _emscripten_glCopyTexSubImage3D, + /** @export */ + emscripten_glCreateProgram: _emscripten_glCreateProgram, + /** @export */ + emscripten_glCreateShader: _emscripten_glCreateShader, + /** @export */ + emscripten_glCullFace: _emscripten_glCullFace, + /** @export */ + emscripten_glDeleteBuffers: _emscripten_glDeleteBuffers, + /** @export */ + emscripten_glDeleteFramebuffers: _emscripten_glDeleteFramebuffers, + /** @export */ + emscripten_glDeleteProgram: _emscripten_glDeleteProgram, + /** @export */ + emscripten_glDeleteQueries: _emscripten_glDeleteQueries, + /** @export */ + emscripten_glDeleteQueriesEXT: _emscripten_glDeleteQueriesEXT, + /** @export */ + emscripten_glDeleteRenderbuffers: _emscripten_glDeleteRenderbuffers, + /** @export */ + emscripten_glDeleteSamplers: _emscripten_glDeleteSamplers, + /** @export */ + emscripten_glDeleteShader: _emscripten_glDeleteShader, + /** @export */ + emscripten_glDeleteSync: _emscripten_glDeleteSync, + /** @export */ + emscripten_glDeleteTextures: _emscripten_glDeleteTextures, + /** @export */ + emscripten_glDeleteTransformFeedbacks: _emscripten_glDeleteTransformFeedbacks, + /** @export */ + emscripten_glDeleteVertexArrays: _emscripten_glDeleteVertexArrays, + /** @export */ + emscripten_glDeleteVertexArraysOES: _emscripten_glDeleteVertexArraysOES, + /** @export */ + emscripten_glDepthFunc: _emscripten_glDepthFunc, + /** @export */ + emscripten_glDepthMask: _emscripten_glDepthMask, + /** @export */ + emscripten_glDepthRangef: _emscripten_glDepthRangef, + /** @export */ + emscripten_glDetachShader: _emscripten_glDetachShader, + /** @export */ + emscripten_glDisable: _emscripten_glDisable, + /** @export */ + emscripten_glDisableVertexAttribArray: _emscripten_glDisableVertexAttribArray, + /** @export */ + emscripten_glDrawArrays: _emscripten_glDrawArrays, + /** @export */ + emscripten_glDrawArraysInstanced: _emscripten_glDrawArraysInstanced, + /** @export */ + emscripten_glDrawArraysInstancedANGLE: _emscripten_glDrawArraysInstancedANGLE, + /** @export */ + emscripten_glDrawArraysInstancedARB: _emscripten_glDrawArraysInstancedARB, + /** @export */ + emscripten_glDrawArraysInstancedEXT: _emscripten_glDrawArraysInstancedEXT, + /** @export */ + emscripten_glDrawArraysInstancedNV: _emscripten_glDrawArraysInstancedNV, + /** @export */ + emscripten_glDrawBuffers: _emscripten_glDrawBuffers, + /** @export */ + emscripten_glDrawBuffersEXT: _emscripten_glDrawBuffersEXT, + /** @export */ + emscripten_glDrawBuffersWEBGL: _emscripten_glDrawBuffersWEBGL, + /** @export */ + emscripten_glDrawElements: _emscripten_glDrawElements, + /** @export */ + emscripten_glDrawElementsInstanced: _emscripten_glDrawElementsInstanced, + /** @export */ + emscripten_glDrawElementsInstancedANGLE: _emscripten_glDrawElementsInstancedANGLE, + /** @export */ + emscripten_glDrawElementsInstancedARB: _emscripten_glDrawElementsInstancedARB, + /** @export */ + emscripten_glDrawElementsInstancedEXT: _emscripten_glDrawElementsInstancedEXT, + /** @export */ + emscripten_glDrawElementsInstancedNV: _emscripten_glDrawElementsInstancedNV, + /** @export */ + emscripten_glDrawRangeElements: _emscripten_glDrawRangeElements, + /** @export */ + emscripten_glEnable: _emscripten_glEnable, + /** @export */ + emscripten_glEnableVertexAttribArray: _emscripten_glEnableVertexAttribArray, + /** @export */ + emscripten_glEndQuery: _emscripten_glEndQuery, + /** @export */ + emscripten_glEndQueryEXT: _emscripten_glEndQueryEXT, + /** @export */ + emscripten_glEndTransformFeedback: _emscripten_glEndTransformFeedback, + /** @export */ + emscripten_glFenceSync: _emscripten_glFenceSync, + /** @export */ + emscripten_glFinish: _emscripten_glFinish, + /** @export */ + emscripten_glFlush: _emscripten_glFlush, + /** @export */ + emscripten_glFramebufferRenderbuffer: _emscripten_glFramebufferRenderbuffer, + /** @export */ + emscripten_glFramebufferTexture2D: _emscripten_glFramebufferTexture2D, + /** @export */ + emscripten_glFramebufferTextureLayer: _emscripten_glFramebufferTextureLayer, + /** @export */ + emscripten_glFrontFace: _emscripten_glFrontFace, + /** @export */ + emscripten_glGenBuffers: _emscripten_glGenBuffers, + /** @export */ + emscripten_glGenFramebuffers: _emscripten_glGenFramebuffers, + /** @export */ + emscripten_glGenQueries: _emscripten_glGenQueries, + /** @export */ + emscripten_glGenQueriesEXT: _emscripten_glGenQueriesEXT, + /** @export */ + emscripten_glGenRenderbuffers: _emscripten_glGenRenderbuffers, + /** @export */ + emscripten_glGenSamplers: _emscripten_glGenSamplers, + /** @export */ + emscripten_glGenTextures: _emscripten_glGenTextures, + /** @export */ + emscripten_glGenTransformFeedbacks: _emscripten_glGenTransformFeedbacks, + /** @export */ + emscripten_glGenVertexArrays: _emscripten_glGenVertexArrays, + /** @export */ + emscripten_glGenVertexArraysOES: _emscripten_glGenVertexArraysOES, + /** @export */ + emscripten_glGenerateMipmap: _emscripten_glGenerateMipmap, + /** @export */ + emscripten_glGetActiveAttrib: _emscripten_glGetActiveAttrib, + /** @export */ + emscripten_glGetActiveUniform: _emscripten_glGetActiveUniform, + /** @export */ + emscripten_glGetActiveUniformBlockName: _emscripten_glGetActiveUniformBlockName, + /** @export */ + emscripten_glGetActiveUniformBlockiv: _emscripten_glGetActiveUniformBlockiv, + /** @export */ + emscripten_glGetActiveUniformsiv: _emscripten_glGetActiveUniformsiv, + /** @export */ + emscripten_glGetAttachedShaders: _emscripten_glGetAttachedShaders, + /** @export */ + emscripten_glGetAttribLocation: _emscripten_glGetAttribLocation, + /** @export */ + emscripten_glGetBooleanv: _emscripten_glGetBooleanv, + /** @export */ + emscripten_glGetBufferParameteri64v: _emscripten_glGetBufferParameteri64v, + /** @export */ + emscripten_glGetBufferParameteriv: _emscripten_glGetBufferParameteriv, + /** @export */ + emscripten_glGetError: _emscripten_glGetError, + /** @export */ + emscripten_glGetFloatv: _emscripten_glGetFloatv, + /** @export */ + emscripten_glGetFragDataLocation: _emscripten_glGetFragDataLocation, + /** @export */ + emscripten_glGetFramebufferAttachmentParameteriv: _emscripten_glGetFramebufferAttachmentParameteriv, + /** @export */ + emscripten_glGetInteger64i_v: _emscripten_glGetInteger64i_v, + /** @export */ + emscripten_glGetInteger64v: _emscripten_glGetInteger64v, + /** @export */ + emscripten_glGetIntegeri_v: _emscripten_glGetIntegeri_v, + /** @export */ + emscripten_glGetIntegerv: _emscripten_glGetIntegerv, + /** @export */ + emscripten_glGetInternalformativ: _emscripten_glGetInternalformativ, + /** @export */ + emscripten_glGetProgramBinary: _emscripten_glGetProgramBinary, + /** @export */ + emscripten_glGetProgramInfoLog: _emscripten_glGetProgramInfoLog, + /** @export */ + emscripten_glGetProgramiv: _emscripten_glGetProgramiv, + /** @export */ + emscripten_glGetQueryObjecti64vEXT: _emscripten_glGetQueryObjecti64vEXT, + /** @export */ + emscripten_glGetQueryObjectivEXT: _emscripten_glGetQueryObjectivEXT, + /** @export */ + emscripten_glGetQueryObjectui64vEXT: _emscripten_glGetQueryObjectui64vEXT, + /** @export */ + emscripten_glGetQueryObjectuiv: _emscripten_glGetQueryObjectuiv, + /** @export */ + emscripten_glGetQueryObjectuivEXT: _emscripten_glGetQueryObjectuivEXT, + /** @export */ + emscripten_glGetQueryiv: _emscripten_glGetQueryiv, + /** @export */ + emscripten_glGetQueryivEXT: _emscripten_glGetQueryivEXT, + /** @export */ + emscripten_glGetRenderbufferParameteriv: _emscripten_glGetRenderbufferParameteriv, + /** @export */ + emscripten_glGetSamplerParameterfv: _emscripten_glGetSamplerParameterfv, + /** @export */ + emscripten_glGetSamplerParameteriv: _emscripten_glGetSamplerParameteriv, + /** @export */ + emscripten_glGetShaderInfoLog: _emscripten_glGetShaderInfoLog, + /** @export */ + emscripten_glGetShaderPrecisionFormat: _emscripten_glGetShaderPrecisionFormat, + /** @export */ + emscripten_glGetShaderSource: _emscripten_glGetShaderSource, + /** @export */ + emscripten_glGetShaderiv: _emscripten_glGetShaderiv, + /** @export */ + emscripten_glGetString: _emscripten_glGetString, + /** @export */ + emscripten_glGetStringi: _emscripten_glGetStringi, + /** @export */ + emscripten_glGetSynciv: _emscripten_glGetSynciv, + /** @export */ + emscripten_glGetTexParameterfv: _emscripten_glGetTexParameterfv, + /** @export */ + emscripten_glGetTexParameteriv: _emscripten_glGetTexParameteriv, + /** @export */ + emscripten_glGetTransformFeedbackVarying: _emscripten_glGetTransformFeedbackVarying, + /** @export */ + emscripten_glGetUniformBlockIndex: _emscripten_glGetUniformBlockIndex, + /** @export */ + emscripten_glGetUniformIndices: _emscripten_glGetUniformIndices, + /** @export */ + emscripten_glGetUniformLocation: _emscripten_glGetUniformLocation, + /** @export */ + emscripten_glGetUniformfv: _emscripten_glGetUniformfv, + /** @export */ + emscripten_glGetUniformiv: _emscripten_glGetUniformiv, + /** @export */ + emscripten_glGetUniformuiv: _emscripten_glGetUniformuiv, + /** @export */ + emscripten_glGetVertexAttribIiv: _emscripten_glGetVertexAttribIiv, + /** @export */ + emscripten_glGetVertexAttribIuiv: _emscripten_glGetVertexAttribIuiv, + /** @export */ + emscripten_glGetVertexAttribPointerv: _emscripten_glGetVertexAttribPointerv, + /** @export */ + emscripten_glGetVertexAttribfv: _emscripten_glGetVertexAttribfv, + /** @export */ + emscripten_glGetVertexAttribiv: _emscripten_glGetVertexAttribiv, + /** @export */ + emscripten_glHint: _emscripten_glHint, + /** @export */ + emscripten_glInvalidateFramebuffer: _emscripten_glInvalidateFramebuffer, + /** @export */ + emscripten_glInvalidateSubFramebuffer: _emscripten_glInvalidateSubFramebuffer, + /** @export */ + emscripten_glIsBuffer: _emscripten_glIsBuffer, + /** @export */ + emscripten_glIsEnabled: _emscripten_glIsEnabled, + /** @export */ + emscripten_glIsFramebuffer: _emscripten_glIsFramebuffer, + /** @export */ + emscripten_glIsProgram: _emscripten_glIsProgram, + /** @export */ + emscripten_glIsQuery: _emscripten_glIsQuery, + /** @export */ + emscripten_glIsQueryEXT: _emscripten_glIsQueryEXT, + /** @export */ + emscripten_glIsRenderbuffer: _emscripten_glIsRenderbuffer, + /** @export */ + emscripten_glIsSampler: _emscripten_glIsSampler, + /** @export */ + emscripten_glIsShader: _emscripten_glIsShader, + /** @export */ + emscripten_glIsSync: _emscripten_glIsSync, + /** @export */ + emscripten_glIsTexture: _emscripten_glIsTexture, + /** @export */ + emscripten_glIsTransformFeedback: _emscripten_glIsTransformFeedback, + /** @export */ + emscripten_glIsVertexArray: _emscripten_glIsVertexArray, + /** @export */ + emscripten_glIsVertexArrayOES: _emscripten_glIsVertexArrayOES, + /** @export */ + emscripten_glLineWidth: _emscripten_glLineWidth, + /** @export */ + emscripten_glLinkProgram: _emscripten_glLinkProgram, + /** @export */ + emscripten_glPauseTransformFeedback: _emscripten_glPauseTransformFeedback, + /** @export */ + emscripten_glPixelStorei: _emscripten_glPixelStorei, + /** @export */ + emscripten_glPolygonModeWEBGL: _emscripten_glPolygonModeWEBGL, + /** @export */ + emscripten_glPolygonOffset: _emscripten_glPolygonOffset, + /** @export */ + emscripten_glPolygonOffsetClampEXT: _emscripten_glPolygonOffsetClampEXT, + /** @export */ + emscripten_glProgramBinary: _emscripten_glProgramBinary, + /** @export */ + emscripten_glProgramParameteri: _emscripten_glProgramParameteri, + /** @export */ + emscripten_glQueryCounterEXT: _emscripten_glQueryCounterEXT, + /** @export */ + emscripten_glReadBuffer: _emscripten_glReadBuffer, + /** @export */ + emscripten_glReadPixels: _emscripten_glReadPixels, + /** @export */ + emscripten_glReleaseShaderCompiler: _emscripten_glReleaseShaderCompiler, + /** @export */ + emscripten_glRenderbufferStorage: _emscripten_glRenderbufferStorage, + /** @export */ + emscripten_glRenderbufferStorageMultisample: _emscripten_glRenderbufferStorageMultisample, + /** @export */ + emscripten_glResumeTransformFeedback: _emscripten_glResumeTransformFeedback, + /** @export */ + emscripten_glSampleCoverage: _emscripten_glSampleCoverage, + /** @export */ + emscripten_glSamplerParameterf: _emscripten_glSamplerParameterf, + /** @export */ + emscripten_glSamplerParameterfv: _emscripten_glSamplerParameterfv, + /** @export */ + emscripten_glSamplerParameteri: _emscripten_glSamplerParameteri, + /** @export */ + emscripten_glSamplerParameteriv: _emscripten_glSamplerParameteriv, + /** @export */ + emscripten_glScissor: _emscripten_glScissor, + /** @export */ + emscripten_glShaderBinary: _emscripten_glShaderBinary, + /** @export */ + emscripten_glShaderSource: _emscripten_glShaderSource, + /** @export */ + emscripten_glStencilFunc: _emscripten_glStencilFunc, + /** @export */ + emscripten_glStencilFuncSeparate: _emscripten_glStencilFuncSeparate, + /** @export */ + emscripten_glStencilMask: _emscripten_glStencilMask, + /** @export */ + emscripten_glStencilMaskSeparate: _emscripten_glStencilMaskSeparate, + /** @export */ + emscripten_glStencilOp: _emscripten_glStencilOp, + /** @export */ + emscripten_glStencilOpSeparate: _emscripten_glStencilOpSeparate, + /** @export */ + emscripten_glTexImage2D: _emscripten_glTexImage2D, + /** @export */ + emscripten_glTexImage3D: _emscripten_glTexImage3D, + /** @export */ + emscripten_glTexParameterf: _emscripten_glTexParameterf, + /** @export */ + emscripten_glTexParameterfv: _emscripten_glTexParameterfv, + /** @export */ + emscripten_glTexParameteri: _emscripten_glTexParameteri, + /** @export */ + emscripten_glTexParameteriv: _emscripten_glTexParameteriv, + /** @export */ + emscripten_glTexStorage2D: _emscripten_glTexStorage2D, + /** @export */ + emscripten_glTexStorage3D: _emscripten_glTexStorage3D, + /** @export */ + emscripten_glTexSubImage2D: _emscripten_glTexSubImage2D, + /** @export */ + emscripten_glTexSubImage3D: _emscripten_glTexSubImage3D, + /** @export */ + emscripten_glTransformFeedbackVaryings: _emscripten_glTransformFeedbackVaryings, + /** @export */ + emscripten_glUniform1f: _emscripten_glUniform1f, + /** @export */ + emscripten_glUniform1fv: _emscripten_glUniform1fv, + /** @export */ + emscripten_glUniform1i: _emscripten_glUniform1i, + /** @export */ + emscripten_glUniform1iv: _emscripten_glUniform1iv, + /** @export */ + emscripten_glUniform1ui: _emscripten_glUniform1ui, + /** @export */ + emscripten_glUniform1uiv: _emscripten_glUniform1uiv, + /** @export */ + emscripten_glUniform2f: _emscripten_glUniform2f, + /** @export */ + emscripten_glUniform2fv: _emscripten_glUniform2fv, + /** @export */ + emscripten_glUniform2i: _emscripten_glUniform2i, + /** @export */ + emscripten_glUniform2iv: _emscripten_glUniform2iv, + /** @export */ + emscripten_glUniform2ui: _emscripten_glUniform2ui, + /** @export */ + emscripten_glUniform2uiv: _emscripten_glUniform2uiv, + /** @export */ + emscripten_glUniform3f: _emscripten_glUniform3f, + /** @export */ + emscripten_glUniform3fv: _emscripten_glUniform3fv, + /** @export */ + emscripten_glUniform3i: _emscripten_glUniform3i, + /** @export */ + emscripten_glUniform3iv: _emscripten_glUniform3iv, + /** @export */ + emscripten_glUniform3ui: _emscripten_glUniform3ui, + /** @export */ + emscripten_glUniform3uiv: _emscripten_glUniform3uiv, + /** @export */ + emscripten_glUniform4f: _emscripten_glUniform4f, + /** @export */ + emscripten_glUniform4fv: _emscripten_glUniform4fv, + /** @export */ + emscripten_glUniform4i: _emscripten_glUniform4i, + /** @export */ + emscripten_glUniform4iv: _emscripten_glUniform4iv, + /** @export */ + emscripten_glUniform4ui: _emscripten_glUniform4ui, + /** @export */ + emscripten_glUniform4uiv: _emscripten_glUniform4uiv, + /** @export */ + emscripten_glUniformBlockBinding: _emscripten_glUniformBlockBinding, + /** @export */ + emscripten_glUniformMatrix2fv: _emscripten_glUniformMatrix2fv, + /** @export */ + emscripten_glUniformMatrix2x3fv: _emscripten_glUniformMatrix2x3fv, + /** @export */ + emscripten_glUniformMatrix2x4fv: _emscripten_glUniformMatrix2x4fv, + /** @export */ + emscripten_glUniformMatrix3fv: _emscripten_glUniformMatrix3fv, + /** @export */ + emscripten_glUniformMatrix3x2fv: _emscripten_glUniformMatrix3x2fv, + /** @export */ + emscripten_glUniformMatrix3x4fv: _emscripten_glUniformMatrix3x4fv, + /** @export */ + emscripten_glUniformMatrix4fv: _emscripten_glUniformMatrix4fv, + /** @export */ + emscripten_glUniformMatrix4x2fv: _emscripten_glUniformMatrix4x2fv, + /** @export */ + emscripten_glUniformMatrix4x3fv: _emscripten_glUniformMatrix4x3fv, + /** @export */ + emscripten_glUseProgram: _emscripten_glUseProgram, + /** @export */ + emscripten_glValidateProgram: _emscripten_glValidateProgram, + /** @export */ + emscripten_glVertexAttrib1f: _emscripten_glVertexAttrib1f, + /** @export */ + emscripten_glVertexAttrib1fv: _emscripten_glVertexAttrib1fv, + /** @export */ + emscripten_glVertexAttrib2f: _emscripten_glVertexAttrib2f, + /** @export */ + emscripten_glVertexAttrib2fv: _emscripten_glVertexAttrib2fv, + /** @export */ + emscripten_glVertexAttrib3f: _emscripten_glVertexAttrib3f, + /** @export */ + emscripten_glVertexAttrib3fv: _emscripten_glVertexAttrib3fv, + /** @export */ + emscripten_glVertexAttrib4f: _emscripten_glVertexAttrib4f, + /** @export */ + emscripten_glVertexAttrib4fv: _emscripten_glVertexAttrib4fv, + /** @export */ + emscripten_glVertexAttribDivisor: _emscripten_glVertexAttribDivisor, + /** @export */ + emscripten_glVertexAttribDivisorANGLE: _emscripten_glVertexAttribDivisorANGLE, + /** @export */ + emscripten_glVertexAttribDivisorARB: _emscripten_glVertexAttribDivisorARB, + /** @export */ + emscripten_glVertexAttribDivisorEXT: _emscripten_glVertexAttribDivisorEXT, + /** @export */ + emscripten_glVertexAttribDivisorNV: _emscripten_glVertexAttribDivisorNV, + /** @export */ + emscripten_glVertexAttribI4i: _emscripten_glVertexAttribI4i, + /** @export */ + emscripten_glVertexAttribI4iv: _emscripten_glVertexAttribI4iv, + /** @export */ + emscripten_glVertexAttribI4ui: _emscripten_glVertexAttribI4ui, + /** @export */ + emscripten_glVertexAttribI4uiv: _emscripten_glVertexAttribI4uiv, + /** @export */ + emscripten_glVertexAttribIPointer: _emscripten_glVertexAttribIPointer, + /** @export */ + emscripten_glVertexAttribPointer: _emscripten_glVertexAttribPointer, + /** @export */ + emscripten_glViewport: _emscripten_glViewport, + /** @export */ + emscripten_glWaitSync: _emscripten_glWaitSync, + /** @export */ + emscripten_resize_heap: _emscripten_resize_heap, + /** @export */ + emscripten_sample_gamepad_data: _emscripten_sample_gamepad_data, + /** @export */ + emscripten_set_canvas_element_size: _emscripten_set_canvas_element_size, + /** @export */ + emscripten_set_click_callback_on_thread: _emscripten_set_click_callback_on_thread, + /** @export */ + emscripten_set_fullscreenchange_callback_on_thread: _emscripten_set_fullscreenchange_callback_on_thread, + /** @export */ + emscripten_set_gamepadconnected_callback_on_thread: _emscripten_set_gamepadconnected_callback_on_thread, + /** @export */ + emscripten_set_gamepaddisconnected_callback_on_thread: _emscripten_set_gamepaddisconnected_callback_on_thread, + /** @export */ + emscripten_set_resize_callback_on_thread: _emscripten_set_resize_callback_on_thread, + /** @export */ + emscripten_set_touchcancel_callback_on_thread: _emscripten_set_touchcancel_callback_on_thread, + /** @export */ + emscripten_set_touchend_callback_on_thread: _emscripten_set_touchend_callback_on_thread, + /** @export */ + emscripten_set_touchmove_callback_on_thread: _emscripten_set_touchmove_callback_on_thread, + /** @export */ + emscripten_set_touchstart_callback_on_thread: _emscripten_set_touchstart_callback_on_thread, + /** @export */ + emscripten_set_window_title: _emscripten_set_window_title, + /** @export */ + emscripten_sleep: _emscripten_sleep, + /** @export */ + exit: _exit, + /** @export */ + fd_close: _fd_close, + /** @export */ + fd_read: _fd_read, + /** @export */ + fd_seek: _fd_seek, + /** @export */ + fd_write: _fd_write, + /** @export */ + glActiveTexture: _glActiveTexture, + /** @export */ + glAttachShader: _glAttachShader, + /** @export */ + glBindAttribLocation: _glBindAttribLocation, + /** @export */ + glBindBuffer: _glBindBuffer, + /** @export */ + glBindFramebuffer: _glBindFramebuffer, + /** @export */ + glBindRenderbuffer: _glBindRenderbuffer, + /** @export */ + glBindTexture: _glBindTexture, + /** @export */ + glBlendFunc: _glBlendFunc, + /** @export */ + glBufferData: _glBufferData, + /** @export */ + glBufferSubData: _glBufferSubData, + /** @export */ + glCheckFramebufferStatus: _glCheckFramebufferStatus, + /** @export */ + glClear: _glClear, + /** @export */ + glClearColor: _glClearColor, + /** @export */ + glClearDepthf: _glClearDepthf, + /** @export */ + glCompileShader: _glCompileShader, + /** @export */ + glCompressedTexImage2D: _glCompressedTexImage2D, + /** @export */ + glCreateProgram: _glCreateProgram, + /** @export */ + glCreateShader: _glCreateShader, + /** @export */ + glCullFace: _glCullFace, + /** @export */ + glDeleteBuffers: _glDeleteBuffers, + /** @export */ + glDeleteFramebuffers: _glDeleteFramebuffers, + /** @export */ + glDeleteProgram: _glDeleteProgram, + /** @export */ + glDeleteRenderbuffers: _glDeleteRenderbuffers, + /** @export */ + glDeleteShader: _glDeleteShader, + /** @export */ + glDeleteTextures: _glDeleteTextures, + /** @export */ + glDepthFunc: _glDepthFunc, + /** @export */ + glDetachShader: _glDetachShader, + /** @export */ + glDisable: _glDisable, + /** @export */ + glDisableVertexAttribArray: _glDisableVertexAttribArray, + /** @export */ + glDrawArrays: _glDrawArrays, + /** @export */ + glDrawElements: _glDrawElements, + /** @export */ + glEnable: _glEnable, + /** @export */ + glEnableVertexAttribArray: _glEnableVertexAttribArray, + /** @export */ + glFramebufferRenderbuffer: _glFramebufferRenderbuffer, + /** @export */ + glFramebufferTexture2D: _glFramebufferTexture2D, + /** @export */ + glFrontFace: _glFrontFace, + /** @export */ + glGenBuffers: _glGenBuffers, + /** @export */ + glGenFramebuffers: _glGenFramebuffers, + /** @export */ + glGenRenderbuffers: _glGenRenderbuffers, + /** @export */ + glGenTextures: _glGenTextures, + /** @export */ + glGetAttribLocation: _glGetAttribLocation, + /** @export */ + glGetFloatv: _glGetFloatv, + /** @export */ + glGetFramebufferAttachmentParameteriv: _glGetFramebufferAttachmentParameteriv, + /** @export */ + glGetProgramInfoLog: _glGetProgramInfoLog, + /** @export */ + glGetProgramiv: _glGetProgramiv, + /** @export */ + glGetShaderInfoLog: _glGetShaderInfoLog, + /** @export */ + glGetShaderiv: _glGetShaderiv, + /** @export */ + glGetString: _glGetString, + /** @export */ + glGetUniformLocation: _glGetUniformLocation, + /** @export */ + glLinkProgram: _glLinkProgram, + /** @export */ + glPixelStorei: _glPixelStorei, + /** @export */ + glReadPixels: _glReadPixels, + /** @export */ + glRenderbufferStorage: _glRenderbufferStorage, + /** @export */ + glShaderSource: _glShaderSource, + /** @export */ + glTexImage2D: _glTexImage2D, + /** @export */ + glTexParameterf: _glTexParameterf, + /** @export */ + glTexParameteri: _glTexParameteri, + /** @export */ + glTexSubImage2D: _glTexSubImage2D, + /** @export */ + glUniform1fv: _glUniform1fv, + /** @export */ + glUniform1i: _glUniform1i, + /** @export */ + glUniform1iv: _glUniform1iv, + /** @export */ + glUniform2fv: _glUniform2fv, + /** @export */ + glUniform2iv: _glUniform2iv, + /** @export */ + glUniform3fv: _glUniform3fv, + /** @export */ + glUniform3iv: _glUniform3iv, + /** @export */ + glUniform4f: _glUniform4f, + /** @export */ + glUniform4fv: _glUniform4fv, + /** @export */ + glUniform4iv: _glUniform4iv, + /** @export */ + glUniformMatrix4fv: _glUniformMatrix4fv, + /** @export */ + glUseProgram: _glUseProgram, + /** @export */ + glVertexAttribPointer: _glVertexAttribPointer, + /** @export */ + glViewport: _glViewport, + /** @export */ + glfwCreateWindow: _glfwCreateWindow, + /** @export */ + glfwDefaultWindowHints: _glfwDefaultWindowHints, + /** @export */ + glfwDestroyWindow: _glfwDestroyWindow, + /** @export */ + glfwGetPrimaryMonitor: _glfwGetPrimaryMonitor, + /** @export */ + glfwGetTime: _glfwGetTime, + /** @export */ + glfwGetVideoModes: _glfwGetVideoModes, + /** @export */ + glfwInit: _glfwInit, + /** @export */ + glfwMakeContextCurrent: _glfwMakeContextCurrent, + /** @export */ + glfwSetCharCallback: _glfwSetCharCallback, + /** @export */ + glfwSetCursorEnterCallback: _glfwSetCursorEnterCallback, + /** @export */ + glfwSetCursorPosCallback: _glfwSetCursorPosCallback, + /** @export */ + glfwSetDropCallback: _glfwSetDropCallback, + /** @export */ + glfwSetErrorCallback: _glfwSetErrorCallback, + /** @export */ + glfwSetKeyCallback: _glfwSetKeyCallback, + /** @export */ + glfwSetMouseButtonCallback: _glfwSetMouseButtonCallback, + /** @export */ + glfwSetScrollCallback: _glfwSetScrollCallback, + /** @export */ + glfwSetWindowFocusCallback: _glfwSetWindowFocusCallback, + /** @export */ + glfwSetWindowIconifyCallback: _glfwSetWindowIconifyCallback, + /** @export */ + glfwSetWindowShouldClose: _glfwSetWindowShouldClose, + /** @export */ + glfwSetWindowSizeCallback: _glfwSetWindowSizeCallback, + /** @export */ + glfwSwapBuffers: _glfwSwapBuffers, + /** @export */ + glfwTerminate: _glfwTerminate, + /** @export */ + glfwWindowHint: _glfwWindowHint +}; +var wasmExports = createWasm(); +var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors', 0); +var _free = createExportWrapper('free', 1); +var _malloc = createExportWrapper('malloc', 1); +var _main = Module['_main'] = createExportWrapper('main', 2); +var _fflush = createExportWrapper('fflush', 1); +var _strerror = createExportWrapper('strerror', 1); +var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])(); +var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])(); +var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])(); +var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])(); +var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports['_emscripten_stack_restore'])(a0); +var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'])(a0); +var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])(); +var ___set_stack_limits = Module['___set_stack_limits'] = createExportWrapper('__set_stack_limits', 2); +var dynCall_vii = Module['dynCall_vii'] = createExportWrapper('dynCall_vii', 3); +var dynCall_viii = Module['dynCall_viii'] = createExportWrapper('dynCall_viii', 4); +var dynCall_viiiii = Module['dynCall_viiiii'] = createExportWrapper('dynCall_viiiii', 6); +var dynCall_viiii = Module['dynCall_viiii'] = createExportWrapper('dynCall_viiii', 5); +var dynCall_vidd = Module['dynCall_vidd'] = createExportWrapper('dynCall_vidd', 4); +var dynCall_ii = Module['dynCall_ii'] = createExportWrapper('dynCall_ii', 2); +var dynCall_iiii = Module['dynCall_iiii'] = createExportWrapper('dynCall_iiii', 4); +var dynCall_fffi = Module['dynCall_fffi'] = createExportWrapper('dynCall_fffi', 4); +var dynCall_ffi = Module['dynCall_ffi'] = createExportWrapper('dynCall_ffi', 3); +var dynCall_iii = Module['dynCall_iii'] = createExportWrapper('dynCall_iii', 3); +var dynCall_viiiiii = Module['dynCall_viiiiii'] = createExportWrapper('dynCall_viiiiii', 7); +var dynCall_vi = Module['dynCall_vi'] = createExportWrapper('dynCall_vi', 2); +var dynCall_vffff = Module['dynCall_vffff'] = createExportWrapper('dynCall_vffff', 5); +var dynCall_vf = Module['dynCall_vf'] = createExportWrapper('dynCall_vf', 2); +var dynCall_viiiiiiii = Module['dynCall_viiiiiiii'] = createExportWrapper('dynCall_viiiiiiii', 9); +var dynCall_viiiiiiiii = Module['dynCall_viiiiiiiii'] = createExportWrapper('dynCall_viiiiiiiii', 10); +var dynCall_i = Module['dynCall_i'] = createExportWrapper('dynCall_i', 1); +var dynCall_vff = Module['dynCall_vff'] = createExportWrapper('dynCall_vff', 3); +var dynCall_v = Module['dynCall_v'] = createExportWrapper('dynCall_v', 1); +var dynCall_viiiiiii = Module['dynCall_viiiiiii'] = createExportWrapper('dynCall_viiiiiii', 8); +var dynCall_vfi = Module['dynCall_vfi'] = createExportWrapper('dynCall_vfi', 3); +var dynCall_viif = Module['dynCall_viif'] = createExportWrapper('dynCall_viif', 4); +var dynCall_vif = Module['dynCall_vif'] = createExportWrapper('dynCall_vif', 3); +var dynCall_viff = Module['dynCall_viff'] = createExportWrapper('dynCall_viff', 4); +var dynCall_vifff = Module['dynCall_vifff'] = createExportWrapper('dynCall_vifff', 5); +var dynCall_viffff = Module['dynCall_viffff'] = createExportWrapper('dynCall_viffff', 6); +var dynCall_vfff = Module['dynCall_vfff'] = createExportWrapper('dynCall_vfff', 4); +var dynCall_viiiiiiiiii = Module['dynCall_viiiiiiiiii'] = createExportWrapper('dynCall_viiiiiiiiii', 11); +var dynCall_viiiiiiiiiii = Module['dynCall_viiiiiiiiiii'] = createExportWrapper('dynCall_viiiiiiiiiii', 12); +var dynCall_viifi = Module['dynCall_viifi'] = createExportWrapper('dynCall_viifi', 5); +var dynCall_iiiii = Module['dynCall_iiiii'] = createExportWrapper('dynCall_iiiii', 5); +var dynCall_jiji = Module['dynCall_jiji'] = createExportWrapper('dynCall_jiji', 5); +var dynCall_iidiiii = Module['dynCall_iidiiii'] = createExportWrapper('dynCall_iidiiii', 7); +var _asyncify_start_unwind = createExportWrapper('asyncify_start_unwind', 1); +var _asyncify_stop_unwind = createExportWrapper('asyncify_stop_unwind', 0); +var _asyncify_start_rewind = createExportWrapper('asyncify_start_rewind', 1); +var _asyncify_stop_rewind = createExportWrapper('asyncify_stop_rewind', 0); + + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === + +Module['addRunDependency'] = addRunDependency; +Module['removeRunDependency'] = removeRunDependency; +Module['FS_createPreloadedFile'] = FS_createPreloadedFile; +Module['FS_unlink'] = FS_unlink; +Module['FS_createPath'] = FS_createPath; +Module['FS_createDevice'] = FS_createDevice; +Module['FS_createDataFile'] = FS_createDataFile; +Module['FS_createLazyFile'] = FS_createLazyFile; +var missingLibrarySymbols = [ + 'writeI53ToI64Clamped', + 'writeI53ToI64Signaling', + 'writeI53ToU64Clamped', + 'writeI53ToU64Signaling', + 'convertU32PairToI53', + 'stackAlloc', + 'getTempRet0', + 'setTempRet0', + 'growMemory', + 'inetPton4', + 'inetNtop4', + 'inetPton6', + 'inetNtop6', + 'readSockaddr', + 'writeSockaddr', + 'emscriptenLog', + 'readEmAsmArgs', + 'getExecutableName', + 'listenOnce', + 'autoResumeAudioContext', + 'dynCallLegacy', + 'getDynCaller', + 'dynCall', + 'asmjsMangle', + 'HandleAllocator', + 'getNativeTypeSize', + 'STACK_SIZE', + 'STACK_ALIGN', + 'POINTER_SIZE', + 'ASSERTIONS', + 'getCFunc', + 'ccall', + 'cwrap', + 'uleb128Encode', + 'generateFuncType', + 'convertJsFunctionToWasm', + 'getEmptyTableSlot', + 'updateTableMap', + 'getFunctionAddress', + 'addFunction', + 'removeFunction', + 'reallyNegative', + 'unSign', + 'strLen', + 'reSign', + 'formatString', + 'intArrayToString', + 'AsciiToString', + 'stringToAscii', + 'UTF16ToString', + 'stringToUTF16', + 'lengthBytesUTF16', + 'UTF32ToString', + 'stringToUTF32', + 'lengthBytesUTF32', + 'stringToUTF8OnStack', + 'writeArrayToMemory', + 'registerKeyEventCallback', + 'registerWheelEventCallback', + 'registerFocusEventCallback', + 'fillDeviceOrientationEventData', + 'registerDeviceOrientationEventCallback', + 'fillDeviceMotionEventData', + 'registerDeviceMotionEventCallback', + 'screenOrientation', + 'fillOrientationChangeEventData', + 'registerOrientationChangeEventCallback', + 'JSEvents_requestFullscreen', + 'JSEvents_resizeCanvasForFullscreen', + 'registerRestoreOldStyle', + 'hideEverythingExceptGivenElement', + 'restoreHiddenElements', + 'setLetterbox', + 'softFullscreenResizeWebGLRenderTarget', + 'doRequestFullscreen', + 'fillPointerlockChangeEventData', + 'registerPointerlockChangeEventCallback', + 'registerPointerlockErrorEventCallback', + 'requestPointerLock', + 'fillVisibilityChangeEventData', + 'registerVisibilityChangeEventCallback', + 'registerBeforeUnloadEventCallback', + 'fillBatteryEventData', + 'battery', + 'registerBatteryEventCallback', + 'setCanvasElementSize', + 'getCanvasElementSize', + 'jsStackTrace', + 'getCallstack', + 'convertPCtoSourceLocation', + 'getEnvStrings', + 'checkWasiClock', + 'wasiRightsToMuslOFlags', + 'wasiOFlagsToMuslOFlags', + 'setImmediateWrapped', + 'safeRequestAnimationFrame', + 'clearImmediateWrapped', + 'polyfillSetImmediate', + 'registerPostMainLoop', + 'registerPreMainLoop', + 'getPromise', + 'makePromise', + 'idsToPromises', + 'makePromiseCallback', + 'ExceptionInfo', + 'findMatchingCatch', + 'Browser_asyncPrepareDataCounter', + 'isLeapYear', + 'ydayFromDate', + 'arraySum', + 'addDays', + 'getSocketFromFD', + 'getSocketAddress', + 'FS_mkdirTree', + '_setNetworkCallback', + 'writeGLArray', + 'registerWebGlEventCallback', + 'ALLOC_NORMAL', + 'ALLOC_STACK', + 'allocate', + 'writeStringToMemory', + 'writeAsciiToMemory', + 'setErrNo', + 'demangle', + 'stackTrace', +]; +missingLibrarySymbols.forEach(missingLibrarySymbol) + +var unexportedSymbols = [ + 'run', + 'addOnPreRun', + 'addOnInit', + 'addOnPreMain', + 'addOnExit', + 'addOnPostRun', + 'out', + 'err', + 'callMain', + 'abort', + 'wasmMemory', + 'wasmExports', + 'writeStackCookie', + 'checkStackCookie', + 'writeI53ToI64', + 'readI53FromI64', + 'readI53FromU64', + 'convertI32PairToI53', + 'convertI32PairToI53Checked', + 'stackSave', + 'stackRestore', + 'ptrToString', + 'zeroMemory', + 'exitJS', + 'getHeapMax', + 'abortOnCannotGrowMemory', + 'ENV', + 'setStackLimits', + 'ERRNO_CODES', + 'strError', + 'DNS', + 'Protocols', + 'Sockets', + 'timers', + 'warnOnce', + 'readEmAsmArgsArray', + 'jstoi_q', + 'jstoi_s', + 'handleException', + 'keepRuntimeAlive', + 'runtimeKeepalivePush', + 'runtimeKeepalivePop', + 'callUserCallback', + 'maybeExit', + 'asyncLoad', + 'alignMemory', + 'mmapAlloc', + 'wasmTable', + 'noExitRuntime', + 'sigToWasmTypes', + 'freeTableIndexes', + 'functionsInTableMap', + 'setValue', + 'getValue', + 'PATH', + 'PATH_FS', + 'UTF8Decoder', + 'UTF8ArrayToString', + 'UTF8ToString', + 'stringToUTF8Array', + 'stringToUTF8', + 'lengthBytesUTF8', + 'intArrayFromString', + 'UTF16Decoder', + 'stringToNewUTF8', + 'JSEvents', + 'specialHTMLTargets', + 'maybeCStringToJsString', + 'findEventTarget', + 'findCanvasEventTarget', + 'getBoundingClientRect', + 'fillMouseEventData', + 'registerMouseEventCallback', + 'registerUiEventCallback', + 'fillFullscreenChangeEventData', + 'registerFullscreenChangeEventCallback', + 'currentFullscreenStrategy', + 'restoreOldWindowedStyle', + 'registerTouchEventCallback', + 'fillGamepadEventData', + 'registerGamepadEventCallback', + 'UNWIND_CACHE', + 'ExitStatus', + 'doReadv', + 'doWritev', + 'initRandomFill', + 'randomFill', + 'safeSetTimeout', + 'promiseMap', + 'uncaughtExceptionCount', + 'exceptionLast', + 'exceptionCaught', + 'Browser', + 'getPreloadedImageData__data', + 'wget', + 'MONTH_DAYS_REGULAR', + 'MONTH_DAYS_LEAP', + 'MONTH_DAYS_REGULAR_CUMULATIVE', + 'MONTH_DAYS_LEAP_CUMULATIVE', + 'SYSCALLS', + 'preloadPlugins', + 'FS_modeStringToFlags', + 'FS_getMode', + 'FS_stdin_getChar_buffer', + 'FS_stdin_getChar', + 'FS_readFile', + 'FS', + 'MEMFS', + 'TTY', + 'PIPEFS', + 'SOCKFS', + 'tempFixedLengthArray', + 'miniTempWebGLFloatBuffers', + 'miniTempWebGLIntBuffers', + 'heapObjectForWebGLType', + 'toTypedArrayIndex', + 'webgl_enable_ANGLE_instanced_arrays', + 'webgl_enable_OES_vertex_array_object', + 'webgl_enable_WEBGL_draw_buffers', + 'webgl_enable_WEBGL_multi_draw', + 'webgl_enable_EXT_polygon_offset_clamp', + 'webgl_enable_EXT_clip_control', + 'webgl_enable_WEBGL_polygon_mode', + 'GL', + 'emscriptenWebGLGet', + 'computeUnpackAlignedImageSize', + 'colorChannelsInGlTextureFormat', + 'emscriptenWebGLGetTexPixelData', + 'emscriptenWebGLGetUniform', + 'webglGetUniformLocation', + 'webglPrepareUniformLocationsBeforeFirstUse', + 'webglGetLeftBracePos', + 'emscriptenWebGLGetVertexAttrib', + '__glGetActiveAttribOrUniform', + 'AL', + 'GLUT', + 'EGL', + 'GLEW', + 'IDBStore', + 'runAndAbortIfError', + 'Asyncify', + 'Fibers', + 'SDL', + 'SDL_gfx', + 'GLFW_Window', + 'GLFW', + 'emscriptenWebGLGetIndexed', + 'webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance', + 'webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance', + 'allocateUTF8', + 'allocateUTF8OnStack', + 'print', + 'printErr', +]; +unexportedSymbols.forEach(unexportedRuntimeSymbol); + + + +var calledRun; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function callMain() { + 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; + + var argc = 0; + var argv = 0; + + try { + + var ret = entryFunction(argc, argv); + + // if we're not running an evented main loop, it's time to exit + exitJS(ret, /* implicit = */ true); + return ret; + } + catch (e) { + return handleException(e); + } +} + +function stackCheckInit() { + // This is normally called automatically during __wasm_call_ctors but need to + // get these values before even running any of the ctors so we call it redundantly + // here. + _emscripten_stack_init(); + // TODO(sbc): Move writeStackCookie to native to to avoid this. + writeStackCookie(); +} + +function run() { + + if (runDependencies > 0) { + return; + } + + stackCheckInit(); + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + Module['onRuntimeInitialized']?.(); + + if (shouldRunNow) callMain(); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(() => { + setTimeout(() => Module['setStatus'](''), 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} + +function checkUnflushedContent() { + // Compiler settings do not allow exiting the runtime, so flushing + // the streams is not possible. but in ASSERTIONS mode we check + // if there was something to flush, and if so tell the user they + // should request that the runtime be exitable. + // Normally we would not even include flush() at all, but in ASSERTIONS + // builds we do so just for this check, and here we see if there is any + // content to flush, that is, we check if there would have been + // something a non-ASSERTIONS build would have not seen. + // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 + // mode (which has its own special function for this; otherwise, all + // the code is inside libc) + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + } + try { // it doesn't matter if it fails + _fflush(0); + // also flush in the JS FS layer + ['stdout', 'stderr'].forEach((name) => { + var info = FS.analyzePath('/dev/' + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty?.output?.length) { + has = true; + } + }); + } catch(e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.'); + } +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +// shouldRunNow refers to calling main(), not run(). +var shouldRunNow = true; + +if (Module['noInitialRun']) shouldRunNow = false; + +run(); + +// end include: postamble.js + diff --git a/docs/assets/nmmo3/game.wasm b/docs/assets/nmmo3/game.wasm new file mode 100755 index 0000000..c328493 Binary files /dev/null and b/docs/assets/nmmo3/game.wasm differ diff --git a/docs/assets/nmmo3/game.wasm.map b/docs/assets/nmmo3/game.wasm.map new file mode 100644 index 0000000..4248a6a --- /dev/null +++ b/docs/assets/nmmo3/game.wasm.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../pufferlib/puffernet.h","../../pufferlib/ocean/nmmo3/nmmo3.h","../../pufferlib/ocean/nmmo3/simplex.h","../../pufferlib/ocean/nmmo3/nmmo3.c","../../../../emsdk/emscripten/system/lib/gl/gl.c","../../../../emsdk/emscripten/system/lib/gl/libprocaddr.c","../../../../emsdk/emscripten/system/lib/gl/webgl1.c","../../../../emsdk/emscripten/system/lib/gl/webgl2.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/access.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/acos.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/acosf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/atan2f.c","../../../../emsdk/emscripten/system/lib/libc/musl/include/math.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/atanf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/close.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__cos.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__rem_pio2_large.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__rem_pio2.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__sin.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/cos.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__cosdf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__sindf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__rem_pio2f.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/cosf.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_memcpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memmove.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memset.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/__errno_location.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_time.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_xflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/libm.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_oflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_uflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/exp2.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_xflowf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_oflowf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_uflowf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/exp2f.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/expf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fabsf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__lockfile.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fclose.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ferror.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fflush.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__toread.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__uflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/floor.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmax.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmaxf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmodf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__fmodeflags.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_seek.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_write.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_read.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_close.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__fdopen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fopen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fread.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/frexp.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fseek.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ftell.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__towrite.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fwrite.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/getcwd.c","../../../../emsdk/emscripten/system/lib/pthread/library_pthread_stub.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_divzero.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_invalid.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/log.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/log2.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_divzerof.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_invalidf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/logf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/lseek.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memcmp.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/time/clock_nanosleep.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/time/nanosleep.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ofl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ofl_add.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__overflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fputc.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/putc.h","../../../../emsdk/emscripten/cache/sysroot/include/atomic_arch.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/pthread_impl.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/perror.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fabs.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/pow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/printf.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_syscall_stubs.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/getpid.c","../../../../emsdk/emscripten/system/lib/pthread/pthread_self_stub.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdlib/qsort.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/atomic.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdlib/qsort_nr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/prng/rand.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/rewind.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/roundf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/scalbn.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/sinf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/sqrt.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/sqrtf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/sscanf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/stdout.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strchrnul.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcmp.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/stpcpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strdup.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/strerror.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strlen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/stpncpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strncpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcspn.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strpbrk.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memrchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strrchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strstr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/syscall_ret.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/expm1.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/tanh.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strnlen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vfprintf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vprintf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vsnprintf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/shgetc.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/copysignl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/scalbnl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__fpclassifyl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmodl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fabsl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/floatscan.c","../../../../emsdk/emscripten/system/lib/libc/musl/include/ctype.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/intscan.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/mbrtowc.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/mbsinit.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vfscanf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vsscanf.c","../../../../emsdk/emscripten/system/lib/libc/wasi-helpers.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wcrtomb.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wctomb.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/exit/abort.c","../../../../emsdk/emscripten/system/lib/dlmalloc.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_get_heap_size.c","../../../../emsdk/emscripten/system/lib/libc/sbrk.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/addtf3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_add_impl.inc","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_lib.h","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/ashlti3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/comparetf2.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_compare_impl.inc","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/divtf3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_div_impl.inc","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/extenddftf2.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_extend.h","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_extend_impl.inc","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/extendsftf2.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/floatsitf.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/floatunsitf.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_mode.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/lshrti3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/multf3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_mul_impl.inc","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/multi3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/subtf3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/trunctfdf2.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc.h","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc_impl.inc","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/trunctfsf2.c","../../../../b/s/w/ir/x/w/install/emscripten/system/lib/compiler-rt/emscripten_tempret.s","../../../../emsdk/emscripten/system/lib/compiler-rt/stack_limits.S","../../../../emsdk/emscripten/system/lib/compiler-rt/stack_ops.S"],"names":[],"mappings":"u2f0KkDA,IAEA,EAYA,IACA,EhFtCA,QACwB,O,EACH,G,Y1F+EK,KAAc,KADb,KAAc,WAEnB,CAAlB,uHAUkC,kCAAlB,EAAgB,4DAPQ,OAA5B,sBAOI,EAAgB,SAPQ,OAA5B,UADc,SAAU,UADM,CAAlB,YADS,CAAf,yFAUgB,kCAAlB,EAAgB,4DAPQ,OAA5B,sBAOI,EAAgB,SAPQ,OAA5B,UADc,SAAU,UADM,CAAlB,YADS,CAAf,KAAlB,kHAUgB,EAAkB,OAAF,oGAGR,UAauB,OAAc,QAAjB,iBAAG,OAAc,QAAjB,aAbiB,OAArC,sBAauB,OAAc,QAAjB,cAda,CAAjB,KAApB,OADiC,CAAjB,KAApB,GARc,SAAU,GAA5B,GADc,SAAU,GAA5B,OADkC,CAAlB,KAApB,OAD6B,CAAf,KAAlB,IAkCJ,C,SCkoBqB,YAAL,IADW,QARR,OAAP,EAAO,EAAP,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EAWa,OAAuB,KAAP,CAA8B,KAAP,CACxD,KAAP,CAAkC,KAAP,CAAgC,KAAP,CAAiC,KAAP,CAD9D,GAEU,QAAR,CAAF,GACU,OAAmB,OAA5B,SAAF,GACM,QAAR,CAAF,GACM,QAAR,CAAF,GACiB,QAAR,CAAF,GACW,QAAR,CAAF,GACF,QAAR,CAAF,GACU,QAAR,CAAF,GA1hBG,KAAa,OAAT,CAAJ,EAGJ,SAAN,EAAwB,gFACd,aAwhBL,O,GAAA,IAAL,MAAiB,oDACrB,C,WAgKiC,OAAP,CAAO,EAtLZ,oBAAL,EAwLQ,MAGS,OAAP,OAKlB,CAhMa,EAgMb,KACA,8BACA,QACA,eAGiB,GACiB,KAAlC,oCAMa,OAAL,GA/BE,KAAN,GAAY,GA8BgB,EAAK,KAAL,QACI,CAAV,GACb,KAAL,OAA8B,CAAV,GAIf,KAAL,GAD0B,KAAL,UAEM,OADA,EAAP,GACf,KAAL,GAAoB,KAEL,SAAL,UAAK,EAGN,KAAL,GAzND,OAAP,EAAO,EAAP,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EAyN6B,GAAR,GACf,KAAL,GAA4B,KAAR,GAQf,KAAL,GANmB,EADS,KAAS,KAAY,SAC9B,QAGA,EAGC,GACf,KAAL,GAA4B,OAAG,CAAX,GACf,KAAL,GAA4B,KAAR,GACf,KAAL,GAA4B,KAAR,QAEhB,OA9BsC,CAAhB,KAAlC,OAD8C,CAAhB,KAAlC,MAPA,gB,SAAA,EACA,e,SAAA,EACA,gB,SAAA,EACA,gB,SAAA,EAwCK,KAAL,GAA4B,KAAV,GACb,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA8B,KAAV,GACf,KAAL,GAA+B,KAAV,GAChB,KAAL,GAA+B,KAAV,GAChB,KAAL,GAA+B,KAAV,GAEZ,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAGlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAGlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,KAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAAlB,KAAL,GAAyB,MAAF,GAEtB,KAAL,GAA+B,MAAV,GAChB,KAAL,GAA+B,MAAV,GAChB,KAAL,GAA+B,MAAV,GAChB,KAAL,GAA+B,MAAV,GAChB,KAAL,GAA+B,MAAV,GAIhB,KAAL,GADuB,SAAL,EACc,UAAM,CAAjB,GAChB,KAAL,GAAgC,UAAQ,CAAnB,GAChB,KAAL,GAA+B,YAAS,CAAjB,iBAAQ,EAAR,SAAF,GAChB,KAAL,GAA+B,YAAS,CAAjB,iBAAQ,EAAR,SAAF,GAChB,KAAL,GAA+B,YAAa,CAArB,iBAAQ,EAAR,SAAF,GAChB,KAAL,GAA+B,YAAa,CAArB,iBAAQ,EAAR,SAAF,GAChB,KAAL,GAA+B,YAAc,CAAtB,iBAAQ,EAAR,SAAF,GAChB,KAAL,GAA+B,YAAW,CAAnB,iBAAQ,EAAR,SAAF,GAChB,KAAL,GAA+B,YAAY,CAApB,iBAAQ,EAAR,SAAF,OA3FoB,CAAhB,OAAP,CAAtB,IA6FJ,C,EAmCA,K,IAAA,IAIkB,QAFK,SADR,GA7BD,E6FvhCiB,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7FshCqB,KAAM,EAAO,KAAP,CAAd,CACD,EAAK,KAAL,MA7HkB,CA8H1B,OAIQ,OACA,UAEZ,4BAGY,QAAe,OAAf,QAAe,OAAf,QAAe,OAAf,QAAe,OAAf,QAAe,GAAf,SAAe,KAAf,OAAe,KAAf,OAAe,KAAf,OAAe,KAAf,OAAe,KAAf,OAAe,OAHF,KAAY,GAArC,IAgCY,QADA,QAGN,QADA,YAQe,QAFZ,OAFD,OAQK,OACA,OAET,MACsB,G,SAAA,C6FjlCH,sBAAD,GAAM,CAA9B,K7F4lCc,E6F5lCd,IACM,CAAJ,C7F2lCY,KAAY,CAAf,SACE,MACW,G,SAAA,CAC9B,C,eAhWgB,IAycH,mBACA,MA7cM,OAAP,EAAO,EAAP,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EAidH,KAZc,OAtRZ,EA4RE,QAIL,GAhSS,EAAN,KA2RE,UAIL,GA/RH,GAAY,CAsRC,MAAd,QAcH,0BAIA,I,CAAA,SACG,EACA,KA1Sa,EAySb,OAzSC,GAAY,CAsRC,MAAd,QAqBC,0BAOE,QADA,QAEG,aACb,EAAmC,KApT3B,SAuTR,YAAmB,GAGP,OAAK,GACJ,KAAL,QAAqC,E,CAAhC,EACA,SAAa,QAAQ,GAE1B,Q,EAAqC,IAArC,EAAqC,MACA,K,EAEzC,EAlHmB,KAkHnB,EAlHmB,GAAL,IACN,OAAK,GAOI,KAvNP,EAqNE,MArNI,EAoNJ,MApNR,EAAM,KAAN,CAAY,CAuNJ,QACF,OAlBM,EAkBN,EAlBM,U,CAAA,EAkBN,CAlBM,O,CAAA,U,CAAA,U,CAAA,U,CAAA,U,CAAA,U,CAAA,U,CAAA,U,CAAA,U,CAAA,U,CAAA,aAkBN,EAlBM,IA2BC,OACU,QAGf,CA/BI,EA+BJ,MACZ,CAAQ,CAAyB,SACjB,GA0CxB,GArCkB,OACK,OACQ,MAEb,GADa,UAIb,EAHA,OADa,GAIb,GAMK,KAhenB,KAge8D,KAjexC,KAAV,KACZ,iBAsbuB,EApbf,KADS,OACjB,QAAuB,qBAA4B,aAmevC,OAAgB,OAAP,CAAc,aAAG,GAA8B,QAhSpC,CAAJ,CAAP,G,SAAA,SAAD,CAAb,CAgSgD,CAApB,SACd,QACT,EAAgB,MAAP,SACZ,EAAgB,cA1kBL,MAwlBpB,CAAQ,CAdiB,cAIT,Q6FhrCW,sBAAD,GAAM,CAA9B,K7F2rCG,OAXW,IA9kBD,C6FlmBb,IACM,CAAJ,C7FgrCwB,EAAO,CA/kBpB,GAAK,CAilBpB,OAjlBe,GAAK,CAmlBpB,OAnlBe,GAAK,CAqlBpB,SArlBe,IAAK,EAwlBa,GACjC,OAAgB,GACpB,GAxfI,gB,SAAA,GA0iBJ,C,eAlfmB,SAAP,K,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,E,EA0oBD,EA1oBN,S,CAAA,EACS,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHJ,EA0oBM,GAAG,SAIG,OACA,GA/oBZ,I,CAAA,EACS,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHJ,EAyiBM,KAAK,GAziBX,I,CAAA,EACS,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHJ,EAsiB+C,MAArB,OAaM,OAAxB,CAA2C,OAA3C,YAPF,EAHK,EAJmB,OAAV,CAAZ,eAA2C,MAAV,CAAF,CAAlC,aAAyB,EAAzB,aAAyB,EAInB,I,CAAA,WAC0B,WAAlC,iBADQ,EACR,aAEQ,EANK,cAML,CANwB,OAAE,GAAF,CAA7B,aAA6B,EAA7B,aAA6B,EAMxB,8BAAL,SAAK,EAIM,CAAP,C8CpzCjB,EnC4DO,CmC5DP,uC,U9CozCY,aAJC,EAID,aAGC,GAgGN,EAhGM,EAgGN,CAhGM,EAiGG,UAyCrB,MApCiB,GACC,SAAK,CAAL,EACa,KACN,UAEZ,EADgB,QACH,aADV,QAEsB,GAC9B,O,SACJ,GAIuB,KA7tBvB,KA6tB+D,KA9tBzC,KAAV,KACZ,mBAEQ,KADS,OACjB,QA0tBuB,QA1tBA,UAA4B,cA8tBrC,OAAK,GAIc,OADA,OAIZ,GAAgB,EAAuB,OAAP,CAAhB,mBACV,QACX,EAAgB,MAAP,SACZ,EAAgB,cAEX,OAAK,GAxEY,EAzmBvB,EAHG,EAqrBP,EArrBO,KAAP,EAqrBA,EArrBA,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EA4mBoB,OA3dzB,G,GAGW,QAAK,CAAL,CmEz3BlB,EDXC,GAAY,CAAZ,CCWD,EADD,eAID,WAJC,E,SAID,YAGkB,CAHlB,GAaQ,oBARL,CAMA,WAEG,GAGF,OAHI,QAMU,GAAN,CANJ,IAMD,GAAK,CAAR,CACA,GAHC,OAJG,YAUmC,GAAN,CAV7B,IAUwB,GAAK,CAAb,CAVhB,MAUW,GAAN,CAVL,IAUA,GAAK,CAAW,CAD0B,CAT1C,QASoC,GAAN,CAT9B,IASyB,GAAK,CAAb,CATjB,MASY,GAAN,CATN,IASC,GAAK,CAAW,CAAyB,CAAlD,CAVK,KAEY,GADT,MACe,GAAF,CAAJ,CAOX,OAAI,CAAV,CACA,CAED,CA2DJ,WAxDK,MAwDL,EAxDK,WAEQ,CAFR,EtCkEL,KACiB,cACT,KmCjIA,SAA8B,CGqHtC,gBApDS,GAEY,YAFZ,MAEE,C,EAFF,EAGC,EFpEC,GAAK,KEqHhB,cA/CO,YACF,I,EAAA,UAMK,KACA,CAAL,MAGG,OACK,QAHK,CAAb,CAKC,CAoBG,CAvBD,MAkBI,WAlBJ,CAAK,gBADG,CAAP,CAGJ,OAaK,CAAM,GAAR,OAAoB,IAAR,CAAa,CAC1B,WAEG,GAMD,GAKD,OACC,OA9BD,MAiCyD,GAAN,CAjCnD,IAiC8C,GAAK,CAAb,CAjCtC,QAiCgC,GAAN,CAjC1B,IAiCqB,GAAK,CAAb,CAjCb,MAiCQ,GAAN,CAjCF,IAiCH,GAAK,CAAW,CAAyB,CACtC,CAjBC,KAEY,GAnBb,IAmBmB,GAAF,GAAJ,CAMZ,OAAK,CAAK,CASX,CAAS,IAEjB,GnEmyBe,UAAF,CAAF,CAwdS,SAxdK,EAwdL,aAAmB,EACd,O,EAAA,cAKL,iBACA,YAGhB,CAGY,Q,CAZS,EAYO,OAAhB,U,CAAA,EAAgB,cAAhB,QAAgB,WAAhB,U,CAAgB,aAAhB,U,CAAA,EAAgB,WAAhB,U,CAAA,EAAgB,oBAAhB,U,CAAgB,SAAhB,U,CAAA,EAAgB,OAAhB,UAAgB,qBAGJ,KAEG,KAtrB3B,KAsrB2D,KAvrBrC,KAAV,KACZ,iBAqqBqB,EAnqBb,KADS,OACjB,QAAuB,qBAA4B,aAwrBvD,G,GAmDY,EACe,QADf,IACmC,CAAf,GAAL,QAEI,MAK/B,EArvBI,gB,SAAA,E,aAwvBuB,YAAL,QAGJ,CAAQ,C,EAAA,GAAR,IAEF,SAIE,OAEG,YADK,QAIR,CAHG,EAKY,OAAb,aADY,GAAJ,CACL,GAAiB,OAAjB,K,EAAA,EAKkB,GAqGzC,MAhGgB,OAAU,gEASR,eAEqB,UAxlBH,CAAJ,CAAP,G,SAAA,SAAD,CAAb,CAwlBO,SAAqB,EAArB,aAAqB,EAArB,IACd,GAEmC,UA3lBH,CAAJ,CAAP,G,SAAA,SAAD,CAAb,CA2lBO,SAAqB,EAArB,aAAqB,EAArB,IACd,GAEmC,UA9lBH,CAAJ,CAAP,G,SAAA,SAAD,CAAb,CA8lBO,SAAqB,EAArB,aAAqB,EAArB,IAId,GADoC,QAjmBJ,CAAJ,CAAP,G,SAAA,SAAD,CAAb,CAimBkB,UAAD,CAAX,sBAGuB,YAAK,CAAL,MApmBJ,CAAJ,CAAP,G,SAAA,SAAD,CAAb,CAomBkB,UAAD,CAAX,yDAYb,wBAII,E,SAAA,qBAVJ,UA7BsB,GA6BtB,kBAayB,MAAoB,GAAF,CAAqB,KAAL,CAAF,SAGrD,CAAQ,C,EAAA,GAAR,IAHqD,E,EAGrD,EACmC,SACnC,CAAQ,CAAR,EAA8B,GACL,eACC,qBACZ,CADY,EAEE,KAAF,GAC1B,OACe,CADf,EAE+B,KAAF,GACI,kBAEjB,GACe,KAAF,GACI,cAGlB,SACK,GAiC5B,QA1BQ,CAAQ,C,EAAA,EAAR,IAA8B,E,EAAA,EAKC,G,EACL,KACL,eACC,qBACZ,CADY,EAEA,OAC1B,OACe,CADf,EAE6B,OACI,kBAEjB,GACa,OACI,cAKrB,IACQ,QAExB,C,EA+mCA,S,kKAAA,M,uBAE+C,IA36D5B,OAAP,EAAO,EAAP,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EA26D4B,KAAnB,QAOO,KAAX,CAAF,CAAN,SAP+B,EAO/B,aAP+B,EAIJ,MADjB,WAMD,CANC,EAMU,CAAX,KAAD,CAAX,CADe,UAES,MAAiB,oBAF1B,IAEgB,SAApB,CAAX,CAFe,OAHN,CAGM,EAHE,MADwB,CAArB,SATJ,OAAc,GAUW,GAAhC,UAYF,sBACK,KAAZ,IACT,GACoB,KAAX,GACT,KACqB,KAAZ,E,EAAA,GAEW,KAAX,C,GAAA,OAKiB,QACA,YAGa,IAFP,EAEO,WAP3B,GAAF,CACW,KAAF,CAAd,CAGa,GAAF,MAAY,MAAO,CAAvB,WAG2B,EAH3B,aAG2B,EAFP,CAAlB,IAAM,EAFF,KAHG,KAAF,CAAd,CAGW,MAAY,MAAO,CAAvB,SAAM,EAAN,aAAM,EAEE,GAAN,I,EAEd,K,EAAA,K,EAAA,2E,EAAA,M,EAAA,M,EAAA,M,YAAA,W,gBAKkD,OAAZ,cAxLtC,UACuB,YAqLO,GAtL9B,M,cAsL8B,QAtL9B,K,gBAAA,OAEA,UAEuB,QADF,CAAS,G,EAD9B,M,cAEuB,IADO,IAD9B,K,gBAAA,OAGA,UACuB,I,6qBAyLX,OAAK,C,EAJM,QAIX,EAAK,E,MAAL,E,KAAK,SACC,sB,EAAA,K,WAAA,S,UAAA,M,GAAA,E,OAGA,wB,EAAA,M,WAAA,S,UAAA,G,EAAA,E,IAJN,E,KAIM,uCAIyB,CAAN,CAAlB,IAAM,KAAN,MACnB,4F,EAAA,K,EAAA,K,cAAA,qB,gBACJ,M,uKAAA,C,EAGA,O,6MAAA,M,uBACmC,E,OAAA,CAAF,I,OACE,EAIX,QAJW,KAAF,IACiB,QAAjB,IACmB,QAAxB,IACwB,UAAxB,IAGxB,Y,2GACuB,OAAL,CAAZ,IACkB,OAAL,GAAb,IACiC,QAAvC,kB,EAAA,M,cAAA,W,gBACuC,QAAvC,kB,EAAA,M,cAAA,W,gBACuC,QAAvC,kB,EAAA,KATQ,C,cASR,IATQ,IASR,G,gBACoC,QAAvC,kB,EAAA,KATW,C,cASX,IATW,IASX,G,gBACuC,QAAvC,kB,EAAA,KATW,C,cASX,IATW,IASX,G,gBAC0C,QAAvC,kB,EAAA,KAfQ,C,cAeR,IAfQ,IAeR,G,gBAE8C,QAA9C,6DAE8C,QAA9C,2C,2QAC8C,QAA9C,0DAG0B,Q,OAAI,EACJ,QADsC,Q,OAClC,EAEO,IAJrC,OAKI,YAJ0C,CAAhB,CAAkB,GAApB,CAAxB,SAIA,EAJA,aAEA,KAAgB,GAAhB,0B,EAAA,QAD2C,CAAjB,CAAmB,GAArB,CAAxB,SACA,EADA,aACA,EAHJ,K,EAII,KAAiB,GAAjB,2B,WAJJ,EAGI,EAHJ,EAII,EAJJ,K,4HAQA,IAEkB,C,KAFlB,E,KAEkB,EAAlB,kC,KAAA,oBASsB,E,KAAA,cACJ,CAAD,CADK,I,SAIO,C,EAXP,U,KAWO,IAAQ,IAAL,GAAK,KAAL,QAAe,GAAlB,UACwC,YAAzD,GAAyB,QAAJ,SAAI,EAAJ,aAAI,EAAzB,K,EAAkB,QAAJ,SAAI,EAAJ,aAAI,G,WAAA,EAAJ,QAAd,K,iBAcK,OAAL,MAAgB,G,QAAX,E,KAAW,IAEA,OAAe,YACA,MACP,qBAMwB,UAJxB,IAAf,CAFe,UACA,IAAf,CADe,MAMxB,0F,EAAA,K,EAAA,K,EAAA,K,cAAA,W,iBArCU,EAqCV,IArCsB,CAAZ,KAAlB,I,KADc,EACd,IAD2B,CAAb,KAAlB,K,KA2CJ,M,kNAAA,C,GExqFA,S,ycAAA,M,uBAAA,OH5FuB,OACc,CAAnB,EADK,EACL,KAfD,UACT,E,sBADS,EAET,O,sBAAA,E2DGA,K,gB3DAJ,E+FxCH,M,WAAA,IACA,G,gBACS,gB,W/FsCN,IACmB,U,UAAA,G,WACnB,K,eACc,Q,GAAA,E,MAAA,E,WACV,O,iBAOJ,OACc,GGnBlB,KACkB,GAEE,SACqB,MAAvB,GAAF,KAC+B,KAAjB,GAAF,UACI,GAAF,KACQ,IAAjB,GAAF,KHsS0B,IAAzB,KG/LF,EHrFwB,WACzB,M,EACb,Y,EAAA,eADa,MACb,eAmRS,wCACoB,CADpB,WArRM,EAqRN,WArRM,EAqRN,GGtSM,SHsQsB,IAAvB,QACL,gBACoB,CADpB,GGtQK,SHoS2B,IAAzB,aAnRH,MACb,eADa,MACb,eAmRS,uCACoB,CADpB,WArRM,EAqRN,WArRM,EAqRN,GGpSM,SH4WyD,IAAzC,aA5VlB,MACb,gBA4VS,iBACoB,CADpB,WA9VM,EA8VN,GG5WS,SACkB,KAAjB,GAAF,KHmOwB,GAAzB,aArNH,MACb,eADa,MACb,gBAqNS,gBACoB,CADpB,WAvNM,EAuNN,WAvNM,EAuNN,GGnOC,SHiQ2B,GAAvB,QACL,gBACoB,CADpB,GGjQM,SHiO0B,GAAzB,aArNH,MACb,eADa,MACb,gBAqNS,gBACoB,CADpB,WAvNM,EAuNN,WAvNM,EAuNN,GGjOE,SHgO8B,EAAzB,aArNH,MACb,eADa,MACb,eAqNS,gBACoB,CADpB,WAvNM,EAuNN,WAvNM,EAuNN,GGhOK,OHiUlB,EAEyC,IAAvB,KGnUA,EHSwB,OA+TiB,IA9T1C,M,EACb,Y,EAAA,OA8TuD,QA/T1C,MACb,OADa,aACb,OADa,aACb,OA0TS,6BADsB,CACtB,SAOY,IAPZ,WA5TM,EA4TN,WA5TM,EA4TN,WA5TM,EA4TN,WA5TM,EA4TN,OAEa,IAFb,GAaT,I,GGlVc,E,EACJ,QH4aa,OAEJ,IADD,WAElB,GG7amB,OACnB,IHOA,kB,EGmFc,EAEJ,wIFuqBwB,KAAvB,OEvqBD,4CFuqBD,WEvqBC,G,EAAA,IFwqBK,GAAF,G,EAAA,KACE,GAAF,WACE,GAAF,aACE,GAAF,OA3kBiB,WACX,UACN,GADF,OA2kBK,QAhNpB,WAO2B,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,aAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,aAFF,cACE,cACA,aAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,cAFF,cACE,cACA,aAFF,cACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,aAFF,aACE,cACA,aAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,aAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,cAFF,aACE,cACA,aAFF,aACE,aACA,aAFF,GA2MrB,KA9ByB,K,EAAA,EAAX,KAAW,EAAN,KACL,GAAF,SACG,GAAF,SACY,GAAT,GAAF,SAEF,GAAF,SACG,GAAF,GAIuB,OADwB,OAC7C,OAAoC,WAxHzB,GAwHpB,gBAAwB,CAAH,CAvHE,KAAZ,GAAF,OACK,KAEL,OADC,OADE,OAqHa,OAGpB,OAAkB,WA1HH,GACG,SAAZ,GAAF,OACK,KAEL,OADC,OADE,OAuHU,WAzHF,SACG,GAAZ,GAAF,OACK,WAyH8B,CAvHnC,OADC,GADE,OAyHS,eAIE,GAAf,GAEY,UAAZ,GAAF,I6FhzBR,I7FioDI,I6FjoDJ,EAAG,CAAD,CAAF,G3FgKF,EFi+CA,EACU,OAGO,GAES,KAr8BE,OAAV,CAq8BQ,EAr8B1B,aACI,CADJ,EACI,GAAmB,OADa,CAAR,OAAV,CAAlB,IAs8B0B,KAt8BE,OAAV,CAs8BQ,EAt8B1B,iBACI,CADJ,EACI,GAAmB,OADa,CAAR,OAAV,CAAlB,IAy8BsB,K,EAAc,K,EAC3B,K,EAAe,K,cADuC,KAjoCnC,EAioCuB,KAjoCvB,OAAR,G,E6FrgBO,sBAAD,GAAM,CAA9B,KAAyB,sBAAD,GAAM,CAA9B,K7F4RN,IACI,G,mB6F7RE,IACM,CAAJ,C7FqgBW,IAAO,C,E6FtgBpB,IACM,CAAJ,C7FsgBW,IAAO,C,MAzOtB,QACI,EAAuC,GAAP,GAAD,UAAd,GAAF,OADW,OAA9B,iBAMkB,CAAlB,SANkB,mCAOd,0CAGqB,KACY,QAAmB,YCpM3C,QAAK,CACC,GAAT,CACS,EDkMqC,EClMrC,SAAT,CACG,QAAK,CAMH,GAAL,aACK,SAAL,CAEC,GAKK,GAAF,MAAK,CAUH,mBAdL,KAKK,GAAF,MAAK,GAEf,6BAAQ,CAGE,EAAK,EAAL,EAFV,6BAAQ,CAEgB,SAAP,IAAP,CAAK,KAAZ,MAA4B,eARrB,MAAY,CAYV,eAXF,MAAY,CAWI,OAHhB,EAGgB,MAHV,IAAN,KAAP,MAA0B,GAShB,EATgB,KAGjB,MAAc,aAGjB,CANoB,EAOV,SAAK,CAAK,SATjB,IAAF,KAAP,MAAkB,GASiB,aAAqB,WAAE,IAAc,CAAhB,CAAxB,E,MAVnC,aADA,GAWmC,KAD1B,CAC0B,EAAhB,SAAK,CAAK,KAAS,WAAqB,WAAE,IAAc,CAAhB,CAAxB,E,MAEtB,GAFsB,YAD1B,CAC0B,EAAhB,SAAK,CAAK,KAAS,WAAqB,WAAE,IAAc,CAAhB,GAAxB,E,MAEX,MAAY,CDmKnB,SAFuB,CAAd,KAAtB,GAQQ,YAHA,YAPM,EAON,IAPgB,CAAV,GAAlB,GADc,EACd,IADyB,CAAX,GAAlB,0BAkB6B,KAAf,qCAEV,E,CAAA,IAEwB,EAFxB,MAEwB,OAAS,GAAZ,C,EAAG,EAAH,EAAR,KAAW,E,EAAA,GAAS,GAAZ,CAAR,KAAW,E,EAAA,GAAS,GAAZ,CAAR,KAAW,E,EAAA,GAAS,GAAZ,GAAR,OAFe,GAA5B,EAA4B,IAA5B,kBAEwB,EAFxB,MAEwB,OAAS,GAAZ,C,EAAG,EAAH,EAAR,OAFe,GAA5B,EAA4B,IAA5B,QADc,EACd,IADyB,CAAX,GAAlB,I,KAMJ,E,gBA2MI,IAGwB,WACN,CAAlB,qDAEsB,SACd,SAAe,iBAAe,YAAyB,GAAlB,CAAzB,SADE,CACd,SAAe,mBAAe,YAAyB,GAAlB,CAAzB,OAFQ,GAAxB,EAAwB,IAAxB,YACkB,OACd,SAAe,mBAAe,YAAyB,CAAlB,CAAzB,IAHF,EAGE,IAHI,CAAN,GAAlB,QAMe,G,UAlNnB,MAkNmB,EAlNnB,EAEsB,CAAlB,mBAE4B,KAIL,SAAZ,SAzKO,CAyKP,EAzKX,8BACI,EAAS,WADW,KACpB,EAAS,WADW,KACpB,EAAS,WADW,KACpB,EAAS,WADW,KACpB,EAAS,WADW,KACpB,EAAS,WADW,KACpB,EAAS,WADW,KACpB,EAAS,SADW,OAAxB,2BACI,EAAS,SADW,OAAxB,cAOY,E6FtKe,sBAAD,GAAM,CAA9B,K7FsKU,MACG,SADI,I6FtKjB,IACM,CAAJ,C7FqKe,KAEJ,SAAF,GACA,OAJK,EAIL,IAJW,CAAN,GAAlB,MAuKA,O,uBACA,QACa,QA/KK,CA+KL,EAGb,YACY,KAAS,OAIb,UAAgB,EAAG,aAAY,CAAf,E6FtVG,sBAAD,GAAM,CAA9B,K7F0Vc,E6F1Vd,IACM,CAAJ,C7FyVmB,GACP,eAEH,GADA,eAKT,QACQ,IACA,KADA,YAQQ,iBAAG,MAAgB,EAAG,aAAY,CAAf,EACf,aACZ,EAAiB,SACI,SACb,CACI,SAKT,aACA,CAAK,cAAG,QAAgB,EAAG,aAAY,GAAf,EACf,aACZ,EAAiB,SACI,SACb,CACI,WAMT,EANS,IAIV,CAEC,GAAQ,YAAG,QAAgB,EAAG,aAAY,GAAf,EAClB,aACZ,EAAiB,SACI,SACb,CACI,WAMT,EANS,IAIV,CAEC,GAAQ,SAAG,MAAgB,EAAG,aAAY,CAAf,EAClB,aACZ,EAAiB,SACI,SACb,CACI,aAIN,CAnDG,MAAjB,WAhBkB,EAgBlB,IAhBqC,CAAnB,GAAtB,IAsEA,K,KACJ,E,oBAGA,MAwHI,EAtHyB,IAsHzB,EAtHyB,MAAd,WAEO,CAAlB,sDAGY,aAAc,CAAd,EAAc,MAGlB,EAAY,SAEA,SACN,UARkB,CAEpB,SAAc,CAMZ,EANY,MAGlB,EAAY,SAEA,SACN,QARkB,OAA5B,UAEsB,OAAd,WAAc,SAGlB,EAAY,SAEA,SACN,QATe,CAAX,KAAlB,IAcA,gBAEsB,CAAlB,UACY,a6FhbW,sBAAD,GAAM,CAA9B,K7FkbgB,E6FlbhB,IACM,CAAJ,C7FibqB,OAIR,E,EAJC,EAID,cAHG,KAGH,MAAF,KALC,EAMK,GAAF,GACF,WATgB,CAAX,KAAlB,eAgBY,IACA,KADA,OAGR,O,uBACA,IACc,MAFd,EAEc,+BAIC,0CAEoB,GAIjB,qBAEN,EAAY,Q,EAAA,yBANW,GAIjB,qBAEN,EAAY,Q,EAAA,YAPY,EAOZ,IAPY,UACD,GAIjB,qBAEN,EAAY,Q,EAAA,WAEhB,uCAR2B,SAIjB,aACF,QACJ,EAAY,Q,EAAA,mBANW,SAIjB,aACF,QACJ,EAAY,Q,EAAA,cAPY,EAOZ,IAPY,IACD,SAIjB,aACF,QACJ,EAAY,Q,EAAA,gBARQ,+CAEG,SAIjB,aACF,QACJ,EAAY,Q,EAAA,mBANW,SAIjB,aACF,QACJ,EAAY,Q,EAAA,YAPY,EAOZ,IAPY,MACD,WAIjB,eACF,QACJ,EAAY,Q,EAAA,OAMpB,gBAWJ,oBACoB,uBACF,EADE,KACF,G,EAAA,Y,EAAA,EADE,EACF,Q,EAAA,EADE,EACF,Q,EADE,EACF,WAFW,OAA7B,qBAOA,SAhBI,EAAa,SAEA,SACN,OACP,GAoBJ,UAPQ,OAAU,I,EAAA,EAAV,GAAU,SAAV,GAAU,OAAV,GAAU,UADW,OAA7B,S6FxemB,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7F8ewB,qBAEZ,KAAU,GAFE,EAGJ,SAEJ,EADW,OACX,IAAU,YAGV,QAPiB,CAAX,OAAlB,IAUJ,MA5D6B,CAAX,KAAlB,SAjBJ,KAiFA,K,KACJ,E,gBA2BI,uF,CAAA,EACI,qBAEkB,oBACG,SAGA,QAHA,kBAID,YACJ,WAFK,OAUjB,KAAa,WACb,QAAwB,WAAF,WACE,MAAF,WACE,IAAF,GAnBR,EAmBQ,IAnBF,CAAN,GAAlB,MAgBI,SAAa,SACb,QAAwB,GAAF,SACE,GAAF,SACE,GAAF,SAnBF,CAgBpB,KAAa,SACb,QAAwB,GAAF,SACE,GAAF,SACE,GAAF,OAnBF,GAAxB,EAAwB,IAAxB,aAgBI,OAAa,SACb,QAAwB,GAAF,SACE,GAAF,SACE,GAAF,IApBZ,EAoBY,IApBN,CAAN,GAAlB,IAuBA,KACA,KACA,KAslCoC,OAAX,OAAK,OAAZ,GAAkB,EAApC,IAmBmB,KA7/CnB,OA2+CS,WAAL,MAAa,GACR,KAAL,KAAc,OAF2B,CAAT,OAAX,OAAK,GAAZ,GAAlB,OAmBmB,SA7/CD,GAAlB,kCACI,CADJ,EACI,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,KACpB,CAAS,EAAT,CAAS,SADW,OAAxB,yBACI,CADJ,EACI,CAAS,SADW,GAAxB,EAAwB,IAAxB,YAOY,E6FtKe,sBAAD,GAAM,CAA9B,K7FsKU,IACG,CADH,EACG,QADI,I6FtKjB,IACM,CAAJ,C7FqKe,KAEJ,CAFI,EAEJ,QAAF,GACA,WAJW,CAAN,KAAlB,GA2/CkD,OAAX,QAAK,eAAZ,CAAY,EAA5C,oBACe,CADf,EACe,IACE,OAEG,EAAL,EAAK,KAAL,+BAeI,IADiC,GAdrC,UAaX,EAbW,EAaX,GAtwBI,EAuwB2B,EAD/B,IACgC,GAAD,CAvwB3B,CAwwBW,QACP,aACqB,OAAP,GAMQ,OAAP,MAOO,OAAP,GAMO,OAAP,UArBR,IADiC,GAsBzB,EA7xBnB,EAuwB2B,EAsBR,IAtBS,GAAD,CAvwB3B,CAwwBW,QACP,aAcsB,OAAP,GAMO,OAAP,MAnBM,OAAP,GAMQ,OAAP,UARR,IADiC,GASzB,EAhxBnB,EAuwB2B,EASR,IATS,GAAD,CAvwB3B,CAwwBW,QACP,aAcsB,OAAP,GAMO,OAAP,MAnBM,OAAP,GAMQ,OAAP,YARR,IADiC,GASzB,EAhxBnB,EAgxBmB,IATS,GAAD,GAvwB3B,GAwwBW,QACP,aAcsB,OAAP,GAMO,OAAP,MAnBM,OAAP,GAMQ,OAAP,UAeA,WAEX,OARW,WAQX,OAfW,WAeX,OArBU,wBA6BV,CA7BU,EA6BS,OAAP,CAAxB,G6FptDuB,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7F6KO,UAAe,UACM,CAAN,YAAW,UAA5B,CAsiDM,aAviDI,EAuiDJ,W,EADX,IAzyBgB,OA6yBZ,E,CAAA,EACA,EAAK,KAAL,OAvnCO,KAAK,GAunCI,GAChB,OAK0B,sBAA0B,OAAP,CAAnB,MACV,KAEpB,GAA8D,OAAP,CAAlB,MAClB,KAEnB,GAA6D,OAAP,CAAjB,MACnB,KAElB,GAA+D,OAAP,CAAnB,MACjB,MAVU,EAe1B,EAAK,KAAL,CA5oCO,EA4oCP,IA5oCO,KAAK,GA4oCI,IAIK,KAAY,EACb,KAAY,EACd,OAAR,KAAsB,SAEb,OAAR,KAAoB,SAEP,OAAR,KAAiB,gCAxFyB,CAAhB,EAAX,KAAK,EAAM,KAAN,CAAZ,CAAhC,IAiGA,UACA,eACA,UACA,OACA,UACA,OACA,OACA,UANA,iBAEA,iBAEA,iBACA,iBACA,iBAPA,OAEA,OAEA,0BAJA,iBAEA,iBAMA,KAG+C,OAAP,CAAO,EAAP,IAEb,YAAL,MAEF,WADH,WAIE,GACf,OACkC,QA12BxB,KAAN,GA22BJ,GAAK,KAAL,GAD6C,QAC7C,EAAe,SAVqD,CAAzB,OAAP,KAkBK,OAAP,CAAO,EAAP,kBAErB,CAFqB,EAED,OAAP,I6FhyDH,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7F6KO,UAAe,UACM,CAAN,YAAW,UAA5B,WAknDO,aAnnDG,EAmnDH,W,EADZ,I6FhyDuB,sBAAD,GAAM,CAA9B,K7FuyDwB,UAAL,MAGG,SADN,OADF,GAIZ,OAC2C,MAl4BjC,KAk4BuB,MAl4B7B,CAAY,a6F36BlB,IACM,CAAJ,C7F06BgB,EAw3BD,MAeL,CAv4BM,EAu4BN,WAJE,EAAK,KAAL,WAMI,kBAUF,QADC,OAGV,SAAL,EAAkC,EAAZ,KAAY,GAAnB,GACC,WAnCiD,CAAxB,OAAP,CAAtC,IAsCA,K,wBAgnBJ,M,o3J2B35EO,O,CAAA,EACY,WACG,OADL,M,EAKP,EAE6D,SAAH,CAF1D,EAGG,G,EAAA,G,IAET,EAAM,KAQV,G,EAZa,EADH,EACG,SAQc,CAAP,aARP,EAQO,kBARP,EASA,I,EAAA,SACoB,CAAP,CAAF,UAAkB,UAAO,CAAjC,aADH,EACG,aAAF,O,4GmC/Cd,kBACU,GAAT,G,yBACI,oBAGO,E,IACV,EAAM,OACN,OAEU,OuDZZ,KACO,CADP,E,IAEE,EAAQ,GAAF,KvDUI,G,EAAA,EACH,KAEK,MAAG,OAAO,CAAV,G,IACZ,EAAM,GACN,GAEU,OAAJ,OAAa,E6ClBT,KACO,CAAR,KACN,E,EACG,U,a7CgBR,E,sBAAA,E,m8I9D26EI,KAEiB,KACI,GAAF,IAGuB,EAAZ,KAAM,EAAM,KAAZ,EAAM,GAAlB,GAAF,MACO,K,EAjI3B,EAiII,EAjIJ,EAKsB,GAAlB,sBAAkB,0EAEC,YAz6Ce,CA46CtB,E,CALM,EAQF,EAHJ,MAGgB,CAAZ,SAAgB,MAGF,C,EAHE,EAGF,IAAd,QAAc,MAGE,C,EAHF,EAGE,UAAJ,CAAZ,MAAgB,MAGF,C,EAHE,EAGF,IAAd,QAAc,MAGA,C,EAHA,EAGA,IAAd,QAAc,QAGE,C,EAHF,EAGE,IAAhB,QAAgB,MAGF,C,EAGE,EAAhB,QAAgB,GANA,EAGF,IAAd,QAAc,EAGE,SAh8CC,mBAs8Cd,SAEF,CAx8CgB,EAw8ChB,aAQE,gBAGH,GACR,OAHQ,GACR,iBATQ,c6Fx2EW,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7F42EiC,EAAO,GAAT,GACvB,G6F92Ee,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7F02EiC,EAAO,GAAT,GACvB,G6F52Ee,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7Fw2EgC,EAAO,GAC/B,gBAn8CsB,GA48Cf,IAIP,WAC6B,e,GAAA,S,GAAA,iBAQrB,GACR,QAJQ,GACR,OAJQ,IASO,oCAOI,WAPJ,EAQE,sDADE,kBACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,oBAHa,CACjB,MACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAFJ,oBACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAFJ,eACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAFJ,kBACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAFJ,kBACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAFJ,oBACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAFJ,oBACF,YAOM,GACf,OAHe,GACf,OAHe,GACf,OAHe,IAWH,2B6Fv5EL,sBAAD,GAAM,CAA9B,K7F45EkC,EACN,KAFqB,QAAjB,CAAY,KACtB,CAAJ,CAAgB,GAEd,S6F95EpB,IACM,CAAJ,C7F65EkB,EADe,IAAK,GACN,IAAe,WAGtB,U6Fj6EF,sBAAD,GAAM,CAA9B,KAAyB,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7Fk6EmB,EAAO,GACa,G6Fp6EzC,IACM,CAAJ,C7Fi6EuB,EAAO,GAEL,CAAP,IAAgB,aACjB,YAKD,GACR,OAHQ,GACR,OAGQ,UAGZ,EAAgB,SA5GM,GAAR,KAAlB,GADc,WAAlB,MA4HA,KAEgC,U,eAAA,Q,+wBAAf,M,gDAAA,YAGc,2BAAF,IACG,0BAAF,IACA,0BAAF,IACE,0BAAF,IACF,2BAAF,IACQ,0BAAF,IACK,0BAAF,IACJ,0BAAF,IACgB,OAAZ,WAAnB,OAAuC,IAAvC,I,uDAAA,M,8CACZ,O,iBACyB,uC,eAAA,O,iBAAA,0CACzB,E,EAAA,S,EAAA,2BACqD,OAAX,KAGZ,KAH6B,CAA7B,GAAF,QAGV,GAHU,EAShB,MALG,CAKX,EAAQ,MAAR,CALW,EAAQ,MAAR,SAK4B,CAAN,KACjC,EAAQ,MAAR,SAAyC,EAAN,GAGnC,EAAQ,MAAR,GAAmC,GACnC,EAAQ,MAAR,IAAmC,OAXM,CAAT,OAAX,KAAK,CAAZ,GAAlB,QAcoB,IACJ,S,YAAA,S,iBAAA,E,EAAA,W,EAAA,mB,YAGA,S,iBAAA,M,EAAA,iB,EAAA,oB,YACI,S,iBAAA,M,EAAA,iB,EAAA,oB,YACM,S,iBAAA,M,EAAA,iB,EAAA,oB,YACG,S,iBAAA,M,EAAA,a,EAAA,mB,84MoC58EvB,I,sBkCPJ,WAEgB,CAFhB,E,CAsCN,UAlCK,QAkCL,EAlCK,IAEI,CAAI,E,CAFR,EzCsFL,KACgB,UACR,KuCxHA,KAAiC,CEkEzC,WA9BS,GAEe,QAFf,IAEC,C,EAFD,EAGC,EDvCC,GAAK,KCkEhB,UAzBO,QACF,QAqBA,aAfK,QAGM,CAAP,CAGM,CAAV,KAFG,YAAK,GAKC,WAIN,KAEO,OADV,GAAS,OAAE,GAAF,CACC,CACH,OAdM,CAQL,KAAc,GAAhB,OALE,IAKF,CAMO,GAAN,CACU,IACtB,G,OlC/BU,EAVF,GAAU,CAUR,GAAS,GAVD,GAWb,eAEW,G,CAGJ,KAHI,EAbE,GAeL,CAwBb,E,CAAA,OAtBQ,CAsBR,EPsDA,KACgB,EIvHkB,KJuHlB,GACR,KIxH0B,KAAe,CGgEjD,UApBQ,IP0ER,KACgB,EIvHkB,KJuHlB,GACR,KIxH0B,KAAe,CGgEjD,OANK,cATqB,GAAF,GAEpB,KACI,CAMM,OAAE,GAAF,CACN,KAEI,CAXN,OAMG,C,EAKG,IADP,GAAS,aACF,CALH,EADJ,SANqB,IAMrB,IACF,CACE,CAKE,CACe,E,u1LpCi7EH,oC,EAAA,a,EAAA,+DAEyB,E,KAAA,OAAZ,QAAY,K,eAAZ,IAAY,K,0BAAZ,EAAY,EAAZ,G,iBAAA,IAAxB,GAAwB,EAAxB,G,EAAwB,W,EAAA,kBACY,Y,eAAZ,IAAY,K,0BAAZ,EAAY,EAAZ,G,iBAAxB,O,EAAwB,W,EAAA,kBACY,Y,eAAZ,IAAY,K,0BAAZ,EAAY,EAAZ,G,iBAAxB,O,EAAwB,W,EAAA,kBACY,Y,eAAZ,IAAY,K,0BAAZ,EAAY,EAAZ,G,iBAAxB,O,EAAwB,W,EAAA,kBACY,Q,YAAZ,IAAY,K,0BAAZ,EAAY,EAAZ,G,iBAAxB,O,EAAwB,W,EAAA,sBALc,KAAxB,GAAlB,I,KAUyB,OAA6B,mBADrC,kBAC2C,GAAE,CAAb,CADhC,UACa,GAAE,GAAZ,GADH,K,YASI,W,iBAAA,4F,YACD,W,iBAAA,M,EAAA,a,EAAA,a,EAAA,a,EAAA,a,EAAA,mBAEpB,M,2BAAA,EEh2EiB,G,YAKT,G,gBAAA,E,YAAA,E,EAAR,E,GAAA,I,4BAAA,EACQ,GAGO,E,IAAA,E,OAAA,EACU,K,EAAS,K,MAAT,EApGb,KAAgB,SAAmB,CAA/C,IAI0D,gBACxC,CADwC,EAC1D,SACoB,8CAMJ,OANI,QAKqB,QACzB,CANI,EAMJ,WAAyB,GADA,QAAF,CACvB,mBAAyB,GADA,QAAF,CACvB,mBAAyB,GADA,QAAF,CACvB,oBAAyB,GADA,QAAF,CACvB,oBAAyB,GADA,QAAF,CACvB,oBAAyB,GADA,QAAF,CACvB,oBAAyB,GADA,QAAF,CACvB,oBAAyB,GADA,QAAF,CACvB,oBAAyB,GADA,QAAF,CACvB,oBAAyB,OAJR,KAAP,QADG,KAAP,IAFJ,EAEI,IAFgB,CAApB,GAAlB,IAaY,OHiQU,KAAgB,KAAa,KACxC,KAAmB,KAAiB,KACpC,KAAoB,KAAqB,KAAoB,KAFxE,GGhQU,KH0NU,OAAiC,EAAlB,KAAkB,KAAR,KAtP3B,CAAlB,gDAC4B,CAAxB,EADJ,EACI,CAAwB,QgDpE3B,Q,KAAA,EpCsDO,CoCtDP,ehDoEa,SAAc,CAAxB,GAAwB,QgDpE3B,Q,KAAA,EpCsDO,CoCtDP,ehDoEa,SAAc,CAAxB,GAAwB,QgDpE3B,Q,KAAA,EpCsDO,CoCtDP,ehDoEa,SAAc,CAAxB,GAAwB,QgDpE3B,U,KAAA,EpCsDO,CoCtDP,iBhDoEa,OADa,OAA3B,4BAC4B,CAAxB,GAAwB,QgDpE3B,U,KAAA,EpCsDO,CoCtDP,iBhDoEa,OADa,OAA3B,UG6BY,OH+PU,KAAgB,KAAa,KACxC,KAAmB,KAAiB,KACpC,KAAoB,KAAqB,OAAoB,KAFxE,UG5PyB,SAAP,CAAO,EAAzB,2CAGqC,WAA7B,IADmB,QACe,KAClC,KAAsC,KAAF,OAHtB,CAGsB,EAHtB,IADgB,CAAb,OAAP,GAAlB,KAGqC,EAHrC,IAC6B,CAEQ,KAA7B,IADmB,QACe,KAClC,KAAsC,GAAF,OAHf,GAAzB,MAMW,KHyTyC,SA9OtC,CG3EH,EHyTnB,kCA9OI,CA8OJ,EA9OI,eACqB,WAAH,EAAqC,EAArC,IAA6B,CAA7B,EAA6B,IAAQ,GAAV,CAA3B,EAA2B,CAAzC,MAAiB,EAAjB,IAD6B,CACZ,KAAH,CAAd,EAAc,GAAqC,EAArC,MAA6B,KAAQ,GAAV,EAAzC,UAD6B,OAAjC,UA8OJ,IA9OI,GACqB,SAAH,IAAqC,EAArC,MAA6B,KAAQ,GAAV,EAAzC,e,EAAA,EG1Ec,CH0Ed,EG1EJ,4EAEI,UADgB,gBAEqB,CAAjC,EAFY,EAEZ,CAAiC,QAAF,SAAE,CAAjC,GAAiC,QAAF,SAAE,CAAjC,GAAiC,QAAF,SAAE,CAAjC,GAAiC,QAAF,OADT,MAAR,kCAMmB,CAAjC,GAAiC,QAAF,SAAE,CAAjC,GAAiC,QAAF,SAAE,CAAjC,GAAiC,QAAF,SAAE,CAAjC,GAAiC,QAAF,OADP,MAAV,oBAMmB,KAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,IAAE,QAAF,mBAKE,KAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,OAAF,GAAE,SAAF,OAlBD,CAApB,KAAlB,IAsBY,KH2JuC,OACxC,WAhNO,CAAlB,2F,CAAA,UAKyC,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,GAAN,OAJI,GAAjC,EAAiC,IAAjC,oBAIqC,CAAjC,GAAiC,aAAF,GAAN,OAJI,GAAjC,EAAiC,IAAjC,QADc,EACd,IAD6B,CAAf,sHAGV,E,CAAA,UACW,YAAyB,QAA5B,OAAG,OAAyB,QAA5B,SAAG,OAAyB,QAA5B,GAAG,QAAyB,UAA5B,eADwB,GAAhC,EAAgC,IAAhC,oBACW,OAAyB,UAA5B,UADwB,GAAhC,EAAgC,IAAhC,cAEiC,CAAjC,GAAiC,UAAF,GAAN,GAJX,EAIW,IAJI,CAAf,GAAlB,GADc,EACd,IAD6B,CAAf,GAAlB,IGqDU,KHsLU,OAAiC,EAAlB,KAAkB,KAAR,KAtP3B,CAAlB,wCAC4B,CAAxB,GAAwB,QgDpE3B,Q,KAAA,EpCsDO,CoCtDP,ehDoEa,SAAc,CAAxB,GAAwB,QgDpE3B,Q,KAAA,EpCsDO,CoCtDP,ehDoEa,SAAc,CAAxB,GAAwB,QgDpE3B,Q,KAAA,EpCsDO,CoCtDP,ehDoEa,SAAc,CAAxB,GAAwB,QgDpE3B,U,KAAA,EpCsDO,CoCtDP,iBhDoEa,OADa,GAA3B,EAA2B,IAA3B,0BAC4B,CAAxB,GAAwB,QgDpE3B,U,KAAA,EpCsDO,CoCtDP,iBhDoEa,OADa,GAA3B,EAA2B,IAA3B,QGkEU,KHkQU,K,EAAgB,K,EAAgB,K,EACzC,K,EAAsB,K,EAAmB,K,EACzC,K,EAAkC,K,UAAmB,KA1PpE,IAC+E,KAyPjD,KAzPiD,IAlEzD,CAAlB,+CAKyC,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,GAJX,EAIW,IAJI,CAAf,MADJ,EACI,IADW,CAAf,oGAGV,E,CAAA,UACW,YAAyB,QAA5B,OAAG,OAAyB,QAA5B,OAAG,SAAyB,QAA5B,GAAG,QAAyB,UAA5B,eADwB,OAAhC,sBACW,SAAyB,QAA5B,UADwB,GAAhC,EAAgC,IAAhC,cAEiC,CAAjC,GAAiC,UAAF,CAAN,GAJX,EAIW,IAJI,CAAf,GAAlB,GADc,EACd,IAD6B,CAAf,GAAlB,mGAeQ,E,CAAA,UACW,YAAyB,QAA5B,OAAG,OAAyB,QAA5B,OAAG,SAAyB,QAA5B,GAAG,QAAyB,UAA5B,eADwB,OAAhC,sBACW,SAAyB,QAA5B,UADwB,GAAhC,EAAgC,IAAhC,cAEkC,CAAlC,GAAyB,K,EAAA,IAAS,YAAF,GAAP,MAJX,EAIW,IAJI,CAAf,GAAlB,GADc,EACd,IAD6B,CAAf,GAAlB,IA0DA,gB,EAAA,8DACsB,gDAGa,KAHb,MAGa,OA/ER,CAAL,QAAF,CAAR,C,EA+EuB,EA/EvB,EA+EY,G,EAAW,K,EAAA,GA/ER,CAAL,QAAF,CAAR,GA+EY,OAFY,GAAhC,EAAgC,IAAhC,aAE+B,KAF/B,MAE+B,OA/ER,CAAL,QAAF,CAAR,C,EA+EuB,EA/EvB,EA+EY,2CAIO,QAAL,I,EAAK,EAAL,EAAF,OAFwB,GAA5C,EAA4C,IAA5C,4CAE2B,UAAL,I,EAAK,EAAL,EAAF,GAAO,WAAL,I,EAAK,EAAL,EAAF,GAAO,WAAL,I,EAAK,EAAL,EAAF,GAAO,WAAL,I,EAAK,EAAL,EAAF,GAFO,EAEP,IAFwB,CAAjB,GAA3B,+BAM+B,KAN/B,MAM+B,OAvFR,CAAL,QAAF,CAAR,C,EAuFuB,EAvFvB,EAuFY,iBAFpB,KAE+B,KAF/B,MAE+B,SAvFR,CAAL,QAAF,CAAR,C,EAuFuB,EAvFvB,EAuFY,GAAW,eAvFR,CAAL,QAAF,CAAR,C,EAuFuB,EAvFvB,EAuFY,GAFO,EAEP,IAFwB,CAAjB,OAVhB,EAUgB,IAVF,CAAd,GAAf,QAiBA,UAEsB,EAFtB,IAEoB,CAAE,iBADG,2CAI8C,EAAtB,MAArC,OAA2D,SAAtB,SACrC,C,EADqC,EACrC,EAAE,QAAuB,UAAF,CAAvB,CAFuB,KAKvB,UADJ,KACgD,GAAL,GAAvC,GAAqC,CADZ,GAAF,GALhB,EAKgB,IALD,CAAf,GAAf,GAHW,EAGX,IAHyB,CAAd,GAAf,IG9BY,KHsJuC,OGtJ3B,KAAM,KHuJnB,WAhNO,CAAlB,2F,CAAA,UAKyC,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,KAAiC,aAAF,CAAN,SAAQ,CAAjC,KAAiC,aAAF,GAAN,OAJI,GAAjC,EAAiC,IAAjC,oBAIqC,CAAjC,GAAiC,aAAF,GAAN,OAJI,GAAjC,EAAiC,IAAjC,QADc,EACd,IAD6B,CAAf,+GAGV,E,CAAA,UACW,YAAyB,QAA5B,OAAG,OAAyB,QAA5B,SAAG,SAAyB,QAA5B,GAAG,QAAyB,UAA5B,eADwB,GAAhC,EAAgC,IAAhC,oBACW,OAAyB,UAA5B,UADwB,GAAhC,EAAgC,IAAhC,cAEiC,CAAjC,GAAiC,UAAF,GAAN,GAJX,EAIW,IAJI,CAAf,GAAlB,GADc,EACd,IAD6B,CAAf,GAAlB,IG0DY,OHsJD,SAhNO,CAAlB,kG,CAAA,UAKyC,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,GAAiC,aAAF,CAAN,SAAQ,CAAjC,KAAiC,aAAF,CAAN,SAAQ,CAAjC,KAAiC,aAAF,GAAN,OAJI,GAAjC,EAAiC,IAAjC,oBAIqC,CAAjC,GAAiC,aAAF,GAAN,OAJI,GAAjC,EAAiC,IAAjC,QADc,EACd,IAD6B,CAAf,+GAGV,E,CAAA,UACW,YAAyB,QAA5B,OAAG,OAAyB,QAA5B,SAAG,SAAyB,QAA5B,GAAG,QAAyB,UAA5B,eADwB,GAAhC,EAAgC,IAAhC,oBACW,OAAyB,UAA5B,UADwB,GAAhC,EAAgC,IAAhC,cAEiC,CAAjC,GAAiC,UAAF,GAAN,GAJX,EAIW,IAJI,CAAf,GAAlB,GADc,EACd,IAD6B,CAAf,GAAlB,IG4D2B,OHgWkB,SA7P3B,CAAlB,yDAI+B,GAJ/B,EAI+B,QACL,CAL1B,E8FrO2B,sBAAD,GAAM,CAA9B,G9F+OM,GALA,yDAC0B,OAAL,GAAH,GAAQ,GAAL,GAAH,GAAQ,GAAL,GAAH,GAAQ,GAAL,GAAH,OADqB,GAAvC,EAAuC,IAAvC,UAKA,IALA,eAC0B,KAAL,GAAH,OADqB,GAAvC,EAAuC,IAAvC,Q8F1OmB,sBAAD,GAAM,CAA9B,SACM,CAAJ,C9F4OiB,MAAO,wBAGG,KAAL,GAAwB,KAA3B,CACF,EAJO,EAIP,C,CAJO,EAEF,EAEL,IAF0B,CAArB,GAAlB,MAGQ,KAAgB,MAIjB,OAhBO,EAgBP,IAhBuB,CAAhB,GAAlB,GADc,EACd,IAD6B,CAAf,OG7DV,IACI,CADJ,EAEmB,QAGnB,KF2pDE,iBAImB,WAzpCd,KAAuB,OAAV,KAArB,WAAsC,CAypChB,EAC7B,QAloCsB,MAEP,KADW,KAAT,KACV,iBAmoCH,GAnoCG,KAqoCE,KAv6BK,OA9NP,KA8NC,CAu6BJ,EAAgB,KA/pCL,KAAuB,OAAV,KAArB,WAAsC,CA0pC7C,IASc,KAnqCC,KAAuB,OAAV,KAArB,WAAsC,CAmqC/B,EACd,QA5oCsB,MAEP,KADW,KAAT,KACV,eA4oCH,GA7lCW,SAAP,GAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EA+lCO,KAClB,OAEK,KAD6B,QAl7BxB,KAAN,GAm7BJ,EAD6C,QAC7C,EAAe,KACE,OA5qCN,KAAuB,OAAV,KAArB,WAAsC,CAoqC7C,IAYc,KAhrCC,KAAuB,SAAV,KAArB,WAAsC,CAgrC/B,EACd,QAzpCsB,MAEP,KADW,KAAT,KACV,kBA6pCM,KA/7BC,OA9NP,KA8NC,CA+7BA,OAAgB,CA7pCT,EA6pCS,IACA,GAxrCT,QAAuB,OAAV,KAArB,C,EAAA,UAAsC,CAirC7C,IAW6B,KAAY,EAAO,KAAP,GAAnB,GAAtB,MAnnCQ,WACS,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHJ,EAqnCe,aACO,OAMd,O,CAAA,EACI,OAAK,CAAL,EAAK,IACA,GACjB,GAAgB,qBAAL,iBAAe,CAAV,EAAU,MACP,GACnB,OAAuB,GACnB,OAEK,KAr9BH,KAo9B4B,MAp9BlC,GAq9BI,EADyC,QACzC,EAAe,KAEnB,G6Fl4DmB,sBAAD,GAAM,CAA9B,K7F04DkB,OAAL,C6F14Db,IACM,CAAJ,C7Fw4Dc,UAAe,CACpB,CADa,EAKb,KAn+BC,KAg+BM,MAh+BZ,GAm+BA,EAFY,QAEZ,MAAe,GAv3Bb,E6FvhCiB,sBAAD,GAAM,CAA9B,SACM,CAAJ,C7FshCqB,KAAM,EAAO,KAAP,CAAd,CACD,EAAK,KAAL,MA7HkB,CA8H1B,EAIQ,EACA,EADA,KACA,UAEZ,GAPI,KAIQ,EAGZ,2BAGY,QAAe,OAAf,QAAe,OAAf,QAAe,OAAf,QAAe,OAAf,QAAe,GAAf,SAAe,KAAf,OAAe,KAAf,OAAe,KAAf,OAAe,KAAf,OAAe,OAAf,OAAe,OAHF,KAAY,GAArC,IAq3BI,EAr3BJ,MAq3BI,GAAe,KAGL,QADA,eAIE,GAEgB,KAAV,EADU,KACA,EAAV,C,EAGY,UAA9B,CAAQ,CAHoB,EAAV,KAG+B,MACvB,sBACI,OACA,IACL,QAAH,GACd,OAMK,KAhgCP,KA6/Bc,MA7/BpB,GAggCQ,EAFY,QAEZ,MAAe,GACG,OAClB,OAIK,KAHO,QAngCd,KAAN,GAsgCQ,EAFY,QAEZ,EAAe,KACH,OAAK,GAGI,cAOpB,GAGD,KAAa,OAAV,CAAH,EAAG,MACA,KAIH,SAAU,CAAV,EAAU,SACA,QAuGI,E,EAAA,IAnGV,CAmGU,EAhzCf,EA8sCP,EA9sCO,GAAP,EA8sCA,EA9sCA,G,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EA+zBA,kBADA,iBAGA,8CAGS,UACI,SAKR,SAEC,GAFD,EAEC,MAHD,SAEC,GAFD,EAEC,MAIF,UACI,SAAK,eAEA,GACZ,mBAFgB,CAAJ,CAuCT,GAKvB,GAzCkC,OAAK,aAEP,GACZ,eAFgB,CAmCb,GAKvB,eApC+B,mBAMX,GAyBG,OAKvB,GA3B2B,OAAS,CAAT,EAKO,IAKF,GACZ,SAWG,EAtBa,QACT,G,CAEO,EAFP,IAEO,G,CAAA,QAEA,GAiBX,GAKvB,WAb+B,uBAKX,GAGG,OAKvB,GA3D4C,SAAwB,GAA5D,GADgC,SAAwB,GAA5D,GAj0BQ,I,CAAA,EACS,UAAL,EAAR,GAEa,KAAY,QAAjB,GAmfe,MAOP,CAPO,EAOP,WAgYxB,G6FznD+B,sBAAD,GAAM,CAA9B,K7F2wCc,I6F3wCd,IACM,CAAJ,C7F0wCY,EAAO,MAgsBf,GAGmB,SAAL,MAEJ,+BAWI,SAAL,eAloCS,CAkoCT,EACT,IA/nCwB,MAioCjB,WAKW,SAlpCG,IAkpCH,EAClB,IACW,OACS,OAroCH,QAuoCb,SAOQ,CAPR,EAQuB,OAAR,OAIC,SADiB,CAAb,GAEpB,GAOuB,KAFD,SACT,IAAgC,MAC3B,EAEF,MACV,KAIY,EAJZ,IAIgC,CAApB,IAEH,SAzwCZ,SAAP,GAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EA2wCI,GAAK,KA15BD,EAIH,EAJG,YAIH,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,O,GAAA,E,CAAA,E,EAAA,K,GAAA,E,CAAA,UAJG,EAm6BH,YAn6BG,EAm6BH,EACZ,CAAO,GAAmC,QAAV,GAEM,UAC9B,EAAK,eACI,C,EADJ,KACI,MAIH,eACG,aACA,QACS,QAAP,SACd,CADc,EACd,CAAkB,KAMf,KAAyB,KACf,sBA/sCM,IA+sCN,EACX,IACI,OACS,OAtsCH,QAwsCb,SAOQ,CAPR,EAOQ,MACQ,CAAQ,CAAR,GACF,OAIE,GADC,OAEjB,GAGwB,WACZ,CAAQ,C,EAAR,GACF,SAGV,GAHU,EAIV,UAGuB,UAAL,EACF,UAGV,GAKU,cADE,WAGT,GADC,OADJ,aAII,WADQ,K,EAAA,EAGW,GACnB,eACI,aACD,QACU,QAAP,SACf,CADe,EACf,CAAmB,YACV,CADU,EA31CjB,EA41CO,EA51CP,GAAP,EA41Cc,EA51Cd,CAAO,EACE,UAAL,EAAR,GAEa,KAAY,QAAjB,GAHG,EAyjBC,MADA,Q,EAEA,SAIG,E,CAJH,EAIG,M,EAAA,WAAoB,WAApB,mC,EAAA,WAJH,EAqBH,qCAMM,EANN,MAII,OAEE,CAtaX,GA0agB,E,EAVX,EAUW,EALP,OAKO,UACF,EA1lBd,SACS,KAAL,GAAK,KAAL,CAAR,GAEyB,QAAjB,GAAK,KAAL,EA4lBQ,GAAK,SAIL,GAKxB,GAtB8B,EAsB9B,IAtB+C,CAAjB,GAAtB,yBACa,OAEE,GAHf,EAnaI,GA0agB,CAPpB,EAOoB,C,EAPpB,EAOoB,EALP,OAKO,UACF,EA1lBd,SAGqB,QAAjB,GAAK,KAAL,CAAR,GAFa,KAAL,GAAK,KAAL,EA8lBQ,GAAK,WAIL,GAKxB,GAtB8B,EAsB9B,IAtB+C,CAAjB,GAAtB,yBACa,OAEE,GAHf,EAnaI,GA0agB,CAPpB,EAOoB,C,EAPpB,EAOoB,EALP,OAKO,UACF,EA1lBd,SAGqB,QAAjB,GAAK,KAAL,CAAR,GAFa,KAAL,GAAK,KAAL,EA8lBQ,GAAK,WAIL,GAKxB,GAtB8B,EAsB9B,IAtB+C,CAAjB,GAAtB,yBACa,OAEE,GAHf,EAnaI,GA0agB,CAPpB,EAOoB,C,EAPpB,EAOoB,EALP,OAKO,YACF,EA1lBd,SAGqB,QAAjB,GAAK,KAAL,CAAR,GAFa,KAAL,GAAK,KAAL,EA8lBQ,GAAK,WAIL,GAKxB,GAtB8B,EAsB9B,IAtB+C,CAAjB,GAAtB,K,EAsBR,GA7BQ,kB,EAkxBoB,IACF,GACV,SACJ,OAnwCkB,CAmwClB,EACO,QACP,GACJ,OAlwC4B,MAkwC5B,EAAW,QACP,GACJ,OAhwCqB,MAgwCrB,EACI,SACJ,WAAkB,WACE,GACpB,OACoB,QAvPwC,CAAhB,EAAnB,KAAY,EAAO,KAAP,CAAnB,GAAtB,MA/BI,kBASA,kBAgRJ,cACsB,GADtB,EACA,iBACsB,CADtB,EACsB,CACM,KAAgB,KAAV,CAChB,KAAV,CAA6B,KAAV,CAAiC,KAAV,CAChC,KAAV,C,EAFoB,EAEpB,EAA+B,OAAV,GAFX,GAFI,EAEJ,IAF2B,CAAvB,SE77Dd,EAGJ,GACc,E,wBFy5FtB,M,8ZACI,IACA,OAAgB,G,uFAAhB,E,KE35FkB,K,EAAmB,UAAC,C,oCF85FlC,E,uCAMY,UAAY,S,4BAAA,EAOQ,QAAT,CAAF,IACrB,KAEQ,M,GAFR,SAEQ,E,QAAA,E,KACJ,E,CAAA,EArKZ,KAsKY,EArK+B,IAAjB,O,UAAA,EA7DW,YAgE7B,U,SAhEgC,CAgEhC,mBAHkB,EAGlB,E,UAAA,E,SAIA,IACwB,kB,UAAA,E,SAExB,IACwB,kB,UAAA,E,SAExB,IACwB,kB,UAAA,E,SAExB,IACwB,sB,UAAA,E,SAEmB,uBAAQ,CAAR,aACjB,CAAN,kB,UAAA,E,SAEuB,uBAAQ,CAAR,WACjB,GAAN,iB,IAI5B,K,uBAAA,KAE6B,CACO,OADA,QAEJ,UAE5B,wC,eAAA,K,wBAGQ,I,IAAA,KACmB,CAAD,CAAF,YACG,CAAD,CAAF,MAOF,SAAL,QAAY,CAAf,SAAQ,EAAR,aAAQ,EAUV,EAVU,EAAR,EACF,CASA,GACK,KAAP,EADK,YAAY,MAAY,CAA3B,SAAG,EAAH,aAAG,EACL,MAhBI,GAWG,E,EAXK,SAAL,QAAY,CAAf,WAAQ,EAAR,aAAQ,EAAR,MACF,I,EAUK,KAAP,EADK,YAAY,MAAY,CAA3B,WAAG,EAAH,aAAG,EACL,QAuBc,G,eAvBP,MAVL,EAUK,EAuBO,EADxB,O,iBAG6B,OAAiB,KAAN,GAAlB,I,QAAwB,EAC1C,E,YAAA,W,iBAAA,IAD0D,CAAhB,EAAjB,OAAiB,KAAN,CAAlB,GAAtB,K,YAIA,G,iBACJ,K,uBAuFI,I,EACQ,E,YAAA,E,0BAnOZ,E,YAEQ,G,sBAAA,I,UAAA,E,SAGA,Q,YApBuB,E,YAqBnB,M,YAzBiB,E,YA2BV,M,YAnBY,E,YAqBZ,M,YAjBa,E,YAmBb,S,YA/BU,E,YAkCd,M,YA9BgB,E,YAgChB,M,YA5BgB,E,YA8BhB,M,YA1BiB,E,YA4BjB,E,gBAAA,E,gBAkCf,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,gBAAA,E,SAJe,SAIf,K,MA6KqB,G,KAEwB,M,EAzT7C,K,uBAnjEmB,SAAP,KAAO,EACE,UAAL,EAAR,GAEa,OAAY,QAAjB,GAHG,EA6jE4B,KAAnB,QAPR,QADA,QASJ,eAAI,UACW,KAAZ,IACf,GAC0B,KAAX,GACf,GAC0B,KAAX,C,EAAA,KAEY,KAAZ,E,GAAA,QASK,iBAJI,IAGG,cAAE,UAAiB,MAAK,YAL1C,CAKkD,CAAX,CAAF,CAApB,CAAF,SADT,CAAY,cAAE,UAAiB,QAAS,UAL9C,CAKkD,CAAX,CAAF,CAApB,GAAF,GAoBP,OALA,SAUjB,6C,eAAA,K,iBALU,EAVE,IASa,CACf,G,EAAA,OAKV,QApBY,OAsBM,C,EAZR,EAYQ,IAbO,CACf,G,EAAA,OAVE,QAKA,OAiBqB,C,EACxB,K,eAHT,IApBY,EAKA,EAiBM,EAAe,EACxB,EAFT,K,iBAAA,IAI6B,OAAiB,KAAN,GAAlB,I,QAAwB,EAC1C,E,YAAA,W,iBAAA,IAD0D,CAAhB,EAAjB,OAAiB,KAAN,CAAlB,GAAtB,K,YAIA,G,iBApRJ,M,uBAjBA,Q,uBAkBI,EAlBJ,wBAkBI,EAlBJ,GAIc,K,CADa,SAGS,UACpB,OAAuB,CADwB,E,EAAA,GAN/D,EAM+D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,OAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,8F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,0F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,QAeU,G,CADa,SAGS,UACpB,QAAuB,CADwB,E,EAAA,GAjB3D,EAiB2D,IAjBpB,iBAVzB,IAUd,sF,EAAA,K,EAAA,K,EAAA,M,eAAA,W,iBAAA,MAeU,GADa,SAGS,YACpB,QAAuB,CADwB,YAjBpB,iBAVzB,IAUd,sF,EAAA,K,EAAA,K,EAAA,K,eAAA,W,iBA0BJ,M,2BAKuB,KACG,GADH,Q,KAAA,EACG,wBAxDR,M,GAAA,cAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,SAMxB,+B,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,IAoE2C,U,eAAA,S,WAAA,G,KAAA,OA9CC,iBAJ9B,IAId,E,GAAA,iB,GAAA,iB,GAAA,iB,GAAA,6D,EAAA,M,EAAA,M,eAAA,qB,iBAAA,aAhCc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,IAoE2C,U,eAAA,S,WAAA,G,KAAA,OA9CC,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,aAhCc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,IAoE2C,U,eAAA,S,WAAA,G,KAAA,OA9CC,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,aAhCc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,IAoE2C,U,eAAA,S,WAAA,G,KAAA,OA9CC,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,aAhCc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,IAoE2C,U,eAAA,S,WAAA,G,KAAA,OA9CC,iBAJ9B,IAId,E,GAAA,W,GAAA,a,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,eAAA,G,KAAA,aAhCc,M,GAAA,cAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,SAMxB,+B,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,aAVc,iBAIU,OAMwB,UALX,KAAnB,IAAT,CADe,UAEa,KAAnB,IAAT,GAFe,IAMxB,wB,GAAA,iB,GAAA,Q,GAAA,oD,EAAA,M,EAAA,M,EAAA,M,eAAA,W,iBAAA,IA8D0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,iB,GAAA,iB,GAAA,iB,GAAA,6D,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,uD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,0F,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,0F,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAwC0C,U,eAAA,S,WAAA,G,KAAA,OAxCE,iBAJ9B,IAId,0F,EAAA,M,EAAA,M,eAAA,qB,eAAA,G,KAAA,uB,KAAA,MA0BwB,KA7DV,G,QAmCd,E,KAnCc,QAGA,UACI,GAAK,CAAd,CADK,UAKM,OAAiB,MAAnB,IAAT,CADe,UAEa,MAFb,E,GAAA,mBAMwB,UAJ9B,IAAT,GAFe,IAMxB,4F,EAAA,M,EAAA,M,EAAA,M,eAAA,W,kBAAA,IA+C+C,KAArB,GAAtB,I,GAAA,G,KAAA,gBAwBmB,gBAEkB,E,EAAA,K,GAtF3B,E,MAsF2B,E,KAtF3B,QAGA,UACI,GAAK,CAAd,CADK,UAKM,OAAiB,MAAnB,IAAT,CADe,UAEa,MAFb,E,GAAA,mBAMwB,UAJ9B,IAAT,GAFe,IAMxB,E,GAAA,W,GAAA,kB,GAAA,6D,EAAA,M,EAAA,M,EAAA,M,eAAA,W,kBAAA,MA4EqC,UAAL,EAn/DZ,MACV,G,GAk/D2B,E,KAl/D3B,cAGqB,IAi/DH,OAAwB,c,eAAA,S,WAAA,I,KAAA,OAxDR,YAJ9B,UACI,GAAK,CAAd,GADK,IAId,E,GAAA,W,GAAA,W,GAAA,W,GAAA,qD,EAAA,M,EAAA,M,eAAA,qB,iBAAA,IAkDmC,KAAT,GAAtB,K,KAzBA,OA0C8C,iBAJhC,IAId,sH,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,8F,EAAA,M,EAAA,M,EAAA,IAAyB,G,eAAzB,EAAyB,EAAzB,iB,iBAAA,OAA8C,iBAJhC,IAId,2FAAyB,G,EAAzB,M,EAAA,M,EAAA,M,eAAA,EAAyB,EAAzB,iB,cAAA,M,GAAA,EAGK,E,MAAA,I,EAAA,IAEqB,C,GAAA,E,MAFrB,E,KAG2E,OAA5D,S,eAAA,S,iBACpB,G,YACoB,S,oBAAA,OAOwB,IAA5C,6E,EAAA,K,EAAA,M,eAAA,qB,kBAGQ,OAAU,I,QAAV,E,YAKiB,IAAzB,EAAyB,G,WAAA,G,KAAA,OACT,IADhB,6E,EAAA,K,EAAA,K,eAAA,qB,kBAGR,M,uBA6MA,K,kCA8PgB,S,QAAA,E,KA1FhB,K,yBACc,OACC,CADD,EACV,gBACkB,OAAyB,UAAY,GAAvB,EACxB,KAAqC,KACjB,gBAElB,OALC,CAAX,I,uBAAA,EAQkC,UAAY,CAAtB,K,uBAAA,EAEpB,IAOyB,QALL,KAsCxB,iB,eAAA,c,iBAAA,KACQ,CAAgB,QAAxB,GADA,EACqC,GAClB,Y,eAAA,Q,WAAA,G,KAAA,OACnB,UAA2B,GAA3B,K,eAA2B,QAA3B,K,iBACJ,K,uDAmCQ,E,kEAI+C,E,sLAAtB,Q,eAAA,S,WAAA,G,KAAA,OACK,gBAAjB,KADb,gG,EAAA,K,EAAA,K,eAAA,qB,07Q0E/mGR,K,uBAAA,MACS,KAES,aAAY,GAAqC,SAAO,CAAf,EAclC,YAA0B,CAAE,YAAkB,CAApB,C,EX0WlC,KAGb,EACM,GACK,GAAQ,GAArB,GW/WD,KA6BD,K,yBCtDA,EDsDA,ECrDsB,C0CDtB,KACO,CADP,E,IAEE,EAAQ,GAAF,M,+gELAR,O,uBAIM,WAAK,EAAL,EAAS,OAAJ,GAAiB,SAAP,SAEpB,IACO,OAAG,EAAH,EAAG,QAAG,U,EAAA,aAAN,WAAgD,GAA7C,UACH,GAAG,aAAI,QAAD,MAAb,EAAO,WAAgD,GAA7C,MAEX,K,2BCZM,EDYN,KCZG,GACK,G,EADL,IACK,G,4kLxECP,E,EAAA,QACgB,KAChB,GADgB,MADhB,G,kDAEA,IADU,M,qSlCFX,SAIQ,G8GLR,KACO,GADP,E,IAEE,EAAQ,GAAF,M,8OrH0nGJ,M,2BAAA,E,EAAA,I,YApCI,G,iBAAA,EACA,K,OEh6Fc,QACF,MAXD,E,KAWC,IAIL,KAAK,I,YAnBR,G,mBAAA,EAAR,Q,KAsBA,EAxIU,GAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACA,KA0HA,KF6oBU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACU,KAAV,GACoB,MA3lBP,KAAb,GACA,K,EAwkBU,GAAV,G,EACU,GAAV,G,EACU,GAAV,G,EACU,GAAV,G,EACU,GAAV,G,EACyB,GAxIZ,KAAb,GACa,KAAb,GACA,K,EAuIyB,GAzIZ,KAAb,GACa,KAAb,GACA,K,EAwIyB,IA1IZ,KAAb,GACa,KAAb,GACA,K,EAyIU,IAAV,G,EACU,GAAV,GA8rDJ,M,uBACI,E,GAAA,e,GAAA,e,GAAA,iB,GAAA,iB,GAAA,iC,eAAA,K,iBACA,E,GAAA,e,GAAA,e,GAAA,e,GAAA,e,GAAA,iC,eAAA,K,iBAGQ,E,GAAA,a,GAAA,0B,eAAA,K,iBAAA,E,GAAA,a,GAAA,0B,eAAA,K,iBAAA,E,GAAA,a,GAAA,0B,eAAA,K,iBAAA,E,GAAA,a,GAAA,0B,eAAA,K,iBAAA,E,GAAA,a,GAAA,0B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,c,GAAA,4B,eAAA,K,iBAAA,E,GAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,0C,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,oD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,qCAAc,CAAd,e,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,wC,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAAA,gD,eAAA,K,iBAGR,oE,kMACA,uC,eAAA,K,iBACA,6C,eAAA,K,iBACA,6C,eAAA,K,iBACA,gB,EAAA,6B,eAAA,K,iBACA,4C,eAAA,K,iBACA,uC,eAAA,K,iBACa,MAAb,I,YACA,G,iBACJ,M,uBEr1EA,M,8cAAA,C,6CA2QI,G,gBAAA,E,27nB4GncwB,Q,EAAA,E,ECb3B,G,SDa2B,kBACL,CAAS,GAAY,SAAD,KAAzC,SAA0D,OAAV,YAAK,KAAhC,CAAS,SACvB,KAAI,KAAJ,OAEC,CAAiB,SAAI,KAAD,oBAA5B,EAC0C,WAAR,OAAN,OAApB,KADA,CAAiB,IAKjB,MAAO,SAAD,KAAf,SAAgC,OAAL,OAAL,CAAb,eAET,K,SAAA,C,m4oCxBZD,K,6BAGC,Q,YmC4uBD,cACQ,G,mBnC1uBP,K,o9pGqCaD,M,uBAG0B,IAAP,MAA2B,GAA3B,WACb,OAAI,4CAQJ,I,SACE,MF0sBA,S,UE1sBA,G,KAAP,M,m/QD5CO,I,cDsvBA,ICtvBA,IDsvBA,S,+e/D9sBY,EAAZ,K,mDAAY,EAAZ,K,wuDAAY,EAAZ,K,mDAAY,EAAZ,K,sjBtDrBC,EDoOa,G,SAAA,EAAa,CAApB,G,SACb,K,SAEY,S,SACR,EAJgB,EAIhB,IAAU,IACR,S,SACF,EADE,EACF,IAAU,IACR,S,SACF,EADE,EACF,IAAU,IACR,S,SACF,EADE,EACF,IAAU,IACR,S,SACF,EADE,EACF,IAAU,IAEF,E,KAAA,EE6XZ,O,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GAGA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GAYA,S,UAAA,G,GACA,S,UAAA,GAIF,KAHE,S,SAAA,EF3iBI,I,KAAY,EEsVhB,M,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GAGA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,GAeF,EAdE,W,SAAA,EFpWI,I,KAAY,EGhFhB,M,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GAKA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GAKA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,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"} \ No newline at end of file diff --git a/docs/assets/nmmo3_thumbnail.png b/docs/assets/nmmo3_thumbnail.png new file mode 100644 index 0000000..f24700d Binary files /dev/null and b/docs/assets/nmmo3_thumbnail.png differ diff --git a/docs/games.js b/docs/games.js index 2d8ac77..ad349c3 100644 --- a/docs/games.js +++ b/docs/games.js @@ -1,7 +1,43 @@ const games = { +/* + nmmo3: { + title: "Neural MMO 3", + description: `A massively multiagent environment with progression and an agent-driven economy. By Joseph Suarez. + +A spiritual successor to Neural MMO 1-2. Explore, forage, fight, and trade in a massive procedurally generated open world. It's playable and quite fun, so I'm not going to tell you much. Your combat and profession levels are displayed overhead. The max in this demo is 40 for each. It starts off hard but you will discover some tricks... probably. Good luck! + +This environment supports configurable difficulty and scale. We are running a medium size map (512x512), but with only 8 agents for browser compatibility. The same map runs 1024 locally. + +Controls: + Move (1st person) or pan (3rd person): W/A/S/D or Arrow keys Sprint (1st person) or increase pan/zoom speed (3rd person): Left shift Use item: Number keys + Attack: Space + Buy/sell: B/V + Debug: H + Switch view: Tab + Zoom (3rd person): Q/E + +Observations: 2D crop of nearby tiles (discrete), 1D vector of self data (mixed discrete/continuous) +Actions: Discrete. Move, sprint, attack, use item, buy, sell`, + thumbnail: "assets/nmmo3_thumbnail.png", + path: "assets/nmmo3/game.html", + width: 960, + height: 704, + }, +*/ moba: { title: "Puffer MOBA", - description: "A Multiplayer Online Battle Arena (MOBA) inspired by games like DoTA and League of Legends. Click to move, Q/W/E for skills. Number keys to switch characters. By Joseph.", + description: `A Multiplayer Online Battle Arena (MOBA) inspired by DoTA and OpenAI Five. By Joseph Suarez. + +This is a 5v5 mirror match with 5 unique characters, each with three unique skills. Your objective is to destroy the enemy base on the other side of the map. There game map has three lanes, each of which contains three towers that will automatically attach nearby enemies. Waves of minions will spawn from each team's base and travel down each lane, fighting each other and towers along the way. In the current version, enemy units are controlled by a simple scripted AI. This environment can also be trained with self-play. + +Controls: + Move: Click or click and hold + Attack: Automatic + Use skill: Q/W/E + Switch character: Number keys + +Observations: 2D crop of nearby tiles (mixed discrete/continuous), 1D vector of self data (mixed discrete/continuous) +Actions: Multi-discrete. Move, use skills`, thumbnail: "assets/moba_thumbnail.png", path: "assets/moba/game.html", width: 1312, @@ -9,7 +45,14 @@ const games = { }, tactics: { title: "Puffer Tactics", - description: "A turn-based tactical combat game. Inspired by games like Fire Emblem and the popular MMO Dofus. By Nathan. Click to move, number keys to select skills.", + description: `A turn-based tactical combat game inspired by the popular MMO Dofus. By Nathan Lichtlé. + +Combat is similar to CRPGs, D&D, and other tactical turn-based games played on a grid. This environment is missing scripted opponent AI and a trained policy. + +Controls: + Move: Click + Select skill: Number keys + Use skill: Click`, thumbnail: "assets/tactical_thumbnail.png", path: "assets/tactical/game.html", width: 1200, @@ -17,7 +60,12 @@ const games = { }, go: { title: "Go", - description: "The ancient board game of territory control and strategic placement. By Spencer. Click to place a stone.", + description: `The ancient board game of territory control. By Spencer Cheng. + +Controls: Click to place a stone or pass + +Observations: 2D tile grid (discrete) +Actions: Discrete. Place a stone, pass`, thumbnail: "assets/go_thumbnail.png", path: "assets/go/game.html", width: 950, @@ -25,66 +73,127 @@ const games = { }, snake: { title: "Multiagent Snake", - description: "A multiplayer version of classic snake. By Joseph. W/A/S/D to move.", + description: `Play with one snake or thousands. By Joseph Suarez. + +Controls: W/A/S/D or Arrow keys to move + +Observations: 2D crop of nearby tiles (discrete) +Actions: Discrete. Move`, thumbnail: "assets/snake_thumbnail.png", path: "assets/snake/game.html", width: 1280, height: 720, }, - tripletriad: { - title: "Triple Triad", - description: "A card game inspired by Final Fantasy. By Spencer. Num keys to select cards, click to place.", - thumbnail: "assets/tripletriad_thumbnail.png", - path: "assets/tripletriad/game.html", - width: 990, - height: 1000, - }, - pong: { - title: "Pong", - description: "A fast version of the classic Atari game. By Nathan. W/S to move.", - thumbnail: "assets/pong_thumbnail.png", - path: "assets/pong/game.html", - width: 620, - height: 640, + enduro: { + title: "Enduro", + description: `A fast version of the classic Atari game. By Daniel Addis. + +Score points by passing cars. Pass enough cars before time runs out to move on to the next day. + +Controls: + Move: A/D or Left/Right + Accelerate: Space + Brake: S or Down + +Observations: 1d vector (continuous) +Actions: Discrete. Move, accelerate, brake`, + thumbnail: "assets/enduro_thumbnail.png", + path: "assets/enduro/game.html", + width: 304, + height: 420, }, breakout: { title: "Breakout", - description: "A fast version of the classic Atari game. By Noah, physics enhanced by David. A/D to move, W to fire.", + description: `A fast version of the classic Atari game. By Noah Farr with physics enhancements by David (dmoore101). + +Break two screens of bricks before losing all five lives to win. + +Controls: + Move: A/D or Left/Right + Fire: W or Up + +Observations: 1d vector (continuous) +Actions: Discrete. Move, fire`, thumbnail: "assets/breakout_thumbnail.png", path: "assets/breakout/game.html", width: 576, height: 330, }, - enduro: { - title: "Enduro", - description: "A fast version of the classic Atari game. By Bet. A/D to steer, space to accelerate.", - thumbnail: "assets/enduro_thumbnail.png", - path: "assets/enduro/game.html", - width: 304, - height: 420, + pong: { + title: "Pong", + description: `A fast version of the classic Atari game. By Nathan Lichtlé. + +First player to score 21 goals wins. + +Controls: W/S or Up/Down to move +Observations: 1d vector (continuous) +Actions: Discrete. Move`, + thumbnail: "assets/pong_thumbnail.png", + path: "assets/pong/game.html", + width: 620, + height: 640, }, - connect4: { - title: "Connect4", - description: "The classic two-player board game. By Spencer, AI enhanced by Jake. Num keys to play in col.", - thumbnail: "assets/connect4_thumbnail.png", - path: "assets/connect4/game.html", - width: 672, - height: 576, + tripletriad: { + title: "Triple Triad", + description: `A card-based minigame from Final Fantasy. By Spencer Cheng. + +When a card is placed next to an opponent's card, the numbers of both cards on that edge will be compared. The higher number card captures the lower number card, converting its color. At the end of the game, the player with the most cards of their own color on the board wins. + +Controls: + Select card: Number keys + Place card: Click + +Observations: 1D vector (continuous) +Actions: Discrete. Select card, place card`, + thumbnail: "assets/tripletriad_thumbnail.png", + path: "assets/tripletriad/game.html", + width: 990, + height: 690, }, rware: { title: "RWare", - description: "Port of the robot warehouse environment RWare to C. By Spencer. W to move, A/D to turn, Enter to load a box.", + description: `Port of the robot warehouse environment RWare to C. By Spencer Cheng. + +Controls: + Move forward: W or Up + Turn left: A or Left + Turn right: D or Right + Load/drop box: Space or Enter + +Observations: 1D flat crop of nearby tiles (continuous) +Actions: Discrete. Move, turn, load/drop box`, thumbnail: "assets/rware_thumbnail.png", path: "assets/rware/game.html", width: 640, height: 704, }, + connect4: { + title: "Connect4", + description: `The classic two-player board game. By Spencer, with opponent AI by Jake Forsey + +Be the first player to get four of your pieces in a row horizontally, vertically, or diagonally to win. + +Controls: Num keys 1-7 to drop a piece in that column + +Observations: 1D vector board state (continuous) +Actions: Discrete. Play piece`, + thumbnail: "assets/connect4_thumbnail.png", + path: "assets/connect4/game.html", + width: 672, + height: 576, + }, }; const wip = { tcg: { title: "TCG", - description: "Prototype of a trading card game inspired by MTG. By Joseph. Num keys to select a card/target, Enter to confirm.", + description: `Prototype of a trading card game inspired by MTG. By Joseph Suarez. + +Currently supports playing lands and minions with no abilities. Help us continue development! + +Controls: + Select card: Num keys + Confirm: Enter`, thumbnail: "assets/tcg_thumbnail.png", path: "assets/tcg/game.html", width: 1080, @@ -92,7 +201,16 @@ const wip = { }, robocode: { title: "Robocode", - description: "A port of the Java programming challenge Robocode to C. By Joseph. W/S to move, A/D to turn, Space to fire.", + description: `Port of the Java programming challenge Robocode to C. By Joseph Suarez. + +Really cool tank battle environment that wouldn't take much work to finish. Help us continue development! + +Controls: + Move forward: W or Up + Move backward: S or Down + Turn left: A or Left + Turn right: D or Right + Fire: Space`, thumbnail: "assets/robocode_thumbnail.png", path: "assets/robocode/game.html", width: 768, @@ -100,4 +218,3 @@ const wip = { }, } - diff --git a/docs/main.js b/docs/main.js index 60f5c68..feff7fb 100644 --- a/docs/main.js +++ b/docs/main.js @@ -45,6 +45,7 @@ function loadGame(game) { featured.src = game.path; document.querySelector('.game-info .game-title').textContent = game.title; + document.querySelector('.game-description').style.whiteSpace = 'pre-wrap'; document.querySelector('.game-description').textContent = game.description; }