diff --git a/index.data b/index.data new file mode 100644 index 0000000..c3edc28 Binary files /dev/null and b/index.data differ diff --git a/index.html b/index.html index d8728f0..9c9ba39 100644 --- a/index.html +++ b/index.html @@ -1,27 +1,225 @@ - - - - - - 나의 첫 정적 웹사이트 + + + + + + Emscripten-Generated Code - - -

hello!

- - \ No newline at end of file + + +
+
Downloading...
+
+ +
+ +
+
+ Resize canvas + Lock/hide mouse pointer +     + + | + + + +
+ +
+ +
+ + + + + + diff --git a/index.js b/index.js new file mode 100644 index 0000000..dfc1524 --- /dev/null +++ b/index.js @@ -0,0 +1,14888 @@ +// Support for growable heap + pthreads, where the buffer may change, so JS views +// must be updated. +function GROWABLE_HEAP_I8() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP8; +} +function GROWABLE_HEAP_U8() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU8; +} +function GROWABLE_HEAP_I16() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP16; +} +function GROWABLE_HEAP_U16() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU16; +} +function GROWABLE_HEAP_I32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAP32; +} +function GROWABLE_HEAP_U32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPU32; +} +function GROWABLE_HEAP_F32() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPF32; +} +function GROWABLE_HEAP_F64() { + if (wasmMemory.buffer != HEAP8.buffer) { + updateMemoryViews(); + } + return HEAPF64; +} + +// 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; + +// Three configurations we can be running in: +// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false) +// 2) We could be the application main() thread proxied to worker. (with Emscripten -sPROXY_TO_WORKER) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false) +// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true) +// The way we signal to a worker that it is hosting a pthread is to construct +// it with a specific name. +var ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && self.name?.startsWith("em-pthread"); + +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? + var worker_threads = require("worker_threads"); + global.Worker = worker_threads.Worker; + ENVIRONMENT_IS_WORKER = !worker_threads.isMainThread; + // Under node we set `workerData` to `em-pthread` to signal that the worker + // is hosting a pthread. + ENVIRONMENT_IS_PTHREAD = ENVIRONMENT_IS_WORKER && worker_threads["workerData"] == "em-pthread"; +} + +// --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: C:\Users\tymmkang\AppData\Local\Temp\tmpyjlnr784.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 = "bin/AxmolTestbed/index.data"; + var REMOTE_PACKAGE_BASE = "index.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 + }))).then(// If fetch fails, rewrite the error to include the failing URL & the cause. + 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 => 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); + } + function runWithFS(Module) { + function assert(check, msg) { + if (!check) throw msg + (new Error).stack; + } + Module["FS_createPath"]("/", "axslc", true, true); + Module["FS_createPath"]("/axslc", "custom", true, true); + Module["FS_createPath"]("/", "fonts", true, true); + Module["FS_createPath"]("/", "res", 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"]); + } + var PACKAGE_UUID = metadata["package_uuid"]; + var IDB_RO = "readonly"; + var IDB_RW = "readwrite"; + var DB_NAME = "EM_PRELOAD_CACHE"; + var DB_VERSION = 1; + var METADATA_STORE_NAME = "METADATA"; + var PACKAGE_STORE_NAME = "PACKAGES"; + function openDatabase(callback, errback) { + if (isNode) { + return errback(); + } + var indexedDB; + if (typeof window === "object") { + indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + } else if (typeof location !== "undefined") { + // worker + indexedDB = self.indexedDB; + } else { + throw "using IndexedDB to cache data can only be done on a web page or in a web worker"; + } + try { + var openRequest = indexedDB.open(DB_NAME, DB_VERSION); + } catch (e) { + return errback(e); + } + openRequest.onupgradeneeded = event => { + var db = /** @type {IDBDatabase} */ (event.target.result); + if (db.objectStoreNames.contains(PACKAGE_STORE_NAME)) { + db.deleteObjectStore(PACKAGE_STORE_NAME); + } + var packages = db.createObjectStore(PACKAGE_STORE_NAME); + if (db.objectStoreNames.contains(METADATA_STORE_NAME)) { + db.deleteObjectStore(METADATA_STORE_NAME); + } + var metadata = db.createObjectStore(METADATA_STORE_NAME); + }; + openRequest.onsuccess = event => { + var db = /** @type {IDBDatabase} */ (event.target.result); + callback(db); + }; + openRequest.onerror = error => errback(error); + } + // This is needed as chromium has a limit on per-entry files in IndexedDB + // https://cs.chromium.org/chromium/src/content/renderer/indexed_db/webidbdatabase_impl.cc?type=cs&sq=package:chromium&g=0&l=177 + // https://cs.chromium.org/chromium/src/out/Debug/gen/third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h?type=cs&sq=package:chromium&g=0&l=60 + // We set the chunk size to 64MB to stay well-below the limit + var CHUNK_SIZE = 64 * 1024 * 1024; + function cacheRemotePackage(db, packageName, packageData, packageMeta, callback, errback) { + var transactionPackages = db.transaction([ PACKAGE_STORE_NAME ], IDB_RW); + var packages = transactionPackages.objectStore(PACKAGE_STORE_NAME); + var chunkSliceStart = 0; + var nextChunkSliceStart = 0; + var chunkCount = Math.ceil(packageData.byteLength / CHUNK_SIZE); + var finishedChunks = 0; + for (var chunkId = 0; chunkId < chunkCount; chunkId++) { + nextChunkSliceStart += CHUNK_SIZE; + var putPackageRequest = packages.put(packageData.slice(chunkSliceStart, nextChunkSliceStart), `package/${packageName}/${chunkId}`); + chunkSliceStart = nextChunkSliceStart; + putPackageRequest.onsuccess = event => { + finishedChunks++; + if (finishedChunks == chunkCount) { + var transaction_metadata = db.transaction([ METADATA_STORE_NAME ], IDB_RW); + var metadata = transaction_metadata.objectStore(METADATA_STORE_NAME); + var putMetadataRequest = metadata.put({ + "uuid": packageMeta.uuid, + "chunkCount": chunkCount + }, `metadata/${packageName}`); + putMetadataRequest.onsuccess = event => callback(packageData); + putMetadataRequest.onerror = error => errback(error); + } + }; + putPackageRequest.onerror = error => errback(error); + } + } + /* Check if there's a cached package, and if so whether it's the latest available */ function checkCachedPackage(db, packageName, callback, errback) { + var transaction = db.transaction([ METADATA_STORE_NAME ], IDB_RO); + var metadata = transaction.objectStore(METADATA_STORE_NAME); + var getRequest = metadata.get(`metadata/${packageName}`); + getRequest.onsuccess = event => { + var result = event.target.result; + if (!result) { + return callback(false, null); + } else { + return callback(PACKAGE_UUID === result["uuid"], result); + } + }; + getRequest.onerror = error => errback(error); + } + function fetchCachedPackage(db, packageName, metadata, callback, errback) { + var transaction = db.transaction([ PACKAGE_STORE_NAME ], IDB_RO); + var packages = transaction.objectStore(PACKAGE_STORE_NAME); + var chunksDone = 0; + var totalSize = 0; + var chunkCount = metadata["chunkCount"]; + var chunks = new Array(chunkCount); + for (var chunkId = 0; chunkId < chunkCount; chunkId++) { + var getRequest = packages.get(`package/${packageName}/${chunkId}`); + getRequest.onsuccess = event => { + if (!event.target.result) { + errback(new Error(`CachedPackageNotFound for: ${packageName}`)); + return; + } + // If there's only 1 chunk, there's nothing to concatenate it with so we can just return it now + if (chunkCount == 1) { + callback(event.target.result); + } else { + chunksDone++; + totalSize += event.target.result.byteLength; + chunks.push(event.target.result); + if (chunksDone == chunkCount) { + if (chunksDone == 1) { + callback(event.target.result); + } else { + var tempTyped = new Uint8Array(totalSize); + var byteOffset = 0; + for (var chunkId in chunks) { + var buffer = chunks[chunkId]; + tempTyped.set(new Uint8Array(buffer), byteOffset); + byteOffset += buffer.byteLength; + buffer = undefined; + } + chunks = undefined; + callback(tempTyped.buffer); + tempTyped = undefined; + } + } + } + }; + getRequest.onerror = error => errback(error); + } + } + 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_bin/AxmolTestbed/index.data"); + } + Module["addRunDependency"]("datafile_bin/AxmolTestbed/index.data"); + Module["preloadResults"] ??= {}; + function preloadFallback(error) { + console.error(error); + console.error("falling back to default preload behavior"); + fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, processPackageData, handleError); + } + openDatabase(db => checkCachedPackage(db, PACKAGE_PATH + PACKAGE_NAME, (useCached, metadata) => { + Module["preloadResults"][PACKAGE_NAME] = { + fromCache: useCached + }; + if (useCached) { + fetchCachedPackage(db, PACKAGE_PATH + PACKAGE_NAME, metadata, processPackageData, preloadFallback); + } else { + fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, packageData => { + cacheRemotePackage(db, PACKAGE_PATH + PACKAGE_NAME, packageData, { + uuid: PACKAGE_UUID + }, processPackageData, error => { + console.error(error); + processPackageData(packageData); + }); + }, preloadFallback); + } + }, preloadFallback), preloadFallback); + Module["setStatus"]?.("Downloading..."); + } + if (Module["calledRun"]) { + runWithFS(Module); + } else { + (Module["preRun"] ??= []).push(runWithFS); + } + } + // FS is not initialized yet, wait for it + loadPackage({ + "files": [ { + "filename": "/CloseNormal.png", + "start": 0, + "end": 3596 + }, { + "filename": "/CloseSelected.png", + "start": 3596, + "end": 6406 + }, { + "filename": "/HelloWorld.png", + "start": 6406, + "end": 17832 + }, { + "filename": "/axslc/cameraClear_fs", + "start": 17832, + "end": 18034 + }, { + "filename": "/axslc/cameraClear_vs", + "start": 18034, + "end": 18423 + }, { + "filename": "/axslc/colorNormalTexture_fs", + "start": 18423, + "end": 23073 + }, { + "filename": "/axslc/colorNormalTexture_fs_1", + "start": 23073, + "end": 27473 + }, { + "filename": "/axslc/colorNormal_fs", + "start": 27473, + "end": 32056 + }, { + "filename": "/axslc/colorTexture_fs", + "start": 32056, + "end": 32367 + }, { + "filename": "/axslc/color_fs", + "start": 32367, + "end": 32587 + }, { + "filename": "/axslc/custom/imgui_sprite_vs", + "start": 32587, + "end": 32959 + }, { + "filename": "/axslc/dualSampler_fs", + "start": 32959, + "end": 33510 + }, { + "filename": "/axslc/dualSampler_gray_fs", + "start": 33510, + "end": 34330 + }, { + "filename": "/axslc/dualSampler_hsv_fs", + "start": 34330, + "end": 36649 + }, { + "filename": "/axslc/grayScale_fs", + "start": 36649, + "end": 37165 + }, { + "filename": "/axslc/hsv_fs", + "start": 37165, + "end": 39230 + }, { + "filename": "/axslc/label_distanceGlow_fs", + "start": 39230, + "end": 40411 + }, { + "filename": "/axslc/label_distanceNormal_fs", + "start": 40411, + "end": 40942 + }, { + "filename": "/axslc/label_distanceOutline_fs", + "start": 40942, + "end": 42179 + }, { + "filename": "/axslc/label_normal_fs", + "start": 42179, + "end": 42562 + }, { + "filename": "/axslc/label_outline_fs", + "start": 42562, + "end": 43488 + }, { + "filename": "/axslc/layer_radialGradient_fs", + "start": 43488, + "end": 44208 + }, { + "filename": "/axslc/lineColor_fs", + "start": 44208, + "end": 44384 + }, { + "filename": "/axslc/lineColor_vs", + "start": 44384, + "end": 44660 + }, { + "filename": "/axslc/particleColor_fs", + "start": 44660, + "end": 44913 + }, { + "filename": "/axslc/particleTexture_fs", + "start": 44913, + "end": 45259 + }, { + "filename": "/axslc/particle_vs", + "start": 45259, + "end": 45650 + }, { + "filename": "/axslc/positionColorLengthTexture_fs", + "start": 45650, + "end": 45890 + }, { + "filename": "/axslc/positionColorLengthTexture_vs", + "start": 45890, + "end": 46328 + }, { + "filename": "/axslc/positionColorTextureAsPointsize_vs", + "start": 46328, + "end": 46749 + }, { + "filename": "/axslc/positionColor_fs", + "start": 46749, + "end": 46925 + }, { + "filename": "/axslc/positionColor_vs", + "start": 46925, + "end": 47190 + }, { + "filename": "/axslc/positionNormalTexture_vs", + "start": 47190, + "end": 48540 + }, { + "filename": "/axslc/positionNormalTexture_vs_1", + "start": 48540, + "end": 52361 + }, { + "filename": "/axslc/positionTexture3D_vs", + "start": 52361, + "end": 52676 + }, { + "filename": "/axslc/positionTextureColorAlphaTest_fs", + "start": 52676, + "end": 53119 + }, { + "filename": "/axslc/positionTextureColor_fs", + "start": 53119, + "end": 53386 + }, { + "filename": "/axslc/positionTextureColor_vs", + "start": 53386, + "end": 53742 + }, { + "filename": "/axslc/positionTextureInstance_vs", + "start": 53742, + "end": 54113 + }, { + "filename": "/axslc/positionTexture_fs", + "start": 54113, + "end": 54347 + }, { + "filename": "/axslc/positionTexture_vs", + "start": 54347, + "end": 54623 + }, { + "filename": "/axslc/positionUColor_vs", + "start": 54623, + "end": 54871 + }, { + "filename": "/axslc/position_vs", + "start": 54871, + "end": 55106 + }, { + "filename": "/axslc/quadColor_fs", + "start": 55106, + "end": 55359 + }, { + "filename": "/axslc/quadColor_vs", + "start": 55359, + "end": 55624 + }, { + "filename": "/axslc/quadTexture_fs", + "start": 55624, + "end": 55970 + }, { + "filename": "/axslc/quadTexture_vs", + "start": 55970, + "end": 56365 + }, { + "filename": "/axslc/skinPositionNormalTexture_vs", + "start": 56365, + "end": 59967 + }, { + "filename": "/axslc/skinPositionNormalTexture_vs_1", + "start": 59967, + "end": 65572 + }, { + "filename": "/axslc/skinPositionTexture_vs", + "start": 65572, + "end": 67853 + }, { + "filename": "/axslc/skybox_fs", + "start": 67853, + "end": 68162 + }, { + "filename": "/axslc/skybox_vs", + "start": 68162, + "end": 68459 + }, { + "filename": "/axslc/terrain_fs", + "start": 68459, + "end": 69871 + }, { + "filename": "/axslc/terrain_vs", + "start": 69871, + "end": 70230 + }, { + "filename": "/axslc/videoTextureBGRA_fs", + "start": 70230, + "end": 70502 + }, { + "filename": "/axslc/videoTextureI420_fs", + "start": 70502, + "end": 71552 + }, { + "filename": "/axslc/videoTextureNV12_fs", + "start": 71552, + "end": 72563 + }, { + "filename": "/axslc/videoTextureYUY2_fs", + "start": 72563, + "end": 73574 + }, { + "filename": "/fonts/Marker Felt.ttf", + "start": 73574, + "end": 99350 + }, { + "filename": "/fonts/arial.ttf", + "start": 99350, + "end": 877902 + }, { + "filename": "/res/.gitkeep", + "start": 877902, + "end": 877902 + } ], + "remote_package_size": 877902, + "package_uuid": "sha256-ee183916b333fcf7d371811b747a8b2cf3bcb1cea09ef4001d4c23413ccaeb20" + }); +})(); + +// end include: C:\Users\tymmkang\AppData\Local\Temp\tmpyjlnr784.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; +}; + +// In MODULARIZE mode _scriptName needs to be captured already at the very top of the page immediately when the page is parsed, so it is generated there +// before the page load. In non-MODULARIZE modes generate it here. +var _scriptName = (typeof document != "undefined") ? document.currentScript?.src : undefined; + +if (ENVIRONMENT_IS_NODE) { + _scriptName = __filename; +} else if (ENVIRONMENT_IS_WORKER) { + _scriptName = self.location.href; +} + +// `/` 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) { + // 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); + 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 // 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); + } + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + if (!ENVIRONMENT_IS_NODE) { + // 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)); + }); + }; + } +} else // end include: web_or_worker_shell_read.js +{} + +// Set up the out() and err() hooks, which are how we can print to stdout or +// stderr, respectively. +// Normally just binding console.log/console.error here works fine, but +// under node (with workers) we see missing/out-of-order messages so route +// directly to stdout and stderr. +// See https://github.com/emscripten-core/emscripten/issues/14804 +var defaultPrint = console.log.bind(console); + +var defaultPrintErr = console.error.bind(console); + +if (ENVIRONMENT_IS_NODE) { + defaultPrint = (...args) => fs.writeSync(1, args.join(" ") + "\n"); + defaultPrintErr = (...args) => fs.writeSync(2, args.join(" ") + "\n"); +} + +var out = Module["print"] || defaultPrint; + +var err = Module["printErr"] || defaultPrintErr; + +// 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; + +// 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"]; + +if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// 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"]; + +// 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; + +// For sending to workers. +var wasmModule; + +//======================================== +// 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) { + // This build was created without ASSERTIONS defined. `assert()` should not + // ever be called in this configuration but in case there are callers in + // the wild leave this simple abort() implementation here for now. + abort(text); + } +} + +// 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 +// include: runtime_pthread.js +// Pthread Web Worker handling code. +// This code runs only on pthread web workers and handles pthread setup +// and communication with the main thread via postMessage. +if (ENVIRONMENT_IS_PTHREAD) { + var wasmModuleReceived; + // Node.js support + if (ENVIRONMENT_IS_NODE) { + // Create as web-worker-like an environment as we can. + var parentPort = worker_threads["parentPort"]; + parentPort.on("message", msg => onmessage({ + data: msg + })); + Object.assign(globalThis, { + self: global, + postMessage: msg => parentPort.postMessage(msg) + }); + } + // Thread-local guard variable for one-time init of the JS state + var initializedJS = false; + function threadPrintErr(...args) { + var text = args.join(" "); + // See https://github.com/emscripten-core/emscripten/issues/14804 + if (ENVIRONMENT_IS_NODE) { + fs.writeSync(2, text + "\n"); + return; + } + console.error(text); + } + if (!Module["printErr"]) err = threadPrintErr; + function threadAlert(...args) { + var text = args.join(" "); + postMessage({ + cmd: "alert", + text, + threadId: _pthread_self() + }); + } + self.alert = threadAlert; + // Turn unhandled rejected promises into errors so that the main thread will be + // notified about them. + self.onunhandledrejection = e => { + throw e.reason || e; + }; + function handleMessage(e) { + try { + var msgData = e["data"]; + //dbg('msgData: ' + Object.keys(msgData)); + var cmd = msgData.cmd; + if (cmd === "load") { + // Preload command that is called once per worker to parse and load the Emscripten code. + // Until we initialize the runtime, queue up any further incoming messages. + let messageQueue = []; + self.onmessage = e => messageQueue.push(e); + // And add a callback for when the runtime is initialized. + self.startWorker = instance => { + // Notify the main thread that this thread has loaded. + postMessage({ + cmd: "loaded" + }); + // Process any messages that were queued before the thread was ready. + for (let msg of messageQueue) { + handleMessage(msg); + } + // Restore the real message handler. + self.onmessage = handleMessage; + }; + // Use `const` here to ensure that the variable is scoped only to + // that iteration, allowing safe reference from a closure. + for (const handler of msgData.handlers) { + // The the main module has a handler for a certain even, but no + // handler exists on the pthread worker, then proxy that handler + // back to the main thread. + if (!Module[handler] || Module[handler].proxy) { + Module[handler] = (...args) => { + postMessage({ + cmd: "callHandler", + handler, + args + }); + }; + // Rebind the out / err handlers if needed + if (handler == "print") out = Module[handler]; + if (handler == "printErr") err = Module[handler]; + } + } + wasmMemory = msgData.wasmMemory; + updateMemoryViews(); + wasmModuleReceived(msgData.wasmModule); + } else if (cmd === "run") { + // Call inside JS module to set up the stack frame for this pthread in JS module scope. + // This needs to be the first thing that we do, as we cannot call to any C/C++ functions + // until the thread stack is initialized. + establishStackSpace(msgData.pthread_ptr); + // Pass the thread address to wasm to store it for fast access. + __emscripten_thread_init(msgData.pthread_ptr, /*is_main=*/ 0, /*is_runtime=*/ 0, /*can_block=*/ 1, 0, 0); + PThread.receiveObjectTransfer(msgData); + PThread.threadInitTLS(); + // Await mailbox notifications with `Atomics.waitAsync` so we can start + // using the fast `Atomics.notify` notification path. + __emscripten_thread_mailbox_await(msgData.pthread_ptr); + if (!initializedJS) { + initializedJS = true; + } + try { + invokeEntryPoint(msgData.start_routine, msgData.arg); + } catch (ex) { + if (ex != "unwind") { + // The pthread "crashed". Do not call `_emscripten_thread_exit` (which + // would make this thread joinable). Instead, re-throw the exception + // and let the top level handler propagate it back to the main thread. + throw ex; + } + } + } else if (msgData.target === "setimmediate") {} else // no-op + if (cmd === "checkMailbox") { + if (initializedJS) { + checkMailbox(); + } + } else if (cmd) { + // The received message looks like something that should be handled by this message + // handler, (since there is a cmd field present), but is not one of the + // recognized commands: + err(`worker: received unknown command ${cmd}`); + err(msgData); + } + } catch (ex) { + __emscripten_thread_crashed(); + throw ex; + } + } + self.onmessage = handleMessage; +} + +// ENVIRONMENT_IS_PTHREAD +// end include: runtime_pthread.js +// In non-standalone/normal mode, we create the memory here. +// include: runtime_init_memory.js +// Create the wasm memory. (Note: this only applies if IMPORTED_MEMORY is defined) +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) +if (!ENVIRONMENT_IS_PTHREAD) { + if (Module["wasmMemory"]) { + wasmMemory = Module["wasmMemory"]; + } else { + var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 134217728; + /** @suppress {checkTypes} */ wasmMemory = new WebAssembly.Memory({ + "initial": INITIAL_MEMORY / 65536, + // In theory we should not need to emit the maximum if we want "unlimited" + // or 4GB of memory, but VMs error on that atm, see + // https://github.com/emscripten-core/emscripten/issues/14130 + // And in the pthreads case we definitely need to emit a maximum. So + // always emit one. + "maximum": 32768, + "shared": true + }); + } + updateMemoryViews(); +} + +// end include: runtime_init_memory.js +// include: runtime_stack_check.js +// 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() { + runtimeInitialized = true; + if (ENVIRONMENT_IS_PTHREAD) return; + if (!Module["noFSInit"] && !FS.initialized) FS.init(); + FS.ignorePermissions = false; + TTY.init(); + PIPEFS.root = FS.mount(PIPEFS, {}, null); + SOCKFS.root = FS.mount(SOCKFS, {}, null); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + if (ENVIRONMENT_IS_PTHREAD) return; + // PThreads reuse the runtime from the main thread. + callRuntimeCallbacks(__ATMAIN__); +} + +function postRun() { + if (ENVIRONMENT_IS_PTHREAD) return; + // PThreads reuse the runtime from the main thread. + 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 +// 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 +function getUniqueRunDependency(id) { + return id; +} + +function addRunDependency(id) { + runDependencies++; + Module["monitorRunDependencies"]?.(runDependencies); +} + +function removeRunDependency(id) { + runDependencies--; + Module["monitorRunDependencies"]?.(runDependencies); + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} + +/** @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; + what += ". Build with -sASSERTIONS for more info."; + // 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 +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +function findWasmBinary() { + var f = "index.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 => WebAssembly.instantiate(binary, imports)).then(receiver, reason => { + err(`failed to asynchronously prepare wasm: ${reason}`); + 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() { + assignWasmImports(); + // 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; + registerTLSInit(wasmExports["_emscripten_tls_init"]); + wasmTable = wasmExports["__indirect_function_table"]; + addOnInit(wasmExports["__wasm_call_ctors"]); + // We now have the Wasm module loaded up, keep a reference to the compiled module so we can post it to the workers. + wasmModule = module; + removeRunDependency("wasm-instantiate"); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency("wasm-instantiate"); + // Prefer streaming instantiation if available. + 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 + receiveInstance(result["instance"], result["module"]); + } + 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; + } + } + if (ENVIRONMENT_IS_PTHREAD) { + return new Promise(resolve => { + wasmModuleReceived = module => { + // Instantiate from the module posted from the main thread. + // We can just use sync instantiation in the worker. + var instance = new WebAssembly.Instance(module, getWasmImports()); + receiveInstance(instance, module); + resolve(); + }; + }); + } + wasmBinaryFile ??= findWasmBinary(); + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult); + return {}; +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; + +var tempI64; + +// include: runtime_debug.js +// end include: runtime_debug.js +// === Body === +var ASM_CONSTS = { + 363188: $0 => { + window.open(UTF8ToString($0)); + }, + 363223: $0 => { + var lang = localStorage.getItem("localization_language"); + if (lang == null) { + stringToUTF8(window.navigator.language.replace(/-.*/, ""), $0, 16); + } else { + stringToUTF8(lang, $0, 16); + } + }, + 363412: ($0, $1) => { + window.alert(UTF8ToString($0) + ": " + UTF8ToString($1)); + }, + 363474: () => (("ontouchstart" in window) || (navigator.maxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0)) ? 1 : 0, + 363589: () => { + document.addEventListener("click", function(event) { + Module.ccall("axmol_onwebclickcallback"); + }); + }, + 363691: () => canvas.getBoundingClientRect().left, + 363734: () => canvas.getBoundingClientRect().top, + 363776: () => window.devicePixelRatio, + 363807: ($0, $1, $2, $3, $4, $5, $6) => { + var lines = UTF8ToString($0).split("\n"); + var fontName = UTF8ToString($1); + var fontSize = $2; + var color = UTF8ToString($3); + var dimWidth = $4; + var dimHeight = $5; + var align = $6; + var canvas = Module.axmolSharedCanvas = Module.axmolSharedCanvas || document.createElement("canvas"); + var context = canvas.getContext("2d", { + willReadFrequently: true + }); + context.font = fontSize + "px " + fontName; + context.textBaseline = "alphabetic"; + var linesWidth = []; + var linesAscent = []; + var linesDescent = []; + var totalHeight = 0; + var maxWidth = dimWidth > 0 ? dimWidth : 0; + var defaultAscent = 0; + var defaultDescent = 0; + var measureDefault = () => { + if (defaultAscent == 0 && defaultDescent == 0) { + var metrics = context.measureText("M"); + defaultAscent = (typeof metrics.actualBoundingBoxAscent === "number") ? metrics.actualBoundingBoxAscent : fontSize * .8; + defaultDescent = (typeof metrics.actualBoundingBoxDescent === "number") ? metrics.actualBoundingBoxDescent : fontSize * .2; + } + }; + for (var i = 0; i < lines.length; i++) { + var metrics = context.measureText(lines[i]); + var lineWidth = metrics.width; + var ascent = (typeof metrics.actualBoundingBoxAscent === "number") ? metrics.actualBoundingBoxAscent : fontSize * .8; + var descent = (typeof metrics.actualBoundingBoxDescent === "number") ? metrics.actualBoundingBoxDescent : fontSize * .2; + var lineHeight = ascent + descent; + if (lineHeight == 0) { + measureDefault(); + ascent = defaultAscent; + descent = defaultDescent; + lineHeight = ascent + descent; + } + linesWidth.push(lineWidth); + linesAscent.push(ascent); + linesDescent.push(descent); + if (dimWidth <= 0 && lineWidth > maxWidth) { + maxWidth = lineWidth; + } + totalHeight += lineHeight; + } + if (dimHeight > 0) { + totalHeight = dimHeight; + } + var canvasWidth = Math.ceil(maxWidth); + var canvasHeight = Math.ceil(totalHeight); + canvas.width = canvasWidth; + canvas.height = canvasHeight; + context.clearRect(0, 0, canvasWidth, canvasHeight); + context.font = fontSize + "px " + fontName; + context.fillStyle = color; + context.textBaseline = "alphabetic"; + var offsetY = 0; + if ((align & 240) === 48) { + offsetY = (canvasHeight - totalHeight) / 2; + } else if ((align & 240) === 32) { + offsetY = canvasHeight - totalHeight; + } + for (var i = 0; i < lines.length; i++) { + var lineH = linesAscent[i] + linesDescent[i]; + var offsetX = 0; + if ((align & 15) === 3) { + offsetX = (canvasWidth - linesWidth[i]) / 2; + } else if ((align & 15) === 2) { + offsetX = canvasWidth - linesWidth[i]; + } + var baselineY = offsetY + linesAscent[i]; + context.fillText(lines[i], offsetX, baselineY); + offsetY += lineH; + } + var data = context.getImageData(0, 0, canvasWidth, canvasHeight).data; + var ptr = _malloc(data.byteLength); + var buffer = new Uint8Array(Module.HEAPU8.buffer, ptr, data.byteLength); + buffer.set(data); + return ptr; + }, + 366583: () => Module.axmolSharedCanvas.width, + 366626: () => Module.axmolSharedCanvas.height, + 366670: () => PThread.unusedWorkers.length +}; + +function ImGui_ImplGlfw_EmscriptenOpenURL(url) { + url = url ? UTF8ToString(url) : null; + if (url) window.open(url, "_blank"); +} + +// end include: preamble.js +class ExitStatus { + name="ExitStatus"; + constructor(status) { + this.message = `Program terminated with exit(${status})`; + this.status = status; + } +} + +var terminateWorker = worker => { + worker.terminate(); + // terminate() can be asynchronous, so in theory the worker can continue + // to run for some amount of time after termination. However from our POV + // the worker now dead and we don't want to hear from it again, so we stub + // out its message handler here. This avoids having to check in each of + // the onmessage handlers if the message was coming from valid worker. + worker.onmessage = e => {}; +}; + +var cleanupThread = pthread_ptr => { + var worker = PThread.pthreads[pthread_ptr]; + PThread.returnWorkerToPool(worker); +}; + +var spawnThread = threadParams => { + var worker = PThread.getNewWorker(); + if (!worker) { + // No available workers in the PThread pool. + return 6; + } + PThread.runningWorkers.push(worker); + // Add to pthreads map + PThread.pthreads[threadParams.pthread_ptr] = worker; + worker.pthread_ptr = threadParams.pthread_ptr; + var msg = { + cmd: "run", + start_routine: threadParams.startRoutine, + arg: threadParams.arg, + pthread_ptr: threadParams.pthread_ptr + }; + if (ENVIRONMENT_IS_NODE) { + // Mark worker as weakly referenced once we start executing a pthread, + // so that its existence does not prevent Node.js from exiting. This + // has no effect if the worker is already weakly referenced (e.g. if + // this worker was previously idle/unused). + worker.unref(); + } + // Ask the worker to start executing its pthread entry point function. + worker.postMessage(msg, threadParams.transferList); + return 0; +}; + +var runtimeKeepaliveCounter = 0; + +var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0; + +var stackSave = () => _emscripten_stack_get_current(); + +var stackRestore = val => __emscripten_stack_restore(val); + +var stackAlloc = sz => __emscripten_stack_alloc(sz); + +var convertI32PairToI53Checked = (lo, hi) => ((hi + 2097152) >>> 0 < 4194305 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + +/** @type{function(number, (number|boolean), ...number)} */ var proxyToMainThread = (funcIndex, emAsmAddr, sync, ...callArgs) => { + // EM_ASM proxying is done by passing a pointer to the address of the EM_ASM + // content as `emAsmAddr`. JS library proxying is done by passing an index + // into `proxiedJSCallArgs` as `funcIndex`. If `emAsmAddr` is non-zero then + // `funcIndex` will be ignored. + // Additional arguments are passed after the first three are the actual + // function arguments. + // The serialization buffer contains the number of call params, and then + // all the args here. + // We also pass 'sync' to C separately, since C needs to look at it. + // Allocate a buffer, which will be copied by the C code. + // First passed parameter specifies the number of arguments to the function. + // When BigInt support is enabled, we must handle types in a more complex + // way, detecting at runtime if a value is a BigInt or not (as we have no + // type info here). To do that, add a "prefix" before each value that + // indicates if it is a BigInt, which effectively doubles the number of + // values we serialize for proxying. TODO: pack this? + var serializedNumCallArgs = callArgs.length; + var sp = stackSave(); + var args = stackAlloc(serializedNumCallArgs * 8); + var b = ((args) >> 3); + for (var i = 0; i < callArgs.length; i++) { + var arg = callArgs[i]; + GROWABLE_HEAP_F64()[b + i] = arg; + } + var rtn = __emscripten_run_on_main_thread_js(funcIndex, emAsmAddr, serializedNumCallArgs, args, sync); + stackRestore(sp); + return rtn; +}; + +function _proc_exit(code) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(0, 0, 1, code); + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + PThread.terminateAllThreads(); + Module["onExit"]?.(code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); +} + +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; + } + quit_(1, e); +}; + +function exitOnMainThread(returnCode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(1, 0, 0, returnCode); + _exit(returnCode); +} + +/** @suppress {duplicate } */ /** @param {boolean|number=} implicit */ var exitJS = (status, implicit) => { + EXITSTATUS = status; + if (ENVIRONMENT_IS_PTHREAD) { + // implicit exit can never happen on a pthread + // When running in a pthread we propagate the exit back to the main thread + // where it can decide if the whole process should be shut down or not. + // The pthread may have decided not to exit its own runtime, for example + // because it runs a main loop, but that doesn't affect the main thread. + exitOnMainThread(status); + throw "unwind"; + } + _proc_exit(status); +}; + +var _exit = exitJS; + +var PThread = { + unusedWorkers: [], + runningWorkers: [], + tlsInitFunctions: [], + pthreads: {}, + init() { + if ((!(ENVIRONMENT_IS_PTHREAD))) { + PThread.initMainThread(); + } + }, + initMainThread() { + var pthreadPoolSize = 4; + // Start loading up the Worker pool, if requested. + while (pthreadPoolSize--) { + PThread.allocateUnusedWorker(); + } + // MINIMAL_RUNTIME takes care of calling loadWasmModuleToAllWorkers + // in postamble_minimal.js + addOnPreRun(() => { + addRunDependency("loading-workers"); + PThread.loadWasmModuleToAllWorkers(() => removeRunDependency("loading-workers")); + }); + }, + terminateAllThreads: () => { + // Attempt to kill all workers. Sadly (at least on the web) there is no + // way to terminate a worker synchronously, or to be notified when a + // worker in actually terminated. This means there is some risk that + // pthreads will continue to be executing after `worker.terminate` has + // returned. For this reason, we don't call `returnWorkerToPool` here or + // free the underlying pthread data structures. + for (var worker of PThread.runningWorkers) { + terminateWorker(worker); + } + for (var worker of PThread.unusedWorkers) { + terminateWorker(worker); + } + PThread.unusedWorkers = []; + PThread.runningWorkers = []; + PThread.pthreads = {}; + }, + returnWorkerToPool: worker => { + // We don't want to run main thread queued calls here, since we are doing + // some operations that leave the worker queue in an invalid state until + // we are completely done (it would be bad if free() ends up calling a + // queued pthread_create which looks at the global data structures we are + // modifying). To achieve that, defer the free() til the very end, when + // we are all done. + var pthread_ptr = worker.pthread_ptr; + delete PThread.pthreads[pthread_ptr]; + // Note: worker is intentionally not terminated so the pool can + // dynamically grow. + PThread.unusedWorkers.push(worker); + PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); + // Not a running Worker anymore + // Detach the worker from the pthread object, and return it to the + // worker pool as an unused worker. + worker.pthread_ptr = 0; + // Finally, free the underlying (and now-unused) pthread structure in + // linear memory. + __emscripten_thread_free_data(pthread_ptr); + }, + receiveObjectTransfer(data) {}, + threadInitTLS() { + // Call thread init functions (these are the _emscripten_tls_init for each + // module loaded. + PThread.tlsInitFunctions.forEach(f => f()); + }, + loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => { + worker.onmessage = e => { + var d = e["data"]; + var cmd = d.cmd; + // If this message is intended to a recipient that is not the main + // thread, forward it to the target thread. + if (d.targetThread && d.targetThread != _pthread_self()) { + var targetWorker = PThread.pthreads[d.targetThread]; + if (targetWorker) { + targetWorker.postMessage(d, d.transferList); + } else { + err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`); + } + return; + } + if (cmd === "checkMailbox") { + checkMailbox(); + } else if (cmd === "spawnThread") { + spawnThread(d); + } else if (cmd === "cleanupThread") { + cleanupThread(d.thread); + } else if (cmd === "loaded") { + worker.loaded = true; + // Check that this worker doesn't have an associated pthread. + if (ENVIRONMENT_IS_NODE && !worker.pthread_ptr) { + // Once worker is loaded & idle, mark it as weakly referenced, + // so that mere existence of a Worker in the pool does not prevent + // Node.js from exiting the app. + worker.unref(); + } + onFinishedLoading(worker); + } else if (cmd === "alert") { + alert(`Thread ${d.threadId}: ${d.text}`); + } else if (d.target === "setimmediate") { + // Worker wants to postMessage() to itself to implement setImmediate() + // emulation. + worker.postMessage(d); + } else if (cmd === "callHandler") { + Module[d.handler](...d.args); + } else if (cmd) { + // The received message looks like something that should be handled by this message + // handler, (since there is a e.data.cmd field present), but is not one of the + // recognized commands: + err(`worker sent an unknown command ${cmd}`); + } + }; + worker.onerror = e => { + var message = "worker sent an error!"; + err(`${message} ${e.filename}:${e.lineno}: ${e.message}`); + throw e; + }; + if (ENVIRONMENT_IS_NODE) { + worker.on("message", data => worker.onmessage({ + data + })); + worker.on("error", e => worker.onerror(e)); + } + // When running on a pthread, none of the incoming parameters on the module + // object are present. Proxy known handlers back to the main thread if specified. + var handlers = []; + var knownHandlers = [ "onExit", "onAbort", "print", "printErr" ]; + for (var handler of knownHandlers) { + if (Module.propertyIsEnumerable(handler)) { + handlers.push(handler); + } + } + // Ask the new worker to load up the Emscripten-compiled page. This is a heavy operation. + worker.postMessage({ + cmd: "load", + handlers, + wasmMemory, + wasmModule + }); + }), + loadWasmModuleToAllWorkers(onMaybeReady) { + // Instantiation is synchronous in pthreads. + if (ENVIRONMENT_IS_PTHREAD) { + return onMaybeReady(); + } + let pthreadPoolReady = Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker)); + pthreadPoolReady.then(onMaybeReady); + }, + allocateUnusedWorker() { + var worker; + var workerOptions = { + // This is the way that we signal to the node worker that it is hosting + // a pthread. + "workerData": "em-pthread", + // This is the way that we signal to the Web Worker that it is hosting + // a pthread. + "name": "em-pthread" + }; + var pthreadMainJs = _scriptName; + // We can't use makeModuleReceiveWithVar here since we want to also + // call URL.createObjectURL on the mainScriptUrlOrBlob. + if (Module["mainScriptUrlOrBlob"]) { + pthreadMainJs = Module["mainScriptUrlOrBlob"]; + if (typeof pthreadMainJs != "string") { + pthreadMainJs = URL.createObjectURL(pthreadMainJs); + } + } + worker = new Worker(pthreadMainJs, workerOptions); + PThread.unusedWorkers.push(worker); + }, + getNewWorker() { + if (PThread.unusedWorkers.length == 0) { + // PTHREAD_POOL_SIZE_STRICT should show a warning and, if set to level `2`, return from the function. + PThread.allocateUnusedWorker(); + PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]); + } + return PThread.unusedWorkers.pop(); + } +}; + +var callRuntimeCallbacks = callbacks => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } +}; + +var establishStackSpace = pthread_ptr => { + // If memory growth is enabled, the memory views may have gotten out of date, + // so resync them before accessing the pthread ptr below. + updateMemoryViews(); + var stackHigh = GROWABLE_HEAP_U32()[(((pthread_ptr) + (52)) >> 2)]; + var stackSize = GROWABLE_HEAP_U32()[(((pthread_ptr) + (56)) >> 2)]; + var stackLow = stackHigh - stackSize; + // Set stack limits used by `emscripten/stack.h` function. These limits are + // cached in wasm-side globals to make checks as fast as possible. + _emscripten_stack_set_limits(stackHigh, stackLow); + // Call inside wasm module to set up the stack frame for this pthread in wasm module scope + stackRestore(stackHigh); +}; + +/** + * @param {number} ptr + * @param {string} type + */ function getValue(ptr, type = "i8") { + if (type.endsWith("*")) type = "*"; + switch (type) { + case "i1": + return GROWABLE_HEAP_I8()[ptr]; + + case "i8": + return GROWABLE_HEAP_I8()[ptr]; + + case "i16": + return GROWABLE_HEAP_I16()[((ptr) >> 1)]; + + case "i32": + return GROWABLE_HEAP_I32()[((ptr) >> 2)]; + + case "i64": + abort("to do getValue(i64) use WASM_BIGINT"); + + case "float": + return GROWABLE_HEAP_F32()[((ptr) >> 2)]; + + case "double": + return GROWABLE_HEAP_F64()[((ptr) >> 3)]; + + case "*": + return GROWABLE_HEAP_U32()[((ptr) >> 2)]; + + default: + abort(`invalid type for getValue: ${type}`); + } +} + +var wasmTableMirror = []; + +/** @type {WebAssembly.Table} */ var wasmTable; + +var getWasmTableEntry = funcPtr => { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + /** @suppress {checkTypes} */ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + return func; +}; + +var invokeEntryPoint = (ptr, arg) => { + // An old thread on this worker may have been canceled without returning the + // `runtimeKeepaliveCounter` to zero. Reset it now so the new thread won't + // be affected. + runtimeKeepaliveCounter = 0; + // Same for noExitRuntime. The default for pthreads should always be false + // otherwise pthreads would never complete and attempts to pthread_join to + // them would block forever. + // pthreads can still choose to set `noExitRuntime` explicitly, or + // call emscripten_unwind_to_js_event_loop to extend their lifetime beyond + // their main function. See comment in src/runtime_pthread.js for more. + noExitRuntime = 0; + // pthread entry points are always of signature 'void *ThreadMain(void *arg)' + // Native codebases sometimes spawn threads with other thread entry point + // signatures, such as void ThreadMain(void *arg), void *ThreadMain(), or + // void ThreadMain(). That is not acceptable per C/C++ specification, but + // x86 compiler ABI extensions enable that to work. If you find the + // following line to crash, either change the signature to "proper" void + // *ThreadMain(void *arg) form, or try linking with the Emscripten linker + // flag -sEMULATE_FUNCTION_POINTER_CASTS to add in emulation for this x86 + // ABI extension. + var result = getWasmTableEntry(ptr)(arg); + function finish(result) { + if (keepRuntimeAlive()) { + EXITSTATUS = result; + } else { + __emscripten_thread_exit(result); + } + } + finish(result); +}; + +var noExitRuntime = Module["noExitRuntime"] || true; + +var registerTLSInit = tlsInitFunc => PThread.tlsInitFunctions.push(tlsInitFunc); + +/** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ function setValue(ptr, value, type = "i8") { + if (type.endsWith("*")) type = "*"; + switch (type) { + case "i1": + GROWABLE_HEAP_I8()[ptr] = value; + break; + + case "i8": + GROWABLE_HEAP_I8()[ptr] = value; + break; + + case "i16": + GROWABLE_HEAP_I16()[((ptr) >> 1)] = value; + break; + + case "i32": + GROWABLE_HEAP_I32()[((ptr) >> 2)] = value; + break; + + case "i64": + abort("to do setValue(i64) use WASM_BIGINT"); + + case "float": + GROWABLE_HEAP_F32()[((ptr) >> 2)] = value; + break; + + case "double": + GROWABLE_HEAP_F64()[((ptr) >> 3)] = value; + break; + + case "*": + GROWABLE_HEAP_U32()[((ptr) >> 2)] = value; + break; + + default: + abort(`invalid type for setValue: ${type}`); + } +} + +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.buffer instanceof ArrayBuffer ? heapOrArray.subarray(idx, endPtr) : heapOrArray.slice(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 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } + } + return str; +}; + +/** + * 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) => ptr ? UTF8ArrayToString(GROWABLE_HEAP_U8(), 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 ___call_sighandler = (fp, sig) => getWasmTableEntry(fp)(sig); + +class ExceptionInfo { + // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it. + constructor(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + } + set_type(type) { + GROWABLE_HEAP_U32()[(((this.ptr) + (4)) >> 2)] = type; + } + get_type() { + return GROWABLE_HEAP_U32()[(((this.ptr) + (4)) >> 2)]; + } + set_destructor(destructor) { + GROWABLE_HEAP_U32()[(((this.ptr) + (8)) >> 2)] = destructor; + } + get_destructor() { + return GROWABLE_HEAP_U32()[(((this.ptr) + (8)) >> 2)]; + } + set_caught(caught) { + caught = caught ? 1 : 0; + GROWABLE_HEAP_I8()[(this.ptr) + (12)] = caught; + } + get_caught() { + return GROWABLE_HEAP_I8()[(this.ptr) + (12)] != 0; + } + set_rethrown(rethrown) { + rethrown = rethrown ? 1 : 0; + GROWABLE_HEAP_I8()[(this.ptr) + (13)] = rethrown; + } + get_rethrown() { + return GROWABLE_HEAP_I8()[(this.ptr) + (13)] != 0; + } + // Initialize native structure fields. Should be called once after allocated. + init(type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + } + set_adjusted_ptr(adjustedPtr) { + GROWABLE_HEAP_U32()[(((this.ptr) + (16)) >> 2)] = adjustedPtr; + } + get_adjusted_ptr() { + return GROWABLE_HEAP_U32()[(((this.ptr) + (16)) >> 2)]; + } +} + +var exceptionLast = 0; + +var uncaughtExceptionCount = 0; + +var ___cxa_throw = (ptr, type, destructor) => { + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw exceptionLast; +}; + +function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(2, 0, 1, pthread_ptr, attr, startRoutine, arg); + return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg); +} + +var _emscripten_has_threading_support = () => typeof SharedArrayBuffer != "undefined"; + +var ___pthread_create_js = (pthread_ptr, attr, startRoutine, arg) => { + if (!_emscripten_has_threading_support()) { + return 6; + } + // List of JS objects that will transfer ownership to the Worker hosting the thread + var transferList = []; + var error = 0; + // Synchronously proxy the thread creation to main thread if possible. If we + // need to transfer ownership of objects, then proxy asynchronously via + // postMessage. + if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) { + return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg); + } + // If on the main thread, and accessing Canvas/OffscreenCanvas failed, abort + // with the detected error. + if (error) return error; + var threadParams = { + startRoutine, + pthread_ptr, + arg, + transferList + }; + if (ENVIRONMENT_IS_PTHREAD) { + // The prepopulated pool of web workers that can host pthreads is stored + // in the main JS thread. Therefore if a pthread is attempting to spawn a + // new thread, the thread creation must be deferred to the main JS thread. + threadParams.cmd = "spawnThread"; + postMessage(threadParams, transferList); + // When we defer thread creation this way, we have no way to detect thread + // creation synchronously today, so we have to assume success and return 0. + return 0; + } + // We are the main thread, so we have the pthread warmup pool in this + // thread and can fire off JS thread creation directly ourselves. + return spawnThread(threadParams); +}; + +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 + // like with most Web APIs, we can't use Web Crypto API directly on shared memory, + // so we need to create an intermediate buffer and copy it to the destination + return view => (view.set(crypto.getRandomValues(new Uint8Array(view.byteLength))), + // Return the original view to match modern native implementations. + 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) {} + } + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + abort("initRandomDevice"); +}; + +var randomFill = view => (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 <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; +}; + +var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + // 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 >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | (u1 & 1023); + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | (u >> 6); + heap[outIdx++] = 128 | (u & 63); + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | (u >> 12); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++] = 240 | (u >> 18); + heap[outIdx++] = 128 | ((u >> 12) & 63); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (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 + }; + 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: [ 3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] + }; + }, + 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) => { + GROWABLE_HEAP_U8().fill(0, address, address + size); +}; + +var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment; + +var mmapAlloc = size => { + size = alignMemory(size, 65536); + var ptr = _emscripten_builtin_memalign(65536, size); + if (ptr) zeroMemory(ptr, size); + return ptr; +}; + +var MEMFS = { + ops_table: null, + mount(mount) { + return MEMFS.createNode(null, "/", 16895, 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 : 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 MEMFS.doesNotExistError; + }, + 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 | 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); + 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) { + // If the buffer is located in main memory (HEAP), and if + // memory can grow, we can't hold on to references of the + // memory buffer, as they may get invalidated. That means we + // need to do copy its contents. + if (buffer.buffer === GROWABLE_HEAP_I8().buffer) { + canOwn = false; + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + // This write is from a typed array to a typed array? + if (canOwn) { + 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]; + } + } + 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 === GROWABLE_HEAP_I8().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); + } + } + GROWABLE_HEAP_I8().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 => { + 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 IDBFS = { + dbs: {}, + indexedDB: () => { + if (typeof indexedDB != "undefined") return indexedDB; + var ret = null; + if (typeof window == "object") ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + return ret; + }, + DB_VERSION: 21, + DB_STORE_NAME: "FILE_DATA", + queuePersist: mount => { + function onPersistComplete() { + if (mount.idbPersistState === "again") startPersist(); else // If a new sync request has appeared in between, kick off a new sync + mount.idbPersistState = 0; + } + // Otherwise reset sync state back to idle to wait for a new sync later + function startPersist() { + mount.idbPersistState = "idb"; + // Mark that we are currently running a sync operation + IDBFS.syncfs(mount, /*populate:*/ false, onPersistComplete); + } + if (!mount.idbPersistState) { + // Programs typically write/copy/move multiple files in the in-memory + // filesystem within a single app frame, so when a filesystem sync + // command is triggered, do not start it immediately, but only after + // the current frame is finished. This way all the modified files + // inside the main loop tick will be batched up to the same sync. + mount.idbPersistState = setTimeout(startPersist, 0); + } else if (mount.idbPersistState === "idb") { + // There is an active IndexedDB sync operation in-flight, but we now + // have accumulated more files to sync. We should therefore queue up + // a new sync after the current one finishes so that all writes + // will be properly persisted. + mount.idbPersistState = "again"; + } + }, + mount: mount => { + // reuse core MEMFS functionality + var mnt = MEMFS.mount(mount); + // If the automatic IDBFS persistence option has been selected, then automatically persist + // all modifications to the filesystem as they occur. + if (mount?.opts?.autoPersist) { + mnt.idbPersistState = 0; + // IndexedDB sync starts in idle state + var memfs_node_ops = mnt.node_ops; + mnt.node_ops = Object.assign({}, mnt.node_ops); + // Clone node_ops to inject write tracking + mnt.node_ops.mknod = (parent, name, mode, dev) => { + var node = memfs_node_ops.mknod(parent, name, mode, dev); + // Propagate injected node_ops to the newly created child node + node.node_ops = mnt.node_ops; + // Remember for each IDBFS node which IDBFS mount point they came from so we know which mount to persist on modification. + node.idbfs_mount = mnt.mount; + // Remember original MEMFS stream_ops for this node + node.memfs_stream_ops = node.stream_ops; + // Clone stream_ops to inject write tracking + node.stream_ops = Object.assign({}, node.stream_ops); + // Track all file writes + node.stream_ops.write = (stream, buffer, offset, length, position, canOwn) => { + // This file has been modified, we must persist IndexedDB when this file closes + stream.node.isModified = true; + return node.memfs_stream_ops.write(stream, buffer, offset, length, position, canOwn); + }; + // Persist IndexedDB on file close + node.stream_ops.close = stream => { + var n = stream.node; + if (n.isModified) { + IDBFS.queuePersist(n.idbfs_mount); + n.isModified = false; + } + if (n.memfs_stream_ops.close) return n.memfs_stream_ops.close(stream); + }; + return node; + }; + // Also kick off persisting the filesystem on other operations that modify the filesystem. + mnt.node_ops.mkdir = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.mkdir(...args)); + mnt.node_ops.rmdir = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.rmdir(...args)); + mnt.node_ops.symlink = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.symlink(...args)); + mnt.node_ops.unlink = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.unlink(...args)); + mnt.node_ops.rename = (...args) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.rename(...args)); + } + return mnt; + }, + syncfs: (mount, populate, callback) => { + IDBFS.getLocalSet(mount, (err, local) => { + if (err) return callback(err); + IDBFS.getRemoteSet(mount, (err, remote) => { + if (err) return callback(err); + var src = populate ? remote : local; + var dst = populate ? local : remote; + IDBFS.reconcile(src, dst, callback); + }); + }); + }, + quit: () => { + Object.values(IDBFS.dbs).forEach(value => value.close()); + IDBFS.dbs = {}; + }, + getDB: (name, callback) => { + // check the cache first + var db = IDBFS.dbs[name]; + if (db) { + return callback(null, db); + } + var req; + try { + req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION); + } catch (e) { + return callback(e); + } + if (!req) { + return callback("Unable to connect to IndexedDB"); + } + req.onupgradeneeded = e => { + var db = /** @type {IDBDatabase} */ (e.target.result); + var transaction = e.target.transaction; + var fileStore; + if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) { + fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME); + } else { + fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME); + } + if (!fileStore.indexNames.contains("timestamp")) { + fileStore.createIndex("timestamp", "timestamp", { + unique: false + }); + } + }; + req.onsuccess = () => { + db = /** @type {IDBDatabase} */ (req.result); + // add to the cache + IDBFS.dbs[name] = db; + callback(null, db); + }; + req.onerror = e => { + callback(e.target.error); + e.preventDefault(); + }; + }, + getLocalSet: (mount, callback) => { + var entries = {}; + function isRealDir(p) { + return p !== "." && p !== ".."; + } + function toAbsolute(root) { + return p => PATH.join2(root, p); + } + var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint)); + while (check.length) { + var path = check.pop(); + var stat; + try { + stat = FS.stat(path); + } catch (e) { + return callback(e); + } + if (FS.isDir(stat.mode)) { + check.push(...FS.readdir(path).filter(isRealDir).map(toAbsolute(path))); + } + entries[path] = { + "timestamp": stat.mtime + }; + } + return callback(null, { + type: "local", + entries + }); + }, + getRemoteSet: (mount, callback) => { + var entries = {}; + IDBFS.getDB(mount.mountpoint, (err, db) => { + if (err) return callback(err); + try { + var transaction = db.transaction([ IDBFS.DB_STORE_NAME ], "readonly"); + transaction.onerror = e => { + callback(e.target.error); + e.preventDefault(); + }; + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + var index = store.index("timestamp"); + index.openKeyCursor().onsuccess = event => { + var cursor = event.target.result; + if (!cursor) { + return callback(null, { + type: "remote", + db, + entries + }); + } + entries[cursor.primaryKey] = { + "timestamp": cursor.key + }; + cursor.continue(); + }; + } catch (e) { + return callback(e); + } + }); + }, + loadLocalEntry: (path, callback) => { + var stat, node; + try { + var lookup = FS.lookupPath(path); + node = lookup.node; + stat = FS.stat(path); + } catch (e) { + return callback(e); + } + if (FS.isDir(stat.mode)) { + return callback(null, { + "timestamp": stat.mtime, + "mode": stat.mode + }); + } else if (FS.isFile(stat.mode)) { + // Performance consideration: storing a normal JavaScript array to a IndexedDB is much slower than storing a typed array. + // Therefore always convert the file contents to a typed array first before writing the data to IndexedDB. + node.contents = MEMFS.getFileDataAsTypedArray(node); + return callback(null, { + "timestamp": stat.mtime, + "mode": stat.mode, + "contents": node.contents + }); + } else { + return callback(new Error("node type not supported")); + } + }, + storeLocalEntry: (path, entry, callback) => { + try { + if (FS.isDir(entry["mode"])) { + FS.mkdirTree(path, entry["mode"]); + } else if (FS.isFile(entry["mode"])) { + FS.writeFile(path, entry["contents"], { + canOwn: true + }); + } else { + return callback(new Error("node type not supported")); + } + FS.chmod(path, entry["mode"]); + FS.utime(path, entry["timestamp"], entry["timestamp"]); + } catch (e) { + return callback(e); + } + callback(null); + }, + removeLocalEntry: (path, callback) => { + try { + var stat = FS.stat(path); + if (FS.isDir(stat.mode)) { + FS.rmdir(path); + } else if (FS.isFile(stat.mode)) { + FS.unlink(path); + } + } catch (e) { + return callback(e); + } + callback(null); + }, + loadRemoteEntry: (store, path, callback) => { + var req = store.get(path); + req.onsuccess = event => callback(null, event.target.result); + req.onerror = e => { + callback(e.target.error); + e.preventDefault(); + }; + }, + storeRemoteEntry: (store, path, entry, callback) => { + try { + var req = store.put(entry, path); + } catch (e) { + callback(e); + return; + } + req.onsuccess = event => callback(); + req.onerror = e => { + callback(e.target.error); + e.preventDefault(); + }; + }, + removeRemoteEntry: (store, path, callback) => { + var req = store.delete(path); + req.onsuccess = event => callback(); + req.onerror = e => { + callback(e.target.error); + e.preventDefault(); + }; + }, + reconcile: (src, dst, callback) => { + var total = 0; + var create = []; + Object.keys(src.entries).forEach(key => { + var e = src.entries[key]; + var e2 = dst.entries[key]; + if (!e2 || e["timestamp"].getTime() != e2["timestamp"].getTime()) { + create.push(key); + total++; + } + }); + var remove = []; + Object.keys(dst.entries).forEach(key => { + if (!src.entries[key]) { + remove.push(key); + total++; + } + }); + if (!total) { + return callback(null); + } + var errored = false; + var db = src.type === "remote" ? src.db : dst.db; + var transaction = db.transaction([ IDBFS.DB_STORE_NAME ], "readwrite"); + var store = transaction.objectStore(IDBFS.DB_STORE_NAME); + function done(err) { + if (err && !errored) { + errored = true; + return callback(err); + } + } + // transaction may abort if (for example) there is a QuotaExceededError + transaction.onerror = transaction.onabort = e => { + done(e.target.error); + e.preventDefault(); + }; + transaction.oncomplete = e => { + if (!errored) { + callback(null); + } + }; + // sort paths in ascending order so directory entries are created + // before the files inside them + create.sort().forEach(path => { + if (dst.type === "local") { + IDBFS.loadRemoteEntry(store, path, (err, entry) => { + if (err) return done(err); + IDBFS.storeLocalEntry(path, entry, done); + }); + } else { + IDBFS.loadLocalEntry(path, (err, entry) => { + if (err) return done(err); + IDBFS.storeRemoteEntry(store, path, entry, done); + }); + } + }); + // sort paths in descending order so files are deleted before their + // parent directories + remove.sort().reverse().forEach(path => { + if (dst.type === "local") { + IDBFS.removeLocalEntry(path, done); + } else { + IDBFS.removeRemoteEntry(store, path, done); + } + }); + } +}; + +var FS = { + root: null, + mounts: [], + devices: {}, + streams: [], + nextInode: 1, + nameTable: null, + currentPath: "/", + initialized: false, + ignorePermissions: true, + ErrnoError: class { + 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) { + this.errno = errno; + } + }, + 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) { + 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) { + // 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) & 255), + makedev: (ma, mi) => ((ma) << 8 | (mi)), + registerDevice(dev, ops) { + FS.devices[dev] = { + stream_ops: ops + }; + }, + getDevice: dev => FS.devices[dev], + getMounts(mount) { + var mounts = []; + var check = [ mount ]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push(...m.mounts); + } + return mounts; + }, + syncfs(populate, callback) { + if (typeof populate == "function") { + callback = populate; + populate = false; + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`); + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + function doCallback(errCode) { + FS.syncFSRequests--; + return callback(errCode); + } + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + } + // sync all mounts + mounts.forEach(mount => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, + mount(type, opts, mountpoint) { + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + mountpoint = lookup.path; + // 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); + 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); + }, + statfs(path) { + // NOTE: None of the defaults here are true. We're just returning safe and + // sane values. + var rtn = { + bsize: 4096, + frsize: 4096, + blocks: 1e6, + bfree: 5e5, + bavail: 5e5, + files: FS.nextInode, + ffree: FS.nextInode - 1, + fsid: 42, + flags: 2, + namelen: 255 + }; + var parent = FS.lookupPath(path, { + follow: true + }).node; + if (parent?.node_ops.statfs) { + Object.assign(rtn, parent.node_ops.statfs(parent.mount.opts.root)); + } + return rtn; + }, + create(path, mode = 438) { + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir(path, mode = 511) { + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + }, + mkdirTree(path, mode) { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode); + } catch (e) { + if (e.errno != 20) throw e; + } + } + }, + mkdev(path, mode, dev) { + if (typeof dev == "undefined") { + dev = mode; + mode = 438; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }, + symlink(oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + }, + rename(old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // 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) {} + // 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 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 = 438) { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == "object") { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) {} + } + // 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) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + }, + write(stream, buffer, offset, length, position, canOwn) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // 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) { + 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", 16895, 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); + }, + staticInit() { + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { + "MEMFS": MEMFS, + "IDBFS": IDBFS + }; + }, + init(input, output, error) { + 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 + // 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 + }; + } + 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); + 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, GROWABLE_HEAP_I8(), ptr, length, position); + return { + ptr, + allocated: true + }; + }; + node.stream_ops = stream_ops; + return node; + } +}; + +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); + GROWABLE_HEAP_I32()[((buf) >> 2)] = stat.dev; + GROWABLE_HEAP_I32()[(((buf) + (4)) >> 2)] = stat.mode; + GROWABLE_HEAP_U32()[(((buf) + (8)) >> 2)] = stat.nlink; + GROWABLE_HEAP_I32()[(((buf) + (12)) >> 2)] = stat.uid; + GROWABLE_HEAP_I32()[(((buf) + (16)) >> 2)] = stat.gid; + GROWABLE_HEAP_I32()[(((buf) + (20)) >> 2)] = stat.rdev; + (tempI64 = [ stat.size >>> 0, (tempDouble = stat.size, (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[(((buf) + (24)) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((buf) + (28)) >> 2)] = tempI64[1]); + GROWABLE_HEAP_I32()[(((buf) + (32)) >> 2)] = 4096; + GROWABLE_HEAP_I32()[(((buf) + (36)) >> 2)] = stat.blocks; + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + (tempI64 = [ Math.floor(atime / 1e3) >>> 0, (tempDouble = Math.floor(atime / 1e3), + (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[(((buf) + (40)) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((buf) + (44)) >> 2)] = tempI64[1]); + GROWABLE_HEAP_U32()[(((buf) + (48)) >> 2)] = (atime % 1e3) * 1e3 * 1e3; + (tempI64 = [ Math.floor(mtime / 1e3) >>> 0, (tempDouble = Math.floor(mtime / 1e3), + (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[(((buf) + (56)) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((buf) + (60)) >> 2)] = tempI64[1]); + GROWABLE_HEAP_U32()[(((buf) + (64)) >> 2)] = (mtime % 1e3) * 1e3 * 1e3; + (tempI64 = [ Math.floor(ctime / 1e3) >>> 0, (tempDouble = Math.floor(ctime / 1e3), + (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[(((buf) + (72)) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((buf) + (76)) >> 2)] = tempI64[1]); + GROWABLE_HEAP_U32()[(((buf) + (80)) >> 2)] = (ctime % 1e3) * 1e3 * 1e3; + (tempI64 = [ stat.ino >>> 0, (tempDouble = stat.ino, (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[(((buf) + (88)) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((buf) + (92)) >> 2)] = tempI64[1]); + 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 = GROWABLE_HEAP_U8().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) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(3, 0, 1, dirfd, path, amode, flags); + try { + path = SYSCALLS.getStr(path); + 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 = () => { + // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number. + var ret = GROWABLE_HEAP_I32()[((+SYSCALLS.varargs) >> 2)]; + SYSCALLS.varargs += 4; + return ret; +}; + +var syscallGetVarargP = syscallGetVarargI; + +function ___syscall_fcntl64(fd, cmd, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(4, 0, 1, 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. + GROWABLE_HEAP_I16()[(((arg) + (offset)) >> 1)] = 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; + } +} + +function ___syscall_fstat64(fd, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(5, 0, 1, fd, buf); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_ftruncate64(fd, length_low, length_high) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(6, 0, 1, fd, length_low, length_high); + var length = convertI32PairToI53Checked(length_low, length_high); + try { + if (isNaN(length)) return 61; + FS.ftruncate(fd, length); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, GROWABLE_HEAP_U8(), outPtr, maxBytesToWrite); + +function ___syscall_getdents64(fd, dirp, count) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(7, 0, 1, fd, dirp, count); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + stream.getdents ||= FS.readdir(stream.path); + var struct_size = 280; + var pos = 0; + var off = FS.llseek(stream, 0, 1); + var idx = Math.floor(off / struct_size); + while (idx < stream.getdents.length && pos + struct_size <= count) { + var id; + var type; + var name = stream.getdents[idx]; + if (name === ".") { + id = stream.node.id; + type = 4; + } else // DT_DIR + if (name === "..") { + var lookup = FS.lookupPath(stream.path, { + parent: true + }); + id = lookup.node.id; + type = 4; + } else // DT_DIR + { + var child = FS.lookupNode(stream.node, name); + id = child.id; + type = FS.isChrdev(child.mode) ? 2 : // DT_CHR, character device. + FS.isDir(child.mode) ? 4 : // DT_DIR, directory. + FS.isLink(child.mode) ? 10 : // DT_LNK, symbolic link. + 8; + } + // DT_REG, regular file. + (tempI64 = [ id >>> 0, (tempDouble = id, (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[((dirp + pos) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((dirp + pos) + (4)) >> 2)] = tempI64[1]); + (tempI64 = [ (idx + 1) * struct_size >>> 0, (tempDouble = (idx + 1) * struct_size, + (+(Math.abs(tempDouble))) >= 1 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[(((dirp + pos) + (8)) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((dirp + pos) + (12)) >> 2)] = tempI64[1]); + GROWABLE_HEAP_I16()[(((dirp + pos) + (16)) >> 1)] = 280; + GROWABLE_HEAP_I8()[(dirp + pos) + (18)] = type; + stringToUTF8(name, dirp + pos + 19, 256); + pos += struct_size; + idx += 1; + } + FS.llseek(stream, idx * struct_size, 0); + return pos; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_ioctl(fd, op, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(8, 0, 1, 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(); + GROWABLE_HEAP_I32()[((argp) >> 2)] = termios.c_iflag || 0; + GROWABLE_HEAP_I32()[(((argp) + (4)) >> 2)] = termios.c_oflag || 0; + GROWABLE_HEAP_I32()[(((argp) + (8)) >> 2)] = termios.c_cflag || 0; + GROWABLE_HEAP_I32()[(((argp) + (12)) >> 2)] = termios.c_lflag || 0; + for (var i = 0; i < 32; i++) { + GROWABLE_HEAP_I8()[(argp + i) + (17)] = 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 = GROWABLE_HEAP_I32()[((argp) >> 2)]; + var c_oflag = GROWABLE_HEAP_I32()[(((argp) + (4)) >> 2)]; + var c_cflag = GROWABLE_HEAP_I32()[(((argp) + (8)) >> 2)]; + var c_lflag = GROWABLE_HEAP_I32()[(((argp) + (12)) >> 2)]; + var c_cc = []; + for (var i = 0; i < 32; i++) { + c_cc.push(GROWABLE_HEAP_I8()[(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(); + GROWABLE_HEAP_I32()[((argp) >> 2)] = 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(); + GROWABLE_HEAP_I16()[((argp) >> 1)] = winsize[0]; + GROWABLE_HEAP_I16()[(((argp) + (2)) >> 1)] = 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_lstat64(path, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(9, 0, 1, path, buf); + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_mkdirat(dirfd, path, mode) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(10, 0, 1, dirfd, path, mode); + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + // remove a trailing slash, if one - /a/b/ has basename of '', but + // we want to create b in the context of this function + path = PATH.normalize(path); + if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1); + FS.mkdir(path, mode, 0); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_newfstatat(dirfd, path, buf, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(11, 0, 1, dirfd, path, buf, flags); + try { + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & (~6400); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_openat(dirfd, path, flags, varargs) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(12, 0, 1, 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 PIPEFS = { + BUCKET_BUFFER_SIZE: 8192, + mount(mount) { + // Do not pollute the real root directory or its child nodes with pipes + // Looks like it is OK to create another pseudo-root node not linked to the FS.root hierarchy this way + return FS.createNode(null, "/", 16384 | 511, 0); + }, + createPipe() { + var pipe = { + buckets: [], + // refcnt 2 because pipe has a read end and a write end. We need to be + // able to read from the read end after write end is closed. + refcnt: 2 + }; + pipe.buckets.push({ + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: 0, + roffset: 0 + }); + var rName = PIPEFS.nextname(); + var wName = PIPEFS.nextname(); + var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0); + var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0); + rNode.pipe = pipe; + wNode.pipe = pipe; + var readableStream = FS.createStream({ + path: rName, + node: rNode, + flags: 0, + seekable: false, + stream_ops: PIPEFS.stream_ops + }); + rNode.stream = readableStream; + var writableStream = FS.createStream({ + path: wName, + node: wNode, + flags: 1, + seekable: false, + stream_ops: PIPEFS.stream_ops + }); + wNode.stream = writableStream; + return { + readable_fd: readableStream.fd, + writable_fd: writableStream.fd + }; + }, + stream_ops: { + poll(stream) { + var pipe = stream.node.pipe; + if ((stream.flags & 2097155) === 1) { + return (256 | 4); + } + if (pipe.buckets.length > 0) { + for (var i = 0; i < pipe.buckets.length; i++) { + var bucket = pipe.buckets[i]; + if (bucket.offset - bucket.roffset > 0) { + return (64 | 1); + } + } + } + return 0; + }, + ioctl(stream, request, varargs) { + return 28; + }, + fsync(stream) { + return 28; + }, + read(stream, buffer, offset, length, position) { + /* ignored */ var pipe = stream.node.pipe; + var currentLength = 0; + for (var i = 0; i < pipe.buckets.length; i++) { + var bucket = pipe.buckets[i]; + currentLength += bucket.offset - bucket.roffset; + } + var data = buffer.subarray(offset, offset + length); + if (length <= 0) { + return 0; + } + if (currentLength == 0) { + // Behave as if the read end is always non-blocking + throw new FS.ErrnoError(6); + } + var toRead = Math.min(currentLength, length); + var totalRead = toRead; + var toRemove = 0; + for (var i = 0; i < pipe.buckets.length; i++) { + var currBucket = pipe.buckets[i]; + var bucketSize = currBucket.offset - currBucket.roffset; + if (toRead <= bucketSize) { + var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset); + if (toRead < bucketSize) { + tmpSlice = tmpSlice.subarray(0, toRead); + currBucket.roffset += toRead; + } else { + toRemove++; + } + data.set(tmpSlice); + break; + } else { + var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset); + data.set(tmpSlice); + data = data.subarray(tmpSlice.byteLength); + toRead -= tmpSlice.byteLength; + toRemove++; + } + } + if (toRemove && toRemove == pipe.buckets.length) { + // Do not generate excessive garbage in use cases such as + // write several bytes, read everything, write several bytes, read everything... + toRemove--; + pipe.buckets[toRemove].offset = 0; + pipe.buckets[toRemove].roffset = 0; + } + pipe.buckets.splice(0, toRemove); + return totalRead; + }, + write(stream, buffer, offset, length, position) { + /* ignored */ var pipe = stream.node.pipe; + var data = buffer.subarray(offset, offset + length); + var dataLen = data.byteLength; + if (dataLen <= 0) { + return 0; + } + var currBucket = null; + if (pipe.buckets.length == 0) { + currBucket = { + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: 0, + roffset: 0 + }; + pipe.buckets.push(currBucket); + } else { + currBucket = pipe.buckets[pipe.buckets.length - 1]; + } + assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE); + var freeBytesInCurrBuffer = PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset; + if (freeBytesInCurrBuffer >= dataLen) { + currBucket.buffer.set(data, currBucket.offset); + currBucket.offset += dataLen; + return dataLen; + } else if (freeBytesInCurrBuffer > 0) { + currBucket.buffer.set(data.subarray(0, freeBytesInCurrBuffer), currBucket.offset); + currBucket.offset += freeBytesInCurrBuffer; + data = data.subarray(freeBytesInCurrBuffer, data.byteLength); + } + var numBuckets = (data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE) | 0; + var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE; + for (var i = 0; i < numBuckets; i++) { + var newBucket = { + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: PIPEFS.BUCKET_BUFFER_SIZE, + roffset: 0 + }; + pipe.buckets.push(newBucket); + newBucket.buffer.set(data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE)); + data = data.subarray(PIPEFS.BUCKET_BUFFER_SIZE, data.byteLength); + } + if (remElements > 0) { + var newBucket = { + buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE), + offset: data.byteLength, + roffset: 0 + }; + pipe.buckets.push(newBucket); + newBucket.buffer.set(data); + } + return dataLen; + }, + close(stream) { + var pipe = stream.node.pipe; + pipe.refcnt--; + if (pipe.refcnt === 0) { + pipe.buckets = null; + } + } + }, + nextname() { + if (!PIPEFS.nextname.current) { + PIPEFS.nextname.current = 0; + } + return "pipe[" + (PIPEFS.nextname.current++) + "]"; + } +}; + +function ___syscall_pipe(fdPtr) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(13, 0, 1, fdPtr); + try { + if (fdPtr == 0) { + throw new FS.ErrnoError(21); + } + var res = PIPEFS.createPipe(); + GROWABLE_HEAP_I32()[((fdPtr) >> 2)] = res.readable_fd; + GROWABLE_HEAP_I32()[(((fdPtr) + (4)) >> 2)] = res.writable_fd; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var SOCKFS = { + websocketArgs: {}, + callbacks: {}, + on(event, callback) { + SOCKFS.callbacks[event] = callback; + }, + emit(event, param) { + SOCKFS.callbacks[event]?.(param); + }, + mount(mount) { + // The incomming Module['websocket'] can be used for configuring + // configuring subprotocol/url, etc + SOCKFS.websocketArgs = Module["websocket"] || {}; + // Add the Event registration mechanism to the exported websocket configuration + // object so we can register network callbacks from native JavaScript too. + // For more documentation see system/include/emscripten/emscripten.h + (Module["websocket"] ??= {})["on"] = SOCKFS.on; + return FS.createNode(null, "/", 16895, 0); + }, + createSocket(family, type, protocol) { + type &= ~526336; + // Some applications may pass it; it makes no sense for a single process. + var streaming = type == 1; + if (streaming && protocol && protocol != 6) { + throw new FS.ErrnoError(66); + } + // create our internal socket structure + var sock = { + family, + type, + protocol, + server: null, + error: null, + // Used in getsockopt for SOL_SOCKET/SO_ERROR test + peers: {}, + pending: [], + recv_queue: [], + sock_ops: SOCKFS.websocket_sock_ops + }; + // create the filesystem node to store the socket structure + var name = SOCKFS.nextname(); + var node = FS.createNode(SOCKFS.root, name, 49152, 0); + node.sock = sock; + // and the wrapping stream that enables library functions such + // as read and write to indirectly interact with the socket + var stream = FS.createStream({ + path: name, + node, + flags: 2, + seekable: false, + stream_ops: SOCKFS.stream_ops + }); + // map the new stream to the socket structure (sockets have a 1:1 + // relationship with a stream) + sock.stream = stream; + return sock; + }, + getSocket(fd) { + var stream = FS.getStream(fd); + if (!stream || !FS.isSocket(stream.node.mode)) { + return null; + } + return stream.node.sock; + }, + stream_ops: { + poll(stream) { + var sock = stream.node.sock; + return sock.sock_ops.poll(sock); + }, + ioctl(stream, request, varargs) { + var sock = stream.node.sock; + return sock.sock_ops.ioctl(sock, request, varargs); + }, + read(stream, buffer, offset, length, position) { + /* ignored */ var sock = stream.node.sock; + var msg = sock.sock_ops.recvmsg(sock, length); + if (!msg) { + // socket is closed + return 0; + } + buffer.set(msg.buffer, offset); + return msg.buffer.length; + }, + write(stream, buffer, offset, length, position) { + /* ignored */ var sock = stream.node.sock; + return sock.sock_ops.sendmsg(sock, buffer, offset, length); + }, + close(stream) { + var sock = stream.node.sock; + sock.sock_ops.close(sock); + } + }, + nextname() { + if (!SOCKFS.nextname.current) { + SOCKFS.nextname.current = 0; + } + return `socket[${SOCKFS.nextname.current++}]`; + }, + websocket_sock_ops: { + createPeer(sock, addr, port) { + var ws; + if (typeof addr == "object") { + ws = addr; + addr = null; + port = null; + } + if (ws) { + // for sockets that've already connected (e.g. we're the server) + // we can inspect the _socket property for the address + if (ws._socket) { + addr = ws._socket.remoteAddress; + port = ws._socket.remotePort; + } else // if we're just now initializing a connection to the remote, + // inspect the url property + { + var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url); + if (!result) { + throw new Error("WebSocket URL must be in the format ws(s)://address:port"); + } + addr = result[1]; + port = parseInt(result[2], 10); + } + } else { + // create the actual websocket object and connect + try { + // The default value is 'ws://' the replace is needed because the compiler replaces '//' comments with '#' + // comments without checking context, so we'd end up with ws:#, the replace swaps the '#' for '//' again. + var url = "ws:#".replace("#", "//"); + // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set. + var subProtocols = "binary"; + // The default value is 'binary' + // The default WebSocket options + var opts = undefined; + // Fetch runtime WebSocket URL config. + if (SOCKFS.websocketArgs["url"]) { + url = SOCKFS.websocketArgs["url"]; + } + // Fetch runtime WebSocket subprotocol config. + if (SOCKFS.websocketArgs["subprotocol"]) { + subProtocols = SOCKFS.websocketArgs["subprotocol"]; + } else if (SOCKFS.websocketArgs["subprotocol"] === null) { + subProtocols = "null"; + } + if (url === "ws://" || url === "wss://") { + // Is the supplied URL config just a prefix, if so complete it. + var parts = addr.split("/"); + url = url + parts[0] + ":" + port + "/" + parts.slice(1).join("/"); + } + if (subProtocols !== "null") { + // The regex trims the string (removes spaces at the beginning and end, then splits the string by + // , into an Array. Whitespace removal is important for Websockify and ws. + subProtocols = subProtocols.replace(/^ +| +$/g, "").split(/ *, */); + opts = subProtocols; + } + // If node we use the ws library. + var WebSocketConstructor; + if (ENVIRONMENT_IS_NODE) { + WebSocketConstructor = /** @type{(typeof WebSocket)} */ (require("ws")); + } else { + WebSocketConstructor = WebSocket; + } + ws = new WebSocketConstructor(url, opts); + ws.binaryType = "arraybuffer"; + } catch (e) { + throw new FS.ErrnoError(23); + } + } + var peer = { + addr, + port, + socket: ws, + msg_send_queue: [] + }; + SOCKFS.websocket_sock_ops.addPeer(sock, peer); + SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer); + // if this is a bound dgram socket, send the port number first to allow + // us to override the ephemeral port reported to us by remotePort on the + // remote end. + if (sock.type === 2 && typeof sock.sport != "undefined") { + peer.msg_send_queue.push(new Uint8Array([ 255, 255, 255, 255, "p".charCodeAt(0), "o".charCodeAt(0), "r".charCodeAt(0), "t".charCodeAt(0), ((sock.sport & 65280) >> 8), (sock.sport & 255) ])); + } + return peer; + }, + getPeer(sock, addr, port) { + return sock.peers[addr + ":" + port]; + }, + addPeer(sock, peer) { + sock.peers[peer.addr + ":" + peer.port] = peer; + }, + removePeer(sock, peer) { + delete sock.peers[peer.addr + ":" + peer.port]; + }, + handlePeerEvents(sock, peer) { + var first = true; + var handleOpen = function() { + sock.connecting = false; + SOCKFS.emit("open", sock.stream.fd); + try { + var queued = peer.msg_send_queue.shift(); + while (queued) { + peer.socket.send(queued); + queued = peer.msg_send_queue.shift(); + } + } catch (e) { + // not much we can do here in the way of proper error handling as we've already + // lied and said this data was sent. shut it down. + peer.socket.close(); + } + }; + function handleMessage(data) { + if (typeof data == "string") { + var encoder = new TextEncoder; + // should be utf-8 + data = encoder.encode(data); + } else // make a typed array from the string + { + assert(data.byteLength !== undefined); + // must receive an ArrayBuffer + if (data.byteLength == 0) { + // An empty ArrayBuffer will emit a pseudo disconnect event + // as recv/recvmsg will return zero which indicates that a socket + // has performed a shutdown although the connection has not been disconnected yet. + return; + } + data = new Uint8Array(data); + } + // if this is the port message, override the peer's port with it + var wasfirst = first; + first = false; + if (wasfirst && data.length === 10 && data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 && data[4] === "p".charCodeAt(0) && data[5] === "o".charCodeAt(0) && data[6] === "r".charCodeAt(0) && data[7] === "t".charCodeAt(0)) { + // update the peer's port and it's key in the peer map + var newport = ((data[8] << 8) | data[9]); + SOCKFS.websocket_sock_ops.removePeer(sock, peer); + peer.port = newport; + SOCKFS.websocket_sock_ops.addPeer(sock, peer); + return; + } + sock.recv_queue.push({ + addr: peer.addr, + port: peer.port, + data + }); + SOCKFS.emit("message", sock.stream.fd); + } + if (ENVIRONMENT_IS_NODE) { + peer.socket.on("open", handleOpen); + peer.socket.on("message", function(data, isBinary) { + if (!isBinary) { + return; + } + handleMessage((new Uint8Array(data)).buffer); + }); + // copy from node Buffer -> ArrayBuffer + peer.socket.on("close", function() { + SOCKFS.emit("close", sock.stream.fd); + }); + peer.socket.on("error", function(error) { + // Although the ws library may pass errors that may be more descriptive than + // ECONNREFUSED they are not necessarily the expected error code e.g. + // ENOTFOUND on getaddrinfo seems to be node.js specific, so using ECONNREFUSED + // is still probably the most useful thing to do. + sock.error = 14; + // Used in getsockopt for SOL_SOCKET/SO_ERROR test. + SOCKFS.emit("error", [ sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused" ]); + }); + } else { + peer.socket.onopen = handleOpen; + peer.socket.onclose = function() { + SOCKFS.emit("close", sock.stream.fd); + }; + peer.socket.onmessage = function peer_socket_onmessage(event) { + handleMessage(event.data); + }; + peer.socket.onerror = function(error) { + // The WebSocket spec only allows a 'simple event' to be thrown on error, + // so we only really know as much as ECONNREFUSED. + sock.error = 14; + // Used in getsockopt for SOL_SOCKET/SO_ERROR test. + SOCKFS.emit("error", [ sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused" ]); + }; + } + }, + poll(sock) { + if (sock.type === 1 && sock.server) { + // listen sockets should only say they're available for reading + // if there are pending clients. + return sock.pending.length ? (64 | 1) : 0; + } + var mask = 0; + var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets + SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) : null; + if (sock.recv_queue.length || !dest || // connection-less sockets are always ready to read + (dest && dest.socket.readyState === dest.socket.CLOSING) || (dest && dest.socket.readyState === dest.socket.CLOSED)) { + // let recv return 0 once closed + mask |= (64 | 1); + } + if (!dest || // connection-less sockets are always ready to write + (dest && dest.socket.readyState === dest.socket.OPEN)) { + mask |= 4; + } + if ((dest && dest.socket.readyState === dest.socket.CLOSING) || (dest && dest.socket.readyState === dest.socket.CLOSED)) { + // When an non-blocking connect fails mark the socket as writable. + // Its up to the calling code to then use getsockopt with SO_ERROR to + // retrieve the error. + // See https://man7.org/linux/man-pages/man2/connect.2.html + if (sock.connecting) { + mask |= 4; + } else { + mask |= 16; + } + } + return mask; + }, + ioctl(sock, request, arg) { + switch (request) { + case 21531: + var bytes = 0; + if (sock.recv_queue.length) { + bytes = sock.recv_queue[0].data.length; + } + GROWABLE_HEAP_I32()[((arg) >> 2)] = bytes; + return 0; + + default: + return 28; + } + }, + close(sock) { + // if we've spawned a listen server, close it + if (sock.server) { + try { + sock.server.close(); + } catch (e) {} + sock.server = null; + } + // close any peer connections + var peers = Object.keys(sock.peers); + for (var i = 0; i < peers.length; i++) { + var peer = sock.peers[peers[i]]; + try { + peer.socket.close(); + } catch (e) {} + SOCKFS.websocket_sock_ops.removePeer(sock, peer); + } + return 0; + }, + bind(sock, addr, port) { + if (typeof sock.saddr != "undefined" || typeof sock.sport != "undefined") { + throw new FS.ErrnoError(28); + } + // already bound + sock.saddr = addr; + sock.sport = port; + // in order to emulate dgram sockets, we need to launch a listen server when + // binding on a connection-less socket + // note: this is only required on the server side + if (sock.type === 2) { + // close the existing server if it exists + if (sock.server) { + sock.server.close(); + sock.server = null; + } + // swallow error operation not supported error that occurs when binding in the + // browser where this isn't supported + try { + sock.sock_ops.listen(sock, 0); + } catch (e) { + if (!(e.name === "ErrnoError")) throw e; + if (e.errno !== 138) throw e; + } + } + }, + connect(sock, addr, port) { + if (sock.server) { + throw new FS.ErrnoError(138); + } + // TODO autobind + // if (!sock.addr && sock.type == 2) { + // } + // early out if we're already connected / in the middle of connecting + if (typeof sock.daddr != "undefined" && typeof sock.dport != "undefined") { + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport); + if (dest) { + if (dest.socket.readyState === dest.socket.CONNECTING) { + throw new FS.ErrnoError(7); + } else { + throw new FS.ErrnoError(30); + } + } + } + // add the socket to our peer list and set our + // destination address / port to match + var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); + sock.daddr = peer.addr; + sock.dport = peer.port; + // because we cannot synchronously block to wait for the WebSocket + // connection to complete, we return here pretending that the connection + // was a success. + sock.connecting = true; + }, + listen(sock, backlog) { + if (!ENVIRONMENT_IS_NODE) { + throw new FS.ErrnoError(138); + } + if (sock.server) { + throw new FS.ErrnoError(28); + } + // already listening + var WebSocketServer = require("ws").Server; + var host = sock.saddr; + sock.server = new WebSocketServer({ + host, + port: sock.sport + }); + // TODO support backlog + SOCKFS.emit("listen", sock.stream.fd); + // Send Event with listen fd. + sock.server.on("connection", function(ws) { + if (sock.type === 1) { + var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol); + // create a peer on the new socket + var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws); + newsock.daddr = peer.addr; + newsock.dport = peer.port; + // push to queue for accept to pick up + sock.pending.push(newsock); + SOCKFS.emit("connection", newsock.stream.fd); + } else { + // create a peer on the listen socket so calling sendto + // with the listen socket and an address will resolve + // to the correct client + SOCKFS.websocket_sock_ops.createPeer(sock, ws); + SOCKFS.emit("connection", sock.stream.fd); + } + }); + sock.server.on("close", function() { + SOCKFS.emit("close", sock.stream.fd); + sock.server = null; + }); + sock.server.on("error", function(error) { + // Although the ws library may pass errors that may be more descriptive than + // ECONNREFUSED they are not necessarily the expected error code e.g. + // ENOTFOUND on getaddrinfo seems to be node.js specific, so using EHOSTUNREACH + // is still probably the most useful thing to do. This error shouldn't + // occur in a well written app as errors should get trapped in the compiled + // app's own getaddrinfo call. + sock.error = 23; + // Used in getsockopt for SOL_SOCKET/SO_ERROR test. + SOCKFS.emit("error", [ sock.stream.fd, sock.error, "EHOSTUNREACH: Host is unreachable" ]); + }); + }, + // don't throw + accept(listensock) { + if (!listensock.server || !listensock.pending.length) { + throw new FS.ErrnoError(28); + } + var newsock = listensock.pending.shift(); + newsock.stream.flags = listensock.stream.flags; + return newsock; + }, + getname(sock, peer) { + var addr, port; + if (peer) { + if (sock.daddr === undefined || sock.dport === undefined) { + throw new FS.ErrnoError(53); + } + addr = sock.daddr; + port = sock.dport; + } else { + // TODO saddr and sport will be set for bind()'d UDP sockets, but what + // should we be returning for TCP sockets that've been connect()'d? + addr = sock.saddr || 0; + port = sock.sport || 0; + } + return { + addr, + port + }; + }, + sendmsg(sock, buffer, offset, length, addr, port) { + if (sock.type === 2) { + // connection-less sockets will honor the message address, + // and otherwise fall back to the bound destination address + if (addr === undefined || port === undefined) { + addr = sock.daddr; + port = sock.dport; + } + // if there was no address to fall back to, error out + if (addr === undefined || port === undefined) { + throw new FS.ErrnoError(17); + } + } else { + // connection-based sockets will only use the bound + addr = sock.daddr; + port = sock.dport; + } + // find the peer for the destination address + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port); + // early out if not connected with a connection-based socket + if (sock.type === 1) { + if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + throw new FS.ErrnoError(53); + } + } + // create a copy of the incoming data to send, as the WebSocket API + // doesn't work entirely with an ArrayBufferView, it'll just send + // the entire underlying buffer + if (ArrayBuffer.isView(buffer)) { + offset += buffer.byteOffset; + buffer = buffer.buffer; + } + var data = buffer.slice(offset, offset + length); + // WebSockets .send() does not allow passing a SharedArrayBuffer, so + // clone the the SharedArrayBuffer as regular ArrayBuffer before + // sending. + if (data instanceof SharedArrayBuffer) { + data = new Uint8Array(new Uint8Array(data)).buffer; + } + // if we don't have a cached connectionless UDP datagram connection, or + // the TCP socket is still connecting, queue the message to be sent upon + // connect, and lie, saying the data was sent now. + if (!dest || dest.socket.readyState !== dest.socket.OPEN) { + // if we're not connected, open a new connection + if (sock.type === 2) { + if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); + } + } + dest.msg_send_queue.push(data); + return length; + } + try { + // send the actual data + dest.socket.send(data); + return length; + } catch (e) { + throw new FS.ErrnoError(28); + } + }, + recvmsg(sock, length) { + // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html + if (sock.type === 1 && sock.server) { + // tcp servers should not be recv()'ing on the listen socket + throw new FS.ErrnoError(53); + } + var queued = sock.recv_queue.shift(); + if (!queued) { + if (sock.type === 1) { + var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport); + if (!dest) { + // if we have a destination address but are not connected, error out + throw new FS.ErrnoError(53); + } + if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) { + // return null if the socket has closed + return null; + } + // else, our socket is in a valid state but truly has nothing available + throw new FS.ErrnoError(6); + } + throw new FS.ErrnoError(6); + } + // queued.data will be an ArrayBuffer if it's unadulterated, but if it's + // requeued TCP data it'll be an ArrayBufferView + var queuedLength = queued.data.byteLength || queued.data.length; + var queuedOffset = queued.data.byteOffset || 0; + var queuedBuffer = queued.data.buffer || queued.data; + var bytesRead = Math.min(length, queuedLength); + var res = { + buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead), + addr: queued.addr, + port: queued.port + }; + // push back any unread data for TCP connections + if (sock.type === 1 && bytesRead < queuedLength) { + var bytesRemaining = queuedLength - bytesRead; + queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining); + sock.recv_queue.unshift(queued); + } + return res; + } + } +}; + +var getSocketFromFD = fd => { + var socket = SOCKFS.getSocket(fd); + if (!socket) throw new FS.ErrnoError(8); + return socket; +}; + +var Sockets = { + BUFFER_SIZE: 10240, + MAX_BUFFER_SIZE: 10485760, + nextFd: 1, + fds: {}, + nextport: 1, + maxport: 65535, + peer: null, + connections: {}, + portmap: {}, + localAddr: 4261412874, + addrPool: [ 33554442, 50331658, 67108874, 83886090, 100663306, 117440522, 134217738, 150994954, 167772170, 184549386, 201326602, 218103818, 234881034 ] +}; + +var inetPton4 = str => { + var b = str.split("."); + for (var i = 0; i < 4; i++) { + var tmp = Number(b[i]); + if (isNaN(tmp)) return null; + b[i] = tmp; + } + return (b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0; +}; + +/** @suppress {checkTypes} */ var jstoi_q = str => parseInt(str); + +var inetPton6 = str => { + var words; + var w, offset, z, i; + /* http://home.deds.nl/~aeron/regex/ */ var valid6regx = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i; + var parts = []; + if (!valid6regx.test(str)) { + return null; + } + if (str === "::") { + return [ 0, 0, 0, 0, 0, 0, 0, 0 ]; + } + // Z placeholder to keep track of zeros when splitting the string on ":" + if (str.startsWith("::")) { + str = str.replace("::", "Z:"); + } else // leading zeros case + { + str = str.replace("::", ":Z:"); + } + if (str.indexOf(".") > 0) { + // parse IPv4 embedded stress + str = str.replace(new RegExp("[.]", "g"), ":"); + words = str.split(":"); + words[words.length - 4] = jstoi_q(words[words.length - 4]) + jstoi_q(words[words.length - 3]) * 256; + words[words.length - 3] = jstoi_q(words[words.length - 2]) + jstoi_q(words[words.length - 1]) * 256; + words = words.slice(0, words.length - 2); + } else { + words = str.split(":"); + } + offset = 0; + z = 0; + for (w = 0; w < words.length; w++) { + if (typeof words[w] == "string") { + if (words[w] === "Z") { + // compressed zeros - write appropriate number of zero words + for (z = 0; z < (8 - words.length + 1); z++) { + parts[w + z] = 0; + } + offset = z - 1; + } else { + // parse hex to field to 16-bit value and write it in network byte-order + parts[w + offset] = _htons(parseInt(words[w], 16)); + } + } else { + // parsed IPv4 words + parts[w + offset] = words[w]; + } + } + return [ (parts[1] << 16) | parts[0], (parts[3] << 16) | parts[2], (parts[5] << 16) | parts[4], (parts[7] << 16) | parts[6] ]; +}; + +/** @param {number=} addrlen */ var writeSockaddr = (sa, family, addr, port, addrlen) => { + switch (family) { + case 2: + addr = inetPton4(addr); + zeroMemory(sa, 16); + if (addrlen) { + GROWABLE_HEAP_I32()[((addrlen) >> 2)] = 16; + } + GROWABLE_HEAP_I16()[((sa) >> 1)] = family; + GROWABLE_HEAP_I32()[(((sa) + (4)) >> 2)] = addr; + GROWABLE_HEAP_I16()[(((sa) + (2)) >> 1)] = _htons(port); + break; + + case 10: + addr = inetPton6(addr); + zeroMemory(sa, 28); + if (addrlen) { + GROWABLE_HEAP_I32()[((addrlen) >> 2)] = 28; + } + GROWABLE_HEAP_I32()[((sa) >> 2)] = family; + GROWABLE_HEAP_I32()[(((sa) + (8)) >> 2)] = addr[0]; + GROWABLE_HEAP_I32()[(((sa) + (12)) >> 2)] = addr[1]; + GROWABLE_HEAP_I32()[(((sa) + (16)) >> 2)] = addr[2]; + GROWABLE_HEAP_I32()[(((sa) + (20)) >> 2)] = addr[3]; + GROWABLE_HEAP_I16()[(((sa) + (2)) >> 1)] = _htons(port); + break; + + default: + return 5; + } + return 0; +}; + +var DNS = { + address_map: { + id: 1, + addrs: {}, + names: {} + }, + lookup_name(name) { + // If the name is already a valid ipv4 / ipv6 address, don't generate a fake one. + var res = inetPton4(name); + if (res !== null) { + return name; + } + res = inetPton6(name); + if (res !== null) { + return name; + } + // See if this name is already mapped. + var addr; + if (DNS.address_map.addrs[name]) { + addr = DNS.address_map.addrs[name]; + } else { + var id = DNS.address_map.id++; + assert(id < 65535, "exceeded max address mappings of 65535"); + addr = "172.29." + (id & 255) + "." + (id & 65280); + DNS.address_map.names[addr] = name; + DNS.address_map.addrs[name] = addr; + } + return addr; + }, + lookup_addr(addr) { + if (DNS.address_map.names[addr]) { + return DNS.address_map.names[addr]; + } + return null; + } +}; + +function ___syscall_recvfrom(fd, buf, len, flags, addr, addrlen) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(14, 0, 1, fd, buf, len, flags, addr, addrlen); + try { + var sock = getSocketFromFD(fd); + var msg = sock.sock_ops.recvmsg(sock, len); + if (!msg) return 0; + // socket is closed + if (addr) { + var errno = writeSockaddr(addr, sock.family, DNS.lookup_name(msg.addr), msg.port, addrlen); + } + GROWABLE_HEAP_U8().set(msg.buffer, buf); + return msg.buffer.byteLength; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(15, 0, 1, olddirfd, oldpath, newdirfd, newpath); + try { + oldpath = SYSCALLS.getStr(oldpath); + newpath = SYSCALLS.getStr(newpath); + oldpath = SYSCALLS.calculateAt(olddirfd, oldpath); + newpath = SYSCALLS.calculateAt(newdirfd, newpath); + FS.rename(oldpath, newpath); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_rmdir(path) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(16, 0, 1, path); + try { + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var inetNtop4 = addr => (addr & 255) + "." + ((addr >> 8) & 255) + "." + ((addr >> 16) & 255) + "." + ((addr >> 24) & 255); + +var inetNtop6 = ints => { + // ref: http://www.ietf.org/rfc/rfc2373.txt - section 2.5.4 + // Format for IPv4 compatible and mapped 128-bit IPv6 Addresses + // 128-bits are split into eight 16-bit words + // stored in network byte order (big-endian) + // | 80 bits | 16 | 32 bits | + // +-----------------------------------------------------------------+ + // | 10 bytes | 2 | 4 bytes | + // +--------------------------------------+--------------------------+ + // + 5 words | 1 | 2 words | + // +--------------------------------------+--------------------------+ + // |0000..............................0000|0000| IPv4 ADDRESS | (compatible) + // +--------------------------------------+----+---------------------+ + // |0000..............................0000|FFFF| IPv4 ADDRESS | (mapped) + // +--------------------------------------+----+---------------------+ + var str = ""; + var word = 0; + var longest = 0; + var lastzero = 0; + var zstart = 0; + var len = 0; + var i = 0; + var parts = [ ints[0] & 65535, (ints[0] >> 16), ints[1] & 65535, (ints[1] >> 16), ints[2] & 65535, (ints[2] >> 16), ints[3] & 65535, (ints[3] >> 16) ]; + // Handle IPv4-compatible, IPv4-mapped, loopback and any/unspecified addresses + var hasipv4 = true; + var v4part = ""; + // check if the 10 high-order bytes are all zeros (first 5 words) + for (i = 0; i < 5; i++) { + if (parts[i] !== 0) { + hasipv4 = false; + break; + } + } + if (hasipv4) { + // low-order 32-bits store an IPv4 address (bytes 13 to 16) (last 2 words) + v4part = inetNtop4(parts[6] | (parts[7] << 16)); + // IPv4-mapped IPv6 address if 16-bit value (bytes 11 and 12) == 0xFFFF (6th word) + if (parts[5] === -1) { + str = "::ffff:"; + str += v4part; + return str; + } + // IPv4-compatible IPv6 address if 16-bit value (bytes 11 and 12) == 0x0000 (6th word) + if (parts[5] === 0) { + str = "::"; + //special case IPv6 addresses + if (v4part === "0.0.0.0") v4part = ""; + // any/unspecified address + if (v4part === "0.0.0.1") v4part = "1"; + // loopback address + str += v4part; + return str; + } + } + // Handle all other IPv6 addresses + // first run to find the longest contiguous zero words + for (word = 0; word < 8; word++) { + if (parts[word] === 0) { + if (word - lastzero > 1) { + len = 0; + } + lastzero = word; + len++; + } + if (len > longest) { + longest = len; + zstart = word - longest + 1; + } + } + for (word = 0; word < 8; word++) { + if (longest > 1) { + // compress contiguous zeros - to produce "::" + if (parts[word] === 0 && word >= zstart && word < (zstart + longest)) { + if (word === zstart) { + str += ":"; + if (zstart === 0) str += ":"; + } + //leading zeros case + continue; + } + } + // converts 16-bit words from big-endian to little-endian before converting to hex string + str += Number(_ntohs(parts[word] & 65535)).toString(16); + str += word < 7 ? ":" : ""; + } + return str; +}; + +var readSockaddr = (sa, salen) => { + // family / port offsets are common to both sockaddr_in and sockaddr_in6 + var family = GROWABLE_HEAP_I16()[((sa) >> 1)]; + var port = _ntohs(GROWABLE_HEAP_U16()[(((sa) + (2)) >> 1)]); + var addr; + switch (family) { + case 2: + if (salen !== 16) { + return { + errno: 28 + }; + } + addr = GROWABLE_HEAP_I32()[(((sa) + (4)) >> 2)]; + addr = inetNtop4(addr); + break; + + case 10: + if (salen !== 28) { + return { + errno: 28 + }; + } + addr = [ GROWABLE_HEAP_I32()[(((sa) + (8)) >> 2)], GROWABLE_HEAP_I32()[(((sa) + (12)) >> 2)], GROWABLE_HEAP_I32()[(((sa) + (16)) >> 2)], GROWABLE_HEAP_I32()[(((sa) + (20)) >> 2)] ]; + addr = inetNtop6(addr); + break; + + default: + return { + errno: 5 + }; + } + return { + family, + addr, + port + }; +}; + +var getSocketAddress = (addrp, addrlen) => { + var info = readSockaddr(addrp, addrlen); + if (info.errno) throw new FS.ErrnoError(info.errno); + info.addr = DNS.lookup_addr(info.addr) || info.addr; + return info; +}; + +function ___syscall_sendto(fd, message, length, flags, addr, addr_len) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(17, 0, 1, fd, message, length, flags, addr, addr_len); + try { + var sock = getSocketFromFD(fd); + if (!addr) { + // send, no address provided + return FS.write(sock.stream, GROWABLE_HEAP_I8(), message, length); + } + var dest = getSocketAddress(addr, addr_len); + // sendto an address + return sock.sock_ops.sendmsg(sock, GROWABLE_HEAP_I8(), message, length, dest.addr, dest.port); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_stat64(path, buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(18, 0, 1, path, buf); + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function ___syscall_unlinkat(dirfd, path, flags) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(19, 0, 1, dirfd, path, flags); + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path); + } else if (flags === 512) { + FS.rmdir(path); + } else { + abort("Invalid flags passed to unlinkat"); + } + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var __abort_js = () => abort(""); + +var nowIsMonotonic = 1; + +var __emscripten_get_now_is_monotonic = () => nowIsMonotonic; + +var __emscripten_init_main_thread_js = tb => { + // Pass the thread address to the native code where they stored in wasm + // globals which act as a form of TLS. Global constructors trying + // to access this value will read the wrong value, but that is UB anyway. + __emscripten_thread_init(tb, /*is_main=*/ !ENVIRONMENT_IS_WORKER, /*is_runtime=*/ 1, /*can_block=*/ !ENVIRONMENT_IS_WEB, /*default_stacksize=*/ 4194304, /*start_profiling=*/ false); + PThread.threadInitTLS(); +}; + +var maybeExit = () => { + if (!keepRuntimeAlive()) { + try { + if (ENVIRONMENT_IS_PTHREAD) __emscripten_thread_exit(EXITSTATUS); else _exit(EXITSTATUS); + } catch (e) { + handleException(e); + } + } +}; + +var callUserCallback = func => { + if (ABORT) { + return; + } + try { + func(); + maybeExit(); + } catch (e) { + handleException(e); + } +}; + +var __emscripten_thread_mailbox_await = pthread_ptr => { + if (typeof Atomics.waitAsync === "function") { + // Wait on the pthread's initial self-pointer field because it is easy and + // safe to access from sending threads that need to notify the waiting + // thread. + // TODO: How to make this work with wasm64? + var wait = Atomics.waitAsync(GROWABLE_HEAP_I32(), ((pthread_ptr) >> 2), pthread_ptr); + wait.value.then(checkMailbox); + var waitingAsync = pthread_ptr + 128; + Atomics.store(GROWABLE_HEAP_I32(), ((waitingAsync) >> 2), 1); + } +}; + +// If `Atomics.waitAsync` is not implemented, then we will always fall back +// to postMessage and there is no need to do anything here. +var checkMailbox = () => { + // Only check the mailbox if we have a live pthread runtime. We implement + // pthread_self to return 0 if there is no live runtime. + var pthread_ptr = _pthread_self(); + if (pthread_ptr) { + // If we are using Atomics.waitAsync as our notification mechanism, wait + // for a notification before processing the mailbox to avoid missing any + // work that could otherwise arrive after we've finished processing the + // mailbox and before we're ready for the next notification. + __emscripten_thread_mailbox_await(pthread_ptr); + callUserCallback(__emscripten_check_mailbox); + } +}; + +var __emscripten_notify_mailbox_postmessage = (targetThread, currThreadId) => { + if (targetThread == currThreadId) { + setTimeout(checkMailbox); + } else if (ENVIRONMENT_IS_PTHREAD) { + postMessage({ + targetThread, + cmd: "checkMailbox" + }); + } else { + var worker = PThread.pthreads[targetThread]; + if (!worker) { + return; + } + worker.postMessage({ + cmd: "checkMailbox" + }); + } +}; + +var proxiedJSCallArgs = []; + +var __emscripten_receive_on_main_thread_js = (funcIndex, emAsmAddr, callingThread, numCallArgs, args) => { + // Sometimes we need to backproxy events to the calling thread (e.g. + // HTML5 DOM events handlers such as + // emscripten_set_mousemove_callback()), so keep track in a globally + // accessible variable about the thread that initiated the proxying. + proxiedJSCallArgs.length = numCallArgs; + var b = ((args) >> 3); + for (var i = 0; i < numCallArgs; i++) { + proxiedJSCallArgs[i] = GROWABLE_HEAP_F64()[b + i]; + } + // Proxied JS library funcs use funcIndex and EM_ASM functions use emAsmAddr + var func = emAsmAddr ? ASM_CONSTS[emAsmAddr] : proxiedFunctionTable[funcIndex]; + PThread.currentProxiedOperationCallerThread = callingThread; + var rtn = func(...proxiedJSCallArgs); + PThread.currentProxiedOperationCallerThread = 0; + return rtn; +}; + +var __emscripten_runtime_keepalive_clear = () => { + noExitRuntime = false; + runtimeKeepaliveCounter = 0; +}; + +var __emscripten_thread_cleanup = thread => { + // Called when a thread needs to be cleaned up so it can be reused. + // A thread is considered reusable when it either returns from its + // entry point, calls pthread_exit, or acts upon a cancellation. + // Detached threads are responsible for calling this themselves, + // otherwise pthread_join is responsible for calling this. + if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread); else postMessage({ + cmd: "cleanupThread", + thread + }); +}; + +var __emscripten_thread_set_strongref = thread => { + // Called when a thread needs to be strongly referenced. + // Currently only used for: + // - keeping the "main" thread alive in PROXY_TO_PTHREAD mode; + // - crashed threads that needs to propagate the uncaught exception + // back to the main thread. + if (ENVIRONMENT_IS_NODE) { + PThread.pthreads[thread].ref(); + } +}; + +var __emscripten_throw_longjmp = () => { + throw Infinity; +}; + +var isLeapYear = year => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + +var MONTH_DAYS_LEAP_CUMULATIVE = [ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 ]; + +var MONTH_DAYS_REGULAR_CUMULATIVE = [ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 ]; + +var ydayFromDate = date => { + var leap = isLeapYear(date.getFullYear()); + var monthDaysCumulative = (leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE); + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + // -1 since it's days since Jan 1 + return yday; +}; + +function __localtime_js(time_low, time_high, tmPtr) { + var time = convertI32PairToI53Checked(time_low, time_high); + var date = new Date(time * 1e3); + GROWABLE_HEAP_I32()[((tmPtr) >> 2)] = date.getSeconds(); + GROWABLE_HEAP_I32()[(((tmPtr) + (4)) >> 2)] = date.getMinutes(); + GROWABLE_HEAP_I32()[(((tmPtr) + (8)) >> 2)] = date.getHours(); + GROWABLE_HEAP_I32()[(((tmPtr) + (12)) >> 2)] = date.getDate(); + GROWABLE_HEAP_I32()[(((tmPtr) + (16)) >> 2)] = date.getMonth(); + GROWABLE_HEAP_I32()[(((tmPtr) + (20)) >> 2)] = date.getFullYear() - 1900; + GROWABLE_HEAP_I32()[(((tmPtr) + (24)) >> 2)] = date.getDay(); + var yday = ydayFromDate(date) | 0; + GROWABLE_HEAP_I32()[(((tmPtr) + (28)) >> 2)] = yday; + GROWABLE_HEAP_I32()[(((tmPtr) + (36)) >> 2)] = -(date.getTimezoneOffset() * 60); + // Attention: DST is in December in South, and some regions don't have DST at all. + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + GROWABLE_HEAP_I32()[(((tmPtr) + (32)) >> 2)] = dst; +} + +function __mmap_js(len, prot, flags, fd, offset_low, offset_high, allocated, addr) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(20, 0, 1, len, prot, flags, fd, offset_low, offset_high, allocated, addr); + var offset = convertI32PairToI53Checked(offset_low, offset_high); + try { + if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + var res = FS.mmap(stream, len, offset, prot, flags); + var ptr = res.ptr; + GROWABLE_HEAP_I32()[((allocated) >> 2)] = res.allocated; + GROWABLE_HEAP_U32()[((addr) >> 2)] = ptr; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +function __munmap_js(addr, len, prot, flags, fd, offset_low, offset_high) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(21, 0, 1, addr, len, prot, flags, fd, offset_low, offset_high); + var offset = convertI32PairToI53Checked(offset_low, offset_high); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + if (prot & 2) { + SYSCALLS.doMsync(addr, stream, len, flags, offset); + } + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno; + } +} + +var __tzset_js = (timezone, daylight, std_name, dst_name) => { + // TODO: Use (malleable) environment variables instead of system settings. + var currentYear = (new Date).getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + // Local standard timezone offset. Local standard time is not adjusted for + // daylight savings. This code uses the fact that getTimezoneOffset returns + // a greater value during Standard Time versus Daylight Saving Time (DST). + // Thus it determines the expected output during Standard Time, and it + // compares whether the output of the given date the same (Standard) or less + // (DST). + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + // timezone is specified as seconds west of UTC ("The external variable + // `timezone` shall be set to the difference, in seconds, between + // Coordinated Universal Time (UTC) and local standard time."), the same + // as returned by stdTimezoneOffset. + // See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html + GROWABLE_HEAP_U32()[((timezone) >> 2)] = stdTimezoneOffset * 60; + GROWABLE_HEAP_I32()[((daylight) >> 2)] = Number(winterOffset != summerOffset); + var extractZone = timezoneOffset => { + // Why inverse sign? + // Read here https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset + var sign = timezoneOffset >= 0 ? "-" : "+"; + var absOffset = Math.abs(timezoneOffset); + var hours = String(Math.floor(absOffset / 60)).padStart(2, "0"); + var minutes = String(absOffset % 60).padStart(2, "0"); + return `UTC${sign}${hours}${minutes}`; + }; + var winterName = extractZone(winterOffset); + var summerName = extractZone(summerOffset); + if (summerOffset < winterOffset) { + // Northern hemisphere + stringToUTF8(winterName, std_name, 17); + stringToUTF8(summerName, dst_name, 17); + } else { + stringToUTF8(winterName, dst_name, 17); + stringToUTF8(summerName, std_name, 17); + } +}; + +var runtimeKeepalivePush = () => { + runtimeKeepaliveCounter += 1; +}; + +var _emscripten_set_main_loop_timing = (mode, value) => { + MainLoop.timingMode = mode; + MainLoop.timingValue = value; + if (!MainLoop.func) { + return 1; + } + // Return non-zero on failure, can't set timing mode when there is no main loop. + if (!MainLoop.running) { + runtimeKeepalivePush(); + 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 + }); + } else // In --proxy-to-worker, route the message via proxyClient.js + postMessage(emscriptenMainLoopMessageId, "*"); + }); + } else { + MainLoop.setImmediate = setImmediate; + } + } + MainLoop.scheduler = function MainLoop_scheduler_setImmediate() { + MainLoop.setImmediate(MainLoop.runner); + }; + MainLoop.method = "immediate"; + } + return 0; +}; + +var _emscripten_get_now = () => performance.timeOrigin + performance.now(); + +var runtimeKeepalivePop = () => { + runtimeKeepaliveCounter -= 1; +}; + +/** + * @param {number=} arg + * @param {boolean=} noSetTiming + */ var setMainLoop = (iterFunc, fps, simulateInfiniteLoop, arg, noSetTiming) => { + MainLoop.func = iterFunc; + MainLoop.arg = arg; + var thisMainLoopId = MainLoop.currentlyRunningMainloop; + function checkIsRunning() { + if (thisMainLoopId < MainLoop.currentlyRunningMainloop) { + runtimeKeepalivePop(); + 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 + .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(); + } + 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, 1e3 / 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; + } + } + callUserCallback(func); + for (var post of MainLoop.postMainLoop) { + post(); + } + }, + nextRAF: 0, + fakeRequestAnimationFrame(func) { + // try to keep 60fps between calls to here + var now = Date.now(); + if (MainLoop.nextRAF === 0) { + MainLoop.nextRAF = now + 1e3 / 60; + } else { + while (now + 2 >= MainLoop.nextRAF) { + // fudge a little, to avoid timer jitter causing us to do lots of delay:0 + MainLoop.nextRAF += 1e3 / 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 AL = { + QUEUE_INTERVAL: 25, + QUEUE_LOOKAHEAD: .1, + DEVICE_NAME: "Emscripten OpenAL", + CAPTURE_DEVICE_NAME: "Emscripten OpenAL capture", + ALC_EXTENSIONS: { + ALC_SOFT_pause_device: true, + ALC_SOFT_HRTF: true + }, + AL_EXTENSIONS: { + AL_EXT_float32: true, + AL_SOFT_loop_points: true, + AL_SOFT_source_length: true, + AL_EXT_source_distance_model: true, + AL_SOFT_source_spatialize: true + }, + _alcErr: 0, + alcErr: 0, + deviceRefCounts: {}, + alcStringCache: {}, + paused: false, + stringCache: {}, + contexts: {}, + currentCtx: null, + buffers: { + 0: { + id: 0, + refCount: 0, + audioBuf: null, + frequency: 0, + bytesPerSample: 2, + channels: 1, + length: 0 + } + }, + paramArray: [], + _nextId: 1, + newId: () => AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++, + freeIds: [], + scheduleContextAudio: ctx => { + // If we are animating using the requestAnimationFrame method, then the main loop does not run when in the background. + // To give a perfect glitch-free audio stop when switching from foreground to background, we need to avoid updating + // audio altogether when in the background, so detect that case and kill audio buffer streaming if so. + if (MainLoop.timingMode === 1 && document["visibilityState"] != "visible") { + return; + } + for (var i in ctx.sources) { + AL.scheduleSourceAudio(ctx.sources[i]); + } + }, + scheduleSourceAudio: (src, lookahead) => { + // See comment on scheduleContextAudio above. + if (MainLoop.timingMode === 1 && document["visibilityState"] != "visible") { + return; + } + if (src.state !== 4114) { + return; + } + var currentTime = AL.updateSourceTime(src); + var startTime = src.bufStartTime; + var startOffset = src.bufOffset; + var bufCursor = src.bufsProcessed; + // Advance past any audio that is already scheduled + for (var i = 0; i < src.audioQueue.length; i++) { + var audioSrc = src.audioQueue[i]; + startTime = audioSrc._startTime + audioSrc._duration; + startOffset = 0; + bufCursor += audioSrc._skipCount + 1; + } + if (!lookahead) { + lookahead = AL.QUEUE_LOOKAHEAD; + } + var lookaheadTime = currentTime + lookahead; + var skipCount = 0; + while (startTime < lookaheadTime) { + if (bufCursor >= src.bufQueue.length) { + if (src.looping) { + bufCursor %= src.bufQueue.length; + } else { + break; + } + } + var buf = src.bufQueue[bufCursor % src.bufQueue.length]; + // If the buffer contains no data, skip it + if (buf.length === 0) { + skipCount++; + // If we've gone through the whole queue and everything is 0 length, just give up + if (skipCount === src.bufQueue.length) { + break; + } + } else { + var audioSrc = src.context.audioCtx.createBufferSource(); + audioSrc.buffer = buf.audioBuf; + audioSrc.playbackRate.value = src.playbackRate; + if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) { + audioSrc.loopStart = buf.audioBuf._loopStart; + audioSrc.loopEnd = buf.audioBuf._loopEnd; + } + var duration = 0; + // If the source is a looping static buffer, use native looping for gapless playback + if (src.type === 4136 && src.looping) { + duration = Number.POSITIVE_INFINITY; + audioSrc.loop = true; + if (buf.audioBuf._loopStart) { + audioSrc.loopStart = buf.audioBuf._loopStart; + } + if (buf.audioBuf._loopEnd) { + audioSrc.loopEnd = buf.audioBuf._loopEnd; + } + } else { + duration = (buf.audioBuf.duration - startOffset) / src.playbackRate; + } + audioSrc._startOffset = startOffset; + audioSrc._duration = duration; + audioSrc._skipCount = skipCount; + skipCount = 0; + audioSrc.connect(src.gain); + if (typeof audioSrc.start != "undefined") { + // Sample the current time as late as possible to mitigate drift + startTime = Math.max(startTime, src.context.audioCtx.currentTime); + audioSrc.start(startTime, startOffset); + } else if (typeof audioSrc.noteOn != "undefined") { + startTime = Math.max(startTime, src.context.audioCtx.currentTime); + audioSrc.noteOn(startTime); + } + audioSrc._startTime = startTime; + src.audioQueue.push(audioSrc); + startTime += duration; + } + startOffset = 0; + bufCursor++; + } + }, + updateSourceTime: src => { + var currentTime = src.context.audioCtx.currentTime; + if (src.state !== 4114) { + return currentTime; + } + // if the start time is unset, determine it based on the current offset. + // This will be the case when a source is resumed after being paused, and + // allows us to pretend that the source actually started playing some time + // in the past such that it would just now have reached the stored offset. + if (!isFinite(src.bufStartTime)) { + src.bufStartTime = currentTime - src.bufOffset / src.playbackRate; + src.bufOffset = 0; + } + var nextStartTime = 0; + while (src.audioQueue.length) { + var audioSrc = src.audioQueue[0]; + src.bufsProcessed += audioSrc._skipCount; + nextStartTime = audioSrc._startTime + audioSrc._duration; + // n.b. audioSrc._duration already factors in playbackRate, so no divide by src.playbackRate on it. + if (currentTime < nextStartTime) { + break; + } + src.audioQueue.shift(); + src.bufStartTime = nextStartTime; + src.bufOffset = 0; + src.bufsProcessed++; + } + if (src.bufsProcessed >= src.bufQueue.length && !src.looping) { + // The source has played its entire queue and is non-looping, so just mark it as stopped. + AL.setSourceState(src, 4116); + } else if (src.type === 4136 && src.looping) { + // If the source is a looping static buffer, determine the buffer offset based on the loop points + var buf = src.bufQueue[0]; + if (buf.length === 0) { + src.bufOffset = 0; + } else { + var delta = (currentTime - src.bufStartTime) * src.playbackRate; + var loopStart = buf.audioBuf._loopStart || 0; + var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration; + if (loopEnd <= loopStart) { + loopEnd = buf.audioBuf.duration; + } + if (delta < loopEnd) { + src.bufOffset = delta; + } else { + src.bufOffset = loopStart + (delta - loopStart) % (loopEnd - loopStart); + } + } + } else if (src.audioQueue[0]) { + // The source is still actively playing, so we just need to calculate where we are in the current buffer + // so it can be remembered if the source gets paused. + src.bufOffset = (currentTime - src.audioQueue[0]._startTime) * src.playbackRate; + } else { + // The source hasn't finished yet, but there is no scheduled audio left for it. This can be because + // the source has just been started/resumed, or due to an underrun caused by a long blocking operation. + // We need to determine what state we would be in by this point in time so that when we next schedule + // audio playback, it will be just as if no underrun occurred. + if (src.type !== 4136 && src.looping) { + // if the source is a looping buffer queue, let's first calculate the queue duration, so we can + // quickly fast forward past any full loops of the queue and only worry about the remainder. + var srcDuration = AL.sourceDuration(src) / src.playbackRate; + if (srcDuration > 0) { + src.bufStartTime += Math.floor((currentTime - src.bufStartTime) / srcDuration) * srcDuration; + } + } + // Since we've already skipped any full-queue loops if there were any, we just need to find + // out where in the queue the remaining time puts us, which won't require stepping through the + // entire queue more than once. + for (var i = 0; i < src.bufQueue.length; i++) { + if (src.bufsProcessed >= src.bufQueue.length) { + if (src.looping) { + src.bufsProcessed %= src.bufQueue.length; + } else { + AL.setSourceState(src, 4116); + break; + } + } + var buf = src.bufQueue[src.bufsProcessed]; + if (buf.length > 0) { + nextStartTime = src.bufStartTime + buf.audioBuf.duration / src.playbackRate; + if (currentTime < nextStartTime) { + src.bufOffset = (currentTime - src.bufStartTime) * src.playbackRate; + break; + } + src.bufStartTime = nextStartTime; + } + src.bufOffset = 0; + src.bufsProcessed++; + } + } + return currentTime; + }, + cancelPendingSourceAudio: src => { + AL.updateSourceTime(src); + for (var i = 1; i < src.audioQueue.length; i++) { + var audioSrc = src.audioQueue[i]; + audioSrc.stop(); + } + if (src.audioQueue.length > 1) { + src.audioQueue.length = 1; + } + }, + stopSourceAudio: src => { + for (var i = 0; i < src.audioQueue.length; i++) { + src.audioQueue[i].stop(); + } + src.audioQueue.length = 0; + }, + setSourceState: (src, state) => { + if (state === 4114) { + if (src.state === 4114 || src.state == 4116) { + src.bufsProcessed = 0; + src.bufOffset = 0; + } else {} + AL.stopSourceAudio(src); + src.state = 4114; + src.bufStartTime = Number.NEGATIVE_INFINITY; + AL.scheduleSourceAudio(src); + } else if (state === 4115) { + if (src.state === 4114) { + // Store off the current offset to restore with on resume. + AL.updateSourceTime(src); + AL.stopSourceAudio(src); + src.state = 4115; + } + } else if (state === 4116) { + if (src.state !== 4113) { + src.state = 4116; + src.bufsProcessed = src.bufQueue.length; + src.bufStartTime = Number.NEGATIVE_INFINITY; + src.bufOffset = 0; + AL.stopSourceAudio(src); + } + } else if (state === 4113) { + if (src.state !== 4113) { + src.state = 4113; + src.bufsProcessed = 0; + src.bufStartTime = Number.NEGATIVE_INFINITY; + src.bufOffset = 0; + AL.stopSourceAudio(src); + } + } + }, + initSourcePanner: src => { + if (src.type === 4144) /* AL_UNDETERMINED */ { + return; + } + // Find the first non-zero buffer in the queue to determine the proper format + var templateBuf = AL.buffers[0]; + for (var i = 0; i < src.bufQueue.length; i++) { + if (src.bufQueue[i].id !== 0) { + templateBuf = src.bufQueue[i]; + break; + } + } + // Create a panner if AL_SOURCE_SPATIALIZE_SOFT is set to true, or alternatively if it's set to auto and the source is mono + if (src.spatialize === 1 || (src.spatialize === 2 && /* AL_AUTO_SOFT */ templateBuf.channels === 1)) { + if (src.panner) { + return; + } + src.panner = src.context.audioCtx.createPanner(); + AL.updateSourceGlobal(src); + AL.updateSourceSpace(src); + src.panner.connect(src.context.gain); + src.gain.disconnect(); + src.gain.connect(src.panner); + } else { + if (!src.panner) { + return; + } + src.panner.disconnect(); + src.gain.disconnect(); + src.gain.connect(src.context.gain); + src.panner = null; + } + }, + updateContextGlobal: ctx => { + for (var i in ctx.sources) { + AL.updateSourceGlobal(ctx.sources[i]); + } + }, + updateSourceGlobal: src => { + var panner = src.panner; + if (!panner) { + return; + } + panner.refDistance = src.refDistance; + panner.maxDistance = src.maxDistance; + panner.rolloffFactor = src.rolloffFactor; + panner.panningModel = src.context.hrtf ? "HRTF" : "equalpower"; + // Use the source's distance model if AL_SOURCE_DISTANCE_MODEL is enabled + var distanceModel = src.context.sourceDistanceModel ? src.distanceModel : src.context.distanceModel; + switch (distanceModel) { + case 0: + panner.distanceModel = "inverse"; + panner.refDistance = 340282e33; + /* FLT_MAX */ break; + + case 53249: + /* AL_INVERSE_DISTANCE */ case 53250: + /* AL_INVERSE_DISTANCE_CLAMPED */ panner.distanceModel = "inverse"; + break; + + case 53251: + /* AL_LINEAR_DISTANCE */ case 53252: + /* AL_LINEAR_DISTANCE_CLAMPED */ panner.distanceModel = "linear"; + break; + + case 53253: + /* AL_EXPONENT_DISTANCE */ case 53254: + /* AL_EXPONENT_DISTANCE_CLAMPED */ panner.distanceModel = "exponential"; + break; + } + }, + updateListenerSpace: ctx => { + var listener = ctx.audioCtx.listener; + if (listener.positionX) { + listener.positionX.value = ctx.listener.position[0]; + listener.positionY.value = ctx.listener.position[1]; + listener.positionZ.value = ctx.listener.position[2]; + } else { + listener.setPosition(ctx.listener.position[0], ctx.listener.position[1], ctx.listener.position[2]); + } + if (listener.forwardX) { + listener.forwardX.value = ctx.listener.direction[0]; + listener.forwardY.value = ctx.listener.direction[1]; + listener.forwardZ.value = ctx.listener.direction[2]; + listener.upX.value = ctx.listener.up[0]; + listener.upY.value = ctx.listener.up[1]; + listener.upZ.value = ctx.listener.up[2]; + } else { + listener.setOrientation(ctx.listener.direction[0], ctx.listener.direction[1], ctx.listener.direction[2], ctx.listener.up[0], ctx.listener.up[1], ctx.listener.up[2]); + } + // Update sources that are relative to the listener + for (var i in ctx.sources) { + AL.updateSourceSpace(ctx.sources[i]); + } + }, + updateSourceSpace: src => { + if (!src.panner) { + return; + } + var panner = src.panner; + var posX = src.position[0]; + var posY = src.position[1]; + var posZ = src.position[2]; + var dirX = src.direction[0]; + var dirY = src.direction[1]; + var dirZ = src.direction[2]; + var listener = src.context.listener; + var lPosX = listener.position[0]; + var lPosY = listener.position[1]; + var lPosZ = listener.position[2]; + // WebAudio does spatialization in world-space coordinates, meaning both the buffer sources and + // the listener position are in the same absolute coordinate system relative to a fixed origin. + // By default, OpenAL works this way as well, but it also provides a "listener relative" mode, where + // a buffer source's coordinate are interpreted not in absolute world space, but as being relative + // to the listener object itself, so as the listener moves the source appears to move with it + // with no update required. Since web audio does not support this mode, we must transform the source + // coordinates from listener-relative space to absolute world space. + // We do this via affine transformation matrices applied to the source position and source direction. + // A change-of-basis converts from listener-space displacements to world-space displacements, + // which must be done for both the source position and direction. Lastly, the source position must be + // added to the listener position to get the final source position, since the source position represents + // a displacement from the listener. + if (src.relative) { + // Negate the listener direction since forward is -Z. + var lBackX = -listener.direction[0]; + var lBackY = -listener.direction[1]; + var lBackZ = -listener.direction[2]; + var lUpX = listener.up[0]; + var lUpY = listener.up[1]; + var lUpZ = listener.up[2]; + var inverseMagnitude = (x, y, z) => { + var length = Math.sqrt(x * x + y * y + z * z); + if (length < Number.EPSILON) { + return 0; + } + return 1 / length; + }; + // Normalize the Back vector + var invMag = inverseMagnitude(lBackX, lBackY, lBackZ); + lBackX *= invMag; + lBackY *= invMag; + lBackZ *= invMag; + // ...and the Up vector + invMag = inverseMagnitude(lUpX, lUpY, lUpZ); + lUpX *= invMag; + lUpY *= invMag; + lUpZ *= invMag; + // Calculate the Right vector as the cross product of the Up and Back vectors + var lRightX = (lUpY * lBackZ - lUpZ * lBackY); + var lRightY = (lUpZ * lBackX - lUpX * lBackZ); + var lRightZ = (lUpX * lBackY - lUpY * lBackX); + // Back and Up might not be exactly perpendicular, so the cross product also needs normalization + invMag = inverseMagnitude(lRightX, lRightY, lRightZ); + lRightX *= invMag; + lRightY *= invMag; + lRightZ *= invMag; + // Recompute Up from the now orthonormal Right and Back vectors so we have a fully orthonormal basis + lUpX = (lBackY * lRightZ - lBackZ * lRightY); + lUpY = (lBackZ * lRightX - lBackX * lRightZ); + lUpZ = (lBackX * lRightY - lBackY * lRightX); + var oldX = dirX; + var oldY = dirY; + var oldZ = dirZ; + // Use our 3 vectors to apply a change-of-basis matrix to the source direction + dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX; + dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY; + dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ; + oldX = posX; + oldY = posY; + oldZ = posZ; + // ...and to the source position + posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX; + posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY; + posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ; + // The change-of-basis corrects the orientation, but the origin is still the listener. + // Translate the source position by the listener position to finish. + posX += lPosX; + posY += lPosY; + posZ += lPosZ; + } + if (panner.positionX) { + // Assigning to panner.positionX/Y/Z unnecessarily seems to cause performance issues + // See https://github.com/emscripten-core/emscripten/issues/15847 + if (posX != panner.positionX.value) panner.positionX.value = posX; + if (posY != panner.positionY.value) panner.positionY.value = posY; + if (posZ != panner.positionZ.value) panner.positionZ.value = posZ; + } else { + panner.setPosition(posX, posY, posZ); + } + if (panner.orientationX) { + // Assigning to panner.orientation/Y/Z unnecessarily seems to cause performance issues + // See https://github.com/emscripten-core/emscripten/issues/15847 + if (dirX != panner.orientationX.value) panner.orientationX.value = dirX; + if (dirY != panner.orientationY.value) panner.orientationY.value = dirY; + if (dirZ != panner.orientationZ.value) panner.orientationZ.value = dirZ; + } else { + panner.setOrientation(dirX, dirY, dirZ); + } + var oldShift = src.dopplerShift; + var velX = src.velocity[0]; + var velY = src.velocity[1]; + var velZ = src.velocity[2]; + var lVelX = listener.velocity[0]; + var lVelY = listener.velocity[1]; + var lVelZ = listener.velocity[2]; + if (posX === lPosX && posY === lPosY && posZ === lPosZ || velX === lVelX && velY === lVelY && velZ === lVelZ) { + src.dopplerShift = 1; + } else { + // Doppler algorithm from 1.1 spec + var speedOfSound = src.context.speedOfSound; + var dopplerFactor = src.context.dopplerFactor; + var slX = lPosX - posX; + var slY = lPosY - posY; + var slZ = lPosZ - posZ; + var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ); + var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl; + var vss = (slX * velX + slY * velY + slZ * velZ) / magSl; + vls = Math.min(vls, speedOfSound / dopplerFactor); + vss = Math.min(vss, speedOfSound / dopplerFactor); + src.dopplerShift = (speedOfSound - dopplerFactor * vls) / (speedOfSound - dopplerFactor * vss); + } + if (src.dopplerShift !== oldShift) { + AL.updateSourceRate(src); + } + }, + updateSourceRate: src => { + if (src.state === 4114) { + // clear scheduled buffers + AL.cancelPendingSourceAudio(src); + var audioSrc = src.audioQueue[0]; + if (!audioSrc) { + return; + } + // It is possible that AL.scheduleContextAudio() has not yet fed the next buffer, if so, skip. + var duration; + if (src.type === 4136 && src.looping) { + duration = Number.POSITIVE_INFINITY; + } else { + // audioSrc._duration is expressed after factoring in playbackRate, so when changing playback rate, need + // to recompute/rescale the rate to the new playback speed. + duration = (audioSrc.buffer.duration - audioSrc._startOffset) / src.playbackRate; + } + audioSrc._duration = duration; + audioSrc.playbackRate.value = src.playbackRate; + // reschedule buffers with the new playbackRate + AL.scheduleSourceAudio(src); + } + }, + sourceDuration: src => { + var length = 0; + for (var i = 0; i < src.bufQueue.length; i++) { + var audioBuf = src.bufQueue[i].audioBuf; + length += audioBuf ? audioBuf.duration : 0; + } + return length; + }, + sourceTell: src => { + AL.updateSourceTime(src); + var offset = 0; + for (var i = 0; i < src.bufsProcessed; i++) { + if (src.bufQueue[i].audioBuf) { + offset += src.bufQueue[i].audioBuf.duration; + } + } + offset += src.bufOffset; + return offset; + }, + sourceSeek: (src, offset) => { + var playing = src.state == 4114; + if (playing) { + AL.setSourceState(src, 4113); + } + if (src.bufQueue[src.bufsProcessed].audioBuf !== null) { + src.bufsProcessed = 0; + while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) { + offset -= src.bufQueue[src.bufsProcessed].audioBuf.duration; + src.bufsProcessed++; + } + src.bufOffset = offset; + } + if (playing) { + AL.setSourceState(src, 4114); + } + }, + getGlobalParam: (funcname, param) => { + if (!AL.currentCtx) { + return null; + } + switch (param) { + case 49152: + return AL.currentCtx.dopplerFactor; + + case 49155: + return AL.currentCtx.speedOfSound; + + case 53248: + return AL.currentCtx.distanceModel; + + default: + AL.currentCtx.err = 40962; + return null; + } + }, + setGlobalParam: (funcname, param, value) => { + if (!AL.currentCtx) { + return; + } + switch (param) { + case 49152: + if (!Number.isFinite(value) || value < 0) { + // Strictly negative values are disallowed + AL.currentCtx.err = 40963; + return; + } + AL.currentCtx.dopplerFactor = value; + AL.updateListenerSpace(AL.currentCtx); + break; + + case 49155: + if (!Number.isFinite(value) || value <= 0) { + // Negative or zero values are disallowed + AL.currentCtx.err = 40963; + return; + } + AL.currentCtx.speedOfSound = value; + AL.updateListenerSpace(AL.currentCtx); + break; + + case 53248: + switch (value) { + case 0: + case 53249: + /* AL_INVERSE_DISTANCE */ case 53250: + /* AL_INVERSE_DISTANCE_CLAMPED */ case 53251: + /* AL_LINEAR_DISTANCE */ case 53252: + /* AL_LINEAR_DISTANCE_CLAMPED */ case 53253: + /* AL_EXPONENT_DISTANCE */ case 53254: + /* AL_EXPONENT_DISTANCE_CLAMPED */ AL.currentCtx.distanceModel = value; + AL.updateContextGlobal(AL.currentCtx); + break; + + default: + AL.currentCtx.err = 40963; + return; + } + break; + + default: + AL.currentCtx.err = 40962; + return; + } + }, + getListenerParam: (funcname, param) => { + if (!AL.currentCtx) { + return null; + } + switch (param) { + case 4100: + return AL.currentCtx.listener.position; + + case 4102: + return AL.currentCtx.listener.velocity; + + case 4111: + return AL.currentCtx.listener.direction.concat(AL.currentCtx.listener.up); + + case 4106: + return AL.currentCtx.gain.gain.value; + + default: + AL.currentCtx.err = 40962; + return null; + } + }, + setListenerParam: (funcname, param, value) => { + if (!AL.currentCtx) { + return; + } + if (value === null) { + AL.currentCtx.err = 40962; + return; + } + var listener = AL.currentCtx.listener; + switch (param) { + case 4100: + if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) { + AL.currentCtx.err = 40963; + return; + } + listener.position[0] = value[0]; + listener.position[1] = value[1]; + listener.position[2] = value[2]; + AL.updateListenerSpace(AL.currentCtx); + break; + + case 4102: + if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) { + AL.currentCtx.err = 40963; + return; + } + listener.velocity[0] = value[0]; + listener.velocity[1] = value[1]; + listener.velocity[2] = value[2]; + AL.updateListenerSpace(AL.currentCtx); + break; + + case 4106: + if (!Number.isFinite(value) || value < 0) { + AL.currentCtx.err = 40963; + return; + } + AL.currentCtx.gain.gain.value = value; + break; + + case 4111: + if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2]) || !Number.isFinite(value[3]) || !Number.isFinite(value[4]) || !Number.isFinite(value[5])) { + AL.currentCtx.err = 40963; + return; + } + listener.direction[0] = value[0]; + listener.direction[1] = value[1]; + listener.direction[2] = value[2]; + listener.up[0] = value[3]; + listener.up[1] = value[4]; + listener.up[2] = value[5]; + AL.updateListenerSpace(AL.currentCtx); + break; + + default: + AL.currentCtx.err = 40962; + return; + } + }, + getBufferParam: (funcname, bufferId, param) => { + if (!AL.currentCtx) { + return; + } + var buf = AL.buffers[bufferId]; + if (!buf || bufferId === 0) { + AL.currentCtx.err = 40961; + return; + } + switch (param) { + case 8193: + /* AL_FREQUENCY */ return buf.frequency; + + case 8194: + /* AL_BITS */ return buf.bytesPerSample * 8; + + case 8195: + /* AL_CHANNELS */ return buf.channels; + + case 8196: + /* AL_SIZE */ return buf.length * buf.bytesPerSample * buf.channels; + + case 8213: + /* AL_LOOP_POINTS_SOFT */ if (buf.length === 0) { + return [ 0, 0 ]; + } + return [ (buf.audioBuf._loopStart || 0) * buf.frequency, (buf.audioBuf._loopEnd || buf.length) * buf.frequency ]; + + default: + AL.currentCtx.err = 40962; + return null; + } + }, + setBufferParam: (funcname, bufferId, param, value) => { + if (!AL.currentCtx) { + return; + } + var buf = AL.buffers[bufferId]; + if (!buf || bufferId === 0) { + AL.currentCtx.err = 40961; + return; + } + if (value === null) { + AL.currentCtx.err = 40962; + return; + } + switch (param) { + case 8196: + /* AL_SIZE */ if (value !== 0) { + AL.currentCtx.err = 40963; + return; + } + // Per the spec, setting AL_SIZE to 0 is a legal NOP. + break; + + case 8213: + /* AL_LOOP_POINTS_SOFT */ if (value[0] < 0 || value[0] > buf.length || value[1] < 0 || value[1] > buf.Length || value[0] >= value[1]) { + AL.currentCtx.err = 40963; + return; + } + if (buf.refCount > 0) { + AL.currentCtx.err = 40964; + return; + } + if (buf.audioBuf) { + buf.audioBuf._loopStart = value[0] / buf.frequency; + buf.audioBuf._loopEnd = value[1] / buf.frequency; + } + break; + + default: + AL.currentCtx.err = 40962; + return; + } + }, + getSourceParam: (funcname, sourceId, param) => { + if (!AL.currentCtx) { + return null; + } + var src = AL.currentCtx.sources[sourceId]; + if (!src) { + AL.currentCtx.err = 40961; + return null; + } + switch (param) { + case 514: + /* AL_SOURCE_RELATIVE */ return src.relative; + + case 4097: + /* AL_CONE_INNER_ANGLE */ return src.coneInnerAngle; + + case 4098: + /* AL_CONE_OUTER_ANGLE */ return src.coneOuterAngle; + + case 4099: + /* AL_PITCH */ return src.pitch; + + case 4100: + return src.position; + + case 4101: + return src.direction; + + case 4102: + return src.velocity; + + case 4103: + /* AL_LOOPING */ return src.looping; + + case 4105: + /* AL_BUFFER */ if (src.type === 4136) { + return src.bufQueue[0].id; + } + return 0; + + case 4106: + return src.gain.gain.value; + + case 4109: + /* AL_MIN_GAIN */ return src.minGain; + + case 4110: + /* AL_MAX_GAIN */ return src.maxGain; + + case 4112: + /* AL_SOURCE_STATE */ return src.state; + + case 4117: + /* AL_BUFFERS_QUEUED */ if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) { + return 0; + } + return src.bufQueue.length; + + case 4118: + /* AL_BUFFERS_PROCESSED */ if ((src.bufQueue.length === 1 && src.bufQueue[0].id === 0) || src.looping) { + return 0; + } + return src.bufsProcessed; + + case 4128: + /* AL_REFERENCE_DISTANCE */ return src.refDistance; + + case 4129: + /* AL_ROLLOFF_FACTOR */ return src.rolloffFactor; + + case 4130: + /* AL_CONE_OUTER_GAIN */ return src.coneOuterGain; + + case 4131: + /* AL_MAX_DISTANCE */ return src.maxDistance; + + case 4132: + /* AL_SEC_OFFSET */ return AL.sourceTell(src); + + case 4133: + /* AL_SAMPLE_OFFSET */ var offset = AL.sourceTell(src); + if (offset > 0) { + offset *= src.bufQueue[0].frequency; + } + return offset; + + case 4134: + /* AL_BYTE_OFFSET */ var offset = AL.sourceTell(src); + if (offset > 0) { + offset *= src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample; + } + return offset; + + case 4135: + /* AL_SOURCE_TYPE */ return src.type; + + case 4628: + /* AL_SOURCE_SPATIALIZE_SOFT */ return src.spatialize; + + case 8201: + /* AL_BYTE_LENGTH_SOFT */ var length = 0; + var bytesPerFrame = 0; + for (var i = 0; i < src.bufQueue.length; i++) { + length += src.bufQueue[i].length; + if (src.bufQueue[i].id !== 0) { + bytesPerFrame = src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels; + } + } + return length * bytesPerFrame; + + case 8202: + /* AL_SAMPLE_LENGTH_SOFT */ var length = 0; + for (var i = 0; i < src.bufQueue.length; i++) { + length += src.bufQueue[i].length; + } + return length; + + case 8203: + /* AL_SEC_LENGTH_SOFT */ return AL.sourceDuration(src); + + case 53248: + return src.distanceModel; + + default: + AL.currentCtx.err = 40962; + return null; + } + }, + setSourceParam: (funcname, sourceId, param, value) => { + if (!AL.currentCtx) { + return; + } + var src = AL.currentCtx.sources[sourceId]; + if (!src) { + AL.currentCtx.err = 40961; + return; + } + if (value === null) { + AL.currentCtx.err = 40962; + return; + } + switch (param) { + case 514: + /* AL_SOURCE_RELATIVE */ if (value === 1) { + src.relative = true; + AL.updateSourceSpace(src); + } else if (value === 0) { + src.relative = false; + AL.updateSourceSpace(src); + } else { + AL.currentCtx.err = 40963; + return; + } + break; + + case 4097: + /* AL_CONE_INNER_ANGLE */ if (!Number.isFinite(value)) { + AL.currentCtx.err = 40963; + return; + } + src.coneInnerAngle = value; + if (src.panner) { + src.panner.coneInnerAngle = value % 360; + } + break; + + case 4098: + /* AL_CONE_OUTER_ANGLE */ if (!Number.isFinite(value)) { + AL.currentCtx.err = 40963; + return; + } + src.coneOuterAngle = value; + if (src.panner) { + src.panner.coneOuterAngle = value % 360; + } + break; + + case 4099: + /* AL_PITCH */ if (!Number.isFinite(value) || value <= 0) { + AL.currentCtx.err = 40963; + return; + } + if (src.pitch === value) { + break; + } + src.pitch = value; + AL.updateSourceRate(src); + break; + + case 4100: + if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) { + AL.currentCtx.err = 40963; + return; + } + src.position[0] = value[0]; + src.position[1] = value[1]; + src.position[2] = value[2]; + AL.updateSourceSpace(src); + break; + + case 4101: + if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) { + AL.currentCtx.err = 40963; + return; + } + src.direction[0] = value[0]; + src.direction[1] = value[1]; + src.direction[2] = value[2]; + AL.updateSourceSpace(src); + break; + + case 4102: + if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) { + AL.currentCtx.err = 40963; + return; + } + src.velocity[0] = value[0]; + src.velocity[1] = value[1]; + src.velocity[2] = value[2]; + AL.updateSourceSpace(src); + break; + + case 4103: + /* AL_LOOPING */ if (value === 1) { + src.looping = true; + AL.updateSourceTime(src); + if (src.type === 4136 && src.audioQueue.length > 0) { + var audioSrc = src.audioQueue[0]; + audioSrc.loop = true; + audioSrc._duration = Number.POSITIVE_INFINITY; + } + } else if (value === 0) { + src.looping = false; + var currentTime = AL.updateSourceTime(src); + if (src.type === 4136 && src.audioQueue.length > 0) { + var audioSrc = src.audioQueue[0]; + audioSrc.loop = false; + audioSrc._duration = src.bufQueue[0].audioBuf.duration / src.playbackRate; + audioSrc._startTime = currentTime - src.bufOffset / src.playbackRate; + } + } else { + AL.currentCtx.err = 40963; + return; + } + break; + + case 4105: + /* AL_BUFFER */ if (src.state === 4114 || src.state === 4115) { + AL.currentCtx.err = 40964; + return; + } + if (value === 0) { + for (var i in src.bufQueue) { + src.bufQueue[i].refCount--; + } + src.bufQueue.length = 1; + src.bufQueue[0] = AL.buffers[0]; + src.bufsProcessed = 0; + src.type = 4144; + } else /* AL_UNDETERMINED */ { + var buf = AL.buffers[value]; + if (!buf) { + AL.currentCtx.err = 40963; + return; + } + for (var i in src.bufQueue) { + src.bufQueue[i].refCount--; + } + src.bufQueue.length = 0; + buf.refCount++; + src.bufQueue = [ buf ]; + src.bufsProcessed = 0; + src.type = 4136; + } + AL.initSourcePanner(src); + AL.scheduleSourceAudio(src); + break; + + case 4106: + if (!Number.isFinite(value) || value < 0) { + AL.currentCtx.err = 40963; + return; + } + src.gain.gain.value = value; + break; + + case 4109: + /* AL_MIN_GAIN */ if (!Number.isFinite(value) || value < 0 || value > Math.min(src.maxGain, 1)) { + AL.currentCtx.err = 40963; + return; + } + src.minGain = value; + break; + + case 4110: + /* AL_MAX_GAIN */ if (!Number.isFinite(value) || value < Math.max(0, src.minGain) || value > 1) { + AL.currentCtx.err = 40963; + return; + } + src.maxGain = value; + break; + + case 4128: + /* AL_REFERENCE_DISTANCE */ if (!Number.isFinite(value) || value < 0) { + AL.currentCtx.err = 40963; + return; + } + src.refDistance = value; + if (src.panner) { + src.panner.refDistance = value; + } + break; + + case 4129: + /* AL_ROLLOFF_FACTOR */ if (!Number.isFinite(value) || value < 0) { + AL.currentCtx.err = 40963; + return; + } + src.rolloffFactor = value; + if (src.panner) { + src.panner.rolloffFactor = value; + } + break; + + case 4130: + /* AL_CONE_OUTER_GAIN */ if (!Number.isFinite(value) || value < 0 || value > 1) { + AL.currentCtx.err = 40963; + return; + } + src.coneOuterGain = value; + if (src.panner) { + src.panner.coneOuterGain = value; + } + break; + + case 4131: + /* AL_MAX_DISTANCE */ if (!Number.isFinite(value) || value < 0) { + AL.currentCtx.err = 40963; + return; + } + src.maxDistance = value; + if (src.panner) { + src.panner.maxDistance = value; + } + break; + + case 4132: + /* AL_SEC_OFFSET */ if (value < 0 || value > AL.sourceDuration(src)) { + AL.currentCtx.err = 40963; + return; + } + AL.sourceSeek(src, value); + break; + + case 4133: + /* AL_SAMPLE_OFFSET */ var srcLen = AL.sourceDuration(src); + if (srcLen > 0) { + var frequency; + for (var bufId in src.bufQueue) { + if (bufId) { + frequency = src.bufQueue[bufId].frequency; + break; + } + } + value /= frequency; + } + if (value < 0 || value > srcLen) { + AL.currentCtx.err = 40963; + return; + } + AL.sourceSeek(src, value); + break; + + case 4134: + /* AL_BYTE_OFFSET */ var srcLen = AL.sourceDuration(src); + if (srcLen > 0) { + var bytesPerSec; + for (var bufId in src.bufQueue) { + if (bufId) { + var buf = src.bufQueue[bufId]; + bytesPerSec = buf.frequency * buf.bytesPerSample * buf.channels; + break; + } + } + value /= bytesPerSec; + } + if (value < 0 || value > srcLen) { + AL.currentCtx.err = 40963; + return; + } + AL.sourceSeek(src, value); + break; + + case 4628: + /* AL_SOURCE_SPATIALIZE_SOFT */ if (value !== 0 && value !== 1 && value !== 2) /* AL_AUTO_SOFT */ { + AL.currentCtx.err = 40963; + return; + } + src.spatialize = value; + AL.initSourcePanner(src); + break; + + case 8201: + /* AL_BYTE_LENGTH_SOFT */ case 8202: + /* AL_SAMPLE_LENGTH_SOFT */ case 8203: + /* AL_SEC_LENGTH_SOFT */ AL.currentCtx.err = 40964; + break; + + case 53248: + switch (value) { + case 0: + case 53249: + /* AL_INVERSE_DISTANCE */ case 53250: + /* AL_INVERSE_DISTANCE_CLAMPED */ case 53251: + /* AL_LINEAR_DISTANCE */ case 53252: + /* AL_LINEAR_DISTANCE_CLAMPED */ case 53253: + /* AL_EXPONENT_DISTANCE */ case 53254: + /* AL_EXPONENT_DISTANCE_CLAMPED */ src.distanceModel = value; + if (AL.currentCtx.sourceDistanceModel) { + AL.updateContextGlobal(AL.currentCtx); + } + break; + + default: + AL.currentCtx.err = 40963; + return; + } + break; + + default: + AL.currentCtx.err = 40962; + return; + } + }, + captures: {}, + sharedCaptureAudioCtx: null, + requireValidCaptureDevice: (deviceId, funcname) => { + if (deviceId === 0) { + AL.alcErr = 40961; + return null; + } + var c = AL.captures[deviceId]; + if (!c) { + AL.alcErr = 40961; + return null; + } + var err = c.mediaStreamError; + if (err) { + AL.alcErr = 40961; + return null; + } + return c; + } +}; + +function _alDeleteBuffers(count, pBufferIds) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(22, 0, 1, count, pBufferIds); + if (!AL.currentCtx) { + return; + } + for (var i = 0; i < count; ++i) { + var bufId = GROWABLE_HEAP_I32()[(((pBufferIds) + (i * 4)) >> 2)]; + /// Deleting the zero buffer is a legal NOP, so ignore it + if (bufId === 0) { + continue; + } + // Make sure the buffer index is valid. + if (!AL.buffers[bufId]) { + AL.currentCtx.err = 40961; + return; + } + // Make sure the buffer is no longer in use. + if (AL.buffers[bufId].refCount) { + AL.currentCtx.err = 40964; + return; + } + } + for (var i = 0; i < count; ++i) { + var bufId = GROWABLE_HEAP_I32()[(((pBufferIds) + (i * 4)) >> 2)]; + if (bufId === 0) { + continue; + } + AL.deviceRefCounts[AL.buffers[bufId].deviceId]--; + delete AL.buffers[bufId]; + AL.freeIds.push(bufId); + } +} + +function _alGetError() { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(23, 0, 1); + if (!AL.currentCtx) { + return 40964; + } + // Reset error on get. + var err = AL.currentCtx.err; + AL.currentCtx.err = 0; + return err; +} + +function _alGetSourcei(sourceId, param, pValue) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(24, 0, 1, sourceId, param, pValue); + var val = AL.getSourceParam("alGetSourcei", sourceId, param); + if (val === null) { + return; + } + if (!pValue) { + AL.currentCtx.err = 40963; + return; + } + switch (param) { + case 514: + /* AL_SOURCE_RELATIVE */ case 4097: + /* AL_CONE_INNER_ANGLE */ case 4098: + /* AL_CONE_OUTER_ANGLE */ case 4103: + /* AL_LOOPING */ case 4105: + /* AL_BUFFER */ case 4112: + /* AL_SOURCE_STATE */ case 4117: + /* AL_BUFFERS_QUEUED */ case 4118: + /* AL_BUFFERS_PROCESSED */ case 4128: + /* AL_REFERENCE_DISTANCE */ case 4129: + /* AL_ROLLOFF_FACTOR */ case 4131: + /* AL_MAX_DISTANCE */ case 4132: + /* AL_SEC_OFFSET */ case 4133: + /* AL_SAMPLE_OFFSET */ case 4134: + /* AL_BYTE_OFFSET */ case 4135: + /* AL_SOURCE_TYPE */ case 4628: + /* AL_SOURCE_SPATIALIZE_SOFT */ case 8201: + /* AL_BYTE_LENGTH_SOFT */ case 8202: + /* AL_SAMPLE_LENGTH_SOFT */ case 53248: + GROWABLE_HEAP_I32()[((pValue) >> 2)] = val; + break; + + default: + AL.currentCtx.err = 40962; + return; + } +} + +function _alIsBuffer(bufferId) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(25, 0, 1, bufferId); + if (!AL.currentCtx) { + return false; + } + if (bufferId > AL.buffers.length) { + return false; + } + if (!AL.buffers[bufferId]) { + return false; + } + return true; +} + +function _alSourcePause(sourceId) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(26, 0, 1, sourceId); + if (!AL.currentCtx) { + return; + } + var src = AL.currentCtx.sources[sourceId]; + if (!src) { + AL.currentCtx.err = 40961; + return; + } + AL.setSourceState(src, 4115); +} + +function _alSourcePlay(sourceId) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(27, 0, 1, sourceId); + if (!AL.currentCtx) { + return; + } + var src = AL.currentCtx.sources[sourceId]; + if (!src) { + AL.currentCtx.err = 40961; + return; + } + AL.setSourceState(src, 4114); +} + +function _alSourceStop(sourceId) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(28, 0, 1, sourceId); + if (!AL.currentCtx) { + return; + } + var src = AL.currentCtx.sources[sourceId]; + if (!src) { + AL.currentCtx.err = 40961; + return; + } + AL.setSourceState(src, 4116); +} + +function _alSourcei(sourceId, param, value) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(29, 0, 1, sourceId, param, value); + switch (param) { + case 514: + /* AL_SOURCE_RELATIVE */ case 4097: + /* AL_CONE_INNER_ANGLE */ case 4098: + /* AL_CONE_OUTER_ANGLE */ case 4103: + /* AL_LOOPING */ case 4105: + /* AL_BUFFER */ case 4128: + /* AL_REFERENCE_DISTANCE */ case 4129: + /* AL_ROLLOFF_FACTOR */ case 4131: + /* AL_MAX_DISTANCE */ case 4132: + /* AL_SEC_OFFSET */ case 4133: + /* AL_SAMPLE_OFFSET */ case 4134: + /* AL_BYTE_OFFSET */ case 4628: + /* AL_SOURCE_SPATIALIZE_SOFT */ case 8201: + /* AL_BYTE_LENGTH_SOFT */ case 8202: + /* AL_SAMPLE_LENGTH_SOFT */ case 53248: + AL.setSourceParam("alSourcei", sourceId, param, value); + break; + + default: + AL.setSourceParam("alSourcei", sourceId, param, null); + break; + } +} + +var readEmAsmArgsArray = []; + +var readEmAsmArgs = (sigPtr, buf) => { + readEmAsmArgsArray.length = 0; + var ch; + // Most arguments are i32s, so shift the buffer pointer so it is a plain + // index into HEAP32. + while (ch = GROWABLE_HEAP_U8()[sigPtr++]) { + // Floats are always passed as doubles, so all types except for 'i' + // are 8 bytes and require alignment. + var wide = (ch != 105); + wide &= (ch != 112); + buf += wide && (buf % 8) ? 4 : 0; + readEmAsmArgsArray.push(// Special case for pointers under wasm64 or CAN_ADDRESS_2GB mode. + ch == 112 ? GROWABLE_HEAP_U32()[((buf) >> 2)] : ch == 105 ? GROWABLE_HEAP_I32()[((buf) >> 2)] : GROWABLE_HEAP_F64()[((buf) >> 3)]); + buf += wide ? 8 : 4; + } + return readEmAsmArgsArray; +}; + +var runEmAsmFunction = (code, sigPtr, argbuf) => { + var args = readEmAsmArgs(sigPtr, argbuf); + return ASM_CONSTS[code](...args); +}; + +var _emscripten_asm_const_int = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf); + +var _emscripten_asm_const_ptr = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf); + +var _emscripten_cancel_main_loop = () => { + MainLoop.pause(); + MainLoop.func = null; +}; + +var warnOnce = text => { + warnOnce.shown ||= {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = "warning: " + text; + err(text); + } +}; + +var _emscripten_check_blocking_allowed = () => {}; + +var _emscripten_date_now = () => Date.now(); + +var _emscripten_exit_with_live_runtime = () => { + runtimeKeepalivePush(); + throw "unwind"; +}; + +var JSEvents = { + memcpy(target, src, size) { + GROWABLE_HEAP_I8().set(GROWABLE_HEAP_I8().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) { + 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; + }, + getTargetThreadForEventCallback(targetThread) { + switch (targetThread) { + case 1: + // The event callback for the current event should be called on the + // main browser thread. (0 == don't proxy) + return 0; + + case 2: + // The event callback for the current event should be backproxied to + // the thread that is registering the event. + // This can be 0 in the case that the caller uses + // EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD but on the main thread + // itself. + return PThread.currentProxiedOperationCallerThread; + + default: + // The event callback for the current event should be proxied to the + // given specific thread. + return targetThread; + } + }, + 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 ? UTF8ToString(cString) : cString; + +/** @type {Object} */ var specialHTMLTargets = [ 0, typeof document != "undefined" ? document : 0, typeof window != "undefined" ? window : 0 ]; + +/** @suppress {duplicate } */ var findEventTarget = target => { + target = maybeCStringToJsString(target); + var domElement = specialHTMLTargets[target] || (typeof document != "undefined" ? document.querySelector(target) : null); + return domElement; +}; + +var findCanvasEventTarget = findEventTarget; + +var getCanvasSizeCallingThread = (target, width, height) => { + var canvas = findCanvasEventTarget(target); + if (!canvas) return -4; + if (!canvas.controlTransferredOffscreen) { + GROWABLE_HEAP_I32()[((width) >> 2)] = canvas.width; + GROWABLE_HEAP_I32()[((height) >> 2)] = canvas.height; + } else { + return -4; + } + return 0; +}; + +function getCanvasSizeMainThread(target, width, height) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(30, 0, 1, target, width, height); + return getCanvasSizeCallingThread(target, width, height); +} + +var _emscripten_get_canvas_element_size = (target, width, height) => { + var canvas = findCanvasEventTarget(target); + if (canvas) { + return getCanvasSizeCallingThread(target, width, height); + } + return getCanvasSizeMainThread(target, width, height); +}; + +var getBoundingClientRect = e => specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : { + "left": 0, + "top": 0 +}; + +function _emscripten_get_element_css_size(target, width, height) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(31, 0, 1, target, width, height); + target = findEventTarget(target); + if (!target) return -4; + var rect = getBoundingClientRect(target); + GROWABLE_HEAP_F64()[((width) >> 3)] = rect.width; + GROWABLE_HEAP_F64()[((height) >> 3)] = rect.height; + return 0; +} + +var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate +// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side +// for any code that deals with heap sizes, which would require special +// casing all heap size related code to treat 0 specially. +2147483648; + +var _emscripten_get_heap_max = () => getHeapMax(); + +var GLctx; + +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 => !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance")); + +var webgl_enable_EXT_polygon_offset_clamp = ctx => !!(ctx.extPolygonOffsetClamp = ctx.getExtension("EXT_polygon_offset_clamp")); + +var webgl_enable_EXT_clip_control = ctx => !!(ctx.extClipControl = ctx.getExtension("EXT_clip_control")); + +var webgl_enable_WEBGL_polygon_mode = ctx => !!(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. +!!(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 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(1282); + } + GROWABLE_HEAP_I32()[(((buffers) + (i * 4)) >> 2)] = id; + } + }, + getSource: (shader, count, string, length) => { + var source = ""; + for (var i = 0; i < count; ++i) { + var len = length ? GROWABLE_HEAP_U32()[(((length) + (i * 4)) >> 2)] : undefined; + source += UTF8ToString(GROWABLE_HEAP_U32()[(((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 = canvas.getContext("webgl2", webGLContextAttributes); + if (!ctx) return 0; + var handle = GL.registerContext(ctx, webGLContextAttributes); + return handle; + }, + registerContext: (ctx, webGLContextAttributes) => { + // with pthreads a context is a location in memory with some synchronized + // data between threads + var handle = _malloc(8); + GROWABLE_HEAP_U32()[(((handle) + (4)) >> 2)] = _pthread_self(); + // the thread pointer of the thread that owns the control of the context + 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 => 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; + } + _free(GL.contexts[contextHandle].handle); + 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 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 == 35051) /*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 == 35052) /*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 (true) { + // 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, GROWABLE_HEAP_U8(), usage, data, size); + } else { + GLctx.bufferData(target, size, usage); + } + return; + } +}; + +var _emscripten_glBufferData = _glBufferData; + +/** @suppress {duplicate } */ var _glBufferSubData = (target, offset, size, data) => { + if (true) { + size && GLctx.bufferSubData(target, offset, GROWABLE_HEAP_U8(), data, size); + return; + } +}; + +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, GROWABLE_HEAP_F32(), ((value) >> 2)); +}; + +var _emscripten_glClearBufferfv = _glClearBufferfv; + +/** @suppress {duplicate } */ var _glClearBufferiv = (buffer, drawbuffer, value) => { + GLctx.clearBufferiv(buffer, drawbuffer, GROWABLE_HEAP_I32(), ((value) >> 2)); +}; + +var _emscripten_glClearBufferiv = _glClearBufferiv; + +/** @suppress {duplicate } */ var _glClearBufferuiv = (buffer, drawbuffer, value) => { + GLctx.clearBufferuiv(buffer, drawbuffer, GROWABLE_HEAP_U32(), ((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) => (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 (true) { + if (GLctx.currentPixelUnpackBufferBinding || !imageSize) { + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); + return; + } + GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, GROWABLE_HEAP_U8(), data, imageSize); + return; + } +}; + +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, GROWABLE_HEAP_U8(), data, imageSize); + } +}; + +var _emscripten_glCompressedTexImage3D = _glCompressedTexImage3D; + +/** @suppress {duplicate } */ var _glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => { + if (true) { + 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, GROWABLE_HEAP_U8(), data, imageSize); + return; + } +}; + +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, GROWABLE_HEAP_U8(), 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 = GROWABLE_HEAP_I32()[(((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 = GROWABLE_HEAP_I32()[(((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(1281); + /* 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 = GROWABLE_HEAP_I32()[(((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 = GROWABLE_HEAP_I32()[(((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 = GROWABLE_HEAP_I32()[(((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 = GROWABLE_HEAP_I32()[(((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(1281); + /* 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(1281); + /* 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 = GROWABLE_HEAP_I32()[(((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 = GROWABLE_HEAP_I32()[(((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 = GROWABLE_HEAP_I32()[(((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] = GROWABLE_HEAP_I32()[(((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(1282); + /* GL_INVALID_OPERATION */ while (i < n) GROWABLE_HEAP_I32()[(((ids) + (i++ * 4)) >> 2)] = 0; + return; + } + var id = GL.getNewId(GL.queries); + query.name = id; + GL.queries[id] = query; + GROWABLE_HEAP_I32()[(((ids) + (i * 4)) >> 2)] = 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) GROWABLE_HEAP_I32()[((length) >> 2)] = numBytesWrittenExclNull; + if (size) GROWABLE_HEAP_I32()[((size) >> 2)] = info.size; + if (type) GROWABLE_HEAP_I32()[((type) >> 2)] = 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) GROWABLE_HEAP_I32()[((length) >> 2)] = numBytesWrittenExclNull; + } else { + if (length) GROWABLE_HEAP_I32()[((length) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + program = GL.programs[program]; + if (pname == 35393) /* GL_UNIFORM_BLOCK_NAME_LENGTH */ { + var name = GLctx.getActiveUniformBlockName(program, uniformBlockIndex); + GROWABLE_HEAP_I32()[((params) >> 2)] = 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 == 35395) /*GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES*/ { + for (var i = 0; i < result.length; i++) { + GROWABLE_HEAP_I32()[(((params) + (i * 4)) >> 2)] = result[i]; + } + } else { + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + if (uniformCount > 0 && uniformIndices == 0) { + GL.recordError(1281); + /* GL_INVALID_VALUE */ return; + } + program = GL.programs[program]; + var ids = []; + for (var i = 0; i < uniformCount; i++) { + ids.push(GROWABLE_HEAP_I32()[(((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++) { + GROWABLE_HEAP_I32()[(((params) + (i * 4)) >> 2)] = 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; + } + GROWABLE_HEAP_I32()[((count) >> 2)] = len; + for (var i = 0; i < len; ++i) { + var id = GL.shaders.indexOf(result[i]); + GROWABLE_HEAP_I32()[(((shaders) + (i * 4)) >> 2)] = id; + } +}; + +var _emscripten_glGetAttachedShaders = _glGetAttachedShaders; + +/** @suppress {duplicate } */ var _glGetAttribLocation = (program, name) => GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name)); + +var _emscripten_glGetAttribLocation = _glGetAttribLocation; + +var writeI53ToI64 = (ptr, num) => { + GROWABLE_HEAP_U32()[((ptr) >> 2)] = num; + var lower = GROWABLE_HEAP_U32()[((ptr) >> 2)]; + GROWABLE_HEAP_U32()[(((ptr) + (4)) >> 2)] = (num - lower) / 4294967296; +}; + +var 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(1281); + /* GL_INVALID_VALUE */ return; + } + var ret = undefined; + switch (name_) { + // Handle a few trivial GLES values + case 36346: + // GL_SHADER_COMPILER + ret = 1; + break; + + case 36344: + // GL_SHADER_BINARY_FORMATS + if (type != 0 && type != 1) { + GL.recordError(1280); + } + // Do not write anything to the out pointer, since no binary formats are + // supported. + return; + + case 34814: + // GL_NUM_PROGRAM_BINARY_FORMATS + case 36345: + // GL_NUM_SHADER_BINARY_FORMATS + ret = 0; + break; + + case 34466: + // 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(34467); + /*GL_COMPRESSED_TEXTURE_FORMATS*/ ret = formats ? formats.length : 0; + break; + + case 33309: + // GL_NUM_EXTENSIONS + if (GL.currentContext.version < 2) { + // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context + GL.recordError(1282); + /* GL_INVALID_OPERATION */ return; + } + ret = webglGetExtensions().length; + break; + + case 33307: + // GL_MAJOR_VERSION + case 33308: + // GL_MINOR_VERSION + if (GL.currentContext.version < 2) { + GL.recordError(1280); + // GL_INVALID_ENUM + return; + } + ret = name_ == 33307 ? 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(1280); + // 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 34964: + // ARRAY_BUFFER_BINDING + case 35725: + // CURRENT_PROGRAM + case 34965: + // ELEMENT_ARRAY_BUFFER_BINDING + case 36006: + // FRAMEBUFFER_BINDING or DRAW_FRAMEBUFFER_BINDING + case 36007: + // RENDERBUFFER_BINDING + case 32873: + // TEXTURE_BINDING_2D + case 34229: + // WebGL 2 GL_VERTEX_ARRAY_BINDING, or WebGL 1 extension OES_vertex_array_object GL_VERTEX_ARRAY_BINDING_OES + case 36662: + // COPY_READ_BUFFER_BINDING or COPY_READ_BUFFER + case 36663: + // COPY_WRITE_BUFFER_BINDING or COPY_WRITE_BUFFER + case 35053: + // PIXEL_PACK_BUFFER_BINDING + case 35055: + // PIXEL_UNPACK_BUFFER_BINDING + case 36010: + // READ_FRAMEBUFFER_BINDING + case 35097: + // SAMPLER_BINDING + case 35869: + // TEXTURE_BINDING_2D_ARRAY + case 32874: + // TEXTURE_BINDING_3D + case 36389: + // TRANSFORM_FEEDBACK_BINDING + case 35983: + // TRANSFORM_FEEDBACK_BUFFER_BINDING + case 35368: + // UNIFORM_BUFFER_BINDING + case 34068: + { + // TEXTURE_BINDING_CUBE_MAP + ret = 0; + break; + } + + default: + { + GL.recordError(1280); + // 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: + GROWABLE_HEAP_I32()[(((p) + (i * 4)) >> 2)] = result[i]; + break; + + case 2: + GROWABLE_HEAP_F32()[(((p) + (i * 4)) >> 2)] = result[i]; + break; + + case 4: + GROWABLE_HEAP_I8()[(p) + (i)] = result[i] ? 1 : 0; + break; + } + } + return; + } else { + try { + ret = result.name | 0; + } catch (e) { + GL.recordError(1280); + // 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(1280); + // 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: + GROWABLE_HEAP_I32()[((p) >> 2)] = ret; + break; + + case 2: + GROWABLE_HEAP_F32()[((p) >> 2)] = ret; + break; + + case 4: + GROWABLE_HEAP_I8()[p] = 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(1281); + /* 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((data) >> 2)] = 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) => 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; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* 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 35983: + // TRANSFORM_FEEDBACK_BUFFER_BINDING + case 35368: + // UNIFORM_BUFFER_BINDING + ret = 0; + break; + + default: + { + GL.recordError(1280); + // GL_INVALID_ENUM + return; + } + } + } else if (result instanceof WebGLBuffer) { + ret = result.name | 0; + } else { + GL.recordError(1280); + // GL_INVALID_ENUM + return; + } + break; + + default: + GL.recordError(1280); + // GL_INVALID_ENUM + return; + } + switch (type) { + case 1: + writeI53ToI64(data, ret); + break; + + case 0: + GROWABLE_HEAP_I32()[((data) >> 2)] = ret; + break; + + case 2: + GROWABLE_HEAP_F32()[((data) >> 2)] = ret; + break; + + case 4: + GROWABLE_HEAP_I8()[data] = 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(1281); + /* 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(1281); + /* 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) { + GROWABLE_HEAP_I32()[(((params) + (i * 4)) >> 2)] = ret[i]; + } +}; + +var _emscripten_glGetInternalformativ = _glGetInternalformativ; + +/** @suppress {duplicate } */ var _glGetProgramBinary = (program, bufSize, length, binaryFormat, binary) => { + GL.recordError(1282); +}; + +/*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) GROWABLE_HEAP_I32()[((length) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + if (program >= GL.counter) { + GL.recordError(1281); + /* GL_INVALID_VALUE */ return; + } + program = GL.programs[program]; + if (pname == 35716) { + // GL_INFO_LOG_LENGTH + var log = GLctx.getProgramInfoLog(program); + if (log === null) log = "(unknown error)"; + GROWABLE_HEAP_I32()[((p) >> 2)] = log.length + 1; + } else if (pname == 35719) /* GL_ACTIVE_UNIFORM_MAX_LENGTH */ { + if (!program.maxUniformLength) { + var numActiveUniforms = GLctx.getProgramParameter(program, 35718); + /*GL_ACTIVE_UNIFORMS*/ for (var i = 0; i < numActiveUniforms; ++i) { + program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length + 1); + } + } + GROWABLE_HEAP_I32()[((p) >> 2)] = program.maxUniformLength; + } else if (pname == 35722) /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */ { + if (!program.maxAttributeLength) { + var numActiveAttributes = GLctx.getProgramParameter(program, 35721); + /*GL_ACTIVE_ATTRIBUTES*/ for (var i = 0; i < numActiveAttributes; ++i) { + program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length + 1); + } + } + GROWABLE_HEAP_I32()[((p) >> 2)] = program.maxAttributeLength; + } else if (pname == 35381) /* GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH */ { + if (!program.maxUniformBlockNameLength) { + var numActiveUniformBlocks = GLctx.getProgramParameter(program, 35382); + /*GL_ACTIVE_UNIFORM_BLOCKS*/ for (var i = 0; i < numActiveUniformBlocks; ++i) { + program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length + 1); + } + } + GROWABLE_HEAP_I32()[((p) >> 2)] = program.maxUniformBlockNameLength; + } else { + GROWABLE_HEAP_I32()[((p) >> 2)] = GLctx.getProgramParameter(program, pname); + } +}; + +var _emscripten_glGetProgramiv = _glGetProgramiv; + +/** @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(1281); + /* 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(1281); + /* 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; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* 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; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_F32()[((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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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) GROWABLE_HEAP_I32()[((length) >> 2)] = numBytesWrittenExclNull; +}; + +var _emscripten_glGetShaderInfoLog = _glGetShaderInfoLog; + +/** @suppress {duplicate } */ var _glGetShaderPrecisionFormat = (shaderType, precisionType, range, precision) => { + var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType); + GROWABLE_HEAP_I32()[((range) >> 2)] = result.rangeMin; + GROWABLE_HEAP_I32()[(((range) + (4)) >> 2)] = result.rangeMax; + GROWABLE_HEAP_I32()[((precision) >> 2)] = 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) GROWABLE_HEAP_I32()[((length) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + if (pname == 35716) { + // 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; + GROWABLE_HEAP_I32()[((p) >> 2)] = logLength; + } else if (pname == 35720) { + // 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; + GROWABLE_HEAP_I32()[((p) >> 2)] = sourceLength; + } else { + GROWABLE_HEAP_I32()[((p) >> 2)] = 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 7939: + /* GL_EXTENSIONS */ ret = stringToNewUTF8(webglGetExtensions().join(" ")); + break; + + case 7936: + /* GL_VENDOR */ case 7937: + /* GL_RENDERER */ case 37445: + /* UNMASKED_VENDOR_WEBGL */ case 37446: + /* UNMASKED_RENDERER_WEBGL */ var s = GLctx.getParameter(name_); + if (!s) { + GL.recordError(1280); + } + ret = s ? stringToNewUTF8(s) : 0; + break; + + case 7938: + /* GL_VERSION */ var webGLVersion = GLctx.getParameter(7938); + // return GLES version string corresponding to the version of the WebGL context + var glVersion = `OpenGL ES 2.0 (${webGLVersion})`; + if (true) glVersion = `OpenGL ES 3.0 (${webGLVersion})`; + ret = stringToNewUTF8(glVersion); + break; + + case 35724: + /* GL_SHADING_LANGUAGE_VERSION */ var glslVersion = GLctx.getParameter(35724); + // 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(1280); + } + // 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(1282); + // 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(1281); + /*GL_INVALID_VALUE*/ return 0; + } + return stringiCache[index]; + } + switch (name) { + case 7939: + /* GL_EXTENSIONS */ var exts = webglGetExtensions().map(stringToNewUTF8); + stringiCache = GL.stringiCache[name] = exts; + if (index < 0 || index >= stringiCache.length) { + GL.recordError(1281); + /*GL_INVALID_VALUE*/ return 0; + } + return stringiCache[index]; + + default: + GL.recordError(1280); + /*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(1281); + /* 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(1281); + /* GL_INVALID_VALUE */ return; + } + var ret = GLctx.getSyncParameter(GL.syncs[sync], pname); + if (ret !== null) { + GROWABLE_HEAP_I32()[((values) >> 2)] = ret; + if (length) GROWABLE_HEAP_I32()[((length) >> 2)] = 1; + } +}; + +// 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_F32()[((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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((params) >> 2)] = 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) GROWABLE_HEAP_I32()[((length) >> 2)] = numBytesWrittenExclNull; + } else { + if (length) GROWABLE_HEAP_I32()[((length) >> 2)] = 0; + } + if (size) GROWABLE_HEAP_I32()[((size) >> 2)] = info.size; + if (type) GROWABLE_HEAP_I32()[((type) >> 2)] = info.type; +}; + +var _emscripten_glGetTransformFeedbackVarying = _glGetTransformFeedbackVarying; + +/** @suppress {duplicate } */ var _glGetUniformBlockIndex = (program, uniformBlockName) => 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(1281); + /* GL_INVALID_VALUE */ return; + } + if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) { + GL.recordError(1281); + /* GL_INVALID_VALUE */ return; + } + program = GL.programs[program]; + var names = []; + for (var i = 0; i < uniformCount; i++) names.push(UTF8ToString(GROWABLE_HEAP_I32()[(((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++) { + GROWABLE_HEAP_I32()[(((uniformIndices) + (i * 4)) >> 2)] = result[i]; + } +}; + +var _emscripten_glGetUniformIndices = _glGetUniformIndices; + +/** @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, 35718); + /*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(1281); + } + /* 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(1282); + } +}; + +/** @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(1281); + /* 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: + GROWABLE_HEAP_I32()[((params) >> 2)] = data; + break; + + case 2: + GROWABLE_HEAP_F32()[((params) >> 2)] = data; + break; + } + } else { + for (var i = 0; i < data.length; i++) { + switch (type) { + case 0: + GROWABLE_HEAP_I32()[(((params) + (i * 4)) >> 2)] = data[i]; + break; + + case 2: + GROWABLE_HEAP_F32()[(((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(1281); + /* GL_INVALID_VALUE */ return; + } + var data = GLctx.getVertexAttrib(index, pname); + if (pname == 34975) /*VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/ { + GROWABLE_HEAP_I32()[((params) >> 2)] = data && data["name"]; + } else if (typeof data == "number" || typeof data == "boolean") { + switch (type) { + case 0: + GROWABLE_HEAP_I32()[((params) >> 2)] = data; + break; + + case 2: + GROWABLE_HEAP_F32()[((params) >> 2)] = data; + break; + + case 5: + GROWABLE_HEAP_I32()[((params) >> 2)] = Math.fround(data); + break; + } + } else { + for (var i = 0; i < data.length; i++) { + switch (type) { + case 0: + GROWABLE_HEAP_I32()[(((params) + (i * 4)) >> 2)] = data[i]; + break; + + case 2: + GROWABLE_HEAP_F32()[(((params) + (i * 4)) >> 2)] = data[i]; + break; + + case 5: + GROWABLE_HEAP_I32()[(((params) + (i * 4)) >> 2)] = 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(1281); + /* GL_INVALID_VALUE */ return; + } + GROWABLE_HEAP_I32()[((pointer) >> 2)] = 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] = GROWABLE_HEAP_I32()[(((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] = GROWABLE_HEAP_I32()[(((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(1280); +}; + +/*GL_INVALID_ENUM*/ var _emscripten_glProgramBinary = _glProgramBinary; + +/** @suppress {duplicate } */ var _glProgramParameteri = (program, pname, value) => { + GL.recordError(1280); +}; + +/*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 - 6402] || 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 -= 5120; + if (type == 0) return GROWABLE_HEAP_I8(); + if (type == 1) return GROWABLE_HEAP_U8(); + if (type == 2) return GROWABLE_HEAP_I16(); + if (type == 4) return GROWABLE_HEAP_I32(); + if (type == 6) return GROWABLE_HEAP_F32(); + if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return GROWABLE_HEAP_U32(); + return GROWABLE_HEAP_U16(); +}; + +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 (true) { + 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 _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 = GROWABLE_HEAP_F32()[((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 = GROWABLE_HEAP_I32()[((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(1280); +}; + +/*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 (true) { + 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 = GROWABLE_HEAP_F32()[((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 = GROWABLE_HEAP_I32()[((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 (true) { + 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(GROWABLE_HEAP_I32()[(((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; + +/** @suppress {duplicate } */ var _glUniform1fv = (location, count, value) => { + count && GLctx.uniform1fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), ((value) >> 2), count); +}; + +var _emscripten_glUniform1fv = _glUniform1fv; + +/** @suppress {duplicate } */ var _glUniform1i = (location, v0) => { + GLctx.uniform1i(webglGetUniformLocation(location), v0); +}; + +var _emscripten_glUniform1i = _glUniform1i; + +/** @suppress {duplicate } */ var _glUniform1iv = (location, count, value) => { + count && GLctx.uniform1iv(webglGetUniformLocation(location), GROWABLE_HEAP_I32(), ((value) >> 2), count); +}; + +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), GROWABLE_HEAP_U32(), ((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) => { + count && GLctx.uniform2fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), ((value) >> 2), count * 2); +}; + +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) => { + count && GLctx.uniform2iv(webglGetUniformLocation(location), GROWABLE_HEAP_I32(), ((value) >> 2), count * 2); +}; + +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), GROWABLE_HEAP_U32(), ((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) => { + count && GLctx.uniform3fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), ((value) >> 2), count * 3); +}; + +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) => { + count && GLctx.uniform3iv(webglGetUniformLocation(location), GROWABLE_HEAP_I32(), ((value) >> 2), count * 3); +}; + +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), GROWABLE_HEAP_U32(), ((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) => { + count && GLctx.uniform4fv(webglGetUniformLocation(location), GROWABLE_HEAP_F32(), ((value) >> 2), count * 4); +}; + +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) => { + count && GLctx.uniform4iv(webglGetUniformLocation(location), GROWABLE_HEAP_I32(), ((value) >> 2), count * 4); +}; + +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), GROWABLE_HEAP_U32(), ((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) => { + count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 4); +}; + +var _emscripten_glUniformMatrix2fv = _glUniformMatrix2fv; + +/** @suppress {duplicate } */ var _glUniformMatrix2x3fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix2x3fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 6); +}; + +var _emscripten_glUniformMatrix2x3fv = _glUniformMatrix2x3fv; + +/** @suppress {duplicate } */ var _glUniformMatrix2x4fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix2x4fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 8); +}; + +var _emscripten_glUniformMatrix2x4fv = _glUniformMatrix2x4fv; + +/** @suppress {duplicate } */ var _glUniformMatrix3fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 9); +}; + +var _emscripten_glUniformMatrix3fv = _glUniformMatrix3fv; + +/** @suppress {duplicate } */ var _glUniformMatrix3x2fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix3x2fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 6); +}; + +var _emscripten_glUniformMatrix3x2fv = _glUniformMatrix3x2fv; + +/** @suppress {duplicate } */ var _glUniformMatrix3x4fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix3x4fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 12); +}; + +var _emscripten_glUniformMatrix3x4fv = _glUniformMatrix3x4fv; + +/** @suppress {duplicate } */ var _glUniformMatrix4fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 16); +}; + +var _emscripten_glUniformMatrix4fv = _glUniformMatrix4fv; + +/** @suppress {duplicate } */ var _glUniformMatrix4x2fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix4x2fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((value) >> 2), count * 8); +}; + +var _emscripten_glUniformMatrix4x2fv = _glUniformMatrix4x2fv; + +/** @suppress {duplicate } */ var _glUniformMatrix4x3fv = (location, count, transpose, value) => { + count && GLctx.uniformMatrix4x3fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), ((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, GROWABLE_HEAP_F32()[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, GROWABLE_HEAP_F32()[v >> 2], GROWABLE_HEAP_F32()[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, GROWABLE_HEAP_F32()[v >> 2], GROWABLE_HEAP_F32()[v + 4 >> 2], GROWABLE_HEAP_F32()[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, GROWABLE_HEAP_F32()[v >> 2], GROWABLE_HEAP_F32()[v + 4 >> 2], GROWABLE_HEAP_F32()[v + 8 >> 2], GROWABLE_HEAP_F32()[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, GROWABLE_HEAP_I32()[v >> 2], GROWABLE_HEAP_I32()[v + 4 >> 2], GROWABLE_HEAP_I32()[v + 8 >> 2], GROWABLE_HEAP_I32()[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, GROWABLE_HEAP_U32()[v >> 2], GROWABLE_HEAP_U32()[v + 4 >> 2], GROWABLE_HEAP_U32()[v + 8 >> 2], GROWABLE_HEAP_U32()[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 _emscripten_num_logical_cores = () => ENVIRONMENT_IS_NODE ? require("os").cpus().length : navigator["hardwareConcurrency"]; + +var growMemory = size => { + var b = wasmMemory.buffer; + var pages = ((size - b.byteLength + 65535) / 65536) | 0; + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow(pages); + // .grow() takes a delta compared to the previous size + updateMemoryViews(); + return 1; + } /*success*/ catch (e) {} +}; + +// implicit 0 return to save code size (caller will cast "undefined" into 0 +// anyhow) +var _emscripten_resize_heap = requestedSize => { + var oldSize = GROWABLE_HEAP_U8().length; + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + requestedSize >>>= 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + if (requestedSize <= oldSize) { + return false; + } + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + return false; + } + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)); + var replacement = growMemory(newSize); + if (replacement) { + return true; + } + } + return false; +}; + +var _emscripten_set_main_loop = (func, fps, simulateInfiniteLoop) => { + var iterFunc = getWasmTableEntry(func); + setMainLoop(iterFunc, fps, simulateInfiniteLoop); +}; + +var registerTouchEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => { + targetThread = JSEvents.getTargetThreadForEventCallback(targetThread); + JSEvents.touchEvent ||= _malloc(1552); + target = findEventTarget(target); + var touchEventHandlerFunc = 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 = targetThread ? _malloc(1552) : JSEvents.touchEvent; + GROWABLE_HEAP_F64()[((touchEvent) >> 3)] = e.timeStamp; + GROWABLE_HEAP_I8()[touchEvent + 12] = e.ctrlKey; + GROWABLE_HEAP_I8()[touchEvent + 13] = e.shiftKey; + GROWABLE_HEAP_I8()[touchEvent + 14] = e.altKey; + GROWABLE_HEAP_I8()[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 + GROWABLE_HEAP_I32()[idx32 + 0] = t.identifier; + GROWABLE_HEAP_I32()[idx32 + 1] = t.screenX; + GROWABLE_HEAP_I32()[idx32 + 2] = t.screenY; + GROWABLE_HEAP_I32()[idx32 + 3] = t.clientX; + GROWABLE_HEAP_I32()[idx32 + 4] = t.clientY; + GROWABLE_HEAP_I32()[idx32 + 5] = t.pageX; + GROWABLE_HEAP_I32()[idx32 + 6] = t.pageY; + GROWABLE_HEAP_I8()[idx + 28] = t.isChanged; + GROWABLE_HEAP_I8()[idx + 29] = t.onTarget; + GROWABLE_HEAP_I32()[idx32 + 8] = t.clientX - (targetRect.left | 0); + GROWABLE_HEAP_I32()[idx32 + 9] = t.clientY - (targetRect.top | 0); + idx += 48; + if (++numTouches > 31) { + break; + } + } + GROWABLE_HEAP_I32()[(((touchEvent) + (8)) >> 2)] = numTouches; + if (targetThread) __emscripten_run_callback_on_thread(targetThread, callbackfunc, eventTypeId, touchEvent, userData); else if (getWasmTableEntry(callbackfunc)(eventTypeId, touchEvent, userData)) e.preventDefault(); + }; + var eventHandler = { + target, + allowsDeferredCalls: eventTypeString == "touchstart" || eventTypeString == "touchend", + eventTypeString, + callbackfunc, + handlerFunc: touchEventHandlerFunc, + useCapture + }; + return JSEvents.registerOrRemoveHandler(eventHandler); +}; + +function _emscripten_set_touchcancel_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(32, 0, 1, target, userData, useCapture, callbackfunc, targetThread); + return registerTouchEventCallback(target, userData, useCapture, callbackfunc, 25, "touchcancel", targetThread); +} + +function _emscripten_set_touchend_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(33, 0, 1, target, userData, useCapture, callbackfunc, targetThread); + return registerTouchEventCallback(target, userData, useCapture, callbackfunc, 23, "touchend", targetThread); +} + +function _emscripten_set_touchmove_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(34, 0, 1, target, userData, useCapture, callbackfunc, targetThread); + return registerTouchEventCallback(target, userData, useCapture, callbackfunc, 24, "touchmove", targetThread); +} + +function _emscripten_set_touchstart_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(35, 0, 1, target, userData, useCapture, callbackfunc, targetThread); + return registerTouchEventCallback(target, userData, useCapture, callbackfunc, 22, "touchstart", targetThread); +} + +var ENV = {}; + +var getExecutableName = () => thisProgram || "./this.program"; + +var getEnvStrings = () => { + if (!getEnvStrings.strings) { + // Default values. + // Browser language detection #8751 + var lang = ((typeof navigator == "object" && navigator.languages && navigator.languages[0]) || "C").replace("-", "_") + ".UTF-8"; + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": lang, + "_": getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + // x is a key in ENV; if ENV[x] is undefined, that means it was + // explicitly set to be so. We allow user code to do that to + // force variables with default values to remain unset. + if (ENV[x] === undefined) delete env[x]; else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(`${x}=${env[x]}`); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; +}; + +var stringToAscii = (str, buffer) => { + for (var i = 0; i < str.length; ++i) { + GROWABLE_HEAP_I8()[buffer++] = str.charCodeAt(i); + } + // Null-terminate the string + GROWABLE_HEAP_I8()[buffer] = 0; +}; + +var _environ_get = function(__environ, environ_buf) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(36, 0, 1, __environ, environ_buf); + var bufSize = 0; + getEnvStrings().forEach((string, i) => { + var ptr = environ_buf + bufSize; + GROWABLE_HEAP_U32()[(((__environ) + (i * 4)) >> 2)] = ptr; + stringToAscii(string, ptr); + bufSize += string.length + 1; + }); + return 0; +}; + +var _environ_sizes_get = function(penviron_count, penviron_buf_size) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(37, 0, 1, penviron_count, penviron_buf_size); + var strings = getEnvStrings(); + GROWABLE_HEAP_U32()[((penviron_count) >> 2)] = strings.length; + var bufSize = 0; + strings.forEach(string => bufSize += string.length + 1); + GROWABLE_HEAP_U32()[((penviron_buf_size) >> 2)] = bufSize; + return 0; +}; + +function _fd_close(fd) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(38, 0, 1, fd); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +/** @param {number=} offset */ var doReadv = (stream, iov, iovcnt, offset) => { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = GROWABLE_HEAP_U32()[((iov) >> 2)]; + var len = GROWABLE_HEAP_U32()[(((iov) + (4)) >> 2)]; + iov += 8; + var curr = FS.read(stream, GROWABLE_HEAP_I8(), ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; + // nothing more to read + if (typeof offset != "undefined") { + offset += curr; + } + } + return ret; +}; + +function _fd_read(fd, iov, iovcnt, pnum) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(39, 0, 1, fd, iov, iovcnt, pnum); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + GROWABLE_HEAP_U32()[((pnum) >> 2)] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(40, 0, 1, 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 ? (tempDouble > 0 ? (+(Math.floor((tempDouble) / 4294967296))) >>> 0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble))) >>> 0)) / 4294967296))))) >>> 0) : 0) ], + GROWABLE_HEAP_I32()[((newOffset) >> 2)] = tempI64[0], GROWABLE_HEAP_I32()[(((newOffset) + (4)) >> 2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + // 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 = GROWABLE_HEAP_U32()[((iov) >> 2)]; + var len = GROWABLE_HEAP_U32()[(((iov) + (4)) >> 2)]; + iov += 8; + var curr = FS.write(stream, GROWABLE_HEAP_I8(), ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) { + // No more space to write. + break; + } + if (typeof offset != "undefined") { + offset += curr; + } + } + return ret; +}; + +function _fd_write(fd, iov, iovcnt, pnum) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(41, 0, 1, fd, iov, iovcnt, pnum); + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + GROWABLE_HEAP_U32()[((pnum) >> 2)] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno; + } +} + +/** @param {number=} timeout */ var safeSetTimeout = (func, timeout) => { + runtimeKeepalivePush(); + return setTimeout(() => { + runtimeKeepalivePop(); + 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); + var img = new Image; + img.onload = () => { + 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! + 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)) & 63; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar & 3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar & 15) << 2]; + ret += PAD; + } + return ret; + } + audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray); + finish(audio); + }; + // 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 + 1e4); + }; + 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: 2 + }; + 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) { + 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(); + }, + 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); + 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 = GROWABLE_HEAP_U32()[((SDL.screen) >> 2)]; + flags = flags | 8388608; + // set SDL_FULLSCREEN flag + GROWABLE_HEAP_I32()[((SDL.screen) >> 2)] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + setWindowedCanvasSize() { + // check if SDL is available + if (typeof SDL != "undefined") { + var flags = GROWABLE_HEAP_U32()[((SDL.screen) >> 2)]; + flags = flags & ~8388608; + // clear SDL_FULLSCREEN flag + GROWABLE_HEAP_I32()[((SDL.screen) >> 2)] = 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"); + } + } + } + } +}; + +/** @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 = { + 208897: 212993, + // GLFW_CURSOR (GLFW_CURSOR_NORMAL) + 208898: 0, + // GLFW_STICKY_KEYS + 208899: 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; +} + +function _emscripten_set_window_title(title) { + if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(42, 0, 1, title); + return document.title = UTF8ToString(title); +} + +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 32: + return 32; + + // DOM_VK_SPACE -> GLFW_KEY_SPACE + case 222: + return 39; + + // DOM_VK_QUOTE -> GLFW_KEY_APOSTROPHE + case 188: + return 44; + + // DOM_VK_COMMA -> GLFW_KEY_COMMA + case 173: + return 45; + + // DOM_VK_HYPHEN_MINUS -> GLFW_KEY_MINUS + case 189: + return 45; + + // DOM_VK_MINUS -> GLFW_KEY_MINUS + case 190: + return 46; + + // DOM_VK_PERIOD -> GLFW_KEY_PERIOD + case 191: + return 47; + + // DOM_VK_SLASH -> GLFW_KEY_SLASH + case 48: + return 48; + + // DOM_VK_0 -> GLFW_KEY_0 + case 49: + return 49; + + // DOM_VK_1 -> GLFW_KEY_1 + case 50: + return 50; + + // DOM_VK_2 -> GLFW_KEY_2 + case 51: + return 51; + + // DOM_VK_3 -> GLFW_KEY_3 + case 52: + return 52; + + // DOM_VK_4 -> GLFW_KEY_4 + case 53: + return 53; + + // DOM_VK_5 -> GLFW_KEY_5 + case 54: + return 54; + + // DOM_VK_6 -> GLFW_KEY_6 + case 55: + return 55; + + // DOM_VK_7 -> GLFW_KEY_7 + case 56: + return 56; + + // DOM_VK_8 -> GLFW_KEY_8 + case 57: + return 57; + + // DOM_VK_9 -> GLFW_KEY_9 + case 59: + return 59; + + // DOM_VK_SEMICOLON -> GLFW_KEY_SEMICOLON + case 61: + return 61; + + // DOM_VK_EQUALS -> GLFW_KEY_EQUAL + case 187: + return 61; + + // DOM_VK_EQUALS -> GLFW_KEY_EQUAL + case 65: + return 65; + + // DOM_VK_A -> GLFW_KEY_A + case 66: + return 66; + + // DOM_VK_B -> GLFW_KEY_B + case 67: + return 67; + + // DOM_VK_C -> GLFW_KEY_C + case 68: + return 68; + + // DOM_VK_D -> GLFW_KEY_D + case 69: + return 69; + + // DOM_VK_E -> GLFW_KEY_E + case 70: + return 70; + + // DOM_VK_F -> GLFW_KEY_F + case 71: + return 71; + + // DOM_VK_G -> GLFW_KEY_G + case 72: + return 72; + + // DOM_VK_H -> GLFW_KEY_H + case 73: + return 73; + + // DOM_VK_I -> GLFW_KEY_I + case 74: + return 74; + + // DOM_VK_J -> GLFW_KEY_J + case 75: + return 75; + + // DOM_VK_K -> GLFW_KEY_K + case 76: + return 76; + + // DOM_VK_L -> GLFW_KEY_L + case 77: + return 77; + + // DOM_VK_M -> GLFW_KEY_M + case 78: + return 78; + + // DOM_VK_N -> GLFW_KEY_N + case 79: + return 79; + + // DOM_VK_O -> GLFW_KEY_O + case 80: + return 80; + + // DOM_VK_P -> GLFW_KEY_P + case 81: + return 81; + + // DOM_VK_Q -> GLFW_KEY_Q + case 82: + return 82; + + // DOM_VK_R -> GLFW_KEY_R + case 83: + return 83; + + // DOM_VK_S -> GLFW_KEY_S + case 84: + return 84; + + // DOM_VK_T -> GLFW_KEY_T + case 85: + return 85; + + // DOM_VK_U -> GLFW_KEY_U + case 86: + return 86; + + // DOM_VK_V -> GLFW_KEY_V + case 87: + return 87; + + // DOM_VK_W -> GLFW_KEY_W + case 88: + return 88; + + // DOM_VK_X -> GLFW_KEY_X + case 89: + return 89; + + // DOM_VK_Y -> GLFW_KEY_Y + case 90: + return 90; + + // DOM_VK_Z -> GLFW_KEY_Z + case 219: + return 91; + + // DOM_VK_OPEN_BRACKET -> GLFW_KEY_LEFT_BRACKET + case 220: + return 92; + + // DOM_VK_BACKSLASH -> GLFW_KEY_BACKSLASH + case 221: + return 93; + + // DOM_VK_CLOSE_BRACKET -> GLFW_KEY_RIGHT_BRACKET + case 192: + return 96; + + // DOM_VK_BACK_QUOTE -> GLFW_KEY_GRAVE_ACCENT + case 27: + return 256; + + // DOM_VK_ESCAPE -> GLFW_KEY_ESCAPE + case 13: + return 257; + + // DOM_VK_RETURN -> GLFW_KEY_ENTER + case 9: + return 258; + + // DOM_VK_TAB -> GLFW_KEY_TAB + case 8: + return 259; + + // DOM_VK_BACK -> GLFW_KEY_BACKSPACE + case 45: + return 260; + + // DOM_VK_INSERT -> GLFW_KEY_INSERT + case 46: + return 261; + + // DOM_VK_DELETE -> GLFW_KEY_DELETE + case 39: + return 262; + + // DOM_VK_RIGHT -> GLFW_KEY_RIGHT + case 37: + return 263; + + // DOM_VK_LEFT -> GLFW_KEY_LEFT + case 40: + return 264; + + // DOM_VK_DOWN -> GLFW_KEY_DOWN + case 38: + return 265; + + // DOM_VK_UP -> GLFW_KEY_UP + case 33: + return 266; + + // DOM_VK_PAGE_UP -> GLFW_KEY_PAGE_UP + case 34: + return 267; + + // DOM_VK_PAGE_DOWN -> GLFW_KEY_PAGE_DOWN + case 36: + return 268; + + // DOM_VK_HOME -> GLFW_KEY_HOME + case 35: + return 269; + + // DOM_VK_END -> GLFW_KEY_END + case 20: + return 280; + + // DOM_VK_CAPS_LOCK -> GLFW_KEY_CAPS_LOCK + case 145: + return 281; + + // DOM_VK_SCROLL_LOCK -> GLFW_KEY_SCROLL_LOCK + case 144: + return 282; + + // DOM_VK_NUM_LOCK -> GLFW_KEY_NUM_LOCK + case 44: + return 283; + + // DOM_VK_SNAPSHOT -> GLFW_KEY_PRINT_SCREEN + case 19: + return 284; + + // DOM_VK_PAUSE -> GLFW_KEY_PAUSE + case 112: + return 290; + + // DOM_VK_F1 -> GLFW_KEY_F1 + case 113: + return 291; + + // DOM_VK_F2 -> GLFW_KEY_F2 + case 114: + return 292; + + // DOM_VK_F3 -> GLFW_KEY_F3 + case 115: + return 293; + + // DOM_VK_F4 -> GLFW_KEY_F4 + case 116: + return 294; + + // DOM_VK_F5 -> GLFW_KEY_F5 + case 117: + return 295; + + // DOM_VK_F6 -> GLFW_KEY_F6 + case 118: + return 296; + + // DOM_VK_F7 -> GLFW_KEY_F7 + case 119: + return 297; + + // DOM_VK_F8 -> GLFW_KEY_F8 + case 120: + return 298; + + // DOM_VK_F9 -> GLFW_KEY_F9 + case 121: + return 299; + + // DOM_VK_F10 -> GLFW_KEY_F10 + case 122: + return 300; + + // DOM_VK_F11 -> GLFW_KEY_F11 + case 123: + return 301; + + // DOM_VK_F12 -> GLFW_KEY_F12 + case 124: + return 302; + + // DOM_VK_F13 -> GLFW_KEY_F13 + case 125: + return 303; + + // DOM_VK_F14 -> GLFW_KEY_F14 + case 126: + return 304; + + // DOM_VK_F15 -> GLFW_KEY_F15 + case 127: + return 305; + + // DOM_VK_F16 -> GLFW_KEY_F16 + case 128: + return 306; + + // DOM_VK_F17 -> GLFW_KEY_F17 + case 129: + return 307; + + // DOM_VK_F18 -> GLFW_KEY_F18 + case 130: + return 308; + + // DOM_VK_F19 -> GLFW_KEY_F19 + case 131: + return 309; + + // DOM_VK_F20 -> GLFW_KEY_F20 + case 132: + return 310; + + // DOM_VK_F21 -> GLFW_KEY_F21 + case 133: + return 311; + + // DOM_VK_F22 -> GLFW_KEY_F22 + case 134: + return 312; + + // DOM_VK_F23 -> GLFW_KEY_F23 + case 135: + return 313; + + // DOM_VK_F24 -> GLFW_KEY_F24 + case 136: + return 314; + + // 0x88 (not used?) -> GLFW_KEY_F25 + case 96: + return 320; + + // DOM_VK_NUMPAD0 -> GLFW_KEY_KP_0 + case 97: + return 321; + + // DOM_VK_NUMPAD1 -> GLFW_KEY_KP_1 + case 98: + return 322; + + // DOM_VK_NUMPAD2 -> GLFW_KEY_KP_2 + case 99: + return 323; + + // DOM_VK_NUMPAD3 -> GLFW_KEY_KP_3 + case 100: + return 324; + + // DOM_VK_NUMPAD4 -> GLFW_KEY_KP_4 + case 101: + return 325; + + // DOM_VK_NUMPAD5 -> GLFW_KEY_KP_5 + case 102: + return 326; + + // DOM_VK_NUMPAD6 -> GLFW_KEY_KP_6 + case 103: + return 327; + + // DOM_VK_NUMPAD7 -> GLFW_KEY_KP_7 + case 104: + return 328; + + // DOM_VK_NUMPAD8 -> GLFW_KEY_KP_8 + case 105: + return 329; + + // DOM_VK_NUMPAD9 -> GLFW_KEY_KP_9 + case 110: + return 330; + + // DOM_VK_DECIMAL -> GLFW_KEY_KP_DECIMAL + case 111: + return 331; + + // DOM_VK_DIVIDE -> GLFW_KEY_KP_DIVIDE + case 106: + return 332; + + // DOM_VK_MULTIPLY -> GLFW_KEY_KP_MULTIPLY + case 109: + return 333; + + // DOM_VK_SUBTRACT -> GLFW_KEY_KP_SUBTRACT + case 107: + 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 16: + return 340; + + // DOM_VK_SHIFT -> GLFW_KEY_LEFT_SHIFT + case 17: + return 341; + + // DOM_VK_CONTROL -> GLFW_KEY_LEFT_CONTROL + case 18: + return 342; + + // DOM_VK_ALT -> GLFW_KEY_LEFT_ALT + case 91: + return 343; + + // DOM_VK_WIN -> GLFW_KEY_LEFT_SUPER + case 224: + 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 93: + return 348; + + // DOM_VK_CONTEXT_MENU -> GLFW_KEY_MENU + // XXX: GLFW_KEY_WORLD_1, GLFW_KEY_WORLD_2 what are these? + default: + return -1; + } + }, + getModBits: win => { + var mod = 0; + if (win.keys[340]) mod |= 1; + // GLFW_MOD_SHIFT + if (win.keys[341]) mod |= 2; + // GLFW_MOD_CONTROL + if (win.keys[342]) mod |= 4; + // GLFW_MOD_ALT + if (win.keys[343] || win.keys[348]) mod |= 8; + // 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 >= 0 && charCode <= 31)) return; + getWasmTableEntry(GLFW.active.charFunc)(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 + getWasmTableEntry(GLFW.active.keyFunc)(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); + } + } + }, + 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) { + getWasmTableEntry(GLFW.active.cursorPosFunc)(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) { + getWasmTableEntry(GLFW.active.cursorEnterFunc)(GLFW.active.id, 1); + } + }, + onMouseleave: event => { + if (!GLFW.active) return; + if (event.target != Module["canvas"]) return; + if (GLFW.active.cursorEnterFunc) { + getWasmTableEntry(GLFW.active.cursorEnterFunc)(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) { + getWasmTableEntry(GLFW.active.mouseButtonFunc)(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; + } + getWasmTableEntry(GLFW.active.scrollFunc)(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; + } + } else // If the client is reverting from fullscreen mode + 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) { + getWasmTableEntry(GLFW.active.windowSizeFunc)(GLFW.active.id, GLFW.active.width, GLFW.active.height); + } + }, + onFramebufferSizeChanged: () => { + if (!GLFW.active) return; + if (GLFW.active.framebufferSizeFunc) { + getWasmTableEntry(GLFW.active.framebufferSizeFunc)(GLFW.active.id, GLFW.active.framebufferWidth, GLFW.active.framebufferHeight); + } + }, + onWindowContentScaleChanged: scale => { + GLFW.scale = scale; + if (!GLFW.active) return; + if (GLFW.active.windowContentScaleFunc) { + getWasmTableEntry(GLFW.active.windowContentScaleFunc)(GLFW.active.id, GLFW.scale, GLFW.scale); + } + }, + getTime: () => _emscripten_get_now() / 1e3, + 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) { + getWasmTableEntry(GLFW.joystickFunc)(joy, 262145); + } + } + var data = GLFW.joys[joy]; + for (var i = 0; i < gamepad.buttons.length; ++i) { + GROWABLE_HEAP_I8()[data.buttons + i] = gamepad.buttons[i].pressed; + } + for (var i = 0; i < gamepad.axes.length; ++i) { + GROWABLE_HEAP_F32()[((data.axes + i * 4) >> 2)] = gamepad.axes[i]; + } + } else { + if (GLFW.joys[joy]) { + out("glfw joystick disconnected", joy); + if (GLFW.joystickFunc) { + getWasmTableEntry(GLFW.joystickFunc)(joy, 262146); + } + _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) { + getWasmTableEntry(GLFW.active.dropFunc)(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); + GROWABLE_HEAP_U32()[((filenames + i * 4) >> 2)] = 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 208897: + { + // GLFW_CURSOR + switch (value) { + case 212993: + { + // GLFW_CURSOR_NORMAL + win.inputModes[mode] = value; + Module["canvas"].removeEventListener("click", GLFW.onClickRequestPointerLock, true); + Module["canvas"].exitPointerLock(); + break; + } + + case 212994: + { + // GLFW_CURSOR_HIDDEN + err("glfwSetInputMode called with GLFW_CURSOR_HIDDEN value not implemented"); + break; + } + + case 212995: + { + // 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 208898: + { + // GLFW_STICKY_KEYS + err("glfwSetInputMode called with GLFW_STICKY_KEYS mode not implemented"); + break; + } + + case 208899: + { + // GLFW_STICKY_MOUSE_BUTTONS + err("glfwSetInputMode called with GLFW_STICKY_MOUSE_BUTTONS mode not implemented"); + break; + } + + case 208900: + { + // GLFW_LOCK_KEY_MODS + err("glfwSetInputMode called with GLFW_LOCK_KEY_MODS mode not implemented"); + break; + } + + case 3342341: + { + // 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) => { + GROWABLE_HEAP_F64()[((x) >> 3)] = Browser.mouseX; + GROWABLE_HEAP_F64()[((y) >> 3)] = Browser.mouseY; + }, + getMousePos: (winid, x, y) => { + GROWABLE_HEAP_I32()[((x) >> 2)] = Browser.mouseX; + GROWABLE_HEAP_I32()[((y) >> 2)] = 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) { + GROWABLE_HEAP_I32()[((x) >> 2)] = wx; + } + if (y) { + GROWABLE_HEAP_I32()[((y) >> 2)] = 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) { + GROWABLE_HEAP_I32()[((width) >> 2)] = ww; + } + if (height) { + GROWABLE_HEAP_I32()[((height) >> 2)] = 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[139265] > 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[135181] > 1), + // GLFW_SAMPLES + depth: (GLFW.hints[135173] > 0), + // GLFW_DEPTH_BITS + stencil: (GLFW.hints[135174] > 0), + // GLFW_STENCIL_BITS + alpha: (GLFW.hints[135172] > 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) { + getWasmTableEntry(win.windowCloseFunc)(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); + 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; + }, + isHiDPIAware() { + if (GLFW.active) return GLFW.active.attributes[139276] > 0; else // GLFW_SCALE_TO_MONITOR + 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; + }, + onDevicePixelRatioChange() { + GLFW.onWindowContentScaleChanged(GLFW.getDevicePixelRatio()); + GLFW.adjustCanvasDimensions(); + }, + GLFW2ParamToGLFW3Param: param => { + var table = { + 196609: 0, + // GLFW_MOUSE_CURSOR + 196610: 0, + // GLFW_STICKY_KEYS + 196611: 0, + // GLFW_STICKY_MOUSE_BUTTONS + 196612: 0, + // GLFW_SYSTEM_KEYS + 196613: 0, + // GLFW_KEY_REPEAT + 196614: 0, + // GLFW_AUTO_POLL_EVENTS + 131073: 0, + // GLFW_OPENED + 131074: 0, + // GLFW_ACTIVE + 131075: 0, + // GLFW_ICONIFIED + 131076: 0, + // GLFW_ACCELERATED + 131077: 135169, + // GLFW_RED_BITS + 131078: 135170, + // GLFW_GREEN_BITS + 131079: 135171, + // GLFW_BLUE_BITS + 131080: 135172, + // GLFW_ALPHA_BITS + 131081: 135173, + // GLFW_DEPTH_BITS + 131082: 135174, + // GLFW_STENCIL_BITS + 131083: 135183, + // GLFW_REFRESH_RATE + 131084: 135175, + // GLFW_ACCUM_RED_BITS + 131085: 135176, + // GLFW_ACCUM_GREEN_BITS + 131086: 135177, + // GLFW_ACCUM_BLUE_BITS + 131087: 135178, + // GLFW_ACCUM_ALPHA_BITS + 131088: 135179, + // GLFW_AUX_BUFFERS + 131089: 135180, + // GLFW_STEREO + 131090: 0, + // GLFW_WINDOW_NO_RESIZE + 131091: 135181, + // GLFW_FSAA_SAMPLES + 131092: 139266, + // GLFW_OPENGL_VERSION_MAJOR + 131093: 139267, + // GLFW_OPENGL_VERSION_MINOR + 131094: 139270, + // GLFW_OPENGL_FORWARD_COMPAT + 131095: 139271, + // GLFW_OPENGL_DEBUG_CONTEXT + 131096: 139272 + }; + // GLFW_OPENGL_PROFILE + return table[param]; + } +}; + +var _glfwCreateStandardCursor = shape => {}; + +var _glfwCreateWindow = (width, height, title, monitor, share) => GLFW.createWindow(width, height, title, monitor, share); + +var _glfwGetClipboardString = win => {}; + +var _glfwGetCurrentContext = () => GLFW.active ? GLFW.active.id : 0; + +var _glfwGetCursorPos = (winid, x, y) => GLFW.getCursorPos(winid, x, y); + +var _glfwGetFramebufferSize = (winid, width, height) => { + var ww = 0; + var wh = 0; + var win = GLFW.WindowFromId(winid); + if (win) { + ww = win.framebufferWidth; + wh = win.framebufferHeight; + } + if (width) { + GROWABLE_HEAP_I32()[((width) >> 2)] = ww; + } + if (height) { + GROWABLE_HEAP_I32()[((height) >> 2)] = wh; + } +}; + +var _glfwGetInputMode = (winid, mode) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + switch (mode) { + case 208897: + { + // GLFW_CURSOR + if (Browser.pointerLock) { + win.inputModes[mode] = 212995; + } else // GLFW_CURSOR_DISABLED + { + win.inputModes[mode] = 212993; + } + } + } + return win.inputModes[mode]; +}; + +var _glfwGetJoystickAxes = (joy, count) => { + GLFW.refreshJoysticks(); + var state = GLFW.joys[joy]; + if (!state || !state.axes) { + GROWABLE_HEAP_I32()[((count) >> 2)] = 0; + return; + } + GROWABLE_HEAP_I32()[((count) >> 2)] = state.axesCount; + return state.axes; +}; + +var _glfwGetJoystickButtons = (joy, count) => { + GLFW.refreshJoysticks(); + var state = GLFW.joys[joy]; + if (!state || !state.buttons) { + GROWABLE_HEAP_I32()[((count) >> 2)] = 0; + return; + } + GROWABLE_HEAP_I32()[((count) >> 2)] = state.buttonsCount; + return state.buttons; +}; + +var _glfwGetKey = (winid, key) => GLFW.getKey(winid, key); + +var _glfwGetMonitorPos = (monitor, x, y) => { + GROWABLE_HEAP_I32()[((x) >> 2)] = 0; + GROWABLE_HEAP_I32()[((y) >> 2)] = 0; +}; + +var _glfwGetMonitorWorkarea = (monitor, x, y, w, h) => { + GROWABLE_HEAP_I32()[((x) >> 2)] = 0; + GROWABLE_HEAP_I32()[((y) >> 2)] = 0; + GROWABLE_HEAP_I32()[((w) >> 2)] = screen.availWidth; + GROWABLE_HEAP_I32()[((h) >> 2)] = screen.availHeight; +}; + +var _glfwGetMonitors = count => { + GROWABLE_HEAP_I32()[((count) >> 2)] = 1; + if (!GLFW.monitors) { + GLFW.monitors = _malloc(4); + GROWABLE_HEAP_I32()[((GLFW.monitors) >> 2)] = 1; + } + return GLFW.monitors; +}; + +var _glfwGetMouseButton = (winid, button) => GLFW.getMouseButton(winid, button); + +var _glfwGetTime = () => GLFW.getTime() - GLFW.initialTime; + +var _glfwGetVideoMode = monitor => 0; + +var _glfwGetWindowAttrib = (winid, attrib) => { + var win = GLFW.WindowFromId(winid); + if (!win) return 0; + return win.attributes[attrib]; +}; + +var _glfwGetWindowPos = (winid, x, y) => GLFW.getWindowPos(winid, x, y); + +var _glfwGetWindowSize = (winid, width, height) => GLFW.getWindowSize(winid, width, height); + +var _glfwGetWindowUserPointer = winid => { + var win = GLFW.WindowFromId(winid); + if (!win) return 0; + return win.userptr; +}; + +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 _glfwPollEvents = () => {}; + +var _glfwSetCharCallback = (winid, cbfun) => GLFW.setCharCallback(winid, cbfun); + +var _glfwSetClipboardString = (win, string) => {}; + +var _glfwSetCursor = (winid, cursor) => {}; + +var _glfwSetCursorEnterCallback = (winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.cursorEnterFunc; + win.cursorEnterFunc = cbfun; + return prevcbfun; +}; + +var _glfwSetCursorPos = (winid, x, y) => GLFW.setCursorPos(winid, x, y); + +var _glfwSetCursorPosCallback = (winid, cbfun) => GLFW.setCursorPosCallback(winid, cbfun); + +var _glfwSetErrorCallback = cbfun => { + var prevcbfun = GLFW.errorFunc; + GLFW.errorFunc = cbfun; + return prevcbfun; +}; + +var _glfwSetInputMode = (winid, mode, value) => { + GLFW.setInputMode(winid, mode, value); +}; + +var _glfwSetKeyCallback = (winid, cbfun) => GLFW.setKeyCallback(winid, cbfun); + +var _glfwSetMonitorCallback = cbfun => { + var prevcbfun = GLFW.monitorFunc; + GLFW.monitorFunc = cbfun; + return prevcbfun; +}; + +var _glfwSetMouseButtonCallback = (winid, cbfun) => GLFW.setMouseButtonCallback(winid, cbfun); + +var _glfwSetScrollCallback = (winid, cbfun) => GLFW.setScrollCallback(winid, cbfun); + +var _glfwSetWindowCloseCallback = (winid, cbfun) => GLFW.setWindowCloseCallback(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 _glfwSetWindowPosCallback = (winid, cbfun) => { + var win = GLFW.WindowFromId(winid); + if (!win) return null; + var prevcbfun = win.windowPosFunc; + win.windowPosFunc = cbfun; + return prevcbfun; +}; + +var _glfwSetWindowShouldClose = (winid, value) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + win.shouldClose = value; +}; + +var _glfwSetWindowSize = (winid, width, height) => GLFW.setWindowSize(winid, width, height); + +var _glfwSetWindowSizeCallback = (winid, cbfun) => GLFW.setWindowSizeCallback(winid, cbfun); + +var _glfwSetWindowUserPointer = (winid, ptr) => { + var win = GLFW.WindowFromId(winid); + if (!win) return; + win.userptr = ptr; +}; + +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 _glfwWindowShouldClose = winid => { + var win = GLFW.WindowFromId(winid); + if (!win) return 0; + return win.shouldClose; +}; + +var stringToUTF8OnStack = str => { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8(str, ret, size); + return ret; +}; + +var getCFunc = ident => { + var func = Module["_" + ident]; + // closure exported function + return func; +}; + +var writeArrayToMemory = (array, buffer) => { + GROWABLE_HEAP_I8().set(array, buffer); +}; + +/** + * @param {string|null=} returnType + * @param {Array=} argTypes + * @param {Arguments|Array=} args + * @param {Object=} opts + */ var ccall = (ident, returnType, argTypes, args, opts) => { + // For fast lookup of conversion functions + var toC = { + "string": str => { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { + // null string + ret = stringToUTF8OnStack(str); + } + return ret; + }, + "array": arr => { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + function convertReturnValue(ret) { + if (returnType === "string") { + return UTF8ToString(ret); + } + if (returnType === "boolean") return Boolean(ret); + return ret; + } + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func(...cArgs); + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret); + } + ret = onDone(ret); + return ret; +}; + +/** + * @param {string=} returnType + * @param {Array=} argTypes + * @param {Object=} opts + */ var cwrap = (ident, returnType, argTypes, opts) => { + // When the function takes numbers and returns a number, we can just return + // the original function + var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean"); + var numericRet = returnType !== "string"; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident); + } + return (...args) => ccall(ident, returnType, argTypes, args, opts); +}; + +var FS_createPath = FS.createPath; + +var FS_unlink = path => FS.unlink(path); + +var FS_createLazyFile = FS.createLazyFile; + +var FS_createDevice = FS.createDevice; + +PThread.init(); + +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; + +// This error may happen quite a bit. To avoid overhead we reuse it (and +// suffer a lack of stack info). +MEMFS.doesNotExistError = new FS.ErrnoError(44); + +/** @suppress {checkTypes} */ MEMFS.doesNotExistError.stack = ""; + +Module["requestAnimationFrame"] = MainLoop.requestAnimationFrame; + +Module["pauseMainLoop"] = MainLoop.pause; + +Module["resumeMainLoop"] = MainLoop.resume; + +MainLoop.init(); + +for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i)); + +// exports +Module["requestFullscreen"] = Browser.requestFullscreen; + +Module["setCanvasSize"] = Browser.setCanvasSize; + +Module["getUserMedia"] = Browser.getUserMedia; + +Module["createContext"] = Browser.createContext; + +// proxiedFunctionTable specifies the list of functions that can be called +// either synchronously or asynchronously from other threads in postMessage()d +// or internally queued events. This way a pthread in a Worker can synchronously +// access e.g. the DOM on the main thread. +var proxiedFunctionTable = [ _proc_exit, exitOnMainThread, pthreadCreateProxied, ___syscall_faccessat, ___syscall_fcntl64, ___syscall_fstat64, ___syscall_ftruncate64, ___syscall_getdents64, ___syscall_ioctl, ___syscall_lstat64, ___syscall_mkdirat, ___syscall_newfstatat, ___syscall_openat, ___syscall_pipe, ___syscall_recvfrom, ___syscall_renameat, ___syscall_rmdir, ___syscall_sendto, ___syscall_stat64, ___syscall_unlinkat, __mmap_js, __munmap_js, _alDeleteBuffers, _alGetError, _alGetSourcei, _alIsBuffer, _alSourcePause, _alSourcePlay, _alSourceStop, _alSourcei, getCanvasSizeMainThread, _emscripten_get_element_css_size, _emscripten_set_touchcancel_callback_on_thread, _emscripten_set_touchend_callback_on_thread, _emscripten_set_touchmove_callback_on_thread, _emscripten_set_touchstart_callback_on_thread, _environ_get, _environ_sizes_get, _fd_close, _fd_read, _fd_seek, _fd_write, _emscripten_set_window_title ]; + +var wasmImports; + +function assignWasmImports() { + wasmImports = { + /** @export */ ImGui_ImplGlfw_EmscriptenOpenURL, + /** @export */ __assert_fail: ___assert_fail, + /** @export */ __call_sighandler: ___call_sighandler, + /** @export */ __cxa_throw: ___cxa_throw, + /** @export */ __pthread_create_js: ___pthread_create_js, + /** @export */ __syscall_faccessat: ___syscall_faccessat, + /** @export */ __syscall_fcntl64: ___syscall_fcntl64, + /** @export */ __syscall_fstat64: ___syscall_fstat64, + /** @export */ __syscall_ftruncate64: ___syscall_ftruncate64, + /** @export */ __syscall_getdents64: ___syscall_getdents64, + /** @export */ __syscall_ioctl: ___syscall_ioctl, + /** @export */ __syscall_lstat64: ___syscall_lstat64, + /** @export */ __syscall_mkdirat: ___syscall_mkdirat, + /** @export */ __syscall_newfstatat: ___syscall_newfstatat, + /** @export */ __syscall_openat: ___syscall_openat, + /** @export */ __syscall_pipe: ___syscall_pipe, + /** @export */ __syscall_recvfrom: ___syscall_recvfrom, + /** @export */ __syscall_renameat: ___syscall_renameat, + /** @export */ __syscall_rmdir: ___syscall_rmdir, + /** @export */ __syscall_sendto: ___syscall_sendto, + /** @export */ __syscall_stat64: ___syscall_stat64, + /** @export */ __syscall_unlinkat: ___syscall_unlinkat, + /** @export */ _abort_js: __abort_js, + /** @export */ _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic, + /** @export */ _emscripten_init_main_thread_js: __emscripten_init_main_thread_js, + /** @export */ _emscripten_notify_mailbox_postmessage: __emscripten_notify_mailbox_postmessage, + /** @export */ _emscripten_receive_on_main_thread_js: __emscripten_receive_on_main_thread_js, + /** @export */ _emscripten_runtime_keepalive_clear: __emscripten_runtime_keepalive_clear, + /** @export */ _emscripten_thread_cleanup: __emscripten_thread_cleanup, + /** @export */ _emscripten_thread_mailbox_await: __emscripten_thread_mailbox_await, + /** @export */ _emscripten_thread_set_strongref: __emscripten_thread_set_strongref, + /** @export */ _emscripten_throw_longjmp: __emscripten_throw_longjmp, + /** @export */ _localtime_js: __localtime_js, + /** @export */ _mmap_js: __mmap_js, + /** @export */ _munmap_js: __munmap_js, + /** @export */ _tzset_js: __tzset_js, + /** @export */ alDeleteBuffers: _alDeleteBuffers, + /** @export */ alGetError: _alGetError, + /** @export */ alGetSourcei: _alGetSourcei, + /** @export */ alIsBuffer: _alIsBuffer, + /** @export */ alSourcePause: _alSourcePause, + /** @export */ alSourcePlay: _alSourcePlay, + /** @export */ alSourceStop: _alSourceStop, + /** @export */ alSourcei: _alSourcei, + /** @export */ emscripten_asm_const_int: _emscripten_asm_const_int, + /** @export */ emscripten_asm_const_ptr: _emscripten_asm_const_ptr, + /** @export */ emscripten_cancel_main_loop: _emscripten_cancel_main_loop, + /** @export */ emscripten_check_blocking_allowed: _emscripten_check_blocking_allowed, + /** @export */ emscripten_date_now: _emscripten_date_now, + /** @export */ emscripten_exit_with_live_runtime: _emscripten_exit_with_live_runtime, + /** @export */ emscripten_get_canvas_element_size: _emscripten_get_canvas_element_size, + /** @export */ emscripten_get_element_css_size: _emscripten_get_element_css_size, + /** @export */ emscripten_get_heap_max: _emscripten_get_heap_max, + /** @export */ emscripten_get_now: _emscripten_get_now, + /** @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_num_logical_cores: _emscripten_num_logical_cores, + /** @export */ emscripten_resize_heap: _emscripten_resize_heap, + /** @export */ emscripten_set_main_loop: _emscripten_set_main_loop, + /** @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 */ environ_get: _environ_get, + /** @export */ environ_sizes_get: _environ_sizes_get, + /** @export */ exit: _exit, + /** @export */ fd_close: _fd_close, + /** @export */ fd_read: _fd_read, + /** @export */ fd_seek: _fd_seek, + /** @export */ fd_write: _fd_write, + /** @export */ glfwCreateStandardCursor: _glfwCreateStandardCursor, + /** @export */ glfwCreateWindow: _glfwCreateWindow, + /** @export */ glfwGetClipboardString: _glfwGetClipboardString, + /** @export */ glfwGetCurrentContext: _glfwGetCurrentContext, + /** @export */ glfwGetCursorPos: _glfwGetCursorPos, + /** @export */ glfwGetFramebufferSize: _glfwGetFramebufferSize, + /** @export */ glfwGetInputMode: _glfwGetInputMode, + /** @export */ glfwGetJoystickAxes: _glfwGetJoystickAxes, + /** @export */ glfwGetJoystickButtons: _glfwGetJoystickButtons, + /** @export */ glfwGetKey: _glfwGetKey, + /** @export */ glfwGetMonitorPos: _glfwGetMonitorPos, + /** @export */ glfwGetMonitorWorkarea: _glfwGetMonitorWorkarea, + /** @export */ glfwGetMonitors: _glfwGetMonitors, + /** @export */ glfwGetMouseButton: _glfwGetMouseButton, + /** @export */ glfwGetTime: _glfwGetTime, + /** @export */ glfwGetVideoMode: _glfwGetVideoMode, + /** @export */ glfwGetWindowAttrib: _glfwGetWindowAttrib, + /** @export */ glfwGetWindowPos: _glfwGetWindowPos, + /** @export */ glfwGetWindowSize: _glfwGetWindowSize, + /** @export */ glfwGetWindowUserPointer: _glfwGetWindowUserPointer, + /** @export */ glfwInit: _glfwInit, + /** @export */ glfwMakeContextCurrent: _glfwMakeContextCurrent, + /** @export */ glfwPollEvents: _glfwPollEvents, + /** @export */ glfwSetCharCallback: _glfwSetCharCallback, + /** @export */ glfwSetClipboardString: _glfwSetClipboardString, + /** @export */ glfwSetCursor: _glfwSetCursor, + /** @export */ glfwSetCursorEnterCallback: _glfwSetCursorEnterCallback, + /** @export */ glfwSetCursorPos: _glfwSetCursorPos, + /** @export */ glfwSetCursorPosCallback: _glfwSetCursorPosCallback, + /** @export */ glfwSetErrorCallback: _glfwSetErrorCallback, + /** @export */ glfwSetInputMode: _glfwSetInputMode, + /** @export */ glfwSetKeyCallback: _glfwSetKeyCallback, + /** @export */ glfwSetMonitorCallback: _glfwSetMonitorCallback, + /** @export */ glfwSetMouseButtonCallback: _glfwSetMouseButtonCallback, + /** @export */ glfwSetScrollCallback: _glfwSetScrollCallback, + /** @export */ glfwSetWindowCloseCallback: _glfwSetWindowCloseCallback, + /** @export */ glfwSetWindowFocusCallback: _glfwSetWindowFocusCallback, + /** @export */ glfwSetWindowIconifyCallback: _glfwSetWindowIconifyCallback, + /** @export */ glfwSetWindowPosCallback: _glfwSetWindowPosCallback, + /** @export */ glfwSetWindowShouldClose: _glfwSetWindowShouldClose, + /** @export */ glfwSetWindowSize: _glfwSetWindowSize, + /** @export */ glfwSetWindowSizeCallback: _glfwSetWindowSizeCallback, + /** @export */ glfwSetWindowUserPointer: _glfwSetWindowUserPointer, + /** @export */ glfwSwapBuffers: _glfwSwapBuffers, + /** @export */ glfwTerminate: _glfwTerminate, + /** @export */ glfwWindowHint: _glfwWindowHint, + /** @export */ glfwWindowShouldClose: _glfwWindowShouldClose, + /** @export */ invoke_ii, + /** @export */ invoke_iii, + /** @export */ invoke_iiii, + /** @export */ invoke_iiiii, + /** @export */ invoke_iiiiiii, + /** @export */ invoke_iiiiiiiiii, + /** @export */ invoke_vi, + /** @export */ invoke_vii, + /** @export */ invoke_viii, + /** @export */ invoke_viiii, + /** @export */ memory: wasmMemory, + /** @export */ proc_exit: _proc_exit + }; +} + +var wasmExports = createWasm(); + +var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["__wasm_call_ctors"])(); + +var _main = Module["_main"] = (a0, a1) => (_main = Module["_main"] = wasmExports["__main_argc_argv"])(a0, a1); + +var _free = a0 => (_free = wasmExports["free"])(a0); + +var _malloc = a0 => (_malloc = wasmExports["malloc"])(a0); + +var _axmol_hdoc_visibilitychange = Module["_axmol_hdoc_visibilitychange"] = a0 => (_axmol_hdoc_visibilitychange = Module["_axmol_hdoc_visibilitychange"] = wasmExports["axmol_hdoc_visibilitychange"])(a0); + +var _axmol_webglcontextlost = Module["_axmol_webglcontextlost"] = () => (_axmol_webglcontextlost = Module["_axmol_webglcontextlost"] = wasmExports["axmol_webglcontextlost"])(); + +var _axmol_webglcontextrestored = Module["_axmol_webglcontextrestored"] = () => (_axmol_webglcontextrestored = Module["_axmol_webglcontextrestored"] = wasmExports["axmol_webglcontextrestored"])(); + +var _axmol_dev_pause = Module["_axmol_dev_pause"] = () => (_axmol_dev_pause = Module["_axmol_dev_pause"] = wasmExports["axmol_dev_pause"])(); + +var _axmol_dev_resume = Module["_axmol_dev_resume"] = () => (_axmol_dev_resume = Module["_axmol_dev_resume"] = wasmExports["axmol_dev_resume"])(); + +var _axmol_dev_step = Module["_axmol_dev_step"] = () => (_axmol_dev_step = Module["_axmol_dev_step"] = wasmExports["axmol_dev_step"])(); + +var _axmol_onwebclickcallback = Module["_axmol_onwebclickcallback"] = () => (_axmol_onwebclickcallback = Module["_axmol_onwebclickcallback"] = wasmExports["axmol_onwebclickcallback"])(); + +var _pthread_self = () => (_pthread_self = wasmExports["pthread_self"])(); + +var _htonl = a0 => (_htonl = wasmExports["htonl"])(a0); + +var _ntohs = a0 => (_ntohs = wasmExports["ntohs"])(a0); + +var __emscripten_tls_init = () => (__emscripten_tls_init = wasmExports["_emscripten_tls_init"])(); + +var _emscripten_builtin_memalign = (a0, a1) => (_emscripten_builtin_memalign = wasmExports["emscripten_builtin_memalign"])(a0, a1); + +var __emscripten_run_callback_on_thread = (a0, a1, a2, a3, a4) => (__emscripten_run_callback_on_thread = wasmExports["_emscripten_run_callback_on_thread"])(a0, a1, a2, a3, a4); + +var __emscripten_thread_init = (a0, a1, a2, a3, a4, a5) => (__emscripten_thread_init = wasmExports["_emscripten_thread_init"])(a0, a1, a2, a3, a4, a5); + +var __emscripten_thread_crashed = () => (__emscripten_thread_crashed = wasmExports["_emscripten_thread_crashed"])(); + +var _emscripten_main_thread_process_queued_calls = () => (_emscripten_main_thread_process_queued_calls = wasmExports["emscripten_main_thread_process_queued_calls"])(); + +var _htons = a0 => (_htons = wasmExports["htons"])(a0); + +var _emscripten_main_runtime_thread_id = () => (_emscripten_main_runtime_thread_id = wasmExports["emscripten_main_runtime_thread_id"])(); + +var __emscripten_run_on_main_thread_js = (a0, a1, a2, a3, a4) => (__emscripten_run_on_main_thread_js = wasmExports["_emscripten_run_on_main_thread_js"])(a0, a1, a2, a3, a4); + +var __emscripten_thread_free_data = a0 => (__emscripten_thread_free_data = wasmExports["_emscripten_thread_free_data"])(a0); + +var __emscripten_thread_exit = a0 => (__emscripten_thread_exit = wasmExports["_emscripten_thread_exit"])(a0); + +var __emscripten_check_mailbox = () => (__emscripten_check_mailbox = wasmExports["_emscripten_check_mailbox"])(); + +var _setThrew = (a0, a1) => (_setThrew = wasmExports["setThrew"])(a0, a1); + +var __emscripten_tempret_set = a0 => (__emscripten_tempret_set = wasmExports["_emscripten_tempret_set"])(a0); + +var _emscripten_stack_set_limits = (a0, a1) => (_emscripten_stack_set_limits = wasmExports["emscripten_stack_set_limits"])(a0, a1); + +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 dynCall_jii = Module["dynCall_jii"] = (a0, a1, a2) => (dynCall_jii = Module["dynCall_jii"] = wasmExports["dynCall_jii"])(a0, a1, a2); + +var dynCall_jiji = Module["dynCall_jiji"] = (a0, a1, a2, a3, a4) => (dynCall_jiji = Module["dynCall_jiji"] = wasmExports["dynCall_jiji"])(a0, a1, a2, a3, a4); + +var dynCall_ji = Module["dynCall_ji"] = (a0, a1) => (dynCall_ji = Module["dynCall_ji"] = wasmExports["dynCall_ji"])(a0, a1); + +var dynCall_iij = Module["dynCall_iij"] = (a0, a1, a2, a3) => (dynCall_iij = Module["dynCall_iij"] = wasmExports["dynCall_iij"])(a0, a1, a2, a3); + +var dynCall_viijii = Module["dynCall_viijii"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_viijii = Module["dynCall_viijii"] = wasmExports["dynCall_viijii"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_iiiiij = Module["dynCall_iiiiij"] = (a0, a1, a2, a3, a4, a5, a6) => (dynCall_iiiiij = Module["dynCall_iiiiij"] = wasmExports["dynCall_iiiiij"])(a0, a1, a2, a3, a4, a5, a6); + +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8) => (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = wasmExports["dynCall_iiiiijj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8); + +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) => (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = wasmExports["dynCall_iiiiiijj"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + +function invoke_iiii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index, a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index, a1, a2, a3) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vii(index, a1, a2) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iii(index, a1, a2) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index, a1) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3, a4); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6); + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0); + } +} + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === +Module["addRunDependency"] = addRunDependency; + +Module["removeRunDependency"] = removeRunDependency; + +Module["ccall"] = ccall; + +Module["cwrap"] = cwrap; + +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 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(args = []) { + var entryFunction = _main; + args.unshift(thisProgram); + var argc = args.length; + var argv = stackAlloc((argc + 1) * 4); + var argv_ptr = argv; + args.forEach(arg => { + GROWABLE_HEAP_U32()[((argv_ptr) >> 2)] = stringToUTF8OnStack(arg); + argv_ptr += 4; + }); + GROWABLE_HEAP_U32()[((argv_ptr) >> 2)] = 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 run(args = arguments_) { + if (runDependencies > 0) { + return; + } + if (ENVIRONMENT_IS_PTHREAD) { + initRuntime(); + startWorker(Module); + return; + } + 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(args); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(() => { + setTimeout(() => Module["setStatus"](""), 1); + doRun(); + }, 1); + } else { + doRun(); + } +} + +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(); diff --git a/index.wasm b/index.wasm new file mode 100644 index 0000000..169c5f0 Binary files /dev/null and b/index.wasm differ