diff --git a/_drafts/sensor_watch.md b/_drafts/sensor_watch.md
index 26759da..c099b4c 100644
--- a/_drafts/sensor_watch.md
+++ b/_drafts/sensor_watch.md
@@ -1,22 +1,93 @@
---
title: Sensor Watch
-date: 2022-02-02
+date: 2022-02-03
layout: post
-image:
+image: /assets/blog/SensorWatch/watch.svg
---
-A while ago I backed a crowdsupply project called [Sensor Watch](https://www.oddlyspecificobjects.com/products/sensorwatch/). It's a replacement logic board for those classic Casio watches that you probably don't know the name of but have certainly seen around. This post goes through the process of getting the board swapped out and programming custom firmware on it.
+A while ago I backed a crowdsupply project called [Sensor Watch](https://www.oddlyspecificobjects.com/products/sensorwatch/). It's a replacement logic board for those classic Casio watches that you probably don't know the name of but have certainly seen around. This post goes through the process of getting the board swapped out and programming custom firmware on it. I also went opted for the [temperature sensor addon board](https://www.sensorwatch.net/docs/sensorboards/).
-I also went opted for the [temperature sensor addon board](https://www.sensorwatch.net/docs/sensorboards/).
+
+
+
+I got this Casio A164W off ebay, it's not quite the classic F-91W model but they all use the same 593 module internally and the sensor watch board replaces that module.
+
+
-## Compiling the firmware
+## The watch firmware
There is a firmware called Movement that already supports most of the things you probably want a watch to do, uses very little power and exposes a nice interface for writing extensions.
+To compile it you need the the [ARMmbed](https://github.com/ARMmbed/homebrew-formulae) toolchain and if you want to test the firmware in a javascript simulator (you do!) then you also need [emscriptem](https://emscripten.org/docs/getting_started/downloads.html):
+```bash
+# first make sure you've activated emscripten
+# in the current shell, see emscripten docs
+# for me this means running
+source ~/git/emsdk/emsdk_env.sh
+cd ~/git/Sensor-Watch/movement/make
-[TOTP tokens](https://blog.singleton.io/posts/2022-10-17-otp-on-wrist/)
+# emmake takes a normal makefile for a C project
+# and compiles it to JS instead
+emmake make
+
+# Serve watch.html locally
+python3 -m http.server 8000 -d build
+```
+The simulator itself is an adapted version of this lovely [simulation of the original watch firmware](https://github.com/alexisphilip/Casio-F-91W) for the sensorwatch project. The contents of watch.html is basically an svg of the watchface, some glue code and the watch firmware in watch.wasm. I factored out the inline svg and glue code to end up with a snippet that I could embed in this page:
+
+```html
+
+{% raw %}{% include watch.svg %}{% endraw %}
+
+
+
+Click the buttons to interact with my watch firmware!
+
+
+
+
+```
+
+Which I can update by re-running emmake and copying over watch.js and watch.wasm:
+```bash
+ emmake make && \
+ cp ./build/watch.wasm ./build/watch.js ~/git/tomhodson.github.com/assets/blog/SensorWatch
+```
+
+
+{% include watch.svg %}
+
+
+
+Click the buttons to interact with my watch firmware!
+
+
+
+
+
+
+
+# Customising the firmware
+TODO
+
+# Doing the board swap
+TODO
-## Future Ideas
+
+
+
+
+
+
+
+
+
+## Related links
+- [TOTP tokens](https://blog.singleton.io/posts/2022-10-17-otp-on-wrist/)
- [Data Runner](https://n-o-d-e.net/datarunner.html)
-- [A buzzer motor?](https://www.instructables.com/MAKE-IT-VIBRATE-Vibrator-Module-for-Casio-F-91W/)
\ No newline at end of file
+- [A buzzer instead of a piezo?](https://www.instructables.com/MAKE-IT-VIBRATE-Vibrator-Module-for-Casio-F-91W/)
\ No newline at end of file
diff --git a/_includes/watch.svg b/_includes/watch.svg
new file mode 100644
index 0000000..2e8d24e
--- /dev/null
+++ b/_includes/watch.svg
@@ -0,0 +1,1281 @@
+
+
diff --git a/assets/blog/SensorWatch/emulator.js b/assets/blog/SensorWatch/emulator.js
new file mode 100644
index 0000000..4e6eaa4
--- /dev/null
+++ b/assets/blog/SensorWatch/emulator.js
@@ -0,0 +1,71 @@
+
+ var outputElement = document.getElementById('output');
+ var Module = {
+ preRun: [],
+ postRun: [],
+ print: (function() {
+ if (outputElement) outputElement.value = ''; // clear browser cache
+ return function(text) {
+ if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' ');
+ console.log(text);
+ if (outputElement) {
+ outputElement.value += text + "\n";
+ outputElement.scrollTop = outputElement.scrollHeight; // focus on bottom
+ }
+ };
+ })(),
+ setStatus: function(text) {
+ if (!text) return;
+ if (text === 'Running...') text += '\n==========';
+
+ if (outputElement) {
+ outputElement.value += text + "\n";
+ outputElement.scrollTop = outputElement.scrollHeight; // focus on bottom
+ }
+ },
+ totalDependencies: 0,
+ monitorRunDependencies: function(left) {
+ this.totalDependencies = Math.max(this.totalDependencies, left);
+ Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
+ }
+ };
+ Module.setStatus('Downloading...');
+ window.onerror = function() {
+ Module.setStatus('Exception thrown, see JavaScript console');
+ Module.setStatus = function(text) {
+ if (text) Module.printErr('[post-exception status] ' + text);
+ };
+ };
+ lat = 0;
+ lon = 0;
+ tx = "";
+ function updateLocation(location) {
+ lat = Math.round(location.coords.latitude * 100);
+ lon = Math.round(location.coords.longitude * 100);
+ }
+ function sendText() {
+ var inputElement = document.getElementById('input');
+ tx = inputElement.value + "\n";
+ inputElement.value = "";
+ }
+ function showError(error) {
+ switch(error.code) {
+ case error.PERMISSION_DENIED:
+ alert("Permission denied");
+ break;
+ case error.POSITION_UNAVAILABLE:
+ alert("Location unavailable");
+ break;
+ case error.TIMEOUT:
+ alert("Request timed out");
+ break;
+ case error.UNKNOWN_ERROR:
+ alert("Unknown error");
+ break;
+ }
+ }
+ function getLocation() {
+ if (navigator.geolocation) {
+ navigator.geolocation.getCurrentPosition(updateLocation, showError);
+ }
+ }
\ No newline at end of file
diff --git a/assets/icons/blog/SensorWatch/real_watch.jpg b/assets/blog/SensorWatch/real_watch.jpg
similarity index 100%
rename from assets/icons/blog/SensorWatch/real_watch.jpg
rename to assets/blog/SensorWatch/real_watch.jpg
diff --git a/assets/blog/SensorWatch/watch.js b/assets/blog/SensorWatch/watch.js
new file mode 100644
index 0000000..e177b0a
--- /dev/null
+++ b/assets/blog/SensorWatch/watch.js
@@ -0,0 +1,2811 @@
+
+
+// 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(Module) { ..generated code.. }
+// 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 : {};
+
+// See https://caniuse.com/mdn-javascript_builtins_object_assign
+
+// See https://caniuse.com/mdn-javascript_builtins_bigint64array
+
+// --pre-jses are emitted after the Module integration code, so that they can
+// refer to Module (if they choose; they can also define Module)
+// {{PRE_JSES}}
+
+// 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;
+};
+
+// 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 importScripts == 'function';
+// 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';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (Module['ENVIRONMENT']) {
+ throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');
+}
+
+// `/` 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 read_,
+ readAsync,
+ readBinary,
+ setWindowTitle;
+
+// Normally we don't log exceptions but instead let them bubble out the top
+// level where the embedding environment (e.g. the browser) can handle
+// them.
+// However under v8 and node we sometimes exit the process direcly in which case
+// its up to use us to log the exception before exiting.
+// If we fix https://github.com/emscripten-core/emscripten/issues/15080
+// this may no longer be needed under node.
+function logExceptionOnExit(e) {
+ if (e instanceof ExitStatus) return;
+ let toLog = e;
+ if (e && typeof e == 'object' && e.stack) {
+ toLog = [e, e.stack];
+ }
+ err('exiting due to exception: ' + toLog);
+}
+
+if (ENVIRONMENT_IS_NODE) {
+ if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
+ if (ENVIRONMENT_IS_WORKER) {
+ scriptDirectory = require('path').dirname(scriptDirectory) + '/';
+ } else {
+ scriptDirectory = __dirname + '/';
+ }
+
+// include: node_shell_read.js
+
+
+// These modules will usually be used on Node.js. Load them eagerly to avoid
+// the complexity of lazy-loading. However, for now we must guard on require()
+// actually existing: if the JS is put in a .mjs file (ES6 module) and run on
+// node, then we'll detect node as the environment and get here, but require()
+// does not exist (since ES6 modules should use |import|). If the code actually
+// uses the node filesystem then it will crash, of course, but in the case of
+// code that never uses it we don't want to crash here, so the guarding if lets
+// such code work properly. See discussion in
+// https://github.com/emscripten-core/emscripten/pull/17851
+var fs, nodePath;
+if (typeof require === 'function') {
+ fs = require('fs');
+ nodePath = require('path');
+}
+
+read_ = (filename, binary) => {
+ filename = nodePath['normalize'](filename);
+ return fs.readFileSync(filename, binary ? undefined : 'utf8');
+};
+
+readBinary = (filename) => {
+ var ret = read_(filename, true);
+ if (!ret.buffer) {
+ ret = new Uint8Array(ret);
+ }
+ assert(ret.buffer);
+ return ret;
+};
+
+readAsync = (filename, onload, onerror) => {
+ filename = nodePath['normalize'](filename);
+ fs.readFile(filename, function(err, data) {
+ if (err) onerror(err);
+ else onload(data.buffer);
+ });
+};
+
+// end include: node_shell_read.js
+ if (process['argv'].length > 1) {
+ thisProgram = process['argv'][1].replace(/\\/g, '/');
+ }
+
+ arguments_ = process['argv'].slice(2);
+
+ if (typeof module != 'undefined') {
+ module['exports'] = Module;
+ }
+
+ process['on']('uncaughtException', function(ex) {
+ // suppress ExitStatus exceptions from showing an error
+ if (!(ex instanceof ExitStatus)) {
+ throw ex;
+ }
+ });
+
+ // Without this older versions of node (< v15) will log unhandled rejections
+ // but return 0, which is not normally the desired behaviour. This is
+ // not be needed with node v15 and about because it is now the default
+ // behaviour:
+ // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
+ process['on']('unhandledRejection', function(reason) { throw reason; });
+
+ quit_ = (status, toThrow) => {
+ if (keepRuntimeAlive()) {
+ process['exitCode'] = status;
+ throw toThrow;
+ }
+ logExceptionOnExit(toThrow);
+ process['exit'](status);
+ };
+
+ Module['inspect'] = function () { return '[Emscripten Module object]'; };
+
+} else
+if (ENVIRONMENT_IS_SHELL) {
+
+ if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
+
+ if (typeof read != 'undefined') {
+ read_ = function shell_read(f) {
+ return read(f);
+ };
+ }
+
+ readBinary = function readBinary(f) {
+ let data;
+ if (typeof readbuffer == 'function') {
+ return new Uint8Array(readbuffer(f));
+ }
+ data = read(f, 'binary');
+ assert(typeof data == 'object');
+ return data;
+ };
+
+ readAsync = function readAsync(f, onload, onerror) {
+ setTimeout(() => onload(readBinary(f)), 0);
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ arguments_ = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ arguments_ = arguments;
+ }
+
+ if (typeof quit == 'function') {
+ quit_ = (status, toThrow) => {
+ logExceptionOnExit(toThrow);
+ quit(status);
+ };
+ }
+
+ if (typeof print != 'undefined') {
+ // Prefer to use print/printErr where they exist, as they usually work better.
+ if (typeof console == 'undefined') console = /** @type{!Console} */({});
+ console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
+ console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print);
+ }
+
+} 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.indexOf('blob:') !== 0) {
+ scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1);
+ } else {
+ scriptDirectory = '';
+ }
+
+ if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');
+
+ // Differentiate the Web Worker from the Node Worker case, as reading must
+ // be done differently.
+ {
+// include: web_or_worker_shell_read.js
+
+
+ read_ = (url) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ }
+
+ if (ENVIRONMENT_IS_WORKER) {
+ readBinary = (url) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.responseType = 'arraybuffer';
+ xhr.send(null);
+ return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
+ };
+ }
+
+ readAsync = (url, onload, onerror) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = () => {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ return;
+ }
+ onerror();
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ }
+
+// end include: web_or_worker_shell_read.js
+ }
+
+ setWindowTitle = (title) => document.title = title;
+} else
+{
+ throw new Error('environment detection error');
+}
+
+var out = Module['print'] || console.log.bind(console);
+var err = Module['printErr'] || console.warn.bind(console);
+
+// Merge back in the overrides
+Object.assign(Module, moduleOverrides);
+// Free the object hierarchy contained in the overrides, this lets the GC
+// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
+moduleOverrides = null;
+checkIncomingModuleAPI();
+
+// Emit code to handle expected values on the Module object. This applies Module.x
+// to the proper local x. This has two benefits: first, we only emit it if it is
+// expected to arrive, and second, by using a local everywhere else that can be
+// minified.
+
+if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_');
+
+if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram');
+
+if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_');
+
+// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
+// Assertions on removed incoming Module JS APIs.
+assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
+assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)');
+assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
+assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
+assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)');
+assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');
+legacyModuleProp('read', 'read_');
+legacyModuleProp('readAsync', 'readAsync');
+legacyModuleProp('readBinary', 'readBinary');
+legacyModuleProp('setWindowTitle', 'setWindowTitle');
+var 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 NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';
+
+assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable.");
+
+
+
+
+var STACK_ALIGN = 16;
+var POINTER_SIZE = 4;
+
+function getNativeTypeSize(type) {
+ switch (type) {
+ case 'i1': case 'i8': case 'u8': return 1;
+ case 'i16': case 'u16': return 2;
+ case 'i32': case 'u32': return 4;
+ case 'i64': case 'u64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length - 1] === '*') {
+ return POINTER_SIZE;
+ }
+ if (type[0] === 'i') {
+ const bits = Number(type.substr(1));
+ assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type);
+ return bits / 8;
+ }
+ return 0;
+ }
+ }
+}
+
+// include: runtime_debug.js
+
+
+function legacyModuleProp(prop, newName) {
+ if (!Object.getOwnPropertyDescriptor(Module, prop)) {
+ Object.defineProperty(Module, prop, {
+ configurable: true,
+ get: function() {
+ abort('Module.' + prop + ' has been replaced with plain ' + newName + ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)');
+ }
+ });
+ }
+}
+
+function ignoredModuleProp(prop) {
+ if (Object.getOwnPropertyDescriptor(Module, prop)) {
+ abort('`Module.' + prop + '` was supplied but `' + prop + '` not included in INCOMING_MODULE_JS_API');
+ }
+}
+
+// forcing the filesystem exports a few things by default
+function isExportedByForceFilesystem(name) {
+ return name === 'FS_createPath' ||
+ name === 'FS_createDataFile' ||
+ name === 'FS_createPreloadedFile' ||
+ name === 'FS_unlink' ||
+ name === 'addRunDependency' ||
+ // The old FS has some functionality that WasmFS lacks.
+ name === 'FS_createLazyFile' ||
+ name === 'FS_createDevice' ||
+ name === 'removeRunDependency';
+}
+
+function missingLibrarySymbol(sym) {
+ if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
+ Object.defineProperty(globalThis, sym, {
+ configurable: true,
+ get: function() {
+ // 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);
+ return undefined;
+ }
+ });
+ }
+}
+
+function unexportedRuntimeSymbol(sym) {
+ if (!Object.getOwnPropertyDescriptor(Module, sym)) {
+ Object.defineProperty(Module, sym, {
+ configurable: true,
+ get: function() {
+ var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)";
+ if (isExportedByForceFilesystem(sym)) {
+ msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
+ }
+ abort(msg);
+ }
+ });
+ }
+}
+
+// end include: runtime_debug.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 (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary');
+var noExitRuntime = Module['noExitRuntime'] || true;legacyModuleProp('noExitRuntime', 'noExitRuntime');
+
+if (typeof WebAssembly != 'object') {
+ abort('no native wasm support detected');
+}
+
+// Wasm globals
+
+var wasmMemory;
+
+//========================================
+// Runtime essentials
+//========================================
+
+// whether we are quitting the application. no code should run after this.
+// set in exit() and abort()
+var ABORT = false;
+
+// set by exit() and abort(). Passed to 'onExit' handler.
+// NOTE: This is also used as the process return code code in shell environments
+// but only when noExitRuntime is false.
+var EXITSTATUS;
+
+/** @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.
+
+// include: runtime_strings.js
+
+
+// runtime_strings.js: String related runtime functions that are part of both
+// MINIMAL_RUNTIME and regular runtime.
+
+var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : 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}
+ */
+function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+ 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 means Infinity)
+ while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+
+ if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+ return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+ }
+ var str = '';
+ // If building with TextDecoder, we have already computed the string length
+ // above, so test loop end condition against that
+ while (idx < endPtr) {
+ // For UTF8 byte structure, see:
+ // http://en.wikipedia.org/wiki/UTF-8#Description
+ // https://www.ietf.org/rfc/rfc2279.txt
+ // https://tools.ietf.org/html/rfc3629
+ var u0 = heapOrArray[idx++];
+ if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
+ var u1 = heapOrArray[idx++] & 63;
+ if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
+ var u2 = heapOrArray[idx++] & 63;
+ if ((u0 & 0xF0) == 0xE0) {
+ u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+ } else {
+ if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');
+ u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+ }
+
+ if (u0 < 0x10000) {
+ str += String.fromCharCode(u0);
+ } else {
+ var ch = u0 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ }
+ }
+ return str;
+}
+
+/**
+ * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+ * emscripten HEAP, returns a copy of that string as a Javascript String object.
+ *
+ * @param {number} ptr
+ * @param {number=} maxBytesToRead - An optional length that specifies the
+ * maximum number of bytes to read. You can omit this parameter to scan the
+ * string until the first \0 byte. If maxBytesToRead is passed, and the string
+ * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+ * string will cut short at that byte index (i.e. maxBytesToRead will not
+ * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+ * frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+ * JS JIT optimizations off, so it is worth to consider consistently using one
+ * @return {string}
+ */
+function UTF8ToString(ptr, maxBytesToRead) {
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+}
+
+/**
+ * Copies the given Javascript String object 'str' to the given byte array at
+ * address 'outIdx', encoded in UTF8 form and null-terminated. The copy will
+ * require at most str.length*4+1 bytes of space in the HEAP. Use the function
+ * lengthBytesUTF8 to compute the exact number of bytes (excluding null
+ * terminator) that this function will write.
+ *
+ * @param {string} str - The Javascript string to copy.
+ * @param {ArrayBufferView|Array} heap - The array to copy to. Each
+ * index in this array is assumed
+ * to be one 8-byte element.
+ * @param {number} outIdx - The starting offset in the array to begin the copying.
+ * @param {number} maxBytesToWrite - The maximum number of bytes this function
+ * can write to the array. This count should
+ * include the null terminator, i.e. if
+ * maxBytesToWrite=1, only the null terminator
+ * will be written and nothing else.
+ * maxBytesToWrite=0 does not write any bytes
+ * to the output, not even the null
+ * terminator.
+ * @return {number} The number of bytes written, EXCLUDING the null terminator.
+ */
+function 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 >= 0xD800 && u <= 0xDFFF) {
+ var u1 = str.charCodeAt(++i);
+ u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
+ }
+ if (u <= 0x7F) {
+ if (outIdx >= endIdx) break;
+ heap[outIdx++] = u;
+ } else if (u <= 0x7FF) {
+ if (outIdx + 1 >= endIdx) break;
+ heap[outIdx++] = 0xC0 | (u >> 6);
+ heap[outIdx++] = 0x80 | (u & 63);
+ } else if (u <= 0xFFFF) {
+ if (outIdx + 2 >= endIdx) break;
+ heap[outIdx++] = 0xE0 | (u >> 12);
+ heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+ heap[outIdx++] = 0x80 | (u & 63);
+ } else {
+ if (outIdx + 3 >= endIdx) break;
+ if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).');
+ heap[outIdx++] = 0xF0 | (u >> 18);
+ heap[outIdx++] = 0x80 | ((u >> 12) & 63);
+ heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+ heap[outIdx++] = 0x80 | (u & 63);
+ }
+ }
+ // Null-terminate the pointer to the buffer.
+ heap[outIdx] = 0;
+ return outIdx - startIdx;
+}
+
+/**
+ * Copies the given Javascript String object 'str' to the emscripten HEAP at
+ * address 'outPtr', null-terminated and encoded in UTF8 form. The copy will
+ * require at most str.length*4+1 bytes of space in the HEAP.
+ * Use the function lengthBytesUTF8 to compute the exact number of bytes
+ * (excluding null terminator) that this function will write.
+ *
+ * @return {number} The number of bytes written, EXCLUDING the null terminator.
+ */
+function stringToUTF8(str, outPtr, maxBytesToWrite) {
+ assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');
+ return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);
+}
+
+/**
+ * Returns the number of bytes the given Javascript string takes if encoded as a
+ * UTF8 byte array, EXCLUDING the null terminator byte.
+ *
+ * @param {string} str - JavaScript string to operator on
+ * @return {number} Length, in bytes, of the UTF8 encoded string.
+ */
+function lengthBytesUTF8(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+ // unit, not a Unicode code point of the character! So decode
+ // UTF16->UTF32->UTF8.
+ // See http://unicode.org/faq/utf_bom.html#utf16-3
+ var c = str.charCodeAt(i); // possibly a lead surrogate
+ if (c <= 0x7F) {
+ len++;
+ } else if (c <= 0x7FF) {
+ len += 2;
+ } else if (c >= 0xD800 && c <= 0xDFFF) {
+ len += 4; ++i;
+ } else {
+ len += 3;
+ }
+ }
+ return len;
+}
+
+// end include: runtime_strings.js
+// Memory management
+
+var HEAP,
+/** @type {!ArrayBuffer} */
+ buffer,
+/** @type {!Int8Array} */
+ HEAP8,
+/** @type {!Uint8Array} */
+ HEAPU8,
+/** @type {!Int16Array} */
+ HEAP16,
+/** @type {!Uint16Array} */
+ HEAPU16,
+/** @type {!Int32Array} */
+ HEAP32,
+/** @type {!Uint32Array} */
+ HEAPU32,
+/** @type {!Float32Array} */
+ HEAPF32,
+/** @type {!Float64Array} */
+ HEAPF64;
+
+function updateGlobalBufferAndViews(buf) {
+ buffer = buf;
+ Module['HEAP8'] = HEAP8 = new Int8Array(buf);
+ Module['HEAP16'] = HEAP16 = new Int16Array(buf);
+ Module['HEAP32'] = HEAP32 = new Int32Array(buf);
+ Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf);
+ Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf);
+ Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf);
+ Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
+ Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
+}
+
+var STACK_SIZE = 5242880;
+if (Module['STACK_SIZE']) assert(STACK_SIZE === Module['STACK_SIZE'], 'the stack size can no longer be determined at runtime')
+
+var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;legacyModuleProp('INITIAL_MEMORY', 'INITIAL_MEMORY');
+
+assert(INITIAL_MEMORY >= STACK_SIZE, 'INITIAL_MEMORY should be larger than STACK_SIZE, was ' + INITIAL_MEMORY + '! (STACK_SIZE=' + STACK_SIZE + ')');
+
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined,
+ 'JS engine does not provide full typed array support');
+
+// If memory is defined in wasm, the user can't provide it.
+assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally');
+assert(INITIAL_MEMORY == 16777216, 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically');
+
+// include: runtime_init_table.js
+// In regular non-RELOCATABLE mode the table is exported
+// from the wasm module and this will be assigned once
+// the exports are available.
+var wasmTable;
+
+// end include: runtime_init_table.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 the (separate) address-zero check
+ // below.
+ if (max == 0) {
+ max += 4;
+ }
+ // The stack grow downwards towards _emscripten_stack_get_end.
+ // We write cookies to the final two words in the stack and detect if they are
+ // ever overwritten.
+ HEAPU32[((max)>>2)] = 0x2135467;
+ HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;
+ // Also test the global address 0 for integrity.
+ HEAPU32[0] = 0x63736d65; /* 'emsc' */
+}
+
+function checkStackCookie() {
+ if (ABORT) return;
+ var max = _emscripten_stack_get_end();
+ // See writeStackCookie().
+ if (max == 0) {
+ max += 4;
+ }
+ var cookie1 = HEAPU32[((max)>>2)];
+ var cookie2 = HEAPU32[(((max)+(4))>>2)];
+ if (cookie1 != 0x2135467 || cookie2 != 0x89BACDFE) {
+ abort('Stack overflow! Stack cookie has been overwritten at ' + ptrToString(max) + ', expected hex dwords 0x89BACDFE and 0x2135467, but received ' + ptrToString(cookie2) + ' ' + ptrToString(cookie1));
+ }
+ // Also test the global address 0 for integrity.
+ if (HEAPU32[0] !== 0x63736d65 /* 'emsc' */) {
+ abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
+ }
+}
+
+// end include: runtime_stack_check.js
+// include: runtime_assertions.js
+
+
+// Endianness check
+(function() {
+ var h16 = new Int16Array(1);
+ var h8 = new Int8Array(h16.buffer);
+ h16[0] = 0x6373;
+ if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';
+})();
+
+// end include: runtime_assertions.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 keepRuntimeAlive() {
+ return noExitRuntime;
+}
+
+function preRun() {
+
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function initRuntime() {
+ assert(!runtimeInitialized);
+ runtimeInitialized = true;
+
+ checkStackCookie();
+
+
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ checkStackCookie();
+
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function postRun() {
+ checkStackCookie();
+
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+
+function addOnExit(cb) {
+}
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+
+// include: runtime_math.js
+
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
+
+assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
+
+// end include: runtime_math.js
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// Module.preRun (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+var runDependencyTracking = {};
+
+function getUniqueRunDependency(id) {
+ var orig = id;
+ while (1) {
+ if (!runDependencyTracking[id]) return id;
+ id = orig + Math.random();
+ }
+}
+
+function addRunDependency(id) {
+ runDependencies++;
+
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+
+ if (id) {
+ assert(!runDependencyTracking[id]);
+ runDependencyTracking[id] = 1;
+ if (runDependencyWatcher === null && typeof setInterval != 'undefined') {
+ // Check for missing dependencies every few seconds
+ runDependencyWatcher = setInterval(function() {
+ if (ABORT) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ return;
+ }
+ var shown = false;
+ for (var dep in runDependencyTracking) {
+ if (!shown) {
+ shown = true;
+ err('still waiting on run dependencies:');
+ }
+ err('dependency: ' + dep);
+ }
+ if (shown) {
+ err('(end of list)');
+ }
+ }, 10000);
+ }
+ } else {
+ err('warning: run dependency added without ID');
+ }
+}
+
+function removeRunDependency(id) {
+ runDependencies--;
+
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+
+ if (id) {
+ assert(runDependencyTracking[id]);
+ delete runDependencyTracking[id];
+ } else {
+ err('warning: run dependency removed without ID');
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+
+/** @param {string|number=} what */
+function abort(what) {
+ if (Module['onAbort']) {
+ 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;
+ EXITSTATUS = 1;
+
+ if (what.indexOf('RuntimeError: unreachable') >= 0) {
+ what += '. "unreachable" may be due to ASYNCIFY_STACK_SIZE not being large enough (try increasing it)';
+ }
+
+ // Use a wasm runtime error, because a JS error might be seen as a foreign
+ // exception, which means we'd run destructors on it. We need the error to
+ // simply make the program stop.
+ // FIXME This approach does not work in Wasm EH because it currently does not assume
+ // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
+ // a trap or not based on a hidden field within the object. So at the moment
+ // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
+ // allows this in the wasm spec.
+
+ // Suppress closure compiler warning here. Closure compiler's builtin extern
+ // defintion 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;
+}
+
+// {{MEM_INITIALIZER}}
+
+// include: memoryprofiler.js
+
+
+// end include: memoryprofiler.js
+// show errors on likely calls to FS when it was not included
+var FS = {
+ error: function() {
+ abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM');
+ },
+ init: function() { FS.error() },
+ createDataFile: function() { FS.error() },
+ createPreloadedFile: function() { FS.error() },
+ createLazyFile: function() { FS.error() },
+ open: function() { FS.error() },
+ mkdev: function() { FS.error() },
+ registerDevice: function() { FS.error() },
+ analyzePath: function() { FS.error() },
+ loadFilesFromDB: function() { FS.error() },
+
+ ErrnoError: function ErrnoError() { FS.error() },
+};
+Module['FS_createDataFile'] = FS.createDataFile;
+Module['FS_createPreloadedFile'] = FS.createPreloadedFile;
+
+// 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.
+function isDataURI(filename) {
+ // Prefix of data URIs emitted by SINGLE_FILE and related options.
+ return filename.startsWith(dataURIPrefix);
+}
+
+// Indicates whether filename is delivered via file protocol (as opposed to http/https)
+function isFileURI(filename) {
+ return filename.startsWith('file://');
+}
+
+// end include: URIUtils.js
+/** @param {boolean=} fixedasm */
+function createExportWrapper(name, fixedasm) {
+ return function() {
+ var displayName = name;
+ var asm = fixedasm;
+ if (!fixedasm) {
+ asm = Module['asm'];
+ }
+ assert(runtimeInitialized, 'native function `' + displayName + '` called before runtime initialization');
+ if (!asm[name]) {
+ assert(asm[name], 'exported native function `' + displayName + '` not found');
+ }
+ return asm[name].apply(null, arguments);
+ };
+}
+
+var wasmBinaryFile;
+ wasmBinaryFile = 'watch.wasm';
+ if (!isDataURI(wasmBinaryFile)) {
+ wasmBinaryFile = locateFile(wasmBinaryFile);
+ }
+
+function getBinary(file) {
+ try {
+ if (file == wasmBinaryFile && wasmBinary) {
+ return new Uint8Array(wasmBinary);
+ }
+ if (readBinary) {
+ return readBinary(file);
+ }
+ throw "both async and sync fetching of the wasm failed";
+ }
+ catch (err) {
+ abort(err);
+ }
+}
+
+function getBinaryPromise() {
+ // If we don't have the binary yet, try to to load it asynchronously.
+ // 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 fetch if it is available and the url is not a file, otherwise fall back to XHR.
+ if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+ if (typeof fetch == 'function'
+ && !isFileURI(wasmBinaryFile)
+ ) {
+ return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {
+ if (!response['ok']) {
+ throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
+ }
+ return response['arrayBuffer']();
+ }).catch(function () {
+ return getBinary(wasmBinaryFile);
+ });
+ }
+ else {
+ if (readAsync) {
+ // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
+ return new Promise(function(resolve, reject) {
+ readAsync(wasmBinaryFile, function(response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))) }, reject)
+ });
+ }
+ }
+ }
+
+ // Otherwise, getBinary should be able to get it synchronously
+ return Promise.resolve().then(function() { return getBinary(wasmBinaryFile); });
+}
+
+// Create the wasm instance.
+// Receives the wasm imports, returns the exports.
+function createWasm() {
+ // prepare imports
+ var info = {
+ 'env': asmLibraryArg,
+ 'wasi_snapshot_preview1': asmLibraryArg,
+ };
+ // 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) {
+ var exports = instance.exports;
+
+ exports = Asyncify.instrumentWasmExports(exports);
+
+ Module['asm'] = exports;
+
+ wasmMemory = Module['asm']['memory'];
+ assert(wasmMemory, "memory not found in wasm exports");
+ // This assertion doesn't hold when emscripten is run in --post-link
+ // mode.
+ // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.
+ //assert(wasmMemory.buffer.byteLength === 16777216);
+ updateGlobalBufferAndViews(wasmMemory.buffer);
+
+ wasmTable = Module['asm']['__indirect_function_table'];
+ assert(wasmTable, "table not found in wasm exports");
+
+ addOnInit(Module['asm']['__wasm_call_ctors']);
+
+ removeRunDependency('wasm-instantiate');
+
+ }
+ // we can't run yet (except in a pthread, where we have a custom sync instantiator)
+ addRunDependency('wasm-instantiate');
+
+ // Prefer streaming instantiation if available.
+ // Async compilation can be confusing when an error on the page overwrites Module
+ // (for example, if the order of elements is wrong, and the one defining Module is
+ // later), so we save Module and check it later.
+ var trueModule = Module;
+ function receiveInstantiationResult(result) {
+ // 'result' is a ResultObject object which has both the module and instance.
+ // receiveInstance() will swap in the exports (to Module.asm) so they can be called
+ assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');
+ trueModule = null;
+ // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
+ // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
+ receiveInstance(result['instance']);
+ }
+
+ function instantiateArrayBuffer(receiver) {
+ return getBinaryPromise().then(function(binary) {
+ return WebAssembly.instantiate(binary, info);
+ }).then(function (instance) {
+ return instance;
+ }).then(receiver, function(reason) {
+ err('failed to asynchronously prepare wasm: ' + reason);
+
+ // Warn on some common problems.
+ if (isFileURI(wasmBinaryFile)) {
+ err('warning: Loading from a file URI (' + wasmBinaryFile + ') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing');
+ }
+ abort(reason);
+ });
+ }
+
+ function instantiateAsync() {
+ if (!wasmBinary &&
+ typeof WebAssembly.instantiateStreaming == 'function' &&
+ !isDataURI(wasmBinaryFile) &&
+ // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
+ !isFileURI(wasmBinaryFile) &&
+ // 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(wasmBinaryFile, { credentials: 'same-origin' }).then(function(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, info);
+
+ return result.then(
+ receiveInstantiationResult,
+ 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(receiveInstantiationResult);
+ });
+ });
+ } else {
+ return instantiateArrayBuffer(receiveInstantiationResult);
+ }
+ }
+
+ // 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 {
+ var exports = Module['instantiateWasm'](info, receiveInstance);
+ exports = Asyncify.instrumentWasmExports(exports);
+ return exports;
+ } catch(e) {
+ err('Module.instantiateWasm callback failed with error: ' + e);
+ return false;
+ }
+ }
+
+ instantiateAsync();
+ return {}; // no exports yet; we'll fill them in later
+}
+
+// Globals used by JS i64 conversions (see makeSetValue)
+var tempDouble;
+var tempI64;
+
+// === Body ===
+
+var ASM_CONSTS = {
+ 5255176: () => { return Module['suspended']; },
+ 5255208: ($0) => { Module['suspended'] = $0; },
+ 5255238: ($0) => { const year = 2020 + (($0 >> 26) & 0x3f); const month = ($0 >> 22) & 0xf; const day = ($0 >> 17) & 0x1f; const hour = ($0 >> 12) & 0x1f; const minute = ($0 >> 6) & 0x3f; const second = $0 & 0x3f; const date = new Date(year, month - 1, day, hour, minute, second); return date - Date.now(); },
+ 5255530: ($0) => { const date = new Date(Date.now() + $0); return date.getSeconds() | (date.getMinutes() << 6) | (date.getHours() << 12) | (date.getDate() << 17) | ((date.getMonth() + 1) << 22) | ((date.getFullYear() - 2020) << 26); },
+ 5255748: ($0, $1, $2) => { const now = Date.now(); const date = new Date(now + $0); const hour = ($1 >> 12) & 0x1f; const minute = ($1 >> 6) & 0x3f; const second = $1 & 0x3f; if ($2 == 1) { if (second < date.getSeconds()) date.setMinutes(date.getMinutes() + 1); date.setSeconds(second); } else if ($2 == 2) { if (second < date.getSeconds()) date.setMinutes(date.getMinutes() + 1); if (minute < date.getMinutes()) date.setHours(date.getHours() + 1); date.setMinutes(minute, second); } else if ($2 == 3) { if (second < date.getSeconds()) date.setMinutes(date.getMinutes() + 1); if (minute < date.getMinutes()) date.setHours(date.getHours() + 1); if (hour < date.getHours()) date.setDate(date.getDate() + 1); date.setHours(hour, minute, second); } else { throw 'Invalid alarm match mask'; } return date - now; },
+ 5256532: ($0, $1) => { document.querySelectorAll("[data-com='" + $0 + "'][data-seg='" + $1 + "']") .forEach((e) => e.style.opacity = 1); },
+ 5256650: ($0, $1) => { document.querySelectorAll("[data-com='" + $0 + "'][data-seg='" + $1 + "']") .forEach((e) => e.style.opacity = 0); },
+ 5256768: () => { document.querySelectorAll("[data-com][data-seg]") .forEach((e) => e.style.opacity = 0); },
+ 5256860: ($0, $1) => { const classList = document.querySelector('#btn' + $0).classList; const highlight = 'highlight'; $1 ? classList.add(highlight) : classList.remove(highlight); },
+ 5257021: ($0, $1) => { document.getElementById('light').style.opacity = $1 / 255; },
+ 5257084: () => { Module['audioContext'] = new (window.AudioContext || window.webkitAudioContext)(); },
+ 5257171: () => { if (Module['audioContext']) { Module['audioContext'].close(); Module['audioContext'] = null; } },
+ 5257270: ($0) => { const audioContext = Module['audioContext']; if (!audioContext) return; if (!(audioContext._oscillator && audioContext._gain)) { const oscillator = audioContext.createOscillator(); const gain = audioContext.createGain(); oscillator.type = 'triangle'; oscillator.connect(gain); gain.connect(audioContext.destination); oscillator.start(0); audioContext._oscillator = oscillator; audioContext._gain = gain; } audioContext._oscillator.frequency.value = 1e6/$0; audioContext._gain.gain.value = 1; },
+ 5257766: () => { const audioContext = Module['audioContext']; if (audioContext && audioContext._gain) { audioContext._gain.gain.value = 0; } },
+ 5257894: () => { return -new Date().getTimezoneOffset(); },
+ 5257938: () => { var len = lengthBytesUTF8(tx) + 1; var s = _malloc(len); stringToUTF8(tx, s, len); return s; },
+ 5258035: () => { tx = ""; },
+ 5258048: () => { return lat; },
+ 5258064: () => { return lon; }
+};
+
+
+
+
+
+
+ /** @constructor */
+ function ExitStatus(status) {
+ this.name = 'ExitStatus';
+ this.message = 'Program terminated with exit(' + status + ')';
+ this.status = status;
+ }
+
+ function callRuntimeCallbacks(callbacks) {
+ while (callbacks.length > 0) {
+ // Pass the module as the first argument.
+ callbacks.shift()(Module);
+ }
+ }
+
+
+ /**
+ * @param {number} ptr
+ * @param {string} type
+ */
+ function getValue(ptr, type = 'i8') {
+ if (type.endsWith('*')) type = '*';
+ switch (type) {
+ case 'i1': return HEAP8[((ptr)>>0)];
+ case 'i8': return HEAP8[((ptr)>>0)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ case '*': return HEAPU32[((ptr)>>2)];
+ default: abort('invalid type for getValue: ' + type);
+ }
+ return null;
+ }
+
+ function ptrToString(ptr) {
+ return '0x' + ptr.toString(16).padStart(8, '0');
+ }
+
+
+ /**
+ * @param {number} ptr
+ * @param {number} value
+ * @param {string} type
+ */
+ function setValue(ptr, value, type = 'i8') {
+ if (type.endsWith('*')) type = '*';
+ switch (type) {
+ case 'i1': HEAP8[((ptr)>>0)] = value; break;
+ case 'i8': HEAP8[((ptr)>>0)] = value; break;
+ case 'i16': HEAP16[((ptr)>>1)] = value; break;
+ case 'i32': HEAP32[((ptr)>>2)] = value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)] = value; break;
+ case 'double': HEAPF64[((ptr)>>3)] = value; break;
+ case '*': HEAPU32[((ptr)>>2)] = value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+ }
+
+ function warnOnce(text) {
+ if (!warnOnce.shown) warnOnce.shown = {};
+ if (!warnOnce.shown[text]) {
+ warnOnce.shown[text] = 1;
+ if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text;
+ err(text);
+ }
+ }
+
+ function ___assert_fail(condition, filename, line, func) {
+ abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);
+ }
+
+ var readAsmConstArgsArray = [];
+ function readAsmConstArgs(sigPtr, buf) {
+ // Nobody should have mutated _readAsmConstArgsArray underneath us to be something else than an array.
+ assert(Array.isArray(readAsmConstArgsArray));
+ // The input buffer is allocated on the stack, so it must be stack-aligned.
+ assert(buf % 16 == 0);
+ readAsmConstArgsArray.length = 0;
+ var ch;
+ // Most arguments are i32s, so shift the buffer pointer so it is a plain
+ // index into HEAP32.
+ buf >>= 2;
+ while (ch = HEAPU8[sigPtr++]) {
+ var chr = String.fromCharCode(ch);
+ var validChars = ['d', 'f', 'i'];
+ assert(validChars.includes(chr), 'Invalid character ' + ch + '("' + chr + '") in readAsmConstArgs! Use only [' + validChars + '], and do not specify "v" for void return argument.');
+ // Floats are always passed as doubles, and doubles and int64s take up 8
+ // bytes (two 32-bit slots) in memory, align reads to these:
+ buf += (ch != 105/*i*/) & buf;
+ readAsmConstArgsArray.push(
+ ch == 105/*i*/ ? HEAP32[buf] :
+ HEAPF64[buf++ >> 1]
+ );
+ ++buf;
+ }
+ return readAsmConstArgsArray;
+ }
+ function _emscripten_asm_const_int(code, sigPtr, argbuf) {
+ var args = readAsmConstArgs(sigPtr, argbuf);
+ if (!ASM_CONSTS.hasOwnProperty(code)) abort('No EM_ASM constant found at address ' + code);
+ return ASM_CONSTS[code].apply(null, args);
+ }
+ function _emscripten_asm_const_double(code, sigPtr, argbuf) {
+ return _emscripten_asm_const_int(code, sigPtr, argbuf);
+ }
+
+
+ function _emscripten_clear_interval(id) {
+
+ clearInterval(id);
+ }
+
+ function _emscripten_clear_timeout(id) {
+ clearTimeout(id);
+ }
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.copyWithin(dest, src, src + num);
+ }
+
+ function _emscripten_request_animation_frame(cb, userData) {
+ return requestAnimationFrame(function(timeStamp) {
+ ((a1, a2) => dynCall_idi.apply(null, [cb, a1, a2]))(timeStamp, userData);
+ });
+ }
+
+ function getHeapMax() {
+ return HEAPU8.length;
+ }
+
+ function abortOnCannotGrowMemory(requestedSize) {
+ abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with -sINITIAL_MEMORY=X with X higher than the current value ' + HEAP8.length + ', (2) compile with -sALLOW_MEMORY_GROWTH which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -sABORTING_MALLOC=0');
+ }
+ function _emscripten_resize_heap(requestedSize) {
+ var oldSize = HEAPU8.length;
+ requestedSize = requestedSize >>> 0;
+ abortOnCannotGrowMemory(requestedSize);
+ }
+
+ function withStackSave(f) {
+ var stack = stackSave();
+ var ret = f();
+ stackRestore(stack);
+ return ret;
+ }
+ var JSEvents = {inEventHandler:0,removeAllEventListeners:function() {
+ for (var i = JSEvents.eventHandlers.length-1; i >= 0; --i) {
+ JSEvents._removeHandler(i);
+ }
+ JSEvents.eventHandlers = [];
+ JSEvents.deferredCalls = [];
+ },registerRemoveEventListeners:function() {
+ if (!JSEvents.removeEventListenersRegistered) {
+ __ATEXIT__.push(JSEvents.removeAllEventListeners);
+ JSEvents.removeEventListenersRegistered = true;
+ }
+ },deferredCalls:[],deferCall:function(targetFunction, precedence, argsList) {
+ function arraysHaveEqualContent(arrA, arrB) {
+ if (arrA.length != arrB.length) return false;
+
+ for (var i in arrA) {
+ if (arrA[i] != arrB[i]) return false;
+ }
+ return true;
+ }
+ // Test if the given call was already queued, and if so, don't add it again.
+ for (var i in JSEvents.deferredCalls) {
+ var call = JSEvents.deferredCalls[i];
+ if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
+ return;
+ }
+ }
+ JSEvents.deferredCalls.push({
+ targetFunction: targetFunction,
+ precedence: precedence,
+ argsList: argsList
+ });
+
+ JSEvents.deferredCalls.sort(function(x,y) { return x.precedence < y.precedence; });
+ },removeDeferredCalls:function(targetFunction) {
+ for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
+ if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
+ JSEvents.deferredCalls.splice(i, 1);
+ --i;
+ }
+ }
+ },canPerformEventHandlerRequests:function() {
+ return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
+ },runDeferredCalls:function() {
+ if (!JSEvents.canPerformEventHandlerRequests()) {
+ return;
+ }
+ for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
+ var call = JSEvents.deferredCalls[i];
+ JSEvents.deferredCalls.splice(i, 1);
+ --i;
+ call.targetFunction.apply(null, call.argsList);
+ }
+ },eventHandlers:[],removeAllHandlersOnTarget:function(target, eventTypeString) {
+ for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
+ if (JSEvents.eventHandlers[i].target == target &&
+ (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
+ JSEvents._removeHandler(i--);
+ }
+ }
+ },_removeHandler:function(i) {
+ var h = JSEvents.eventHandlers[i];
+ h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
+ JSEvents.eventHandlers.splice(i, 1);
+ },registerOrRemoveHandler:function(eventHandler) {
+ var jsEventHandler = function jsEventHandler(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;
+ };
+
+ if (eventHandler.callbackfunc) {
+ eventHandler.eventListenerFunc = jsEventHandler;
+ eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
+ JSEvents.eventHandlers.push(eventHandler);
+ JSEvents.registerRemoveEventListeners();
+ } else {
+ for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
+ if (JSEvents.eventHandlers[i].target == eventHandler.target
+ && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
+ JSEvents._removeHandler(i--);
+ }
+ }
+ }
+ },getNodeNameForTarget:function(target) {
+ if (!target) return '';
+ if (target == window) return '#window';
+ if (target == screen) return '#screen';
+ return (target && target.nodeName) ? target.nodeName : '';
+ },fullscreenEnabled:function() {
+ return document.fullscreenEnabled
+ // 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
+ ;
+ }};
+
+ function maybeCStringToJsString(cString) {
+ // "cString > 2" checks if the input is a number, and isn't of the special
+ // values we accept here, EMSCRIPTEN_EVENT_TARGET_* (which map to 0, 1, 2).
+ // In other words, if cString > 2 then it's a pointer to a valid place in
+ // memory, and points to a C string.
+ return cString > 2 ? UTF8ToString(cString) : cString;
+ }
+
+ var specialHTMLTargets = [0, typeof document != 'undefined' ? document : 0, typeof window != 'undefined' ? window : 0];
+ function findEventTarget(target) {
+ target = maybeCStringToJsString(target);
+ var domElement = specialHTMLTargets[target] || (typeof document != 'undefined' ? document.querySelector(target) : undefined);
+ return domElement;
+ }
+ function registerFocusEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
+ if (!JSEvents.focusEvent) JSEvents.focusEvent = _malloc( 256 );
+
+ var focusEventHandlerFunc = function(ev) {
+ var e = ev || event;
+
+ var nodeName = JSEvents.getNodeNameForTarget(e.target);
+ var id = e.target.id ? e.target.id : '';
+
+ var focusEvent = JSEvents.focusEvent;
+ stringToUTF8(nodeName, focusEvent + 0, 128);
+ stringToUTF8(id, focusEvent + 128, 128);
+
+ if (((a1, a2, a3) => dynCall_iiii.apply(null, [callbackfunc, a1, a2, a3]))(eventTypeId, focusEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target: findEventTarget(target),
+ eventTypeString: eventTypeString,
+ callbackfunc: callbackfunc,
+ handlerFunc: focusEventHandlerFunc,
+ useCapture: useCapture
+ };
+ JSEvents.registerOrRemoveHandler(eventHandler);
+ }
+ function _emscripten_set_blur_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerFocusEventCallback(target, userData, useCapture, callbackfunc, 12, "blur", targetThread);
+ return 0;
+ }
+
+ function _emscripten_set_focus_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerFocusEventCallback(target, userData, useCapture, callbackfunc, 13, "focus", targetThread);
+ return 0;
+ }
+
+ function handleException(e) {
+ // Certain exception types we do not treat as errors since they are used for
+ // internal control flow.
+ // 1. ExitStatus, which is thrown by exit()
+ // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
+ // that wish to return to JS event loop.
+ if (e instanceof ExitStatus || e == 'unwind') {
+ return EXITSTATUS;
+ }
+ checkStackCookie();
+ if (e instanceof WebAssembly.RuntimeError) {
+ if (_emscripten_stack_get_current() <= 0) {
+ err('Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to ' + STACK_SIZE + ')');
+ }
+ }
+ quit_(1, e);
+ }
+ function callUserCallback(func) {
+ if (ABORT) {
+ err('user callback triggered after runtime exited or application aborted. Ignoring.');
+ return;
+ }
+ try {
+ func();
+ } catch (e) {
+ handleException(e);
+ }
+ }
+ function _emscripten_set_interval(cb, msecs, userData) {
+
+ return setInterval(function() {
+ callUserCallback(function() {
+ ((a1) => dynCall_vi.apply(null, [cb, a1]))(userData)
+ });
+ }, msecs);
+ }
+
+ function registerKeyEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
+ if (!JSEvents.keyEvent) JSEvents.keyEvent = _malloc( 176 );
+
+ var keyEventHandlerFunc = function(e) {
+ assert(e);
+
+ var keyEventData = JSEvents.keyEvent;
+ HEAPF64[((keyEventData)>>3)] = e.timeStamp;
+
+ var idx = keyEventData >> 2;
+
+ HEAP32[idx + 2] = e.location;
+ HEAP32[idx + 3] = e.ctrlKey;
+ HEAP32[idx + 4] = e.shiftKey;
+ HEAP32[idx + 5] = e.altKey;
+ HEAP32[idx + 6] = e.metaKey;
+ HEAP32[idx + 7] = e.repeat;
+ HEAP32[idx + 8] = e.charCode;
+ HEAP32[idx + 9] = e.keyCode;
+ HEAP32[idx + 10] = e.which;
+ stringToUTF8(e.key || '', keyEventData + 44, 32);
+ stringToUTF8(e.code || '', keyEventData + 76, 32);
+ stringToUTF8(e.char || '', keyEventData + 108, 32);
+ stringToUTF8(e.locale || '', keyEventData + 140, 32);
+
+ if (((a1, a2, a3) => dynCall_iiii.apply(null, [callbackfunc, a1, a2, a3]))(eventTypeId, keyEventData, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target: findEventTarget(target),
+ allowsDeferredCalls: true,
+ eventTypeString: eventTypeString,
+ callbackfunc: callbackfunc,
+ handlerFunc: keyEventHandlerFunc,
+ useCapture: useCapture
+ };
+ JSEvents.registerOrRemoveHandler(eventHandler);
+ }
+ function _emscripten_set_keydown_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerKeyEventCallback(target, userData, useCapture, callbackfunc, 2, "keydown", targetThread);
+ return 0;
+ }
+
+ function _emscripten_set_keyup_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerKeyEventCallback(target, userData, useCapture, callbackfunc, 3, "keyup", targetThread);
+ return 0;
+ }
+
+ function getBoundingClientRect(e) {
+ return specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : {'left':0,'top':0};
+ }
+ function fillMouseEventData(eventStruct, e, target) {
+ assert(eventStruct % 4 == 0);
+ HEAPF64[((eventStruct)>>3)] = e.timeStamp;
+ var idx = eventStruct >> 2;
+ HEAP32[idx + 2] = e.screenX;
+ HEAP32[idx + 3] = e.screenY;
+ HEAP32[idx + 4] = e.clientX;
+ HEAP32[idx + 5] = e.clientY;
+ HEAP32[idx + 6] = e.ctrlKey;
+ HEAP32[idx + 7] = e.shiftKey;
+ HEAP32[idx + 8] = e.altKey;
+ HEAP32[idx + 9] = e.metaKey;
+ HEAP16[idx*2 + 20] = e.button;
+ HEAP16[idx*2 + 21] = e.buttons;
+
+ HEAP32[idx + 11] = e["movementX"]
+ ;
+
+ HEAP32[idx + 12] = e["movementY"]
+ ;
+
+ var rect = getBoundingClientRect(target);
+ HEAP32[idx + 13] = e.clientX - rect.left;
+ HEAP32[idx + 14] = e.clientY - rect.top;
+
+ }
+ function registerMouseEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
+ if (!JSEvents.mouseEvent) JSEvents.mouseEvent = _malloc( 72 );
+ target = findEventTarget(target);
+
+ var mouseEventHandlerFunc = function(ev) {
+ var e = ev || event;
+
+ // TODO: Make this access thread safe, or this could update live while app is reading it.
+ fillMouseEventData(JSEvents.mouseEvent, e, target);
+
+ if (((a1, a2, a3) => dynCall_iiii.apply(null, [callbackfunc, a1, a2, a3]))(eventTypeId, JSEvents.mouseEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target: target,
+ allowsDeferredCalls: eventTypeString != 'mousemove' && eventTypeString != 'mouseenter' && eventTypeString != 'mouseleave', // Mouse move events do not allow fullscreen/pointer lock requests to be handled in them!
+ eventTypeString: eventTypeString,
+ callbackfunc: callbackfunc,
+ handlerFunc: mouseEventHandlerFunc,
+ useCapture: useCapture
+ };
+ JSEvents.registerOrRemoveHandler(eventHandler);
+ }
+ function _emscripten_set_mousedown_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerMouseEventCallback(target, userData, useCapture, callbackfunc, 5, "mousedown", targetThread);
+ return 0;
+ }
+
+ function _emscripten_set_mouseout_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerMouseEventCallback(target, userData, useCapture, callbackfunc, 36, "mouseout", targetThread);
+ return 0;
+ }
+
+ function _emscripten_set_mouseup_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerMouseEventCallback(target, userData, useCapture, callbackfunc, 6, "mouseup", targetThread);
+ return 0;
+ }
+
+ /** @param {number=} timeout */
+ function safeSetTimeout(func, timeout) {
+
+ return setTimeout(function() {
+
+ callUserCallback(func);
+ }, timeout);
+ }
+ function _emscripten_set_timeout(cb, msecs, userData) {
+ return safeSetTimeout(() => ((a1) => dynCall_vi.apply(null, [cb, a1]))(userData), msecs);
+ }
+
+ function registerTouchEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
+ if (!JSEvents.touchEvent) JSEvents.touchEvent = _malloc( 1696 );
+
+ target = findEventTarget(target);
+
+ var touchEventHandlerFunc = function(e) {
+ assert(e);
+ var t, touches = {}, et = e.touches;
+ // To ease marshalling different kinds of touches that browser reports (all touches are listed in e.touches,
+ // only changed touches in e.changedTouches, and touches on target at a.targetTouches), mark a boolean in
+ // each Touch object so that we can later loop only once over all touches we see to marshall over to Wasm.
+
+ for (var i = 0; i < et.length; ++i) {
+ t = et[i];
+ // 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 (var i = 0; i < e.changedTouches.length; ++i) {
+ t = e.changedTouches[i];
+ t.isChanged = 1;
+ touches[t.identifier] = t;
+ }
+ // Mark which touches are part of the targetTouches list.
+ for (var i = 0; i < e.targetTouches.length; ++i) {
+ touches[e.targetTouches[i].identifier].onTarget = 1;
+ }
+
+ var touchEvent = JSEvents.touchEvent;
+ HEAPF64[((touchEvent)>>3)] = e.timeStamp;
+ var idx = touchEvent>>2; // Pre-shift the ptr to index to HEAP32 to save code size
+ HEAP32[idx + 3] = e.ctrlKey;
+ HEAP32[idx + 4] = e.shiftKey;
+ HEAP32[idx + 5] = e.altKey;
+ HEAP32[idx + 6] = e.metaKey;
+ idx += 7; // Advance to the start of the touch array.
+ var targetRect = getBoundingClientRect(target);
+ var numTouches = 0;
+ for (var i in touches) {
+ t = touches[i];
+ HEAP32[idx + 0] = t.identifier;
+ HEAP32[idx + 1] = t.screenX;
+ HEAP32[idx + 2] = t.screenY;
+ HEAP32[idx + 3] = t.clientX;
+ HEAP32[idx + 4] = t.clientY;
+ HEAP32[idx + 5] = t.pageX;
+ HEAP32[idx + 6] = t.pageY;
+ HEAP32[idx + 7] = t.isChanged;
+ HEAP32[idx + 8] = t.onTarget;
+ HEAP32[idx + 9] = t.clientX - targetRect.left;
+ HEAP32[idx + 10] = t.clientY - targetRect.top;
+
+ idx += 13;
+
+ if (++numTouches > 31) {
+ break;
+ }
+ }
+ HEAP32[(((touchEvent)+(8))>>2)] = numTouches;
+
+ if (((a1, a2, a3) => dynCall_iiii.apply(null, [callbackfunc, a1, a2, a3]))(eventTypeId, touchEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target: target,
+ allowsDeferredCalls: eventTypeString == 'touchstart' || eventTypeString == 'touchend',
+ eventTypeString: eventTypeString,
+ callbackfunc: callbackfunc,
+ handlerFunc: touchEventHandlerFunc,
+ useCapture: useCapture
+ };
+ JSEvents.registerOrRemoveHandler(eventHandler);
+ }
+ function _emscripten_set_touchend_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerTouchEventCallback(target, userData, useCapture, callbackfunc, 23, "touchend", targetThread);
+ return 0;
+ }
+
+ function _emscripten_set_touchstart_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
+ registerTouchEventCallback(target, userData, useCapture, callbackfunc, 22, "touchstart", targetThread);
+ return 0;
+ }
+
+ function _emscripten_sleep(ms) {
+ // emscripten_sleep() does not return a value, but we still need a |return|
+ // here for stack switching support (ASYNCIFY=2). In that mode this function
+ // returns a Promise instead of nothing, and that Promise is what tells the
+ // wasm VM to pause the stack.
+ return Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
+ }
+
+ var printCharBuffers = [null,[],[]];
+ function printChar(stream, curr) {
+ var buffer = printCharBuffers[stream];
+ assert(buffer);
+ if (curr === 0 || curr === 10) {
+ (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+ buffer.length = 0;
+ } else {
+ buffer.push(curr);
+ }
+ }
+ function flush_NO_FILESYSTEM() {
+ // flush anything remaining in the buffers during shutdown
+ _fflush(0);
+ if (printCharBuffers[1].length) printChar(1, 10);
+ if (printCharBuffers[2].length) printChar(2, 10);
+ }
+
+ var SYSCALLS = {varargs:undefined,get:function() {
+ assert(SYSCALLS.varargs != undefined);
+ SYSCALLS.varargs += 4;
+ var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
+ return ret;
+ },getStr:function(ptr) {
+ var ret = UTF8ToString(ptr);
+ return ret;
+ }};
+ function _fd_write(fd, iov, iovcnt, pnum) {
+ // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
+ var num = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[((iov)>>2)];
+ var len = HEAPU32[(((iov)+(4))>>2)];
+ iov += 8;
+ for (var j = 0; j < len; j++) {
+ printChar(fd, HEAPU8[ptr+j]);
+ }
+ num += len;
+ }
+ HEAPU32[((pnum)>>2)] = num;
+ return 0;
+ }
+
+ function _proc_exit(code) {
+ EXITSTATUS = code;
+ if (!keepRuntimeAlive()) {
+ if (Module['onExit']) Module['onExit'](code);
+ ABORT = true;
+ }
+ quit_(code, new ExitStatus(code));
+ }
+ /** @param {boolean|number=} implicit */
+ function exitJS(status, implicit) {
+ EXITSTATUS = status;
+
+ checkUnflushedContent();
+
+ // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
+ if (keepRuntimeAlive() && !implicit) {
+ var msg = 'program exited (with status: ' + status + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)';
+ err(msg);
+ }
+
+ _proc_exit(status);
+ }
+
+
+ function runAndAbortIfError(func) {
+ try {
+ return func();
+ } catch (e) {
+ abort(e);
+ }
+ }
+
+ function sigToWasmTypes(sig) {
+ var typeNames = {
+ 'i': 'i32',
+ // i64 values will be split into two i32s.
+ 'j': 'i32',
+ 'f': 'f32',
+ 'd': 'f64',
+ 'p': 'i32',
+ };
+ var type = {
+ parameters: [],
+ results: sig[0] == 'v' ? [] : [typeNames[sig[0]]]
+ };
+ for (var i = 1; i < sig.length; ++i) {
+ assert(sig[i] in typeNames, 'invalid signature char: ' + sig[i]);
+ type.parameters.push(typeNames[sig[i]]);
+ if (sig[i] === 'j') {
+ type.parameters.push('i32');
+ }
+ }
+ return type;
+ }
+
+ function runtimeKeepalivePush() {
+ }
+
+ function runtimeKeepalivePop() {
+ }
+ var Asyncify = {instrumentWasmImports:function(imports) {
+ var ASYNCIFY_IMPORTS = ["env.invoke_*","env.emscripten_sleep","env.emscripten_wget","env.emscripten_wget_data","env.emscripten_idb_load","env.emscripten_idb_store","env.emscripten_idb_delete","env.emscripten_idb_exists","env.emscripten_idb_load_blob","env.emscripten_idb_store_blob","env.SDL_Delay","env.emscripten_scan_registers","env.emscripten_lazy_load_code","env.emscripten_fiber_swap","wasi_snapshot_preview1.fd_sync","env.__wasi_fd_sync","env._emval_await","env._dlopen_js","env.__asyncjs__*"].map((x) => x.split('.')[1]);
+ for (var x in imports) {
+ (function(x) {
+ var original = imports[x];
+ var sig = original.sig;
+ if (typeof original == 'function') {
+ var isAsyncifyImport = ASYNCIFY_IMPORTS.indexOf(x) >= 0 ||
+ x.startsWith('__asyncjs__');
+ imports[x] = function() {
+ var originalAsyncifyState = Asyncify.state;
+ try {
+ return original.apply(null, arguments);
+ } finally {
+ // Only asyncify-declared imports are allowed to change the
+ // state.
+ // Changing the state from normal to disabled is allowed (in any
+ // function) as that is what shutdown does (and we don't have an
+ // explicit list of shutdown imports).
+ var changedToDisabled =
+ originalAsyncifyState === Asyncify.State.Normal &&
+ Asyncify.state === Asyncify.State.Disabled;
+ // invoke_* functions are allowed to change the state if we do
+ // not ignore indirect calls.
+ var ignoredInvoke = x.startsWith('invoke_') &&
+ true;
+ if (Asyncify.state !== originalAsyncifyState &&
+ !isAsyncifyImport &&
+ !changedToDisabled &&
+ !ignoredInvoke) {
+ throw new Error('import ' + x + ' was not in ASYNCIFY_IMPORTS, but changed the state');
+ }
+ }
+ };
+ }
+ })(x);
+ }
+ },instrumentWasmExports:function(exports) {
+ var ret = {};
+ for (var x in exports) {
+ (function(x) {
+ var original = exports[x];
+ if (typeof original == 'function') {
+ ret[x] = function() {
+ Asyncify.exportCallStack.push(x);
+ try {
+ return original.apply(null, arguments);
+ } finally {
+ if (!ABORT) {
+ var y = Asyncify.exportCallStack.pop();
+ assert(y === x);
+ Asyncify.maybeStopUnwind();
+ }
+ }
+ };
+ } else {
+ ret[x] = original;
+ }
+ })(x);
+ }
+ return ret;
+ },State:{Normal:0,Unwinding:1,Rewinding:2,Disabled:3},state:0,StackSize:4096,currData:null,handleSleepReturnValue:0,exportCallStack:[],callStackNameToId:{},callStackIdToName:{},callStackId:0,asyncPromiseHandlers:null,sleepCallbacks:[],getCallStackId:function(funcName) {
+ var id = Asyncify.callStackNameToId[funcName];
+ if (id === undefined) {
+ id = Asyncify.callStackId++;
+ Asyncify.callStackNameToId[funcName] = id;
+ Asyncify.callStackIdToName[id] = funcName;
+ }
+ return id;
+ },maybeStopUnwind:function() {
+ if (Asyncify.currData &&
+ Asyncify.state === Asyncify.State.Unwinding &&
+ Asyncify.exportCallStack.length === 0) {
+ // We just finished unwinding.
+ // Be sure to set the state before calling any other functions to avoid
+ // possible infinite recursion here (For example in debug pthread builds
+ // the dbg() function itself can call back into WebAssembly to get the
+ // current pthread_self() pointer).
+ Asyncify.state = Asyncify.State.Normal;
+
+ // Keep the runtime alive so that a re-wind can be done later.
+ runAndAbortIfError(_asyncify_stop_unwind);
+ if (typeof Fibers != 'undefined') {
+ Fibers.trampoline();
+ }
+ }
+ },whenDone:function() {
+ assert(Asyncify.currData, 'Tried to wait for an async operation when none is in progress.');
+ assert(!Asyncify.asyncPromiseHandlers, 'Cannot have multiple async operations in flight at once');
+ return new Promise((resolve, reject) => {
+ Asyncify.asyncPromiseHandlers = {
+ resolve: resolve,
+ reject: reject
+ };
+ });
+ },allocateData:function() {
+ // An asyncify data structure has three fields:
+ // 0 current stack pos
+ // 4 max stack pos
+ // 8 id of function at bottom of the call stack (callStackIdToName[id] == name of js function)
+ //
+ // The Asyncify ABI only interprets the first two fields, the rest is for the runtime.
+ // We also embed a stack in the same memory region here, right next to the structure.
+ // This struct is also defined as asyncify_data_t in emscripten/fiber.h
+ var ptr = _malloc(12 + Asyncify.StackSize);
+ Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize);
+ Asyncify.setDataRewindFunc(ptr);
+ return ptr;
+ },setDataHeader:function(ptr, stack, stackSize) {
+ HEAP32[((ptr)>>2)] = stack;
+ HEAP32[(((ptr)+(4))>>2)] = stack + stackSize;
+ },setDataRewindFunc:function(ptr) {
+ var bottomOfCallStack = Asyncify.exportCallStack[0];
+ var rewindId = Asyncify.getCallStackId(bottomOfCallStack);
+ HEAP32[(((ptr)+(8))>>2)] = rewindId;
+ },getDataRewindFunc:function(ptr) {
+ var id = HEAP32[(((ptr)+(8))>>2)];
+ var name = Asyncify.callStackIdToName[id];
+ var func = Module['asm'][name];
+ return func;
+ },doRewind:function(ptr) {
+ var start = Asyncify.getDataRewindFunc(ptr);
+ // Once we have rewound and the stack we no longer need to artificially
+ // keep the runtime alive.
+
+ return start();
+ },handleSleep:function(startAsync) {
+ assert(Asyncify.state !== Asyncify.State.Disabled, 'Asyncify cannot be done during or after the runtime exits');
+ if (ABORT) return;
+ if (Asyncify.state === Asyncify.State.Normal) {
+ // Prepare to sleep. Call startAsync, and see what happens:
+ // if the code decided to call our callback synchronously,
+ // then no async operation was in fact begun, and we don't
+ // need to do anything.
+ var reachedCallback = false;
+ var reachedAfterCallback = false;
+ startAsync((handleSleepReturnValue) => {
+ assert(!handleSleepReturnValue || typeof handleSleepReturnValue == 'number' || typeof handleSleepReturnValue == 'boolean'); // old emterpretify API supported other stuff
+ if (ABORT) return;
+ Asyncify.handleSleepReturnValue = handleSleepReturnValue || 0;
+ reachedCallback = true;
+ if (!reachedAfterCallback) {
+ // We are happening synchronously, so no need for async.
+ return;
+ }
+ // This async operation did not happen synchronously, so we did
+ // unwind. In that case there can be no compiled code on the stack,
+ // as it might break later operations (we can rewind ok now, but if
+ // we unwind again, we would unwind through the extra compiled code
+ // too).
+ assert(!Asyncify.exportCallStack.length, 'Waking up (starting to rewind) must be done from JS, without compiled code on the stack.');
+ Asyncify.state = Asyncify.State.Rewinding;
+ runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData));
+ if (typeof Browser != 'undefined' && Browser.mainLoop.func) {
+ Browser.mainLoop.resume();
+ }
+ var asyncWasmReturnValue, isError = false;
+ try {
+ asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData);
+ } catch (err) {
+ asyncWasmReturnValue = err;
+ isError = true;
+ }
+ // Track whether the return value was handled by any promise handlers.
+ var handled = false;
+ if (!Asyncify.currData) {
+ // All asynchronous execution has finished.
+ // `asyncWasmReturnValue` now contains the final
+ // return value of the exported async WASM function.
+ //
+ // Note: `asyncWasmReturnValue` is distinct from
+ // `Asyncify.handleSleepReturnValue`.
+ // `Asyncify.handleSleepReturnValue` contains the return
+ // value of the last C function to have executed
+ // `Asyncify.handleSleep()`, where as `asyncWasmReturnValue`
+ // contains the return value of the exported WASM function
+ // that may have called C functions that
+ // call `Asyncify.handleSleep()`.
+ var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers;
+ if (asyncPromiseHandlers) {
+ Asyncify.asyncPromiseHandlers = null;
+ (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue);
+ handled = true;
+ }
+ }
+ if (isError && !handled) {
+ // If there was an error and it was not handled by now, we have no choice but to
+ // rethrow that error into the global scope where it can be caught only by
+ // `onerror` or `onunhandledpromiserejection`.
+ throw asyncWasmReturnValue;
+ }
+ });
+ reachedAfterCallback = true;
+ if (!reachedCallback) {
+ // A true async operation was begun; start a sleep.
+ Asyncify.state = Asyncify.State.Unwinding;
+ // TODO: reuse, don't alloc/free every sleep
+ Asyncify.currData = Asyncify.allocateData();
+ if (typeof Browser != 'undefined' && Browser.mainLoop.func) {
+ Browser.mainLoop.pause();
+ }
+ runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData));
+ }
+ } else if (Asyncify.state === Asyncify.State.Rewinding) {
+ // Stop a resume.
+ Asyncify.state = Asyncify.State.Normal;
+ runAndAbortIfError(_asyncify_stop_rewind);
+ _free(Asyncify.currData);
+ Asyncify.currData = null;
+ // Call all sleep callbacks now that the sleep-resume is all done.
+ Asyncify.sleepCallbacks.forEach((func) => callUserCallback(func));
+ } else {
+ abort('invalid state: ' + Asyncify.state);
+ }
+ return Asyncify.handleSleepReturnValue;
+ },handleAsync:function(startAsync) {
+ return Asyncify.handleSleep((wakeUp) => {
+ // TODO: add error handling as a second param when handleSleep implements it.
+ startAsync().then(wakeUp);
+ });
+ }};
+var ASSERTIONS = true;
+
+function checkIncomingModuleAPI() {
+ ignoredModuleProp('fetchSettings');
+}
+var asmLibraryArg = {
+ "__assert_fail": ___assert_fail,
+ "emscripten_asm_const_double": _emscripten_asm_const_double,
+ "emscripten_asm_const_int": _emscripten_asm_const_int,
+ "emscripten_clear_interval": _emscripten_clear_interval,
+ "emscripten_clear_timeout": _emscripten_clear_timeout,
+ "emscripten_memcpy_big": _emscripten_memcpy_big,
+ "emscripten_request_animation_frame": _emscripten_request_animation_frame,
+ "emscripten_resize_heap": _emscripten_resize_heap,
+ "emscripten_set_blur_callback_on_thread": _emscripten_set_blur_callback_on_thread,
+ "emscripten_set_focus_callback_on_thread": _emscripten_set_focus_callback_on_thread,
+ "emscripten_set_interval": _emscripten_set_interval,
+ "emscripten_set_keydown_callback_on_thread": _emscripten_set_keydown_callback_on_thread,
+ "emscripten_set_keyup_callback_on_thread": _emscripten_set_keyup_callback_on_thread,
+ "emscripten_set_mousedown_callback_on_thread": _emscripten_set_mousedown_callback_on_thread,
+ "emscripten_set_mouseout_callback_on_thread": _emscripten_set_mouseout_callback_on_thread,
+ "emscripten_set_mouseup_callback_on_thread": _emscripten_set_mouseup_callback_on_thread,
+ "emscripten_set_timeout": _emscripten_set_timeout,
+ "emscripten_set_touchend_callback_on_thread": _emscripten_set_touchend_callback_on_thread,
+ "emscripten_set_touchstart_callback_on_thread": _emscripten_set_touchstart_callback_on_thread,
+ "emscripten_sleep": _emscripten_sleep,
+ "fd_write": _fd_write
+};
+Asyncify.instrumentWasmImports(asmLibraryArg);
+var asm = createWasm();
+/** @type {function(...*):?} */
+var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors");
+
+/** @type {function(...*):?} */
+var _main = Module["_main"] = createExportWrapper("main");
+
+/** @type {function(...*):?} */
+var _malloc = Module["_malloc"] = createExportWrapper("malloc");
+
+/** @type {function(...*):?} */
+var _free = Module["_free"] = createExportWrapper("free");
+
+/** @type {function(...*):?} */
+var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location");
+
+/** @type {function(...*):?} */
+var _fflush = Module["_fflush"] = createExportWrapper("fflush");
+
+/** @type {function(...*):?} */
+var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() {
+ return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var _emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = function() {
+ return (_emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = Module["asm"]["emscripten_stack_set_limits"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() {
+ return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() {
+ return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() {
+ return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var stackSave = Module["stackSave"] = createExportWrapper("stackSave");
+
+/** @type {function(...*):?} */
+var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore");
+
+/** @type {function(...*):?} */
+var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc");
+
+/** @type {function(...*):?} */
+var _emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = function() {
+ return (_emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var dynCall_idi = Module["dynCall_idi"] = createExportWrapper("dynCall_idi");
+
+/** @type {function(...*):?} */
+var dynCall_vi = Module["dynCall_vi"] = createExportWrapper("dynCall_vi");
+
+/** @type {function(...*):?} */
+var dynCall_iiii = Module["dynCall_iiii"] = createExportWrapper("dynCall_iiii");
+
+/** @type {function(...*):?} */
+var dynCall_iii = Module["dynCall_iii"] = createExportWrapper("dynCall_iii");
+
+/** @type {function(...*):?} */
+var dynCall_v = Module["dynCall_v"] = createExportWrapper("dynCall_v");
+
+/** @type {function(...*):?} */
+var dynCall_viii = Module["dynCall_viii"] = createExportWrapper("dynCall_viii");
+
+/** @type {function(...*):?} */
+var dynCall_vii = Module["dynCall_vii"] = createExportWrapper("dynCall_vii");
+
+/** @type {function(...*):?} */
+var dynCall_iiiiii = Module["dynCall_iiiiii"] = createExportWrapper("dynCall_iiiiii");
+
+/** @type {function(...*):?} */
+var dynCall_ii = Module["dynCall_ii"] = createExportWrapper("dynCall_ii");
+
+/** @type {function(...*):?} */
+var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");
+
+/** @type {function(...*):?} */
+var dynCall_iidiiii = Module["dynCall_iidiiii"] = createExportWrapper("dynCall_iidiiii");
+
+/** @type {function(...*):?} */
+var _asyncify_start_unwind = Module["_asyncify_start_unwind"] = createExportWrapper("asyncify_start_unwind");
+
+/** @type {function(...*):?} */
+var _asyncify_stop_unwind = Module["_asyncify_stop_unwind"] = createExportWrapper("asyncify_stop_unwind");
+
+/** @type {function(...*):?} */
+var _asyncify_start_rewind = Module["_asyncify_start_rewind"] = createExportWrapper("asyncify_start_rewind");
+
+/** @type {function(...*):?} */
+var _asyncify_stop_rewind = Module["_asyncify_stop_rewind"] = createExportWrapper("asyncify_stop_rewind");
+
+
+
+
+
+// === Auto-generated postamble setup entry stuff ===
+
+
+var unexportedRuntimeSymbols = [
+ 'run',
+ 'UTF8ArrayToString',
+ 'UTF8ToString',
+ 'stringToUTF8Array',
+ 'stringToUTF8',
+ 'lengthBytesUTF8',
+ 'addOnPreRun',
+ 'addOnInit',
+ 'addOnPreMain',
+ 'addOnExit',
+ 'addOnPostRun',
+ 'addRunDependency',
+ 'removeRunDependency',
+ 'FS_createFolder',
+ 'FS_createPath',
+ 'FS_createDataFile',
+ 'FS_createPreloadedFile',
+ 'FS_createLazyFile',
+ 'FS_createLink',
+ 'FS_createDevice',
+ 'FS_unlink',
+ 'getLEB',
+ 'getFunctionTables',
+ 'alignFunctionTables',
+ 'registerFunctions',
+ 'prettyPrint',
+ 'getCompilerSetting',
+ 'out',
+ 'err',
+ 'callMain',
+ 'abort',
+ 'keepRuntimeAlive',
+ 'wasmMemory',
+ 'stackAlloc',
+ 'stackSave',
+ 'stackRestore',
+ 'getTempRet0',
+ 'setTempRet0',
+ 'writeStackCookie',
+ 'checkStackCookie',
+ 'ptrToString',
+ 'zeroMemory',
+ 'stringToNewUTF8',
+ 'exitJS',
+ 'getHeapMax',
+ 'abortOnCannotGrowMemory',
+ 'emscripten_realloc_buffer',
+ 'ENV',
+ 'ERRNO_CODES',
+ 'ERRNO_MESSAGES',
+ 'setErrNo',
+ 'inetPton4',
+ 'inetNtop4',
+ 'inetPton6',
+ 'inetNtop6',
+ 'readSockaddr',
+ 'writeSockaddr',
+ 'DNS',
+ 'getHostByName',
+ 'Protocols',
+ 'Sockets',
+ 'getRandomDevice',
+ 'warnOnce',
+ 'traverseStack',
+ 'UNWIND_CACHE',
+ 'convertPCtoSourceLocation',
+ 'readAsmConstArgsArray',
+ 'readAsmConstArgs',
+ 'mainThreadEM_ASM',
+ 'jstoi_q',
+ 'jstoi_s',
+ 'getExecutableName',
+ 'listenOnce',
+ 'autoResumeAudioContext',
+ 'dynCallLegacy',
+ 'getDynCaller',
+ 'dynCall',
+ 'handleException',
+ 'runtimeKeepalivePush',
+ 'runtimeKeepalivePop',
+ 'callUserCallback',
+ 'maybeExit',
+ 'safeSetTimeout',
+ 'asmjsMangle',
+ 'asyncLoad',
+ 'alignMemory',
+ 'mmapAlloc',
+ 'writeI53ToI64',
+ 'writeI53ToI64Clamped',
+ 'writeI53ToI64Signaling',
+ 'writeI53ToU64Clamped',
+ 'writeI53ToU64Signaling',
+ 'readI53FromI64',
+ 'readI53FromU64',
+ 'convertI32PairToI53',
+ 'convertI32PairToI53Checked',
+ 'convertU32PairToI53',
+ 'getCFunc',
+ 'ccall',
+ 'cwrap',
+ 'uleb128Encode',
+ 'sigToWasmTypes',
+ 'generateFuncType',
+ 'convertJsFunctionToWasm',
+ 'freeTableIndexes',
+ 'functionsInTableMap',
+ 'getEmptyTableSlot',
+ 'updateTableMap',
+ 'addFunction',
+ 'removeFunction',
+ 'reallyNegative',
+ 'unSign',
+ 'strLen',
+ 'reSign',
+ 'formatString',
+ 'setValue',
+ 'getValue',
+ 'PATH',
+ 'PATH_FS',
+ 'intArrayFromString',
+ 'intArrayToString',
+ 'AsciiToString',
+ 'stringToAscii',
+ 'UTF16Decoder',
+ 'UTF16ToString',
+ 'stringToUTF16',
+ 'lengthBytesUTF16',
+ 'UTF32ToString',
+ 'stringToUTF32',
+ 'lengthBytesUTF32',
+ 'allocateUTF8',
+ 'allocateUTF8OnStack',
+ 'writeStringToMemory',
+ 'writeArrayToMemory',
+ 'writeAsciiToMemory',
+ 'SYSCALLS',
+ 'getSocketFromFD',
+ 'getSocketAddress',
+ 'JSEvents',
+ 'registerKeyEventCallback',
+ 'specialHTMLTargets',
+ 'maybeCStringToJsString',
+ 'findEventTarget',
+ 'findCanvasEventTarget',
+ 'getBoundingClientRect',
+ 'fillMouseEventData',
+ 'registerMouseEventCallback',
+ 'registerWheelEventCallback',
+ 'registerUiEventCallback',
+ 'registerFocusEventCallback',
+ 'fillDeviceOrientationEventData',
+ 'registerDeviceOrientationEventCallback',
+ 'fillDeviceMotionEventData',
+ 'registerDeviceMotionEventCallback',
+ 'screenOrientation',
+ 'fillOrientationChangeEventData',
+ 'registerOrientationChangeEventCallback',
+ 'fillFullscreenChangeEventData',
+ 'registerFullscreenChangeEventCallback',
+ 'JSEvents_requestFullscreen',
+ 'JSEvents_resizeCanvasForFullscreen',
+ 'registerRestoreOldStyle',
+ 'hideEverythingExceptGivenElement',
+ 'restoreHiddenElements',
+ 'setLetterbox',
+ 'currentFullscreenStrategy',
+ 'restoreOldWindowedStyle',
+ 'softFullscreenResizeWebGLRenderTarget',
+ 'doRequestFullscreen',
+ 'fillPointerlockChangeEventData',
+ 'registerPointerlockChangeEventCallback',
+ 'registerPointerlockErrorEventCallback',
+ 'requestPointerLock',
+ 'fillVisibilityChangeEventData',
+ 'registerVisibilityChangeEventCallback',
+ 'registerTouchEventCallback',
+ 'fillGamepadEventData',
+ 'registerGamepadEventCallback',
+ 'registerBeforeUnloadEventCallback',
+ 'fillBatteryEventData',
+ 'battery',
+ 'registerBatteryEventCallback',
+ 'setCanvasElementSize',
+ 'getCanvasElementSize',
+ 'demangle',
+ 'demangleAll',
+ 'jsStackTrace',
+ 'stackTrace',
+ 'ExitStatus',
+ 'getEnvStrings',
+ 'checkWasiClock',
+ 'flush_NO_FILESYSTEM',
+ 'dlopenMissingError',
+ 'createDyncallWrapper',
+ 'setImmediateWrapped',
+ 'clearImmediateWrapped',
+ 'polyfillSetImmediate',
+ 'uncaughtExceptionCount',
+ 'exceptionLast',
+ 'exceptionCaught',
+ 'ExceptionInfo',
+ 'exception_addRef',
+ 'exception_decRef',
+ 'Browser',
+ 'setMainLoop',
+ 'wget',
+ 'FS',
+ 'MEMFS',
+ 'TTY',
+ 'PIPEFS',
+ 'SOCKFS',
+ '_setNetworkCallback',
+ 'tempFixedLengthArray',
+ 'miniTempWebGLFloatBuffers',
+ 'heapObjectForWebGLType',
+ 'heapAccessShiftForWebGLHeap',
+ 'GL',
+ 'emscriptenWebGLGet',
+ 'computeUnpackAlignedImageSize',
+ 'emscriptenWebGLGetTexPixelData',
+ 'emscriptenWebGLGetUniform',
+ 'webglGetUniformLocation',
+ 'webglPrepareUniformLocationsBeforeFirstUse',
+ 'webglGetLeftBracePos',
+ 'emscriptenWebGLGetVertexAttrib',
+ 'writeGLArray',
+ 'AL',
+ 'SDL_unicode',
+ 'SDL_ttfContext',
+ 'SDL_audio',
+ 'SDL',
+ 'SDL_gfx',
+ 'GLUT',
+ 'EGL',
+ 'GLFW_Window',
+ 'GLFW',
+ 'GLEW',
+ 'IDBStore',
+ 'runAndAbortIfError',
+ 'Asyncify',
+ 'Fibers',
+ 'ALLOC_NORMAL',
+ 'ALLOC_STACK',
+ 'allocate',
+];
+unexportedRuntimeSymbols.forEach(unexportedRuntimeSymbol);
+var missingLibrarySymbols = [
+ 'zeroMemory',
+ 'stringToNewUTF8',
+ 'emscripten_realloc_buffer',
+ 'setErrNo',
+ 'inetPton4',
+ 'inetNtop4',
+ 'inetPton6',
+ 'inetNtop6',
+ 'readSockaddr',
+ 'writeSockaddr',
+ 'getHostByName',
+ 'getRandomDevice',
+ 'traverseStack',
+ 'convertPCtoSourceLocation',
+ 'mainThreadEM_ASM',
+ 'jstoi_q',
+ 'jstoi_s',
+ 'getExecutableName',
+ 'listenOnce',
+ 'autoResumeAudioContext',
+ 'dynCallLegacy',
+ 'getDynCaller',
+ 'dynCall',
+ 'maybeExit',
+ 'asmjsMangle',
+ 'asyncLoad',
+ 'alignMemory',
+ 'mmapAlloc',
+ 'writeI53ToI64',
+ 'writeI53ToI64Clamped',
+ 'writeI53ToI64Signaling',
+ 'writeI53ToU64Clamped',
+ 'writeI53ToU64Signaling',
+ 'readI53FromI64',
+ 'readI53FromU64',
+ 'convertI32PairToI53',
+ 'convertI32PairToI53Checked',
+ 'convertU32PairToI53',
+ 'getCFunc',
+ 'ccall',
+ 'cwrap',
+ 'uleb128Encode',
+ 'generateFuncType',
+ 'convertJsFunctionToWasm',
+ 'getEmptyTableSlot',
+ 'updateTableMap',
+ 'addFunction',
+ 'removeFunction',
+ 'reallyNegative',
+ 'unSign',
+ 'strLen',
+ 'reSign',
+ 'formatString',
+ 'intArrayFromString',
+ 'intArrayToString',
+ 'AsciiToString',
+ 'stringToAscii',
+ 'UTF16ToString',
+ 'stringToUTF16',
+ 'lengthBytesUTF16',
+ 'UTF32ToString',
+ 'stringToUTF32',
+ 'lengthBytesUTF32',
+ 'allocateUTF8',
+ 'allocateUTF8OnStack',
+ 'writeStringToMemory',
+ 'writeArrayToMemory',
+ 'writeAsciiToMemory',
+ 'getSocketFromFD',
+ 'getSocketAddress',
+ 'findCanvasEventTarget',
+ 'registerWheelEventCallback',
+ 'registerUiEventCallback',
+ 'fillDeviceOrientationEventData',
+ 'registerDeviceOrientationEventCallback',
+ 'fillDeviceMotionEventData',
+ 'registerDeviceMotionEventCallback',
+ 'screenOrientation',
+ 'fillOrientationChangeEventData',
+ 'registerOrientationChangeEventCallback',
+ 'fillFullscreenChangeEventData',
+ 'registerFullscreenChangeEventCallback',
+ 'JSEvents_requestFullscreen',
+ 'JSEvents_resizeCanvasForFullscreen',
+ 'registerRestoreOldStyle',
+ 'hideEverythingExceptGivenElement',
+ 'restoreHiddenElements',
+ 'setLetterbox',
+ 'softFullscreenResizeWebGLRenderTarget',
+ 'doRequestFullscreen',
+ 'fillPointerlockChangeEventData',
+ 'registerPointerlockChangeEventCallback',
+ 'registerPointerlockErrorEventCallback',
+ 'requestPointerLock',
+ 'fillVisibilityChangeEventData',
+ 'registerVisibilityChangeEventCallback',
+ 'fillGamepadEventData',
+ 'registerGamepadEventCallback',
+ 'registerBeforeUnloadEventCallback',
+ 'fillBatteryEventData',
+ 'battery',
+ 'registerBatteryEventCallback',
+ 'setCanvasElementSize',
+ 'getCanvasElementSize',
+ 'demangle',
+ 'demangleAll',
+ 'jsStackTrace',
+ 'stackTrace',
+ 'getEnvStrings',
+ 'checkWasiClock',
+ 'createDyncallWrapper',
+ 'setImmediateWrapped',
+ 'clearImmediateWrapped',
+ 'polyfillSetImmediate',
+ 'ExceptionInfo',
+ 'exception_addRef',
+ 'exception_decRef',
+ 'setMainLoop',
+ '_setNetworkCallback',
+ 'heapObjectForWebGLType',
+ 'heapAccessShiftForWebGLHeap',
+ 'emscriptenWebGLGet',
+ 'computeUnpackAlignedImageSize',
+ 'emscriptenWebGLGetTexPixelData',
+ 'emscriptenWebGLGetUniform',
+ 'webglGetUniformLocation',
+ 'webglPrepareUniformLocationsBeforeFirstUse',
+ 'webglGetLeftBracePos',
+ 'emscriptenWebGLGetVertexAttrib',
+ 'writeGLArray',
+ 'SDL_unicode',
+ 'SDL_ttfContext',
+ 'SDL_audio',
+ 'GLFW_Window',
+ 'ALLOC_NORMAL',
+ 'ALLOC_STACK',
+ 'allocate',
+];
+missingLibrarySymbols.forEach(missingLibrarySymbol)
+
+
+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) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ var entryFunction = Module['_main'];
+
+ var argc = 0;
+ var argv = 0;
+
+ try {
+
+ var ret = entryFunction(argc, argv);
+
+ // In PROXY_TO_PTHREAD builds, we should never exit the runtime below, as
+ // execution is asynchronously handed off to a pthread.
+ // if we're not running an evented main loop, it's time to exit
+ exitJS(ret, /* implicit = */ true);
+ return ret;
+ }
+ catch (e) {
+ return handleException(e);
+ }
+}
+
+function stackCheckInit() {
+ // This is normally called automatically during __wasm_call_ctors but need to
+ // get these values before even running any of the ctors so we call it redundantly
+ // here.
+ _emscripten_stack_init();
+ // TODO(sbc): Move writeStackCookie to native to to avoid this.
+ writeStackCookie();
+}
+
+/** @type {function(Array=)} */
+function run(args) {
+ args = args || arguments_;
+
+ if (runDependencies > 0) {
+ return;
+ }
+
+ stackCheckInit();
+
+ preRun();
+
+ // a preRun added a dependency, run will be called later
+ if (runDependencies > 0) {
+ return;
+ }
+
+ function doRun() {
+ // run may have just been called through dependencies being fulfilled just in this very frame,
+ // or while the async setStatus time below was happening
+ if (calledRun) return;
+ calledRun = true;
+ Module['calledRun'] = true;
+
+ if (ABORT) return;
+
+ initRuntime();
+
+ preMain();
+
+ if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
+
+ if (shouldRunNow) callMain(args);
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ doRun();
+ }, 1);
+ } else
+ {
+ doRun();
+ }
+ checkStackCookie();
+}
+
+function checkUnflushedContent() {
+ // Compiler settings do not allow exiting the runtime, so flushing
+ // the streams is not possible. but in ASSERTIONS mode we check
+ // if there was something to flush, and if so tell the user they
+ // should request that the runtime be exitable.
+ // Normally we would not even include flush() at all, but in ASSERTIONS
+ // builds we do so just for this check, and here we see if there is any
+ // content to flush, that is, we check if there would have been
+ // something a non-ASSERTIONS build would have not seen.
+ // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
+ // mode (which has its own special function for this; otherwise, all
+ // the code is inside libc)
+ var oldOut = out;
+ var oldErr = err;
+ var has = false;
+ out = err = (x) => {
+ has = true;
+ }
+ try { // it doesn't matter if it fails
+ flush_NO_FILESYSTEM();
+ } catch(e) {}
+ out = oldOut;
+ err = oldErr;
+ if (has) {
+ warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.');
+ warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)');
+ }
+}
+
+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/assets/blog/SensorWatch/watch.svg b/assets/blog/SensorWatch/watch.svg
new file mode 100644
index 0000000..2e8d24e
--- /dev/null
+++ b/assets/blog/SensorWatch/watch.svg
@@ -0,0 +1,1281 @@
+
+
diff --git a/assets/blog/SensorWatch/watch.wasm b/assets/blog/SensorWatch/watch.wasm
new file mode 100755
index 0000000..2187300
Binary files /dev/null and b/assets/blog/SensorWatch/watch.wasm differ
diff --git a/assets/icons/blog/SensorWatch/watch_back.jpg b/assets/blog/SensorWatch/watch_back.jpg
similarity index 100%
rename from assets/icons/blog/SensorWatch/watch_back.jpg
rename to assets/blog/SensorWatch/watch_back.jpg
+