// 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<Module>

// 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" && process.versions?.node && 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) {

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: /var/folders/nh/hbz5f40j1nb0m6t1hnbbz8q40000gn/T/tmpjk0o_otn.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";

async 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 = "step4.data";

var REMOTE_PACKAGE_BASE = "step4.data";

var REMOTE_PACKAGE_NAME = Module["locateFile"]?.(REMOTE_PACKAGE_BASE, "") ?? REMOTE_PACKAGE_BASE;

var REMOTE_PACKAGE_SIZE = metadata["remote_package_size"];

async function fetchRemotePackage(packageName, packageSize) {

if (isNode) {

var fsPromises = require("fs/promises");

var contents = await fsPromises.readFile(packageName);

return contents.buffer;

}

Module["dataFileDownloads"] ??= {};

try {

var response = await fetch(packageName);

} catch (e) {

throw new Error(`Network Error: ${packageName}`, {

e

});

}

if (!response.ok) {

throw new Error(`${response.status}: ${response.url}`);

}

const chunks = [];

const headers = response.headers;

const total = Number(headers.get("Content-Length") ?? packageSize);

let loaded = 0;

Module["setStatus"]?.("Downloading data...");

const reader = response.body.getReader();

while (1) {

var {done, value} = await reader.read();

if (done) break;

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})`);

}

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;

}

return packageData.buffer;

}

var fetchedCallback;

var fetched = Module["getPreloadedPackage"]?.(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE);

if (!fetched) {

// Note that we don't use await here because we want to execute the

// the rest of this function immediately.

fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE).then(data => {

if (fetchedCallback) {

fetchedCallback(data);

fetchedCallback = null;

} else {

fetched = data;

}

});

}

async function runWithFS(Module) {

function assert(check, msg) {

if (!check) throw new Error(msg);

}

Module["FS_createPath"]("/", "data", 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: async function(byteArray) {

var that = this;

// canOwn this data in the filesystem, it is a slice into the heap that will never change

Module["FS_createDataFile"](this.name, null, byteArray, true, true, true);

Module["removeRunDependency"](`fp ${that.name}`);

this.requests[this.name] = null;

}

};

var files = metadata["files"];

for (var i = 0; i < files.length; ++i) {

new DataRequest(files[i]["start"], files[i]["end"], files[i]["audio"] || 0).open("GET", files[i]["filename"]);

}

function processPackageData(arrayBuffer) {

assert(arrayBuffer, "Loading data file failed.");

assert(arrayBuffer.constructor.name === ArrayBuffer.name, "bad input to processPackageData");

var byteArray = new Uint8Array(arrayBuffer);

var curr;

// Reuse the bytearray from the XHR as the source for file reads.

DataRequest.prototype.byteArray = byteArray;

var files = metadata["files"];

for (var i = 0; i < files.length; ++i) {

DataRequest.prototype.requests[files[i].filename].onload();

}

Module["removeRunDependency"]("datafile_step4.data");

}

Module["addRunDependency"]("datafile_step4.data");

Module["preloadResults"] ??= {};

Module["preloadResults"][PACKAGE_NAME] = {

fromCache: false

};

if (fetched) {

processPackageData(fetched);

fetched = null;

} else {

fetchedCallback = processPackageData;

}

}

if (Module["calledRun"]) {

runWithFS(Module);

} else {

(Module["preRun"] ??= []).push(runWithFS);

}

}

loadPackage({

"files": [ {

"filename": "/data/IBMPlexMono-Bold.ttf",

"start": 0,

"end": 115628

}, {

"filename": "/data/IBMPlexSans-Bold.ttf",

"start": 115628,

"end": 302132

}, {

"filename": "/data/IBMPlexSans-Regular.ttf",

"start": 302132,

"end": 488492

}, {

"filename": "/data/bg.png",

"start": 488492,

"end": 548405

}, {

"filename": "/data/frag.emscripten.sh",

"start": 548405,

"end": 548531

}, {

"filename": "/data/frag.sh",

"start": 548531,

"end": 548634

}, {

"filename": "/data/greece.png",

"start": 548634,

"end": 1073653

}, {

"filename": "/data/mask.png",

"start": 1073653,

"end": 1090700

}, {

"filename": "/data/ring1.png",

"start": 1090700,

"end": 1097876

}, {

"filename": "/data/ring2.png",

"start": 1097876,

"end": 1106307

}, {

"filename": "/data/ring3.png",

"start": 1106307,

"end": 1115785

}, {

"filename": "/data/vert.emscripten.sh",

"start": 1115785,

"end": 1115968

}, {

"filename": "/data/vert.sh",

"start": 1115968,

"end": 1116128

} ],

"remote_package_size": 1116128

});

})();

// end include: /var/folders/nh/hbz5f40j1nb0m6t1hnbbz8q40000gn/T/tmpjk0o_otn.js

// include: /var/folders/nh/hbz5f40j1nb0m6t1hnbbz8q40000gn/T/tmpx8wkep4x.js

// All the pre-js content up to here must remain later on, we need to run

// it.

if ((typeof ENVIRONMENT_IS_WASM_WORKER != "undefined" && ENVIRONMENT_IS_WASM_WORKER) || (typeof ENVIRONMENT_IS_PTHREAD != "undefined" && ENVIRONMENT_IS_PTHREAD) || (typeof ENVIRONMENT_IS_AUDIO_WORKLET != "undefined" && ENVIRONMENT_IS_AUDIO_WORKLET)) Module["preRun"] = [];

var necessaryPreJSTasks = Module["preRun"].slice();

// end include: /var/folders/nh/hbz5f40j1nb0m6t1hnbbz8q40000gn/T/tmpx8wkep4x.js

// include: /var/folders/nh/hbz5f40j1nb0m6t1hnbbz8q40000gn/T/tmpjxgprh09.js

if (!Module["preRun"]) throw "Module.preRun should exist because file support used it; did a pre-js delete it?";

necessaryPreJSTasks.forEach(task => {

if (Module["preRun"].indexOf(task) < 0) throw "All preRun tasks that exist before user pre-js code should remain after; did you replace Module or modify Module.preRun?";

});

// end include: /var/folders/nh/hbz5f40j1nb0m6t1hnbbz8q40000gn/T/tmpjxgprh09.js

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 (typeof __filename != "undefined") {

// 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) {

const isNode = typeof process == "object" && process.versions?.node && process.type != "renderer";

if (!isNode) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");

var nodeVersion = process.versions.node;

var numericVersion = nodeVersion.split(".").slice(0, 3);

numericVersion = (numericVersion[0] * 1e4) + (numericVersion[1] * 100) + (numericVersion[2].split("-")[0] * 1);

if (numericVersion < 160400) {

throw new Error("This emscripten-generated code requires node v16.04.4.0 (detected v" + nodeVersion + ")");

}

// These modules will usually be used on Node.js. Load them eagerly to avoid

// the complexity of lazy-loading.

var fs = require("fs");

scriptDirectory = __dirname + "/";

// include: node_shell_read.js

readBinary = filename => {

// We need to re-wrap `file://` strings to URLs.

filename = isFileURI(filename) ? new URL(filename) : filename;

var ret = fs.readFileSync(filename);

assert(Buffer.isBuffer(ret));

return ret;

};

readAsync = async (filename, binary = true) => {

// See the comment in the `readBinary` function.

filename = isFileURI(filename) ? new URL(filename) : filename;

var ret = fs.readFileSync(filename, binary ? undefined : "utf8");

assert(binary ? Buffer.isBuffer(ret) : typeof ret == "string");

return ret;

};

// end include: node_shell_read.js

if (process.argv.length > 1) {

thisProgram = process.argv[1].replace(/\\/g, "/");

}

arguments_ = process.argv.slice(2);

// MODULARIZE will export the module in the proper place outside, we don't need to export here

if (typeof module != "undefined") {

module["exports"] = Module;

}

quit_ = (status, toThrow) => {

process.exitCode = status;

throw toThrow;

};

} else if (ENVIRONMENT_IS_SHELL) {

const isNode = typeof process == "object" && process.versions?.node && process.type != "renderer";

if (isNode || typeof window == "object" || typeof WorkerGlobalScope != "undefined") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");

} else // Note that this includes Node.js workers when relevant (pthreads is enabled).

// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and

// ENVIRONMENT_IS_NODE.

if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {

try {

scriptDirectory = new URL(".", _scriptName).href;

} catch {}

if (!(typeof window == "object" || typeof WorkerGlobalScope != "undefined")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");

// 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 = async 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);

});

}

var response = await fetch(url, {

credentials: "same-origin"

});

if (response.ok) {

return response.arrayBuffer();

}

throw new Error(response.status + " : " + response.url);

};

}

} else {

throw new Error("environment detection error");

}

// 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) {

var utils = require("util");

var stringify = a => typeof a == "object" ? utils.inspect(a) : a;

defaultPrint = (...args) => fs.writeSync(1, args.map(stringify).join(" ") + "\n");

defaultPrintErr = (...args) => fs.writeSync(2, args.map(stringify).join(" ") + "\n");

}

var out = defaultPrint;

var err = defaultPrintErr;

var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";

var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";

var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";

var FETCHFS = "FETCHFS is no longer included by default; build with -lfetchfs.js";

var ICASEFS = "ICASEFS is no longer included by default; build with -licasefs.js";

var JSFILEFS = "JSFILEFS is no longer included by default; build with -ljsfilefs.js";

var OPFS = "OPFS is no longer included by default; build with -lopfs.js";

var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";

// perform assertions in shell.js after we set up out() and err(), as otherwise

// if an assertion fails it cannot print the message

assert(ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_NODE, "Pthreads do not work in this environment yet (need Web Workers, or an alternative to them)");

assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.");

// end include: shell.js

// include: preamble.js

// === Preamble library stuff ===

// Documentation for the public APIs defined in this file must be updated in:

// site/source/docs/api_reference/preamble.js.rst

// A prebuilt local version of the documentation is available at:

// site/build/text/docs/api_reference/preamble.js.txt

// You can also build docs locally as HTML or other formats in site/

// An online HTML version (which may be of a different version of Emscripten)

// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html

var wasmBinary;

if (typeof WebAssembly != "object") {

err("no native wasm support detected");

}

// Wasm globals

// 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) {

abort("Assertion failed" + (text ? ": " + text : ""));

}

}

// We used to include malloc/free by default in the past. Show a helpful error in

// builds with assertions.

/**

* Indicates whether filename is delivered via file protocol (as opposed to http/https)

* @noinline

*/ var isFileURI = filename => filename.startsWith("file://");

// include: runtime_common.js

// include: runtime_stack_check.js

// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.

function writeStackCookie() {

var max = _emscripten_stack_get_end();

assert((max & 3) == 0);

// If the stack ends at address zero we write our cookies 4 bytes into the

// stack. This prevents interference with SAFE_HEAP and ASAN which also

// monitor writes to address zero.

if (max == 0) {

max += 4;

}

// The stack grow downwards towards _emscripten_stack_get_end.

// We write cookies to the final two words in the stack and detect if they are

// ever overwritten.

(growMemViews(), HEAPU32)[((max) >> 2)] = 34821223;

(growMemViews(), HEAPU32)[(((max) + (4)) >> 2)] = 2310721022;

// Also test the global address 0 for integrity.

(growMemViews(), HEAPU32)[((0) >> 2)] = 1668509029;

}

function checkStackCookie() {

if (ABORT) return;

var max = _emscripten_stack_get_end();

// See writeStackCookie().

if (max == 0) {

max += 4;

}

var cookie1 = (growMemViews(), HEAPU32)[((max) >> 2)];

var cookie2 = (growMemViews(), HEAPU32)[(((max) + (4)) >> 2)];

if (cookie1 != 34821223 || cookie2 != 2310721022) {

abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);

}

// Also test the global address 0 for integrity.

if ((growMemViews(), HEAPU32)[((0) >> 2)] != 1668509029) {

abort("Runtime error: The application has corrupted its heap memory area (address zero)!");

}

}

// end include: runtime_stack_check.js

// include: runtime_exceptions.js

// end include: runtime_exceptions.js

// include: runtime_debug.js

var runtimeDebug = true;

// Switch to false at runtime to disable logging at the right times

// Used by XXXXX_DEBUG settings to output debug messages.

function dbg(...args) {

if (!runtimeDebug && typeof runtimeDebug != "undefined") return;

// Avoid using the console for debugging in multi-threaded node applications

// See https://github.com/emscripten-core/emscripten/issues/14804

if (ENVIRONMENT_IS_NODE) {

// TODO(sbc): Unify with err/out implementation in shell.sh.

var fs = require("fs");

var utils = require("util");

var stringify = a => typeof a == "object" ? utils.inspect(a) : a;

fs.writeSync(2, args.map(stringify).join(" ") + "\n");

} else // TODO(sbc): Make this configurable somehow. Its not always convenient for

// logging to show up as warnings.

console.warn(...args);

}

// Endianness check

(() => {

var h16 = new Int16Array(1);

var h8 = new Int8Array(h16.buffer);

h16[0] = 25459;

if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";

})();

function consumedModuleProp(prop) {

if (!Object.getOwnPropertyDescriptor(Module, prop)) {

Object.defineProperty(Module, prop, {

configurable: true,

set() {

abort(`Attempt to set \`Module.${prop}\` after it has already been processed. This can happen, for example, when code is injected via '--post-js' rather than '--pre-js'`);

}

});

}

}

function makeInvalidEarlyAccess(name) {

return () => assert(false, `call to '${name}' via reference taken before Wasm module initialization`);

}

function ignoredModuleProp(prop) {

if (Object.getOwnPropertyDescriptor(Module, prop)) {

abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);

}

}

// forcing the filesystem exports a few things by default

function isExportedByForceFilesystem(name) {

return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_preloadFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.

name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";

}

/**

* Intercept access to a global symbol. This enables us to give informative

* warnings/errors when folks attempt to use symbols they did not include in

* their build, or no symbols that no longer exist.

*/ function hookGlobalSymbolAccess(sym, func) {

if (typeof globalThis != "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {

Object.defineProperty(globalThis, sym, {

configurable: true,

get() {

func();

return undefined;

}

});

}

}

function missingGlobal(sym, msg) {

hookGlobalSymbolAccess(sym, () => {

warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);

});

}

missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");

missingGlobal("asm", "Please use wasmExports instead");

function missingLibrarySymbol(sym) {

hookGlobalSymbolAccess(sym, () => {

// Can't `abort()` here because it would break code that does runtime

// checks. e.g. `if (typeof SDL === 'undefined')`.

var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;

// DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in

// library.js, which means $name for a JS name with no prefix, or name

// for a JS name like _name.

var librarySymbol = sym;

if (!librarySymbol.startsWith("_")) {

librarySymbol = "$" + sym;

}

msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;

if (isExportedByForceFilesystem(sym)) {

msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";

}

warnOnce(msg);

});

// Any symbol that is not included from the JS library is also (by definition)

// not exported on the Module object.

unexportedRuntimeSymbol(sym);

}

function unexportedRuntimeSymbol(sym) {

if (ENVIRONMENT_IS_PTHREAD) {

return;

}

if (!Object.getOwnPropertyDescriptor(Module, sym)) {

Object.defineProperty(Module, sym, {

configurable: true,

get() {

var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;

if (isExportedByForceFilesystem(sym)) {

msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";

}

abort(msg);

}

});

}

}

/**

* Override `err`/`out`/`dbg` to report thread / worker information

*/ function initWorkerLogging() {

function getLogPrefix() {

var t = 0;

if (runtimeInitialized && typeof _pthread_self != "undefined") {

t = _pthread_self();

}

return `w:${workerID},t:${ptrToString(t)}:`;

}

// Prefix all dbg() messages with the calling thread info.

var origDbg = dbg;

dbg = (...args) => origDbg(getLogPrefix(), ...args);

}

initWorkerLogging();

// end include: runtime_debug.js

// Support for growable heap + pthreads, where the buffer may change, so JS views

// must be updated.

function growMemViews() {

// `updateMemoryViews` updates all the views simultaneously, so it's enough to check any of them.

if (wasmMemory.buffer != HEAP8.buffer) {

updateMemoryViews();

}

}

var wasmModuleReceived;

if (ENVIRONMENT_IS_NODE && (ENVIRONMENT_IS_PTHREAD)) {

// Create as web-worker-like an environment as we can.

var parentPort = worker_threads["parentPort"];

parentPort.on("message", msg => global.onmessage?.({

data: msg

}));

Object.assign(globalThis, {

self: global,

postMessage: msg => parentPort["postMessage"](msg)

});

}

// 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.

// Unique ID of the current pthread worker (zero on non-pthread-workers

// including the main thread).

var workerID = 0;

var startWorker;

if (ENVIRONMENT_IS_PTHREAD) {

// Thread-local guard variable for one-time init of the JS state

var initializedJS = false;

// 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.

workerID = msgData.workerID;

// 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.

startWorker = () => {

// 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") {

assert(msgData.pthread_ptr);

// 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.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 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) {

err(`worker: onmessage() captured an uncaught exception: ${ex}`);

if (ex?.stack) err(ex.stack);

__emscripten_thread_crashed();

throw ex;

}

}

self.onmessage = handleMessage;

}

// ENVIRONMENT_IS_PTHREAD

// end include: runtime_pthread.js

// Memory management

var wasmMemory;

var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;

// BigInt64Array type is not correctly defined in closure

var /** not-@type {!BigInt64Array} */ HEAP64, /* BigUint64Array type is not correctly defined in closure

/** not-@type {!BigUint64Array} */ HEAPU64;

var runtimeInitialized = false;

function updateMemoryViews() {

var b = wasmMemory.buffer;

HEAP8 = new Int8Array(b);

HEAP16 = new Int16Array(b);

HEAPU8 = new Uint8Array(b);

HEAPU16 = new Uint16Array(b);

HEAP32 = new Int32Array(b);

HEAPU32 = new Uint32Array(b);

HEAPF32 = new Float32Array(b);

HEAPF64 = new Float64Array(b);

HEAP64 = new BigInt64Array(b);

HEAPU64 = new BigUint64Array(b);

}

// 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)

function initMemory() {

if ((ENVIRONMENT_IS_PTHREAD)) {

return;

}

if (Module["wasmMemory"]) {

wasmMemory = Module["wasmMemory"];

} else {

var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;

assert(INITIAL_MEMORY >= 65536, "INITIAL_MEMORY should be larger than STACK_SIZE, was " + INITIAL_MEMORY + "! (STACK_SIZE=" + 65536 + ")");

/** @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: memoryprofiler.js

// end include: memoryprofiler.js

// end include: runtime_common.js

assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");

function preRun() {

assert(!ENVIRONMENT_IS_PTHREAD);

// PThreads reuse the runtime from the main thread.

if (Module["preRun"]) {

if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];

while (Module["preRun"].length) {

addOnPreRun(Module["preRun"].shift());

}

}

consumedModuleProp("preRun");

// Begin ATPRERUNS hooks

callRuntimeCallbacks(onPreRuns);

}

function initRuntime() {

assert(!runtimeInitialized);

runtimeInitialized = true;

if (ENVIRONMENT_IS_PTHREAD) return startWorker();

checkStackCookie();

// Begin ATINITS hooks

if (!Module["noFSInit"] && !FS.initialized) FS.init();

TTY.init();

// End ATINITS hooks

wasmExports["__wasm_call_ctors"]();

// Begin ATPOSTCTORS hooks

FS.ignorePermissions = false;

}

function preMain() {

checkStackCookie();

}

function postRun() {

checkStackCookie();

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());

}

}

consumedModuleProp("postRun");

// Begin ATPOSTRUNS hooks

callRuntimeCallbacks(onPostRuns);

}

// 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 dependenciesFulfilled = null;

// overridden to take different actions when all run dependencies are fulfilled

var runDependencyTracking = {};

var runDependencyWatcher = null;

function addRunDependency(id) {

runDependencies++;

Module["monitorRunDependencies"]?.(runDependencies);

assert(id, "addRunDependency requires an ID");

assert(!runDependencyTracking[id]);

runDependencyTracking[id] = 1;

if (runDependencyWatcher === null && typeof setInterval != "undefined") {

// Check for missing dependencies every few seconds

runDependencyWatcher = setInterval(() => {

if (ABORT) {

clearInterval(runDependencyWatcher);

runDependencyWatcher = null;

return;

}

var shown = false;

for (var dep in runDependencyTracking) {

if (!shown) {

shown = true;

err("still waiting on run dependencies:");

}

err(`dependency: ${dep}`);

}

if (shown) {

err("(end of list)");

}

}, 1e4);

// Prevent this timer from keeping the runtime alive if nothing

// else is.

runDependencyWatcher.unref?.();

}

}

function removeRunDependency(id) {

runDependencies--;

Module["monitorRunDependencies"]?.(runDependencies);

assert(id, "removeRunDependency requires an ID");

assert(runDependencyTracking[id]);

delete runDependencyTracking[id];

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;

// 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