From cdd8b4dc4f73209fdb43ded3494820eeba146618 Mon Sep 17 00:00:00 2001 From: garrettmills Date: Wed, 6 May 2020 00:52:12 -0500 Subject: [PATCH] Initial commit --- .envrc | 1 + .idea/.gitignore | 8 + .idea/cppjs.iml | 8 + .idea/misc.xml | 6 + .idea/modules.xml | 8 + embuild | 12 + ems-core.js | 61 + hello.html | 22 + hello.js | 7005 +++++++++++++++++++++++++++++++++++++++ hello.wasm | Bin 0 -> 285504 bytes init.js | 57 + main.cpp | 41 + shell_minimal.html | 20 + src/class/Component.cpp | 5 + src/class/Component.h | 19 + src/class/Element.cpp | 161 + src/class/Element.h | 44 + src/class/EventBus.cpp | 25 + src/class/EventBus.h | 21 + src/proc/document.cpp | 116 + src/proc/event.cpp | 18 + src/proc/string.cpp | 102 + src/proc/uuid.cpp | 44 + 23 files changed, 7804 insertions(+) create mode 100755 .envrc create mode 100644 .idea/.gitignore create mode 100644 .idea/cppjs.iml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100755 embuild create mode 100644 ems-core.js create mode 100644 hello.html create mode 100644 hello.js create mode 100644 hello.wasm create mode 100644 init.js create mode 100644 main.cpp create mode 100644 shell_minimal.html create mode 100644 src/class/Component.cpp create mode 100644 src/class/Component.h create mode 100644 src/class/Element.cpp create mode 100644 src/class/Element.h create mode 100644 src/class/EventBus.cpp create mode 100644 src/class/EventBus.h create mode 100644 src/proc/document.cpp create mode 100644 src/proc/event.cpp create mode 100644 src/proc/string.cpp create mode 100644 src/proc/uuid.cpp diff --git a/.envrc b/.envrc new file mode 100755 index 0000000..985da80 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +export PATH=/home/garrettmills/.clone/emsdk:/home/garrettmills/.clone/emsdk/node/12.9.1_64bit/bin:/home/garrettmills/.clone/emsdk/upstream/emscripten:$PATH diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..73f69e0 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/.idea/cppjs.iml b/.idea/cppjs.iml new file mode 100644 index 0000000..bc2cd87 --- /dev/null +++ b/.idea/cppjs.iml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..28a804d --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..233c6fd --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/embuild b/embuild new file mode 100755 index 0000000..e338c37 --- /dev/null +++ b/embuild @@ -0,0 +1,12 @@ +#!/bin/bash + +emcc main.cpp --std=c++14 \ + --shell-file shell_minimal.html \ + --emrun \ + -o hello.html \ + -s NO_EXIT_RUNTIME=1 \ + -s EXPORTED_FUNCTIONS="['_main', '_itest', '_str_pass_size', '_fire_event_bus']" \ + -s EXTRA_EXPORTED_RUNTIME_METHODS="['cwrap', 'ccall', 'stringToUTF8', 'setValue', 'getValue', 'UTF8ToString']" \ + -s WASM=1 \ + -s DISABLE_EXCEPTION_CATCHING=0 \ + --bind diff --git a/ems-core.js b/ems-core.js new file mode 100644 index 0000000..d69746b --- /dev/null +++ b/ems-core.js @@ -0,0 +1,61 @@ +var Module = { + preRun: [], + postRun: [], + print: (function() { + var element = document.getElementById('output'); + if (element) element.value = ''; // clear browser cache + return function(text) { + if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' '); + // These replacements are necessary if you render to raw HTML + //text = text.replace(/&/g, "&"); + //text = text.replace(//g, ">"); + //text = text.replace('\n', '
', 'g'); + console.log(text); + if (element) { + element.value += text + "\n"; + element.scrollTop = element.scrollHeight; // focus on bottom + } + }; + })(), + printErr: function(text) { + if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' '); + console.error(text); + }, + /*canvas: (function() { + var canvas = document.getElementById('canvas'); + + // As a default initial behavior, pop up an alert when webgl context is lost. To make your + // application robust, you may want to override this behavior before shipping! + // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2 + canvas.addEventListener("webglcontextlost", function(e) { alert('WebGL context lost. You will need to reload the page.'); e.preventDefault(); }, false); + + return canvas; + })(),*/ + /*setStatus: function(text) { + if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' }; + if (text === Module.setStatus.last.text) return; + var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/); + var now = Date.now(); + if (m && now - Module.setStatus.last.time < 30) return; // if this is a progress update, skip it if too soon + Module.setStatus.last.time = now; + Module.setStatus.last.text = text; + if (m) { + text = m[1]; + progressElement.value = parseInt(m[2])*100; + progressElement.max = parseInt(m[4])*100; + progressElement.hidden = false; + spinnerElement.hidden = false; + } else { + progressElement.value = null; + progressElement.max = null; + progressElement.hidden = true; + if (!text) spinnerElement.hidden = true; + } + statusElement.innerHTML = text; + },*/ + totalDependencies: 0, + monitorRunDependencies: function(left) { + this.totalDependencies = Math.max(this.totalDependencies, left); + } +}; \ No newline at end of file diff --git a/hello.html b/hello.html new file mode 100644 index 0000000..bf448d7 --- /dev/null +++ b/hello.html @@ -0,0 +1,22 @@ + + + + + + Emscripten-Generated Code + + + + +

+

Hello, world!

+ + + + + + + diff --git a/hello.js b/hello.js new file mode 100644 index 0000000..14d945c --- /dev/null +++ b/hello.js @@ -0,0 +1,7005 @@ +/** + * @license + * Copyright 2010 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// 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 : {}; + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +/** + * @license + * Copyright 2013 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// Route URL GET parameters to argc+argv +if (typeof window === "object") { + Module['arguments'] = window.location.search.substr(1).trim().split('&'); + // If no args were passed arguments = [''], in which case kill the single empty string. + if (!Module['arguments'][0]) { + Module['arguments'] = []; + } +} + + + +// 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 = {}; +var key; +for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } +} + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = function(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). + +var ENVIRONMENT_IS_WEB = false; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; +ENVIRONMENT_IS_WEB = typeof window === 'object'; +ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'; +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, -s ENVIRONMENT=web or -s ENVIRONMENT=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; + +var nodeFS; +var nodePath; + +if (ENVIRONMENT_IS_NODE) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = require('path').dirname(scriptDirectory) + '/'; + } else { + scriptDirectory = __dirname + '/'; + } + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + + read_ = function shell_read(filename, binary) { + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + return nodeFS['readFileSync'](filename, binary ? null : 'utf8'); + }; + + readBinary = function readBinary(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + + + + + 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; + } + }); + + process['on']('unhandledRejection', abort); + + quit_ = function(status) { + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; + + + +} else +if (ENVIRONMENT_IS_SHELL) { + + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + var data; + if (typeof readbuffer === 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data === 'object'); + return data; + }; + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit === 'function') { + quit_ = function(status) { + 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 (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.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + + read_ = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + readBinary = function 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 = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function 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); + }; + + + + + } + + setWindowTitle = function(title) { document.title = title }; +} else +{ + throw new Error('environment detection error'); +} + + +// Set up the out() and err() hooks, which are how we can print to stdout or +// stderr, respectively. +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + +// Merge back in the overrides +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} +// 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; + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. +if (Module['arguments']) arguments_ = Module['arguments'];if (!Object.getOwnPropertyDescriptor(Module, 'arguments')) Object.defineProperty(Module, 'arguments', { configurable: true, get: function() { abort('Module.arguments has been replaced with plain arguments_') } }); +if (Module['thisProgram']) thisProgram = Module['thisProgram'];if (!Object.getOwnPropertyDescriptor(Module, 'thisProgram')) Object.defineProperty(Module, 'thisProgram', { configurable: true, get: function() { abort('Module.thisProgram has been replaced with plain thisProgram') } }); +if (Module['quit']) quit_ = Module['quit'];if (!Object.getOwnPropertyDescriptor(Module, 'quit')) Object.defineProperty(Module, 'quit', { configurable: true, get: function() { abort('Module.quit has been replaced with plain 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'); +if (!Object.getOwnPropertyDescriptor(Module, 'read')) Object.defineProperty(Module, 'read', { configurable: true, get: function() { abort('Module.read has been replaced with plain read_') } }); +if (!Object.getOwnPropertyDescriptor(Module, 'readAsync')) Object.defineProperty(Module, 'readAsync', { configurable: true, get: function() { abort('Module.readAsync has been replaced with plain readAsync') } }); +if (!Object.getOwnPropertyDescriptor(Module, 'readBinary')) Object.defineProperty(Module, 'readBinary', { configurable: true, get: function() { abort('Module.readBinary has been replaced with plain readBinary') } }); +if (!Object.getOwnPropertyDescriptor(Module, 'setWindowTitle')) Object.defineProperty(Module, 'setWindowTitle', { configurable: true, get: function() { abort('Module.setWindowTitle has been replaced with plain 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'; + + + + +/** + * @license + * Copyright 2017 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// {{PREAMBLE_ADDITIONS}} + +var STACK_ALIGN = 16; + +// stack management, and other functionality that is provided by the compiled code, +// should not be used before it is ready + +/** @suppress{duplicate} */ +var stackSave; +/** @suppress{duplicate} */ +var stackRestore; +/** @suppress{duplicate} */ +var stackAlloc; + +stackSave = stackRestore = stackAlloc = function() { + abort('cannot use the stack before compiled code is ready to run, and has provided stack access'); +}; + +function staticAlloc(size) { + abort('staticAlloc is no longer available at runtime; instead, perform static allocations at compile time (using makeStaticAlloc)'); +} + +function dynamicAlloc(size) { + assert(DYNAMICTOP_PTR); + var ret = HEAP32[DYNAMICTOP_PTR>>2]; + var end = (ret + size + 15) & -16; + assert(end <= HEAP8.length, 'failure to dynamicAlloc - memory growth etc. is not supported there, call malloc/sbrk directly'); + HEAP32[DYNAMICTOP_PTR>>2] = end; + return ret; +} + +function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default + return Math.ceil(size / factor) * factor; +} + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': return 1; + case 'i16': return 2; + case 'i32': return 4; + case 'i64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length-1] === '*') { + return 4; // A pointer + } else if (type[0] === 'i') { + var bits = Number(type.substr(1)); + assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); + return bits / 8; + } else { + return 0; + } + } + } +} + +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } +} + + + + + +/** + * @license + * Copyright 2020 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + + +// Wraps a JS function as a wasm function with a given signature. +function convertJsFunctionToWasm(func, sig) { + + // If the type reflection proposal is available, use the new + // "WebAssembly.Function" constructor. + // Otherwise, construct a minimal wasm module importing the JS function and + // re-exporting it. + if (typeof WebAssembly.Function === "function") { + var typeNames = { + 'i': 'i32', + 'j': 'i64', + 'f': 'f32', + 'd': 'f64' + }; + var type = { + parameters: [], + results: sig[0] == 'v' ? [] : [typeNames[sig[0]]] + }; + for (var i = 1; i < sig.length; ++i) { + type.parameters.push(typeNames[sig[i]]); + } + return new WebAssembly.Function(type, func); + } + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // id: section, + 0x00, // length: 0 (placeholder) + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the overall length of the type section back into the section header + // (excepting the 2 bytes for the section id and length) + typeSection[1] = typeSection.length - 2; + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + 'e': { + 'f': func + } + }); + var wrappedFunc = instance.exports['f']; + return wrappedFunc; +} + +var freeTableIndexes = []; + +// Weak map of functions in the table to their indexes, created on first use. +var functionsInTableMap; + +// Add a wasm function to the table. +function addFunctionWasm(func, sig) { + var table = wasmTable; + + // Check if the function is already in the table, to ensure each function + // gets a unique index. First, create the map if this is the first use. + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + for (var i = 0; i < table.length; i++) { + var item = table.get(i); + // Ignore null values. + if (item) { + functionsInTableMap.set(item, i); + } + } + } + if (functionsInTableMap.has(func)) { + return functionsInTableMap.get(func); + } + + // It's not in the table, add it now. + + + var ret; + // Reuse a free index if there is one, otherwise grow. + if (freeTableIndexes.length) { + ret = freeTableIndexes.pop(); + } else { + ret = table.length; + // Grow the table + try { + table.grow(1); + } catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.'; + } + } + + // Set the new value. + try { + // Attempting to call this with JS function will cause of table.set() to fail + table.set(ret, func); + } catch (err) { + if (!(err instanceof TypeError)) { + throw err; + } + assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction'); + var wrapped = convertJsFunctionToWasm(func, sig); + table.set(ret, wrapped); + } + + functionsInTableMap.set(func, ret); + + return ret; +} + +function removeFunctionWasm(index) { + functionsInTableMap.delete(wasmTable.get(index)); + freeTableIndexes.push(index); +} + +// 'sig' parameter is required for the llvm backend but only when func is not +// already a WebAssembly function. +function addFunction(func, sig) { + assert(typeof func !== 'undefined'); + + return addFunctionWasm(func, sig); +} + +function removeFunction(index) { + removeFunctionWasm(index); +} + + + +var funcWrappers = {}; + +function getFuncWrapper(func, sig) { + if (!func) return; // on null pointer, return undefined + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + // optimize away arguments usage in common cases + if (sig.length === 1) { + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func); + }; + } else if (sig.length === 2) { + sigCache[func] = function dynCall_wrapper(arg) { + return dynCall(sig, func, [arg]); + }; + } else { + // general case + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func, Array.prototype.slice.call(arguments)); + }; + } + } + return sigCache[func]; +} + + +/** + * @license + * Copyright 2020 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + + + + +function makeBigInt(low, high, unsigned) { + return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); +} + +/** @param {Array=} args */ +function dynCall(sig, ptr, args) { + if (args && args.length) { + // j (64-bit integer) must be passed in as two numbers [low 32, high 32]. + assert(args.length === sig.substring(1).replace(/j/g, '--').length); + assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); + return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); + } else { + assert(sig.length == 1); + assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); + return Module['dynCall_' + sig].call(null, ptr); + } +} + +var tempRet0 = 0; + +var setTempRet0 = function(value) { + tempRet0 = value; +}; + +var getTempRet0 = function() { + return tempRet0; +}; + +function getCompilerSetting(name) { + throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for getCompilerSetting or emscripten_get_compiler_setting to work'; +} + +// The address globals begin at. Very low in memory, for code size and optimization opportunities. +// Above 0 is static memory, starting with globals. +// Then the stack. +// Then 'dynamic' memory for sbrk. +var GLOBAL_BASE = 1024; + + + +/** + * @license + * Copyright 2010 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// === 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'];if (!Object.getOwnPropertyDescriptor(Module, 'wasmBinary')) Object.defineProperty(Module, 'wasmBinary', { configurable: true, get: function() { abort('Module.wasmBinary has been replaced with plain wasmBinary') } }); +var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime'];if (!Object.getOwnPropertyDescriptor(Module, 'noExitRuntime')) Object.defineProperty(Module, 'noExitRuntime', { configurable: true, get: function() { abort('Module.noExitRuntime has been replaced with plain noExitRuntime') } }); + + +if (typeof WebAssembly !== 'object') { + abort('No WebAssembly support found. Build with -s WASM=0 to target JavaScript instead.'); +} + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking. +// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties) + +/** @param {number} ptr + @param {number} value + @param {string} type + @param {number|boolean=} noSafe */ +function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + 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; + default: abort('invalid type for setValue: ' + type); + } +} + +/** @param {number} ptr + @param {string} type + @param {number|boolean=} noSafe */ +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + 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)]; + default: abort('invalid type for getValue: ' + type); + } + return null; +} + + + + + +// Wasm globals + +var wasmMemory; + +// In fastcomp asm.js, we don't need a wasm Table at all. +// In the wasm backend, we polyfill the WebAssembly object, +// so this creates a (non-native-wasm) table for us. +var wasmTable = new WebAssembly.Table({ + 'initial': 626, + 'maximum': 626 + 0, + 'element': 'anyfunc' +}); + + +//======================================== +// 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 = 0; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +// Returns the C function with a specified identifier (for C++, you need to do manual name mangling) +function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; +} + +// C calling interface. +/** @param {string|null=} returnType + @param {Array=} argTypes + @param {Arguments|Array=} args + @param {Object=} opts */ +function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') return UTF8ToString(ret); + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + assert(returnType !== 'array', 'Return type should not be "array".'); + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + + ret = convertReturnValue(ret); + if (stack !== 0) stackRestore(stack); + return ret; +} + +/** @param {string=} returnType + @param {Array=} argTypes + @param {Object=} opts */ +function cwrap(ident, returnType, argTypes, opts) { + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk +var ALLOC_NONE = 3; // Do not allocate + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((TypedArray|Array|number), string, number, number=)} */ +function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr; + } else { + ret = [_malloc, + stackAlloc, + dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length)); + } + + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[((ptr)>>2)]=0; + } + stop = ret + size; + while (ptr < stop) { + HEAP8[((ptr++)>>0)]=0; + } + return ret; + } + + if (singleType === 'i8') { + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; + } + + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + assert(type, 'Must know what type to store in allocate!'); + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + + // no need to look up size unless type changes, so cache it + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + + return ret; +} + +// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready +function getMemory(size) { + if (!runtimeInitialized) return dynamicAlloc(size); + return _malloc(size); +} + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime. + +// Given a pointer 'ptr' 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. + +var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + +/** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(heap, 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 (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { + return UTF8Decoder.decode(heap.subarray(idx, endPtr)); + } else { + 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 = heap[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heap[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heap[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string on the asm.js/wasm heap to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[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. +// 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 +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @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. +// Parameters: +// str: the Javascript string to copy. +// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// 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. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + 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 >= 0x200000) warnOnce('Invalid Unicode code point 0x' + u.toString(16) + ' encountered when serializing a JS string to an UTF-8 string on the asm.js/wasm heap! (Valid unicode code points should be in range 0-0x1FFFFF).'); + 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. +// Returns 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. +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 u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + + + +/** + * @license + * Copyright 2020 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime. + +// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + +function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + +// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; + +function UTF16ToString(ptr) { + assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); + var endPtr = ptr; + // 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. + var idx = endPtr >> 1; + while (HEAP16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var i = 0; + + var str = ''; + while (1) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) return str; + ++i; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. +// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. +// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF16(str, outPtr, maxBytesToWrite) { + assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)]=codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr) { + assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); + var i = 0; + + var str = ''; + while (1) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) return str; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. +// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. +// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF32(str, outPtr, maxBytesToWrite) { + assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + 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! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)]=codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(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! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// a maximum length limit of how many bytes it is allowed to write. Prefer calling the +// function stringToUTF8Array() instead, which takes in a maximum length that can be used +// to be secure from out of bounds writes. +/** @deprecated + @param {boolean=} dontAddNull */ +function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +function writeArrayToMemory(array, buffer) { + assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') + HEAP8.set(array, buffer); +} + +/** @param {boolean=} dontAddNull */ +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === str.charCodeAt(i)&0xff); + HEAP8[((buffer++)>>0)]=str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)]=0; +} + + + +// Memory management + +var PAGE_SIZE = 16384; +var WASM_PAGE_SIZE = 65536; +var ASMJS_PAGE_SIZE = 16777216; + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; +} + +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 STATIC_BASE = 1024, + STACK_BASE = 5270112, + STACKTOP = STACK_BASE, + STACK_MAX = 27232, + DYNAMIC_BASE = 5270112, + DYNAMICTOP_PTR = 27056; + +assert(STACK_BASE % 16 === 0, 'stack must start aligned'); +assert(DYNAMIC_BASE % 16 === 0, 'heap must start aligned'); + + + +var TOTAL_STACK = 5242880; +if (Module['TOTAL_STACK']) assert(TOTAL_STACK === Module['TOTAL_STACK'], 'the stack size can no longer be determined at runtime') + +var INITIAL_INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;if (!Object.getOwnPropertyDescriptor(Module, 'INITIAL_MEMORY')) Object.defineProperty(Module, 'INITIAL_MEMORY', { configurable: true, get: function() { abort('Module.INITIAL_MEMORY has been replaced with plain INITIAL_INITIAL_MEMORY') } }); + +assert(INITIAL_INITIAL_MEMORY >= TOTAL_STACK, 'INITIAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL_INITIAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); + +// 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'); + + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + + + + +// In standalone mode, the wasm creates the memory, and the user can't provide it. +// In non-standalone/normal mode, we create the memory here. + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm +// memory is created in the wasm, not in JS.) + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else + { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE + , + 'maximum': INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE + }); + } + + +if (wasmMemory) { + buffer = wasmMemory.buffer; +} + +// If the user provides an incorrect length, just use that length instead rather than providing the user to +// specifically provide the memory length with Module['INITIAL_MEMORY']. +INITIAL_INITIAL_MEMORY = buffer.byteLength; +assert(INITIAL_INITIAL_MEMORY % WASM_PAGE_SIZE === 0); +updateGlobalBufferAndViews(buffer); + +HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; + + + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + assert((STACK_MAX & 3) == 0); + // The stack grows downwards + HEAPU32[(STACK_MAX >> 2)+1] = 0x2135467; + HEAPU32[(STACK_MAX >> 2)+2] = 0x89BACDFE; + // Also test the global address 0 for integrity. + // We don't do this with ASan because ASan does its own checks for this. + HEAP32[0] = 0x63736d65; /* 'emsc' */ +} + +function checkStackCookie() { + var cookie1 = HEAPU32[(STACK_MAX >> 2)+1]; + var cookie2 = HEAPU32[(STACK_MAX >> 2)+2]; + if (cookie1 != 0x2135467 || cookie2 != 0x89BACDFE) { + abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x' + cookie2.toString(16) + ' ' + cookie1.toString(16)); + } + // Also test the global address 0 for integrity. + // We don't do this with ASan because ASan does its own checks for this. + if (HEAP32[0] !== 0x63736d65 /* 'emsc' */) abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); +} + +function abortStackOverflow(allocSize) { + abort('Stack overflow! Attempted to allocate ' + allocSize + ' bytes on the stack, but stack has only ' + (STACK_MAX - stackSave() + allocSize) + ' bytes available!'); +} + + + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// Endianness check (note: assumes compiler arch was little-endian) +(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!'; +})(); + +function abortFnPtrError(ptr, sig) { + abort("Invalid function pointer " + ptr + " called with signature '" + sig + "'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this). Build with ASSERTIONS=2 for more info."); +} + + + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(Module); // Pass the module as the first argument. + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + Module['dynCall_v'](func); + } else { + Module['dynCall_vi'](func, callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } +} + +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; +var runtimeExited = false; + + +function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + checkStackCookie(); + assert(!runtimeInitialized); + runtimeInitialized = true; + if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + checkStackCookie(); + FS.ignorePermissions = false; + callRuntimeCallbacks(__ATMAIN__); +} + +function exitRuntime() { + checkStackCookie(); + runtimeExited = true; +} + +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); +} + +/** @param {number|boolean=} ignore */ +function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts + : Math.pow(2, bits) + value; +} +/** @param {number|boolean=} ignore */ +function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + + +/** + * @license + * Copyright 2019 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// 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'); + +var Math_abs = Math.abs; +var Math_cos = Math.cos; +var Math_sin = Math.sin; +var Math_tan = Math.tan; +var Math_acos = Math.acos; +var Math_asin = Math.asin; +var Math_atan = Math.atan; +var Math_atan2 = Math.atan2; +var Math_exp = Math.exp; +var Math_log = Math.log; +var Math_sqrt = Math.sqrt; +var Math_ceil = Math.ceil; +var Math_floor = Math.floor; +var Math_pow = Math.pow; +var Math_imul = Math.imul; +var Math_fround = Math.fround; +var Math_round = Math.round; +var Math_min = Math.min; +var Math_max = Math.max; +var Math_clz32 = Math.clz32; +var Math_trunc = Math.trunc; + + + +// 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 + } + } +} + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + + +/** @param {string|number=} what */ +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what += ''; + out(what); + err(what); + + ABORT = true; + EXITSTATUS = 1; + + var output = 'abort(' + what + ') at ' + stackTrace(); + what = output; + + // Throw 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. + throw new WebAssembly.RuntimeError(what); +} + + +var memoryInitializer = null; + + +/** + * @license + * Copyright 2015 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + + + + + + + +/** + * @license + * Copyright 2017 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +function hasPrefix(str, prefix) { + return String.prototype.startsWith ? + str.startsWith(prefix) : + str.indexOf(prefix) === 0; +} + +// 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) { + return hasPrefix(filename, dataURIPrefix); +} + +var fileURIPrefix = "file://"; + +// Indicates whether filename is delivered via file protocol (as opposed to http/https) +function isFileURI(filename) { + return hasPrefix(filename, fileURIPrefix); +} + + + +var wasmBinaryFile = 'hello.wasm'; +if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); +} + +function getBinary() { + try { + if (wasmBinary) { + return new Uint8Array(wasmBinary); + } + + if (readBinary) { + return readBinary(wasmBinaryFile); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise() { + // If we don't have the binary yet, and have the Fetch api, use that; + // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function' + // Let's not use fetch to get objects over file:// as it's most likely Cordova which doesn't support fetch for file:// + && !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(); + }); + } + // Otherwise, getBinary should be able to get it synchronously + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); +} + + + +// 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; + Module['asm'] = exports; + removeRunDependency('wasm-instantiate'); + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + + // 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 receiveInstantiatedSource(output) { + // 'output' is a WebAssemblyInstantiatedSource 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(output['instance']); + } + + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + abort(reason); + }); + } + + // Prefer streaming instantiation if available. + 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) && + typeof fetch === 'function') { + fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiatedSource, 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'); + instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + // 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. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + 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 +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = { + 1029: function($0, $1, $2) {try { return cjs.string_pass(document.querySelectorAll(cjs.receive($1))[$2].getAttribute(cjs.receive($0))); } catch (e) { return 0; }}, + 1211: function($0, $1, $2, $3) {document.querySelectorAll(cjs.receive($2))[$3].setAttribute(cjs.receive($0), cjs.receive($1));}, + 1310: function($0, $1, $2, $3) {document.querySelectorAll(cjs.receive($2))[$3].addEventListener(cjs.receive($0), () => cjs.fire_event_bus(cjs.receive($1)));}, + 1527: function() {InitWrappers()} +}; + +function _emscripten_asm_const_iii(code, sigPtr, argbuf) { + var args = readAsmConstArgs(sigPtr, argbuf); + return ASM_CONSTS[code].apply(null, args); +} + + + +// STATICTOP = STATIC_BASE + 26208; +/* global initializers */ __ATINIT__.push({ func: function() { ___wasm_call_ctors() } }); + + + + +/* no memory initializer */ +// {{PRE_LIBRARY}} + + + function demangle(func) { + warnOnce('warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling'); + return func; + } + + function demangleAll(text) { + var regex = + /\b_Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); + } + + function jsStackTrace() { + var err = new Error(); + if (!err.stack) { + // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, + // so try that as a special-case. + try { + throw new Error(); + } catch(e) { + err = e; + } + if (!err.stack) { + return '(no stack trace available)'; + } + } + return err.stack.toString(); + } + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + + function ___cxa_allocate_exception(size) { + return _malloc(size); + } + + + function _atexit(func, arg) { + warnOnce('atexit() called, but EXIT_RUNTIME is not set, so atexits() will not be called. set EXIT_RUNTIME to 1 (see the FAQ)'); + __ATEXIT__.unshift({ func: func, arg: arg }); + }function ___cxa_atexit(a0,a1 + ) { + return _atexit(a0,a1); + } + + + var ___exception_infos={}; + + var ___exception_caught= []; + + function ___exception_addRef(ptr) { + if (!ptr) return; + var info = ___exception_infos[ptr]; + info.refcount++; + } + + function ___exception_deAdjust(adjusted) { + if (!adjusted || ___exception_infos[adjusted]) return adjusted; + for (var key in ___exception_infos) { + var ptr = +key; // the iteration key is a string, and if we throw this, it must be an integer as that is what we look for + var adj = ___exception_infos[ptr].adjusted; + var len = adj.length; + for (var i = 0; i < len; i++) { + if (adj[i] === adjusted) { + return ptr; + } + } + } + return adjusted; + }function ___cxa_begin_catch(ptr) { + var info = ___exception_infos[ptr]; + if (info && !info.caught) { + info.caught = true; + __ZSt18uncaught_exceptionv.uncaught_exceptions--; + } + if (info) info.rethrown = false; + ___exception_caught.push(ptr); + ___exception_addRef(___exception_deAdjust(ptr)); + return ptr; + } + + + var ___exception_last=0; + + + function ___cxa_free_exception(ptr) { + try { + return _free(ptr); + } catch(e) { + err('exception during cxa_free_exception: ' + e); + } + }function ___exception_decRef(ptr) { + if (!ptr) return; + var info = ___exception_infos[ptr]; + assert(info.refcount > 0); + info.refcount--; + // A rethrown exception can reach refcount 0; it must not be discarded + // Its next handler will clear the rethrown flag and addRef it, prior to + // final decRef and destruction here + if (info.refcount === 0 && !info.rethrown) { + if (info.destructor) { + // In Wasm, destructors return 'this' as in ARM + Module['dynCall_ii'](info.destructor, ptr); + } + delete ___exception_infos[ptr]; + ___cxa_free_exception(ptr); + } + }function ___cxa_end_catch() { + // Clear state flag. + _setThrew(0); + // Call destructor if one is registered then clear it. + var ptr = ___exception_caught.pop(); + if (ptr) { + ___exception_decRef(___exception_deAdjust(ptr)); + ___exception_last = 0; // XXX in decRef? + } + } + + function ___cxa_find_matching_catch_2() { + var thrown = ___exception_last; + if (!thrown) { + // just pass through the null ptr + return ((setTempRet0(0),0)|0); + } + var info = ___exception_infos[thrown]; + var throwntype = info.type; + if (!throwntype) { + // just pass through the thrown ptr + return ((setTempRet0(0),thrown)|0); + } + var typeArray = Array.prototype.slice.call(arguments); + + var pointer = ___cxa_is_pointer_type(throwntype); + // can_catch receives a **, add indirection + var buffer = 27216; + HEAP32[((buffer)>>2)]=thrown; + thrown = buffer; + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + if (typeArray[i] && ___cxa_can_catch(typeArray[i], throwntype, thrown)) { + thrown = HEAP32[((thrown)>>2)]; // undo indirection + info.adjusted.push(thrown); + return ((setTempRet0(typeArray[i]),thrown)|0); + } + } + // Shouldn't happen unless we have bogus data in typeArray + // or encounter a type for which emscripten doesn't have suitable + // typeinfo defined. Best-efforts match just in case. + thrown = HEAP32[((thrown)>>2)]; // undo indirection + return ((setTempRet0(throwntype),thrown)|0); + } + + function ___cxa_find_matching_catch_3() { + var thrown = ___exception_last; + if (!thrown) { + // just pass through the null ptr + return ((setTempRet0(0),0)|0); + } + var info = ___exception_infos[thrown]; + var throwntype = info.type; + if (!throwntype) { + // just pass through the thrown ptr + return ((setTempRet0(0),thrown)|0); + } + var typeArray = Array.prototype.slice.call(arguments); + + var pointer = ___cxa_is_pointer_type(throwntype); + // can_catch receives a **, add indirection + var buffer = 27216; + HEAP32[((buffer)>>2)]=thrown; + thrown = buffer; + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + if (typeArray[i] && ___cxa_can_catch(typeArray[i], throwntype, thrown)) { + thrown = HEAP32[((thrown)>>2)]; // undo indirection + info.adjusted.push(thrown); + return ((setTempRet0(typeArray[i]),thrown)|0); + } + } + // Shouldn't happen unless we have bogus data in typeArray + // or encounter a type for which emscripten doesn't have suitable + // typeinfo defined. Best-efforts match just in case. + thrown = HEAP32[((thrown)>>2)]; // undo indirection + return ((setTempRet0(throwntype),thrown)|0); + } + + + function ___cxa_rethrow() { + var ptr = ___exception_caught.pop(); + ptr = ___exception_deAdjust(ptr); + if (!___exception_infos[ptr].rethrown) { + // Only pop if the corresponding push was through rethrow_primary_exception + ___exception_caught.push(ptr); + ___exception_infos[ptr].rethrown = true; + } + ___exception_last = ptr; + throw ptr; + } + + function ___cxa_throw(ptr, type, destructor) { + ___exception_infos[ptr] = { + ptr: ptr, + adjusted: [ptr], + type: type, + destructor: destructor, + refcount: 0, + caught: false, + rethrown: false + }; + ___exception_last = ptr; + if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) { + __ZSt18uncaught_exceptionv.uncaught_exceptions = 1; + } else { + __ZSt18uncaught_exceptionv.uncaught_exceptions++; + } + throw ptr; + } + + function ___cxa_uncaught_exceptions() { + return __ZSt18uncaught_exceptionv.uncaught_exceptions; + } + + function ___handle_stack_overflow() { + abort('stack overflow') + } + + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)]=value; + return value; + }function ___map_file(pathname, size) { + setErrNo(63); + return -1; + } + + function ___resumeException(ptr) { + if (!___exception_last) { ___exception_last = ptr; } + throw ptr; + } + + + + + var PATH={splitPath:function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function(path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:function(path) { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function(path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },extname:function(path) { + return PATH.splitPath(path)[3]; + },join:function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:function(l, r) { + return PATH.normalize(l + '/' + r); + }}; + + + var PATH_FS={resolve:function() { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + },relative:function(from, to) { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }}; + + var TTY={ttys:[],init:function () { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process['stdin']['setEncoding']('utf8'); + // } + },shutdown:function() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process['stdin']['pause'](); + // } + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + // flush any pending line data + stream.tty.ops.flush(stream.tty); + },flush:function(stream) { + stream.tty.ops.flush(stream.tty); + },read:function(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + },write:function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE); + var bytesRead = 0; + + try { + bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes, + // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0. + if (e.toString().indexOf('EOF') != -1) bytesRead = 0; + else throw e; + } + + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString('utf-8'); + } else { + result = null; + } + } else + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + if (result !== null) { + result += '\n'; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + },put_char:function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }},default_tty1_ops:{put_char:function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + + var MEMFS={ops_table:null,mount:function(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + },createNode:function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + }; + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + } + return node; + },getFileDataAsRegularArray:function(node) { + if (node.contents && node.contents.subarray) { + var arr = []; + for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]); + return arr; // Returns a copy of the original data. + } + return node.contents; // No-op, the file contents are already in a JS array. Return as-is. + },getFileDataAsTypedArray:function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + },expandFileStorage:function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + return; + },resizeFileStorage:function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + return; + } + if (!node.contents || node.contents.subarray) { // Resize a typed array if that is being used as the backing store. + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + return; + } + // Backing with a JS array. + if (!node.contents) node.contents = []; + if (node.contents.length > newSize) node.contents.length = newSize; + else while (node.contents.length < newSize) node.contents.push(0); + node.usedBytes = newSize; + },node_ops:{getattr:function(node) { + var attr = {}; + // device numbers reuse inode numbers. + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + },setattr:function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + },lookup:function(parent, name) { + throw FS.genericErrors[44]; + },mknod:function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + },rename:function(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + // do the internal rewiring + delete old_node.parent.contents[old_node.name]; + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + old_node.parent = new_dir; + },unlink:function(parent, name) { + delete parent.contents[name]; + },rmdir:function(parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + },readdir:function(node) { + var entries = ['.', '..']; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue; + } + entries.push(key); + } + return entries; + },symlink:function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + },readlink:function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }},stream_ops:{read:function(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + assert(size >= 0); + if (size > 8 && contents.subarray) { // non-trivial, and typed array + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + },write:function(stream, buffer, offset, length, position, canOwn) { + // The data buffer should be a typed array view + assert(!(buffer instanceof ArrayBuffer)); + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + if (canOwn) { + assert(position === 0, 'canOwn must imply no weird position inside the file'); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position); // Use typed array write if available. + else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + },llseek:function(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + },allocate:function(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + },mmap:function(stream, buffer, offset, length, position, prot, flags) { + // The data buffer should be a typed array view + assert(!(buffer instanceof ArrayBuffer)); + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + // Only make a new copy when MAP_PRIVATE is specified. + if ( !(flags & 2) && + contents.buffer === buffer.buffer ) { + // We can't emulate MAP_SHARED when the file is not backed by the buffer + // we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + // Try to avoid unnecessary slices. + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + // malloc() can lead to growing the heap. If targeting the heap, we need to + // re-acquire the heap buffer object in case growth had occurred. + var fromHeap = (buffer.buffer == HEAP8.buffer); + ptr = _malloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + (fromHeap ? HEAP8 : buffer).set(contents, ptr); + } + return { ptr: ptr, allocated: allocated }; + },msync:function(stream, buffer, offset, length, mmapFlags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (mmapFlags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }}}; + + var ERRNO_MESSAGES={0:"Success",1:"Arg list too long",2:"Permission denied",3:"Address already in use",4:"Address not available",5:"Address family not supported by protocol family",6:"No more processes",7:"Socket already connected",8:"Bad file number",9:"Trying to read unreadable message",10:"Mount device busy",11:"Operation canceled",12:"No children",13:"Connection aborted",14:"Connection refused",15:"Connection reset by peer",16:"File locking deadlock error",17:"Destination address required",18:"Math arg out of domain of func",19:"Quota exceeded",20:"File exists",21:"Bad address",22:"File too large",23:"Host is unreachable",24:"Identifier removed",25:"Illegal byte sequence",26:"Connection already in progress",27:"Interrupted system call",28:"Invalid argument",29:"I/O error",30:"Socket is already connected",31:"Is a directory",32:"Too many symbolic links",33:"Too many open files",34:"Too many links",35:"Message too long",36:"Multihop attempted",37:"File or path name too long",38:"Network interface is not configured",39:"Connection reset by network",40:"Network is unreachable",41:"Too many open files in system",42:"No buffer space available",43:"No such device",44:"No such file or directory",45:"Exec format error",46:"No record locks available",47:"The link has been severed",48:"Not enough core",49:"No message of desired type",50:"Protocol not available",51:"No space left on device",52:"Function not implemented",53:"Socket is not connected",54:"Not a directory",55:"Directory not empty",56:"State not recoverable",57:"Socket operation on non-socket",59:"Not a typewriter",60:"No such device or address",61:"Value too large for defined data type",62:"Previous owner died",63:"Not super-user",64:"Broken pipe",65:"Protocol error",66:"Unknown protocol",67:"Protocol wrong type for socket",68:"Math result not representable",69:"Read only file system",70:"Illegal seek",71:"No such process",72:"Stale file handle",73:"Connection timed out",74:"Text file busy",75:"Cross-device link",100:"Device not a stream",101:"Bad font file fmt",102:"Invalid slot",103:"Invalid request code",104:"No anode",105:"Block device required",106:"Channel number out of range",107:"Level 3 halted",108:"Level 3 reset",109:"Link number out of range",110:"Protocol driver not attached",111:"No CSI structure available",112:"Level 2 halted",113:"Invalid exchange",114:"Invalid request descriptor",115:"Exchange full",116:"No data (for no delay io)",117:"Timer expired",118:"Out of streams resources",119:"Machine is not on the network",120:"Package not installed",121:"The object is remote",122:"Advertise error",123:"Srmount error",124:"Communication error on send",125:"Cross mount point (not really error)",126:"Given log. name not unique",127:"f.d. invalid for this operation",128:"Remote address changed",129:"Can access a needed shared lib",130:"Accessing a corrupted shared lib",131:".lib section in a.out corrupted",132:"Attempting to link in too many libs",133:"Attempting to exec a shared library",135:"Streams pipe error",136:"Too many users",137:"Socket type not supported",138:"Not supported",139:"Protocol family not supported",140:"Can't send after socket shutdown",141:"Too many references",142:"Host is down",148:"No medium (in tape drive)",156:"Level 2 not synchronized"}; + + var ERRNO_CODES={EPERM:63,ENOENT:44,ESRCH:71,EINTR:27,EIO:29,ENXIO:60,E2BIG:1,ENOEXEC:45,EBADF:8,ECHILD:12,EAGAIN:6,EWOULDBLOCK:6,ENOMEM:48,EACCES:2,EFAULT:21,ENOTBLK:105,EBUSY:10,EEXIST:20,EXDEV:75,ENODEV:43,ENOTDIR:54,EISDIR:31,EINVAL:28,ENFILE:41,EMFILE:33,ENOTTY:59,ETXTBSY:74,EFBIG:22,ENOSPC:51,ESPIPE:70,EROFS:69,EMLINK:34,EPIPE:64,EDOM:18,ERANGE:68,ENOMSG:49,EIDRM:24,ECHRNG:106,EL2NSYNC:156,EL3HLT:107,EL3RST:108,ELNRNG:109,EUNATCH:110,ENOCSI:111,EL2HLT:112,EDEADLK:16,ENOLCK:46,EBADE:113,EBADR:114,EXFULL:115,ENOANO:104,EBADRQC:103,EBADSLT:102,EDEADLOCK:16,EBFONT:101,ENOSTR:100,ENODATA:116,ETIME:117,ENOSR:118,ENONET:119,ENOPKG:120,EREMOTE:121,ENOLINK:47,EADV:122,ESRMNT:123,ECOMM:124,EPROTO:65,EMULTIHOP:36,EDOTDOT:125,EBADMSG:9,ENOTUNIQ:126,EBADFD:127,EREMCHG:128,ELIBACC:129,ELIBBAD:130,ELIBSCN:131,ELIBMAX:132,ELIBEXEC:133,ENOSYS:52,ENOTEMPTY:55,ENAMETOOLONG:37,ELOOP:32,EOPNOTSUPP:138,EPFNOSUPPORT:139,ECONNRESET:15,ENOBUFS:42,EAFNOSUPPORT:5,EPROTOTYPE:67,ENOTSOCK:57,ENOPROTOOPT:50,ESHUTDOWN:140,ECONNREFUSED:14,EADDRINUSE:3,ECONNABORTED:13,ENETUNREACH:40,ENETDOWN:38,ETIMEDOUT:73,EHOSTDOWN:142,EHOSTUNREACH:23,EINPROGRESS:26,EALREADY:7,EDESTADDRREQ:17,EMSGSIZE:35,EPROTONOSUPPORT:66,ESOCKTNOSUPPORT:137,EADDRNOTAVAIL:4,ENETRESET:39,EISCONN:30,ENOTCONN:53,ETOOMANYREFS:141,EUSERS:136,EDQUOT:19,ESTALE:72,ENOTSUP:138,ENOMEDIUM:148,EILSEQ:25,EOVERFLOW:61,ECANCELED:11,ENOTRECOVERABLE:56,EOWNERDEAD:62,ESTRPIPE:135};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,trackingDelegate:{},tracking:{openFlags:{READ:1,WRITE:2}},ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,handleFSError:function(e) { + if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace(); + return setErrNo(e.errno); + },lookupPath:function(path, opts) { + path = PATH_FS.resolve(FS.cwd(), path); + opts = opts || {}; + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + for (var key in defaults) { + if (opts[key] === undefined) { + opts[key] = defaults[key]; + } + } + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the path + var parts = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), false); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },getPath:function(node) { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path; + } + path = path ? node.name + '/' + path : node.name; + node = node.parent; + } + },hashName:function(parentid, name) { + var hash = 0; + + + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + },hashAddNode:function(node) { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + },hashRemoveNode:function(node) { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + },lookupNode:function(parent, name) { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + },createNode:function(parent, name, mode, rdev) { + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + },destroyNode:function(node) { + FS.hashRemoveNode(node); + },isRoot:function(node) { + return node === node.parent; + },isMountpoint:function(node) { + return !!node.mounted; + },isFile:function(mode) { + return (mode & 61440) === 32768; + },isDir:function(mode) { + return (mode & 61440) === 16384; + },isLink:function(mode) { + return (mode & 61440) === 40960; + },isChrdev:function(mode) { + return (mode & 61440) === 8192; + },isBlkdev:function(mode) { + return (mode & 61440) === 24576; + },isFIFO:function(mode) { + return (mode & 61440) === 4096; + },isSocket:function(mode) { + return (mode & 49152) === 49152; + },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function(str) { + var flags = FS.flagModes[str]; + if (typeof flags === 'undefined') { + throw new Error('Unknown file open mode: ' + str); + } + return flags; + },flagsToPermissionString:function(flag) { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + },nodePermissions:function(node, perms) { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.indexOf('r') !== -1 && !(node.mode & 292)) { + return 2; + } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) { + return 2; + } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) { + return 2; + } + return 0; + },mayLookup:function(dir) { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:function(dir, name) { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + },mayDelete:function(dir, name, isdir) { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + },mayOpen:function(node, flags) { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:function(fd_start, fd_end) { + fd_start = fd_start || 0; + fd_end = fd_end || FS.MAX_OPEN_FDS; + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + },getStream:function(fd) { + return FS.streams[fd]; + },createStream:function(stream, fd_start, fd_end) { + if (!FS.FSStream) { + FS.FSStream = /** @constructor */ function(){}; + FS.FSStream.prototype = { + object: { + get: function() { return this.node; }, + set: function(val) { this.node = val; } + }, + isRead: { + get: function() { return (this.flags & 2097155) !== 1; } + }, + isWrite: { + get: function() { return (this.flags & 2097155) !== 0; } + }, + isAppend: { + get: function() { return (this.flags & 1024); } + } + }; + } + // clone it, so we can return an instance of FSStream + var newStream = new FS.FSStream(); + for (var p in stream) { + newStream[p] = stream[p]; + } + stream = newStream; + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:function(fd) { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:function(stream) { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + },llseek:function() { + throw new FS.ErrnoError(70); + }},major:function(dev) { + return ((dev) >> 8); + },minor:function(dev) { + return ((dev) & 0xff); + },makedev:function(ma, mi) { + return ((ma) << 8 | (mi)); + },registerDevice:function(dev, ops) { + FS.devices[dev] = { stream_ops: ops }; + },getDevice:function(dev) { + return FS.devices[dev]; + },getMounts:function(mount) { + var mounts = []; + var check = [mount]; + + while (check.length) { + var m = check.pop(); + + mounts.push(m); + + check.push.apply(check, m.mounts); + } + + return mounts; + },syncfs:function(populate, callback) { + if (typeof(populate) === 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work'); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach(function (mount) { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + },mount:function(type, opts, mountpoint) { + if (typeof type === 'string') { + // The filesystem was not included, and instead we have an error + // message stored in the variable. + throw type; + } + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:function (mountpoint) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach(function (hash) { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.indexOf(current.mount) !== -1) { + FS.destroyNode(current); + } + + current = next; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + },lookup:function(parent, name) { + return parent.node_ops.lookup(parent, name); + },mknod:function(path, mode, dev) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:function(path, mode) { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:function(path, mode) { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:function(path, mode) { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:function(path, mode, dev) { + if (typeof(dev) === 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:function(oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:function(old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + try { + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + } catch (e) { + throw new FS.ErrnoError(10); + } + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + // if we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + try { + if (FS.trackingDelegate['willMovePath']) { + FS.trackingDelegate['willMovePath'](old_path, new_path); + } + } catch(e) { + err("FS.trackingDelegate['willMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message); + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + FS.hashAddNode(old_node); + } + try { + if (FS.trackingDelegate['onMovePath']) FS.trackingDelegate['onMovePath'](old_path, new_path); + } catch(e) { + err("FS.trackingDelegate['onMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message); + } + },rmdir:function(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + try { + if (FS.trackingDelegate['willDeletePath']) { + FS.trackingDelegate['willDeletePath'](path); + } + } catch(e) { + err("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + try { + if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path); + } catch(e) { + err("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message); + } + },readdir:function(path) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:function(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + try { + if (FS.trackingDelegate['willDeletePath']) { + FS.trackingDelegate['willDeletePath'](path); + } + } catch(e) { + err("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + try { + if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path); + } catch(e) { + err("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message); + } + },readlink:function(path) { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:function(path, dontFollow) { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:function(path) { + return FS.stat(path, true); + },chmod:function(path, mode, dontFollow) { + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:function(path, mode) { + FS.chmod(path, mode, true); + },fchmod:function(fd, mode) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:function(path, uid, gid, dontFollow) { + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + },lchown:function(path, uid, gid) { + FS.chown(path, uid, gid, true); + },fchown:function(fd, uid, gid) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:function(path, len) { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:function(fd, len) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + },utime:function(path, atime, mtime) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + },open:function(path, flags, mode, fd_start, fd_end) { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path === 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512)) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), // we want the absolute path to the node + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }, fd_start, fd_end); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + err("FS.trackingDelegate error on read file: " + path); + } + } + try { + if (FS.trackingDelegate['onOpenFile']) { + var trackingFlags = 0; + if ((flags & 2097155) !== 1) { + trackingFlags |= FS.tracking.openFlags.READ; + } + if ((flags & 2097155) !== 0) { + trackingFlags |= FS.tracking.openFlags.WRITE; + } + FS.trackingDelegate['onOpenFile'](path, trackingFlags); + } + } catch(e) { + err("FS.trackingDelegate['onOpenFile']('"+path+"', flags) threw an exception: " + e.message); + } + return stream; + },close:function(stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:function(stream) { + return stream.fd === null; + },llseek:function(stream, offset, whence) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:function(stream, buffer, offset, length, position) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position !== 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:function(stream, buffer, offset, length, position, canOwn) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position !== 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + try { + if (stream.path && FS.trackingDelegate['onWriteToFile']) FS.trackingDelegate['onWriteToFile'](stream.path); + } catch(e) { + err("FS.trackingDelegate['onWriteToFile']('"+stream.path+"') threw an exception: " + e.message); + } + return bytesWritten; + },allocate:function(stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:function(stream, buffer, offset, length, position, prot, flags) { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags); + },msync:function(stream, buffer, offset, length, mmapFlags) { + if (!stream || !stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:function(stream) { + return 0; + },ioctl:function(stream, cmd, arg) { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:function(path, opts) { + opts = opts || {}; + opts.flags = opts.flags || 'r'; + opts.encoding = opts.encoding || 'binary'; + if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === 'utf8') { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + },writeFile:function(path, data, opts) { + opts = opts || {}; + opts.flags = opts.flags || 'w'; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data === 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + },cwd:function() { + return FS.currentPath; + },chdir:function(path) { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:function() { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:function() { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: function() { return 0; }, + write: function(stream, buffer, offset, length, pos) { return length; } + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using Module['printErr'] + // so we register a second tty just for it. + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + // setup /dev/[u]random + var random_device; + if (typeof crypto === 'object' && typeof crypto['getRandomValues'] === 'function') { + // for modern web browsers + var randomBuffer = new Uint8Array(1); + random_device = function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; }; + } else + if (ENVIRONMENT_IS_NODE) { + // for nodejs with or without crypto support included + try { + var crypto_module = require('crypto'); + // nodejs has crypto support + random_device = function() { return crypto_module['randomBytes'](1)[0]; }; + } catch (e) { + // nodejs doesn't have crypto support + } + } else + {} + if (!random_device) { + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + random_device = function() { abort("no cryptographic support found for random_device. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };"); }; + } + FS.createDevice('/dev', 'random', random_device); + FS.createDevice('/dev', 'urandom', random_device); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + },createSpecialDirectories:function() { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: function() { + var node = FS.createNode('/proc/self', 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup: function(parent, name) { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: function() { return stream.path } } + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:function() { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 'r'); + var stdout = FS.open('/dev/stdout', 'w'); + var stderr = FS.open('/dev/stderr', 'w'); + assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')'); + assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')'); + assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')'); + },ensureErrnoError:function() { + if (FS.ErrnoError) return; + FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) { + this.node = node; + this.setErrno = /** @this{Object} */ function(errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + + // Try to get a maximally helpful stack trace. On Node.js, getting Error.stack + // now ensures it shows what we want. + if (this.stack) { + // Define the stack property for Node.js 4, which otherwise errors on the next line. + Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach(function(code) { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:function() { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + },init:function(input, output, error) { + assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'); + FS.init.initialized = true; + + FS.ensureErrnoError(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:function() { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + var fflush = Module['_fflush']; + if (fflush) fflush(0); + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },getMode:function(canRead, canWrite) { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + },joinPath:function(parts, forceRelative) { + var path = PATH.join.apply(null, parts); + if (forceRelative && path[0] == '/') path = path.substr(1); + return path; + },absolutePath:function(relative, base) { + return PATH_FS.resolve(base, relative); + },standardizePath:function(path) { + return PATH.normalize(path); + },findObject:function(path, dontResolveLastLink) { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + setErrNo(ret.error); + return null; + } + },analyzePath:function(path, dontResolveLastLink) { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createFolder:function(parent, name, canRead, canWrite) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.mkdir(path, mode); + },createPath:function(parent, path, canRead, canWrite) { + parent = typeof parent === 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + },createFile:function(parent, name, properties, canRead, canWrite) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + },createDataFile:function(parent, name, data, canRead, canWrite, canOwn) { + var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent; + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data === 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 'w'); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:function(parent, name, input, output) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open: function(stream) { + stream.seekable = false; + }, + close: function(stream) { + // flush any pending line data + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: function(stream, buffer, offset, length, pos /* ignored */) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: function(stream, buffer, offset, length, pos) { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },createLink:function(parent, name, target, canRead, canWrite) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + return FS.symlink(target, path); + },forceLoadFile:function(obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + var success = true; + if (typeof XMLHttpRequest !== 'undefined') { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + success = false; + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + if (!success) setErrNo(29); + return success; + },createLazyFile:function(parent, name, url, canRead, canWrite) { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + /** @constructor */ + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (function(from, to) { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(/** @type{Array} */(xhr.response || [])); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }); + var lazyArray = this; + lazyArray.setDataGetter(function(chunkNum) { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest !== 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: /** @this{Object} */ function() { + if(!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: /** @this{Object} */ function() { + if(!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: /** @this {FSNode} */ function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(function(key) { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + if (!FS.forceLoadFile(node)) { + throw new FS.ErrnoError(29); + } + return fn.apply(null, arguments); + }; + }); + // use a custom read function + stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) { + if (!FS.forceLoadFile(node)) { + throw new FS.ErrnoError(29); + } + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + }; + node.stream_ops = stream_ops; + return node; + },createPreloadedFile:function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + Browser.init(); // XXX perhaps this method should move onto Browser? + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + var handled = false; + Module['preloadPlugins'].forEach(function(plugin) { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, function() { + if (onerror) onerror(); + removeRunDependency(dep); + }); + handled = true; + } + }); + if (!handled) finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + Browser.asyncLoad(url, function(byteArray) { + processData(byteArray); + }, onerror); + } else { + processData(url); + } + },indexedDB:function() { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + },DB_NAME:function() { + return 'EM_FS_' + window.location.pathname; + },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function(paths, onload, onerror) { + onload = onload || function(){}; + onerror = onerror || function(){}; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = function openRequest_onupgradeneeded() { + out('creating db'); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite'); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach(function(path) { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() }; + putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },loadFilesFromDB:function(paths, onload, onerror) { + onload = onload || function(){}; + onerror = onerror || function(){}; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; // no database to load from + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly'); + } catch(e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach(function(path) { + var getRequest = files.get(path); + getRequest.onsuccess = function getRequest_onsuccess() { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) finish(); + }; + getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }};var SYSCALLS={mappings:{},DEFAULT_POLLMASK:5,umask:511,calculateAt:function(dirfd, path) { + if (path[0] !== '/') { + // relative path + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) throw new FS.ErrnoError(8); + dir = dirstream.path; + } + path = PATH.join2(dir, path); + } + return path; + },doStat:function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + // an error occurred while trying to look up the path; we should just report ENOTDIR + return -54; + } + throw e; + } + HEAP32[((buf)>>2)]=stat.dev; + HEAP32[(((buf)+(4))>>2)]=0; + HEAP32[(((buf)+(8))>>2)]=stat.ino; + HEAP32[(((buf)+(12))>>2)]=stat.mode; + HEAP32[(((buf)+(16))>>2)]=stat.nlink; + HEAP32[(((buf)+(20))>>2)]=stat.uid; + HEAP32[(((buf)+(24))>>2)]=stat.gid; + HEAP32[(((buf)+(28))>>2)]=stat.rdev; + HEAP32[(((buf)+(32))>>2)]=0; + (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(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[(((buf)+(40))>>2)]=tempI64[0],HEAP32[(((buf)+(44))>>2)]=tempI64[1]); + HEAP32[(((buf)+(48))>>2)]=4096; + HEAP32[(((buf)+(52))>>2)]=stat.blocks; + HEAP32[(((buf)+(56))>>2)]=(stat.atime.getTime() / 1000)|0; + HEAP32[(((buf)+(60))>>2)]=0; + HEAP32[(((buf)+(64))>>2)]=(stat.mtime.getTime() / 1000)|0; + HEAP32[(((buf)+(68))>>2)]=0; + HEAP32[(((buf)+(72))>>2)]=(stat.ctime.getTime() / 1000)|0; + HEAP32[(((buf)+(76))>>2)]=0; + (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(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[(((buf)+(80))>>2)]=tempI64[0],HEAP32[(((buf)+(84))>>2)]=tempI64[1]); + return 0; + },doMsync:function(addr, stream, len, flags, offset) { + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + },doMkdir:function(path, mode) { + // remove a trailing slash, if one - /a/b/ has basename of '', but + // we want to create b in the context of this function + path = PATH.normalize(path); + if (path[path.length-1] === '/') path = path.substr(0, path.length-1); + FS.mkdir(path, mode, 0); + return 0; + },doMknod:function(path, mode, dev) { + // we don't want this in the JS API as it uses mknod to create all nodes. + switch (mode & 61440) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: return -28; + } + FS.mknod(path, mode, dev); + return 0; + },doReadlink:function(path, buf, bufsize) { + if (bufsize <= 0) return -28; + var ret = FS.readlink(path); + + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf+len]; + stringToUTF8(ret, buf, bufsize+1); + // readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!) + // stringToUTF8() always appends a null byte, so restore the character under the null byte after the write. + HEAP8[buf+len] = endChar; + + return len; + },doAccess:function(path, amode) { + if (amode & ~7) { + // need a valid mode + return -28; + } + var node; + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + if (!node) { + return -44; + } + var perms = ''; + if (amode & 4) perms += 'r'; + if (amode & 2) perms += 'w'; + if (amode & 1) perms += 'x'; + if (perms /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + },doDup:function(path, flags, suggestFD) { + var suggest = FS.getStream(suggestFD); + if (suggest) FS.close(suggest); + return FS.open(path, flags, 0, suggestFD, suggestFD).fd; + },doReadv:function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + } + return ret; + },doWritev:function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + },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; + },getStreamFromFD:function(fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + },get64:function(low, high) { + if (low >= 0) assert(high === 0); + else assert(high === -1); + return low; + }};function syscallMunmap(addr, len) { + if ((addr | 0) === -1 || len === 0) { + return -28; + } + // TODO: support unmmap'ing parts of allocations + var info = SYSCALLS.mappings[addr]; + if (!info) return 0; + if (len === info.len) { + var stream = FS.getStream(info.fd); + if (info.prot & 2) { + SYSCALLS.doMsync(addr, stream, len, info.flags, info.offset); + } + FS.munmap(stream); + SYSCALLS.mappings[addr] = null; + if (info.allocated) { + _free(info.malloc); + } + } + return 0; + }function ___sys_munmap(addr, len) {try { + + return syscallMunmap(addr, len); + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___sys_open(path, flags, varargs) {SYSCALLS.varargs = varargs; + try { + + var pathname = SYSCALLS.getStr(path); + var mode = SYSCALLS.get(); + var stream = FS.open(pathname, flags, mode); + return stream.fd; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + function ___sys_read(fd, buf, count) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + return FS.read(stream, HEAP8,buf, count); + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } + } + + + function getShiftFromSize(size) { + switch (size) { + case 1: return 0; + case 2: return 1; + case 4: return 2; + case 8: return 3; + default: + throw new TypeError('Unknown type size: ' + size); + } + } + + + + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + }var embind_charCodes=undefined;function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + + + var awaitingDependencies={}; + + var registeredTypes={}; + + var typeDependencies={}; + + + + + + + var char_0=48; + + var char_9=57;function makeLegalFunctionName(name) { + if (undefined === name) { + return '_unknown'; + } + name = name.replace(/[^a-zA-Z0-9_]/g, '$'); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return '_' + name; + } else { + return name; + } + }function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + /*jshint evil:true*/ + return new Function( + "body", + "return function " + name + "() {\n" + + " \"use strict\";" + + " return body.apply(this, arguments);\n" + + "};\n" + )(body); + }function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return this.name + ': ' + this.message; + } + }; + + return errorClass; + }var BindingError=undefined;function throwBindingError(message) { + throw new BindingError(message); + } + + + + var InternalError=undefined;function throwInternalError(message) { + throw new InternalError(message); + }function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach(function(dt, i) { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(function() { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + }/** @param {Object=} options */ + function registerType(rawType, registeredInstance, options) { + options = options || {}; + + if (!('argPackAdvance' in registeredInstance)) { + throw new TypeError('registerType registeredInstance requires argPackAdvance'); + } + + var name = registeredInstance.name; + if (!rawType) { + throwBindingError('type "' + name + '" must have a positive integer typeid pointer'); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError("Cannot register type '" + name + "' twice"); + } + } + + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(function(cb) { + cb(); + }); + } + }function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': function(pointer) { + // TODO: if heap is fixed (like in asm.js) this could be executed outside + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this['fromWireType'](heap[pointer >> shift]); + }, + destructorFunction: null, // This type does not need a destructor + }); + } + + + + var emval_free_list=[]; + + var emval_handle_array=[{},{value:undefined},{value:null},{value:true},{value:false}];function __emval_decref(handle) { + if (handle > 4 && 0 === --emval_handle_array[handle].refcount) { + emval_handle_array[handle] = undefined; + emval_free_list.push(handle); + } + } + + + + function count_emval_handles() { + var count = 0; + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + ++count; + } + } + return count; + } + + function get_first_emval() { + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + return emval_handle_array[i]; + } + } + return null; + }function init_emval() { + Module['count_emval_handles'] = count_emval_handles; + Module['get_first_emval'] = get_first_emval; + }function __emval_register(value) { + + switch(value){ + case undefined :{ return 1; } + case null :{ return 2; } + case true :{ return 3; } + case false :{ return 4; } + default:{ + var handle = emval_free_list.length ? + emval_free_list.pop() : + emval_handle_array.length; + + emval_handle_array[handle] = {refcount: 1, value: value}; + return handle; + } + } + } + + function simpleReadValueFromPointer(pointer) { + return this['fromWireType'](HEAPU32[pointer >> 2]); + }function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(handle) { + var rv = emval_handle_array[handle].value; + __emval_decref(handle); + return rv; + }, + 'toWireType': function(destructors, value) { + return __emval_register(value); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }); + } + + + function _embind_repr(v) { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + } + + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: return function(pointer) { + return this['fromWireType'](HEAPF32[pointer >> 2]); + }; + case 3: return function(pointer) { + return this['fromWireType'](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + }function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + return value; + }, + 'toWireType': function(destructors, value) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could + // avoid the following if() and assume value is of proper type. + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + return value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': floatReadValueFromPointer(name, shift), + destructorFunction: null, // This type does not need a destructor + }); + } + + + function integerReadValueFromPointer(name, shift, signed) { + // integers are quite common, so generate very specialized functions + switch (shift) { + case 0: return signed ? + function readS8FromPointer(pointer) { return HEAP8[pointer]; } : + function readU8FromPointer(pointer) { return HEAPU8[pointer]; }; + case 1: return signed ? + function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : + function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; }; + case 2: return signed ? + function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : + function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; }; + default: + throw new TypeError("Unknown integer type: " + name); + } + }function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come out as 'i32 -1'. Always treat those as max u32. + maxRange = 4294967295; + } + + var shift = getShiftFromSize(size); + + var fromWireType = function(value) { + return value; + }; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = function(value) { + return (value << bitshift) >>> bitshift; + }; + } + + var isUnsignedType = (name.indexOf('unsigned') != -1); + + registerType(primitiveType, { + name: name, + 'fromWireType': fromWireType, + 'toWireType': function(destructors, value) { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: we could + // avoid the following two if()s and assume value is of proper type. + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + if (value < minRange || value > maxRange) { + throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ', ' + maxRange + ']!'); + } + return isUnsignedType ? (value >>> 0) : (value | 0); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + } + + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; // in elements + var data = heap[handle + 1]; // byte offset into emscripten heap + return new TA(buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': 8, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + } + + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + var length = HEAPU32[value >> 2]; + + var str; + if (stdStringIsUTF8) { + //ensure null termination at one-past-end byte if not present yet + var endChar = HEAPU8[value + 4 + length]; + var endCharSwap = 0; + if (endChar != 0) { + endCharSwap = endChar; + HEAPU8[value + 4 + length] = 0; + } + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (HEAPU8[currentBytePtr] == 0) { + var stringSegment = UTF8ToString(decodeStartPtr); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + + if (endCharSwap != 0) { + HEAPU8[value + 4 + length] = endCharSwap; + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[value + 4 + i]); + } + str = a.join(''); + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + + var getLength; + var valueIsOfTypeString = (typeof value === 'string'); + + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError('Cannot pass non-string to std::string'); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + getLength = function() {return lengthBytesUTF8(value);}; + } else { + getLength = function() {return value.length;}; + } + + // assumes 4-byte alignment + var length = getLength(); + var ptr = _malloc(4 + length + 1); + HEAPU32[ptr >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr + 4, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + 4 + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + 4 + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = function() { return HEAPU16; }; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = function() { return HEAPU32; }; + shift = 2; + } + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + // Ensure null termination at one-past-end byte if not present yet + var endChar = HEAP[(value + 4 + length * charSize) >> shift]; + var endCharSwap = 0; + if (endChar != 0) { + endCharSwap = endChar; + HEAP[(value + 4 + length * charSize) >> shift] = 0; + } + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (HEAP[currentBytePtr >> shift] == 0) { + var stringSegment = decodeString(decodeStartPtr); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + + if (endCharSwap != 0) { + HEAP[(value + 4 + length * charSize) >> shift] = endCharSwap; + } + + _free(value); + + return str; + }, + 'toWireType': function(destructors, value) { + if (!(typeof value === 'string')) { + throwBindingError('Cannot pass non-string to C++ string type ' + name); + } + + // assumes 4-byte alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name: name, + 'argPackAdvance': 0, + 'fromWireType': function() { + return undefined; + }, + 'toWireType': function(destructors, o) { + // TODO: assert if anything else is given? + return undefined; + }, + }); + } + + function _abort() { + abort(); + } + + function _emscripten_get_sbrk_ptr() { + return 27056; + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + + function _emscripten_get_heap_size() { + return HEAPU8.length; + } + + function abortOnCannotGrowMemory(requestedSize) { + abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with -s INITIAL_MEMORY=X with X higher than the current value ' + HEAP8.length + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 '); + }function _emscripten_resize_heap(requestedSize) { + requestedSize = requestedSize >>> 0; + abortOnCannotGrowMemory(requestedSize); + } + + + + var ENV={}; + + function __getExecutableName() { + return thisProgram || './this.program'; + }function getEnvStrings() { + if (!getEnvStrings.strings) { + // Default values. + var env = { + 'USER': 'web_user', + 'LOGNAME': 'web_user', + 'PATH': '/', + 'PWD': '/', + 'HOME': '/home/web_user', + // Browser language detection #8751 + 'LANG': ((typeof navigator === 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8', + '_': __getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + '=' + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + }function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAP32[(((__environ)+(i * 4))>>2)]=ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } + + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAP32[((penviron_count)>>2)]=strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAP32[((penviron_buf_size)>>2)]=bufSize; + return 0; + } + + function _fd_close(fd) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {try { + + + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 0x100000000; // 2^32 + // use an unsigned operator on low and shift high by 32-bits + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + + var DOUBLE_LIMIT = 0x20000000000000; // 2^53 + // we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT + if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) { + return -61; + } + + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(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[((newOffset)>>2)]=tempI64[0],HEAP32[(((newOffset)+(4))>>2)]=tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _fd_write(fd, iov, iovcnt, pnum) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doWritev(stream, iov, iovcnt); + HEAP32[((pnum)>>2)]=num + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + function _getTempRet0() { + return (getTempRet0() | 0); + } + + function _llvm_eh_typeid_for(type) { + return type; + } + + function _setTempRet0($i) { + setTempRet0(($i) | 0); + } + + + + function __isLeapYear(year) { + return year%4 === 0 && (year%100 !== 0 || year%400 === 0); + } + + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) { + // no-op + } + return sum; + } + + + var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31]; + + var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while(days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + + if (days > daysInCurrentMonth-newDate.getDate()) { + // we spill over to next month + days -= (daysInCurrentMonth-newDate.getDate()+1); + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth+1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear()+1); + } + } else { + // we stay in current month + newDate.setDate(newDate.getDate()+days); + return newDate; + } + } + + return newDate; + }function _strftime(s, maxsize, format, tm) { + // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html + + var tm_zone = HEAP32[(((tm)+(40))>>2)]; + + var date = { + tm_sec: HEAP32[((tm)>>2)], + tm_min: HEAP32[(((tm)+(4))>>2)], + tm_hour: HEAP32[(((tm)+(8))>>2)], + tm_mday: HEAP32[(((tm)+(12))>>2)], + tm_mon: HEAP32[(((tm)+(16))>>2)], + tm_year: HEAP32[(((tm)+(20))>>2)], + tm_wday: HEAP32[(((tm)+(24))>>2)], + tm_yday: HEAP32[(((tm)+(28))>>2)], + tm_isdst: HEAP32[(((tm)+(32))>>2)], + tm_gmtoff: HEAP32[(((tm)+(36))>>2)], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : '' + }; + + var pattern = UTF8ToString(format); + + // expand format + var EXPANSION_RULES_1 = { + '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013 + '%D': '%m/%d/%y', // Equivalent to %m / %d / %y + '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d + '%h': '%b', // Equivalent to %b + '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation + '%R': '%H:%M', // Replaced by the time in 24-hour notation + '%T': '%H:%M:%S', // Replaced by the time + '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation + '%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation + // Modified Conversion Specifiers + '%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation. + '%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation. + '%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation. + '%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation. + '%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation. + '%EY': '%Y', // Replaced by the full alternative year representation. + '%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading characters. + '%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading characters. + '%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols. + '%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols. + '%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols. + '%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols. + '%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols. + '%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1). + '%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols. + '%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols. + '%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols. + '%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols. + '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols. + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]); + } + + var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; + var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; + + function leadingSomething(value, digits, character) { + var str = typeof value === 'number' ? value.toString() : (value || ''); + while (str.length < digits) { + str = character[0]+str; + } + return str; + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, '0'); + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : (value > 0 ? 1 : 0); + } + + var compare; + if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) { + compare = sgn(date1.getDate()-date2.getDate()); + } + } + return compare; + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: // Sunday + return new Date(janFourth.getFullYear()-1, 11, 29); + case 1: // Monday + return janFourth; + case 2: // Tuesday + return new Date(janFourth.getFullYear(), 0, 3); + case 3: // Wednesday + return new Date(janFourth.getFullYear(), 0, 2); + case 4: // Thursday + return new Date(janFourth.getFullYear(), 0, 1); + case 5: // Friday + return new Date(janFourth.getFullYear()-1, 11, 31); + case 6: // Saturday + return new Date(janFourth.getFullYear()-1, 11, 30); + } + } + + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + // this date is after the start of the first week of this year + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear()+1; + } else { + return thisDate.getFullYear(); + } + } else { + return thisDate.getFullYear()-1; + } + } + + var EXPANSION_RULES_2 = { + '%a': function(date) { + return WEEKDAYS[date.tm_wday].substring(0,3); + }, + '%A': function(date) { + return WEEKDAYS[date.tm_wday]; + }, + '%b': function(date) { + return MONTHS[date.tm_mon].substring(0,3); + }, + '%B': function(date) { + return MONTHS[date.tm_mon]; + }, + '%C': function(date) { + var year = date.tm_year+1900; + return leadingNulls((year/100)|0,2); + }, + '%d': function(date) { + return leadingNulls(date.tm_mday, 2); + }, + '%e': function(date) { + return leadingSomething(date.tm_mday, 2, ' '); + }, + '%g': function(date) { + // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year. + // In this system, weeks begin on a Monday and week 1 of the year is the week that includes + // January 4th, which is also the week that includes the first Thursday of the year, and + // is also the first week that contains at least four days in the year. + // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of + // the last week of the preceding year; thus, for Saturday 2nd January 1999, + // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th, + // or 31st is a Monday, it and any following days are part of week 1 of the following year. + // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01. + + return getWeekBasedYear(date).toString().substring(2); + }, + '%G': function(date) { + return getWeekBasedYear(date); + }, + '%H': function(date) { + return leadingNulls(date.tm_hour, 2); + }, + '%I': function(date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + '%j': function(date) { + // Day of the year (001-366) + return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3); + }, + '%m': function(date) { + return leadingNulls(date.tm_mon+1, 2); + }, + '%M': function(date) { + return leadingNulls(date.tm_min, 2); + }, + '%n': function() { + return '\n'; + }, + '%p': function(date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return 'AM'; + } else { + return 'PM'; + } + }, + '%S': function(date) { + return leadingNulls(date.tm_sec, 2); + }, + '%t': function() { + return '\t'; + }, + '%u': function(date) { + return date.tm_wday || 7; + }, + '%U': function(date) { + // Replaced by the week number of the year as a decimal number [00,53]. + // The first Sunday of January is the first day of week 1; + // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday] + var janFirst = new Date(date.tm_year+1900, 0, 1); + var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7-janFirst.getDay()); + var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday); + + // is target date after the first Sunday? + if (compareByDay(firstSunday, endDate) < 0) { + // calculate difference in days between first Sunday and endDate + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31; + var firstSundayUntilEndJanuary = 31-firstSunday.getDate(); + var days = firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate(); + return leadingNulls(Math.ceil(days/7), 2); + } + + return compareByDay(firstSunday, janFirst) === 0 ? '01': '00'; + }, + '%V': function(date) { + // Replaced by the week number of the year (Monday as the first day of the week) + // as a decimal number [01,53]. If the week containing 1 January has four + // or more days in the new year, then it is considered week 1. + // Otherwise, it is the last week of the previous year, and the next week is week 1. + // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday] + var janFourthThisYear = new Date(date.tm_year+1900, 0, 4); + var janFourthNextYear = new Date(date.tm_year+1901, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + var endDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + if (compareByDay(endDate, firstWeekStartThisYear) < 0) { + // if given date is before this years first week, then it belongs to the 53rd week of last year + return '53'; + } + + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + // if given date is after next years first week, then it belongs to the 01th week of next year + return '01'; + } + + // given date is in between CW 01..53 of this calendar year + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date.tm_year+1900) { + // first CW of this year starts last year + daysDifference = date.tm_yday+32-firstWeekStartThisYear.getDate() + } else { + // first CW of this year starts this year + daysDifference = date.tm_yday+1-firstWeekStartThisYear.getDate(); + } + return leadingNulls(Math.ceil(daysDifference/7), 2); + }, + '%w': function(date) { + return date.tm_wday; + }, + '%W': function(date) { + // Replaced by the week number of the year as a decimal number [00,53]. + // The first Monday of January is the first day of week 1; + // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday] + var janFirst = new Date(date.tm_year, 0, 1); + var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1); + var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday); + + // is target date after the first Monday? + if (compareByDay(firstMonday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31; + var firstMondayUntilEndJanuary = 31-firstMonday.getDate(); + var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate(); + return leadingNulls(Math.ceil(days/7), 2); + } + return compareByDay(firstMonday, janFirst) === 0 ? '01': '00'; + }, + '%y': function(date) { + // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year] + return (date.tm_year+1900).toString().substring(2); + }, + '%Y': function(date) { + // Replaced by the year as a decimal number (for example, 1997). [ tm_year] + return date.tm_year+1900; + }, + '%z': function(date) { + // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ). + // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich). + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + // convert from minutes into hhmm format (which means 60 minutes = 100 units) + off = (off / 60)*100 + (off % 60); + return (ahead ? '+' : '-') + String("0000" + off).slice(-4); + }, + '%Z': function(date) { + return date.tm_zone; + }, + '%%': function() { + return '%'; + } + }; + for (var rule in EXPANSION_RULES_2) { + if (pattern.indexOf(rule) >= 0) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date)); + } + } + + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + + writeArrayToMemory(bytes, s); + return bytes.length-1; + }function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm); // no locale support yet + } + + function readAsmConstArgs(sigPtr, buf) { + if (!readAsmConstArgs.array) { + readAsmConstArgs.array = []; + } + var args = readAsmConstArgs.array; + args.length = 0; + var ch; + while (ch = HEAPU8[sigPtr++]) { + if (ch === 100/*'d'*/ || ch === 102/*'f'*/) { + buf = (buf + 7) & ~7; + args.push(HEAPF64[(buf >> 3)]); + buf += 8; + } else + if (ch === 105 /*'i'*/) + { + buf = (buf + 3) & ~3; + args.push(HEAP32[(buf >> 2)]); + buf += 4; + } + else abort("unexpected char in asm const signature " + ch); + } + return args; + } +var FSNode = /** @constructor */ function(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292/*292*/ | 73/*73*/; + var writeMode = 146/*146*/; + Object.defineProperties(FSNode.prototype, { + read: { + get: /** @this{FSNode} */function() { + return (this.mode & readMode) === readMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: /** @this{FSNode} */function() { + return (this.mode & writeMode) === writeMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: /** @this{FSNode} */function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: /** @this{FSNode} */function() { + return FS.isChrdev(this.mode); + } + } + }); + FS.FSNode = FSNode; + FS.staticInit();; +embind_init_charCodes(); +BindingError = Module['BindingError'] = extendError(Error, 'BindingError');; +InternalError = Module['InternalError'] = extendError(Error, 'InternalError');; +init_emval();; +var ASSERTIONS = true; + +/** + * @license + * Copyright 2017 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +/** @type {function(string, boolean=, number=)} */ +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} + + +var asmGlobalArg = {}; +var asmLibraryArg = { "__cxa_allocate_exception": ___cxa_allocate_exception, "__cxa_atexit": ___cxa_atexit, "__cxa_begin_catch": ___cxa_begin_catch, "__cxa_end_catch": ___cxa_end_catch, "__cxa_find_matching_catch_2": ___cxa_find_matching_catch_2, "__cxa_find_matching_catch_3": ___cxa_find_matching_catch_3, "__cxa_free_exception": ___cxa_free_exception, "__cxa_rethrow": ___cxa_rethrow, "__cxa_throw": ___cxa_throw, "__cxa_uncaught_exceptions": ___cxa_uncaught_exceptions, "__handle_stack_overflow": ___handle_stack_overflow, "__map_file": ___map_file, "__resumeException": ___resumeException, "__sys_munmap": ___sys_munmap, "__sys_open": ___sys_open, "__sys_read": ___sys_read, "_embind_register_bool": __embind_register_bool, "_embind_register_emval": __embind_register_emval, "_embind_register_float": __embind_register_float, "_embind_register_integer": __embind_register_integer, "_embind_register_memory_view": __embind_register_memory_view, "_embind_register_std_string": __embind_register_std_string, "_embind_register_std_wstring": __embind_register_std_wstring, "_embind_register_void": __embind_register_void, "abort": _abort, "emscripten_asm_const_iii": _emscripten_asm_const_iii, "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "fd_close": _fd_close, "fd_seek": _fd_seek, "fd_write": _fd_write, "getTempRet0": _getTempRet0, "invoke_diii": invoke_diii, "invoke_fiii": invoke_fiii, "invoke_i": invoke_i, "invoke_ii": invoke_ii, "invoke_iii": invoke_iii, "invoke_iiii": invoke_iiii, "invoke_iiiii": invoke_iiiii, "invoke_iiiiii": invoke_iiiiii, "invoke_iiiiiii": invoke_iiiiiii, "invoke_iiiiiiii": invoke_iiiiiiii, "invoke_iiiiiiiiiii": invoke_iiiiiiiiiii, "invoke_iiiiiiiiiiii": invoke_iiiiiiiiiiii, "invoke_iiiiiiiiiiiii": invoke_iiiiiiiiiiiii, "invoke_jiiii": invoke_jiiii, "invoke_v": invoke_v, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_viii": invoke_viii, "invoke_viiii": invoke_viiii, "invoke_viiiii": invoke_viiiii, "invoke_viiiiiii": invoke_viiiiiii, "invoke_viiiiiiiiii": invoke_viiiiiiiiii, "invoke_viiiiiiiiiiiiiii": invoke_viiiiiiiiiiiiiii, "llvm_eh_typeid_for": _llvm_eh_typeid_for, "memory": wasmMemory, "setTempRet0": _setTempRet0, "strftime_l": _strftime_l, "table": wasmTable }; +var asm = createWasm(); +Module["asm"] = asm; +/** @type {function(...*):?} */ +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__wasm_call_ctors"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _free = Module["_free"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["free"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _itest = Module["_itest"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["itest"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _str_pass_size = Module["_str_pass_size"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["str_pass_size"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _fire_event_bus = Module["_fire_event_bus"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["fire_event_bus"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _main = Module["_main"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["main"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var ___errno_location = Module["___errno_location"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__errno_location"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _fflush = Module["_fflush"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["fflush"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _setThrew = Module["_setThrew"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["setThrew"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var __ZSt18uncaught_exceptionv = Module["__ZSt18uncaught_exceptionv"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["_ZSt18uncaught_exceptionv"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var _malloc = Module["_malloc"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["malloc"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var ___cxa_can_catch = Module["___cxa_can_catch"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__cxa_can_catch"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__cxa_is_pointer_type"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var ___getTypeName = Module["___getTypeName"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__getTypeName"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__embind_register_native_and_builtin_types"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_v = Module["dynCall_v"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_v"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_vi = Module["dynCall_vi"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_vi"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_vii = Module["dynCall_vii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_vii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viii = Module["dynCall_viii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viiii = Module["dynCall_viiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viiiii = Module["dynCall_viiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viiiiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viiiiiiiiiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_i = Module["dynCall_i"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_i"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_ii = Module["dynCall_ii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_ii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iii = Module["dynCall_iii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiii = Module["dynCall_iiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiii = Module["dynCall_iiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiiiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_jiiii = Module["dynCall_jiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_jiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_fiii = Module["dynCall_fiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_fiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_diii = Module["dynCall_diii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_diii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var ___set_stack_limit = Module["___set_stack_limit"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__set_stack_limit"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var stackSave = Module["stackSave"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["stackSave"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var stackAlloc = Module["stackAlloc"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["stackAlloc"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var stackRestore = Module["stackRestore"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["stackRestore"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var __growWasmMemory = Module["__growWasmMemory"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["__growWasmMemory"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viijii = Module["dynCall_viijii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viijii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiij"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiid = Module["dynCall_iiiiid"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiid"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiijj"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_iiiiiijj"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_viiiiii"].apply(null, arguments) +}; + +/** @type {function(...*):?} */ +var dynCall_jiji = Module["dynCall_jiji"] = function() { + assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)'); + assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + return Module["asm"]["dynCall_jiji"].apply(null, arguments) +}; + + +function invoke_vii(index,a1,a2) { + var sp = stackSave(); + try { + dynCall_vii(index,a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return dynCall_iiii(index,a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iii(index,a1,a2) { + var sp = stackSave(); + try { + return dynCall_iii(index,a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index,a1) { + var sp = stackSave(); + try { + return dynCall_ii(index,a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + dynCall_viiii(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_v(index) { + var sp = stackSave(); + try { + dynCall_v(index); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index,a1,a2,a3) { + var sp = stackSave(); + try { + dynCall_viii(index,a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index,a1) { + var sp = stackSave(); + try { + dynCall_vi(index,a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiii(index,a1,a2,a3,a4,a5,a6) { + var sp = stackSave(); + try { + return dynCall_iiiiiii(index,a1,a2,a3,a4,a5,a6); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiii(index,a1,a2,a3,a4,a5) { + var sp = stackSave(); + try { + dynCall_viiiii(index,a1,a2,a3,a4,a5); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiii(index,a1,a2,a3,a4,a5) { + var sp = stackSave(); + try { + return dynCall_iiiiii(index,a1,a2,a3,a4,a5); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiii(index,a1,a2,a3,a4,a5,a6,a7) { + var sp = stackSave(); + try { + return dynCall_iiiiiiii(index,a1,a2,a3,a4,a5,a6,a7); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return dynCall_iiiii(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_fiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return dynCall_fiii(index,a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_diii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return dynCall_diii(index,a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_i(index) { + var sp = stackSave(); + try { + return dynCall_i(index); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7) { + var sp = stackSave(); + try { + dynCall_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) { + var sp = stackSave(); + try { + return dynCall_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) { + var sp = stackSave(); + try { + dynCall_viiiiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + +function invoke_jiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return dynCall_jiiii(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0 && e !== 'longjmp') throw e; + _setThrew(1, 0); + } +} + + +/** + * @license + * Copyright 2010 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +// === Auto-generated postamble setup entry stuff === + +Module['asm'] = asm; + +if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString")) Module["intArrayFromString"] = function() { abort("'intArrayFromString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString")) Module["intArrayToString"] = function() { abort("'intArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +Module["ccall"] = ccall; +Module["cwrap"] = cwrap; +Module["setValue"] = setValue; +Module["getValue"] = getValue; +if (!Object.getOwnPropertyDescriptor(Module, "allocate")) Module["allocate"] = function() { abort("'allocate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getMemory")) Module["getMemory"] = function() { abort("'getMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString")) Module["UTF8ArrayToString"] = function() { abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +Module["UTF8ToString"] = UTF8ToString; +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = function() { abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +Module["stringToUTF8"] = stringToUTF8; +if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8")) Module["lengthBytesUTF8"] = function() { abort("'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() { abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun")) Module["addOnPreRun"] = function() { abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "addOnInit")) Module["addOnInit"] = function() { abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain")) Module["addOnPreMain"] = function() { abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +Module["addOnExit"] = addOnExit; +if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun")) Module["addOnPostRun"] = function() { abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory")) Module["writeStringToMemory"] = function() { abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory")) Module["writeArrayToMemory"] = function() { abort("'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory")) Module["writeAsciiToMemory"] = function() { abort("'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency")) Module["addRunDependency"] = function() { abort("'addRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "removeRunDependency")) Module["removeRunDependency"] = function() { abort("'removeRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createFolder")) Module["FS_createFolder"] = function() { abort("'FS_createFolder' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath")) Module["FS_createPath"] = function() { abort("'FS_createPath' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createDataFile")) Module["FS_createDataFile"] = function() { abort("'FS_createDataFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createPreloadedFile")) Module["FS_createPreloadedFile"] = function() { abort("'FS_createPreloadedFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createLazyFile")) Module["FS_createLazyFile"] = function() { abort("'FS_createLazyFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createLink")) Module["FS_createLink"] = function() { abort("'FS_createLink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice")) Module["FS_createDevice"] = function() { abort("'FS_createDevice' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS_unlink")) Module["FS_unlink"] = function() { abort("'FS_unlink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you") }; +if (!Object.getOwnPropertyDescriptor(Module, "dynamicAlloc")) Module["dynamicAlloc"] = function() { abort("'dynamicAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "loadDynamicLibrary")) Module["loadDynamicLibrary"] = function() { abort("'loadDynamicLibrary' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "loadWebAssemblyModule")) Module["loadWebAssemblyModule"] = function() { abort("'loadWebAssemblyModule' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getLEB")) Module["getLEB"] = function() { abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables")) Module["getFunctionTables"] = function() { abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables")) Module["alignFunctionTables"] = function() { abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions")) Module["registerFunctions"] = function() { abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "addFunction")) Module["addFunction"] = function() { abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "removeFunction")) Module["removeFunction"] = function() { abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = function() { abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint")) Module["prettyPrint"] = function() { abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "makeBigInt")) Module["makeBigInt"] = function() { abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = function() { abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting")) Module["getCompilerSetting"] = function() { abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "print")) Module["print"] = function() { abort("'print' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "printErr")) Module["printErr"] = function() { abort("'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0")) Module["getTempRet0"] = function() { abort("'getTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0")) Module["setTempRet0"] = function() { abort("'setTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "callMain")) Module["callMain"] = function() { abort("'callMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "abort")) Module["abort"] = function() { abort("'abort' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8")) Module["stringToNewUTF8"] = function() { abort("'stringToNewUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "abortOnCannotGrowMemory")) Module["abortOnCannotGrowMemory"] = function() { abort("'abortOnCannotGrowMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer")) Module["emscripten_realloc_buffer"] = function() { abort("'emscripten_realloc_buffer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ENV")) Module["ENV"] = function() { abort("'ENV' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "setjmpId")) Module["setjmpId"] = function() { abort("'setjmpId' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES")) Module["ERRNO_CODES"] = function() { abort("'ERRNO_CODES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES")) Module["ERRNO_MESSAGES"] = function() { abort("'ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "setErrNo")) Module["setErrNo"] = function() { abort("'setErrNo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "DNS")) Module["DNS"] = function() { abort("'DNS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "GAI_ERRNO_MESSAGES")) Module["GAI_ERRNO_MESSAGES"] = function() { abort("'GAI_ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "Protocols")) Module["Protocols"] = function() { abort("'Protocols' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "Sockets")) Module["Sockets"] = function() { abort("'Sockets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE")) Module["UNWIND_CACHE"] = function() { abort("'UNWIND_CACHE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs")) Module["readAsmConstArgs"] = function() { abort("'readAsmConstArgs' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q")) Module["jstoi_q"] = function() { abort("'jstoi_q' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s")) Module["jstoi_s"] = function() { abort("'jstoi_s' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "reallyNegative")) Module["reallyNegative"] = function() { abort("'reallyNegative' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "formatString")) Module["formatString"] = function() { abort("'formatString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "PATH")) Module["PATH"] = function() { abort("'PATH' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS")) Module["PATH_FS"] = function() { abort("'PATH_FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS")) Module["SYSCALLS"] = function() { abort("'SYSCALLS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "syscallMmap2")) Module["syscallMmap2"] = function() { abort("'syscallMmap2' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "syscallMunmap")) Module["syscallMunmap"] = function() { abort("'syscallMunmap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "JSEvents")) Module["JSEvents"] = function() { abort("'JSEvents' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "specialHTMLTargets")) Module["specialHTMLTargets"] = function() { abort("'specialHTMLTargets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "demangle")) Module["demangle"] = function() { abort("'demangle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "demangleAll")) Module["demangleAll"] = function() { abort("'demangleAll' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace")) Module["jsStackTrace"] = function() { abort("'jsStackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() { abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getEnvStrings")) Module["getEnvStrings"] = function() { abort("'getEnvStrings' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64")) Module["writeI53ToI64"] = function() { abort("'writeI53ToI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped")) Module["writeI53ToI64Clamped"] = function() { abort("'writeI53ToI64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling")) Module["writeI53ToI64Signaling"] = function() { abort("'writeI53ToI64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped")) Module["writeI53ToU64Clamped"] = function() { abort("'writeI53ToU64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling")) Module["writeI53ToU64Signaling"] = function() { abort("'writeI53ToU64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64")) Module["readI53FromI64"] = function() { abort("'readI53FromI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64")) Module["readI53FromU64"] = function() { abort("'readI53FromU64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53")) Module["convertI32PairToI53"] = function() { abort("'convertI32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53")) Module["convertU32PairToI53"] = function() { abort("'convertU32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "Browser")) Module["Browser"] = function() { abort("'Browser' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "FS")) Module["FS"] = function() { abort("'FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "MEMFS")) Module["MEMFS"] = function() { abort("'MEMFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "TTY")) Module["TTY"] = function() { abort("'TTY' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS")) Module["PIPEFS"] = function() { abort("'PIPEFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS")) Module["SOCKFS"] = function() { abort("'SOCKFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "GL")) Module["GL"] = function() { abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet")) Module["emscriptenWebGLGet"] = function() { abort("'emscriptenWebGLGet' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData")) Module["emscriptenWebGLGetTexPixelData"] = function() { abort("'emscriptenWebGLGetTexPixelData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform")) Module["emscriptenWebGLGetUniform"] = function() { abort("'emscriptenWebGLGetUniform' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib")) Module["emscriptenWebGLGetVertexAttrib"] = function() { abort("'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "AL")) Module["AL"] = function() { abort("'AL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SDL_unicode")) Module["SDL_unicode"] = function() { abort("'SDL_unicode' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SDL_ttfContext")) Module["SDL_ttfContext"] = function() { abort("'SDL_ttfContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SDL_audio")) Module["SDL_audio"] = function() { abort("'SDL_audio' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SDL")) Module["SDL"] = function() { abort("'SDL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx")) Module["SDL_gfx"] = function() { abort("'SDL_gfx' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "GLUT")) Module["GLUT"] = function() { abort("'GLUT' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "EGL")) Module["EGL"] = function() { abort("'EGL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window")) Module["GLFW_Window"] = function() { abort("'GLFW_Window' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "GLFW")) Module["GLFW"] = function() { abort("'GLFW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "GLEW")) Module["GLEW"] = function() { abort("'GLEW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "IDBStore")) Module["IDBStore"] = function() { abort("'IDBStore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError")) Module["runAndAbortIfError"] = function() { abort("'runAndAbortIfError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emval_handle_array")) Module["emval_handle_array"] = function() { abort("'emval_handle_array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emval_free_list")) Module["emval_free_list"] = function() { abort("'emval_free_list' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emval_symbols")) Module["emval_symbols"] = function() { abort("'emval_symbols' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "init_emval")) Module["init_emval"] = function() { abort("'init_emval' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "count_emval_handles")) Module["count_emval_handles"] = function() { abort("'count_emval_handles' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "get_first_emval")) Module["get_first_emval"] = function() { abort("'get_first_emval' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getStringOrSymbol")) Module["getStringOrSymbol"] = function() { abort("'getStringOrSymbol' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "requireHandle")) Module["requireHandle"] = function() { abort("'requireHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emval_newers")) Module["emval_newers"] = function() { abort("'emval_newers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "craftEmvalAllocator")) Module["craftEmvalAllocator"] = function() { abort("'craftEmvalAllocator' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emval_get_global")) Module["emval_get_global"] = function() { abort("'emval_get_global' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "emval_methodCallers")) Module["emval_methodCallers"] = function() { abort("'emval_methodCallers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "InternalError")) Module["InternalError"] = function() { abort("'InternalError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "BindingError")) Module["BindingError"] = function() { abort("'BindingError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "UnboundTypeError")) Module["UnboundTypeError"] = function() { abort("'UnboundTypeError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "PureVirtualError")) Module["PureVirtualError"] = function() { abort("'PureVirtualError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "init_embind")) Module["init_embind"] = function() { abort("'init_embind' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "throwInternalError")) Module["throwInternalError"] = function() { abort("'throwInternalError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "throwBindingError")) Module["throwBindingError"] = function() { abort("'throwBindingError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "throwUnboundTypeError")) Module["throwUnboundTypeError"] = function() { abort("'throwUnboundTypeError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ensureOverloadTable")) Module["ensureOverloadTable"] = function() { abort("'ensureOverloadTable' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "exposePublicSymbol")) Module["exposePublicSymbol"] = function() { abort("'exposePublicSymbol' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "replacePublicSymbol")) Module["replacePublicSymbol"] = function() { abort("'replacePublicSymbol' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "extendError")) Module["extendError"] = function() { abort("'extendError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "createNamedFunction")) Module["createNamedFunction"] = function() { abort("'createNamedFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "registeredInstances")) Module["registeredInstances"] = function() { abort("'registeredInstances' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getBasestPointer")) Module["getBasestPointer"] = function() { abort("'getBasestPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "registerInheritedInstance")) Module["registerInheritedInstance"] = function() { abort("'registerInheritedInstance' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "unregisterInheritedInstance")) Module["unregisterInheritedInstance"] = function() { abort("'unregisterInheritedInstance' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getInheritedInstance")) Module["getInheritedInstance"] = function() { abort("'getInheritedInstance' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getInheritedInstanceCount")) Module["getInheritedInstanceCount"] = function() { abort("'getInheritedInstanceCount' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getLiveInheritedInstances")) Module["getLiveInheritedInstances"] = function() { abort("'getLiveInheritedInstances' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "registeredTypes")) Module["registeredTypes"] = function() { abort("'registeredTypes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "awaitingDependencies")) Module["awaitingDependencies"] = function() { abort("'awaitingDependencies' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "typeDependencies")) Module["typeDependencies"] = function() { abort("'typeDependencies' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "registeredPointers")) Module["registeredPointers"] = function() { abort("'registeredPointers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "registerType")) Module["registerType"] = function() { abort("'registerType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "whenDependentTypesAreResolved")) Module["whenDependentTypesAreResolved"] = function() { abort("'whenDependentTypesAreResolved' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "embind_charCodes")) Module["embind_charCodes"] = function() { abort("'embind_charCodes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "embind_init_charCodes")) Module["embind_init_charCodes"] = function() { abort("'embind_init_charCodes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "readLatin1String")) Module["readLatin1String"] = function() { abort("'readLatin1String' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getTypeName")) Module["getTypeName"] = function() { abort("'getTypeName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "heap32VectorToArray")) Module["heap32VectorToArray"] = function() { abort("'heap32VectorToArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "requireRegisteredType")) Module["requireRegisteredType"] = function() { abort("'requireRegisteredType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "getShiftFromSize")) Module["getShiftFromSize"] = function() { abort("'getShiftFromSize' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "integerReadValueFromPointer")) Module["integerReadValueFromPointer"] = function() { abort("'integerReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "enumReadValueFromPointer")) Module["enumReadValueFromPointer"] = function() { abort("'enumReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "floatReadValueFromPointer")) Module["floatReadValueFromPointer"] = function() { abort("'floatReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "simpleReadValueFromPointer")) Module["simpleReadValueFromPointer"] = function() { abort("'simpleReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "runDestructors")) Module["runDestructors"] = function() { abort("'runDestructors' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "new_")) Module["new_"] = function() { abort("'new_' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "craftInvokerFunction")) Module["craftInvokerFunction"] = function() { abort("'craftInvokerFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "embind__requireFunction")) Module["embind__requireFunction"] = function() { abort("'embind__requireFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "tupleRegistrations")) Module["tupleRegistrations"] = function() { abort("'tupleRegistrations' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "structRegistrations")) Module["structRegistrations"] = function() { abort("'structRegistrations' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "genericPointerToWireType")) Module["genericPointerToWireType"] = function() { abort("'genericPointerToWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "constNoSmartPtrRawPointerToWireType")) Module["constNoSmartPtrRawPointerToWireType"] = function() { abort("'constNoSmartPtrRawPointerToWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "nonConstNoSmartPtrRawPointerToWireType")) Module["nonConstNoSmartPtrRawPointerToWireType"] = function() { abort("'nonConstNoSmartPtrRawPointerToWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "init_RegisteredPointer")) Module["init_RegisteredPointer"] = function() { abort("'init_RegisteredPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer")) Module["RegisteredPointer"] = function() { abort("'RegisteredPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_getPointee")) Module["RegisteredPointer_getPointee"] = function() { abort("'RegisteredPointer_getPointee' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_destructor")) Module["RegisteredPointer_destructor"] = function() { abort("'RegisteredPointer_destructor' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_deleteObject")) Module["RegisteredPointer_deleteObject"] = function() { abort("'RegisteredPointer_deleteObject' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_fromWireType")) Module["RegisteredPointer_fromWireType"] = function() { abort("'RegisteredPointer_fromWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "runDestructor")) Module["runDestructor"] = function() { abort("'runDestructor' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "releaseClassHandle")) Module["releaseClassHandle"] = function() { abort("'releaseClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "finalizationGroup")) Module["finalizationGroup"] = function() { abort("'finalizationGroup' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "detachFinalizer_deps")) Module["detachFinalizer_deps"] = function() { abort("'detachFinalizer_deps' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "detachFinalizer")) Module["detachFinalizer"] = function() { abort("'detachFinalizer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "attachFinalizer")) Module["attachFinalizer"] = function() { abort("'attachFinalizer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "makeClassHandle")) Module["makeClassHandle"] = function() { abort("'makeClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "init_ClassHandle")) Module["init_ClassHandle"] = function() { abort("'init_ClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle")) Module["ClassHandle"] = function() { abort("'ClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_isAliasOf")) Module["ClassHandle_isAliasOf"] = function() { abort("'ClassHandle_isAliasOf' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "throwInstanceAlreadyDeleted")) Module["throwInstanceAlreadyDeleted"] = function() { abort("'throwInstanceAlreadyDeleted' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_clone")) Module["ClassHandle_clone"] = function() { abort("'ClassHandle_clone' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_delete")) Module["ClassHandle_delete"] = function() { abort("'ClassHandle_delete' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "deletionQueue")) Module["deletionQueue"] = function() { abort("'deletionQueue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_isDeleted")) Module["ClassHandle_isDeleted"] = function() { abort("'ClassHandle_isDeleted' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_deleteLater")) Module["ClassHandle_deleteLater"] = function() { abort("'ClassHandle_deleteLater' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "flushPendingDeletes")) Module["flushPendingDeletes"] = function() { abort("'flushPendingDeletes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "delayFunction")) Module["delayFunction"] = function() { abort("'delayFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "setDelayFunction")) Module["setDelayFunction"] = function() { abort("'setDelayFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "RegisteredClass")) Module["RegisteredClass"] = function() { abort("'RegisteredClass' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "shallowCopyInternalPointer")) Module["shallowCopyInternalPointer"] = function() { abort("'shallowCopyInternalPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "downcastPointer")) Module["downcastPointer"] = function() { abort("'downcastPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "upcastPointer")) Module["upcastPointer"] = function() { abort("'upcastPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "validateThis")) Module["validateThis"] = function() { abort("'validateThis' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "char_0")) Module["char_0"] = function() { abort("'char_0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "char_9")) Module["char_9"] = function() { abort("'char_9' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "makeLegalFunctionName")) Module["makeLegalFunctionName"] = function() { abort("'makeLegalFunctionName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "warnOnce")) Module["warnOnce"] = function() { abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stackSave")) Module["stackSave"] = function() { abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stackRestore")) Module["stackRestore"] = function() { abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc")) Module["stackAlloc"] = function() { abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString")) Module["AsciiToString"] = function() { abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii")) Module["stringToAscii"] = function() { abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString")) Module["UTF16ToString"] = function() { abort("'UTF16ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16")) Module["stringToUTF16"] = function() { abort("'stringToUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16")) Module["lengthBytesUTF16"] = function() { abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString")) Module["UTF32ToString"] = function() { abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32")) Module["stringToUTF32"] = function() { abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32")) Module["lengthBytesUTF32"] = function() { abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8")) Module["allocateUTF8"] = function() { abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack")) Module["allocateUTF8OnStack"] = function() { abort("'allocateUTF8OnStack' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") }; +Module["writeStackCookie"] = writeStackCookie; +Module["checkStackCookie"] = checkStackCookie; +Module["abortStackOverflow"] = abortStackOverflow;if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL")) Object.defineProperty(Module, "ALLOC_NORMAL", { configurable: true, get: function() { abort("'ALLOC_NORMAL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); +if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK")) Object.defineProperty(Module, "ALLOC_STACK", { configurable: true, get: function() { abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); +if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_DYNAMIC")) Object.defineProperty(Module, "ALLOC_DYNAMIC", { configurable: true, get: function() { abort("'ALLOC_DYNAMIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); +if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NONE")) Object.defineProperty(Module, "ALLOC_NONE", { configurable: true, get: function() { abort("'ALLOC_NONE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); + + + +var calledRun; + + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + + +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']; + + + args = args || []; + + var argc = args.length+1; + var argv = stackAlloc((argc + 1) * 4); + HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram); + for (var i = 1; i < argc; i++) { + HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]); + } + HEAP32[(argv >> 2) + argc] = 0; + + + try { + + Module['___set_stack_limit'](STACK_MAX); + + 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 + exit(ret, /* implicit = */ true); + } + catch(e) { + if (e instanceof ExitStatus) { + // exit() throws this once it's done to make sure execution + // has been stopped completely + return; + } else if (e == 'unwind') { + // running an evented main loop, don't immediately exit + noExitRuntime = true; + return; + } else { + var toLog = e; + if (e && typeof e === 'object' && e.stack) { + toLog = [e, e.stack]; + } + err('exception thrown: ' + toLog); + quit_(1, e); + } + } finally { + calledMain = true; + } +} + + + + +/** @type {function(Array=)} */ +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + writeStackCookie(); + + preRun(); + + if (runDependencies > 0) return; // a preRun added a dependency, run will be called later + + 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(); +} +Module['run'] = run; + +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 print = out; + var printErr = err; + var has = false; + out = err = function(x) { + has = true; + } + try { // it doesn't matter if it fails + var flush = Module['_fflush']; + if (flush) flush(0); + // also flush in the JS FS layer + ['stdout', 'stderr'].forEach(function(name) { + var info = FS.analyzePath('/dev/' + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty && tty.output && tty.output.length) { + has = true; + } + }); + } catch(e) {} + out = print; + err = printErr; + 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.'); + } +} + +/** @param {boolean|number=} implicit */ +function exit(status, implicit) { + checkUnflushedContent(); + + // if this is just main exit-ing implicitly, and the status is 0, then we + // don't need to do anything here and can just leave. if the status is + // non-zero, though, then we need to report it. + // (we may have warned about this earlier, if a situation justifies doing so) + if (implicit && noExitRuntime && status === 0) { + return; + } + + if (noExitRuntime) { + // if exit() was called, we may warn the user if the runtime isn't actually being shut down + if (!implicit) { + err('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)'); + } + } else { + + ABORT = true; + EXITSTATUS = status; + + exitRuntime(); + + if (Module['onExit']) Module['onExit'](status); + } + + quit_(status, new ExitStatus(status)); +} + +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; + + + noExitRuntime = true; + +run(); + + + + + +// {{MODULE_ADDITIONS}} + + + +/** + * @license + * Copyright 2013 The Emscripten Authors + * SPDX-License-Identifier: MIT + */ + +if (typeof window === "object" && (typeof ENVIRONMENT_IS_PTHREAD === 'undefined' || !ENVIRONMENT_IS_PTHREAD)) { + var emrun_register_handlers = function() { + // When C code exit()s, we may still have remaining stdout and stderr messages in flight. In that case, we can't close + // the browser until all those XHRs have finished, so the following state variables track that all communication is done, + // after which we can close. + var emrun_num_post_messages_in_flight = 0; + var emrun_should_close_itself = false; + var postExit = function(msg) { + var http = new XMLHttpRequest(); + // Don't do this immediately, this may race with the notification about the return code reaching the + // server. Send a *sync* xhr so that we know for sure that the server has gotten the return code + // before we continue. + http.open("POST", "stdio.html", false); + http.send(msg); + try { + // Try closing the current browser window, since it exit()ed itself. This can shut down the browser process + // and then emrun does not need to kill the whole browser process. + window.close(); + } catch(e) {} + }; + var post = function(msg) { + var http = new XMLHttpRequest(); + ++emrun_num_post_messages_in_flight; + http.onreadystatechange = function() { + if (http.readyState == 4 /*DONE*/) { + if (--emrun_num_post_messages_in_flight == 0 && emrun_should_close_itself) postExit('^exit^'+EXITSTATUS); + } + } + http.open("POST", "stdio.html", true); + http.send(msg); + }; + // If the address contains localhost, or we are running the page from port 6931, we can assume we're running the test runner and should post stdout logs. + if (document.URL.search("localhost") != -1 || document.URL.search(":6931/") != -1) { + var emrun_http_sequence_number = 1; + var prevPrint = out; + var prevErr = err; + Module['addOnExit'](function() { if (emrun_num_post_messages_in_flight == 0) postExit('^exit^'+EXITSTATUS); else emrun_should_close_itself = true; }); + out = function(text) { post('^out^'+(emrun_http_sequence_number++)+'^'+encodeURIComponent(text)); prevPrint(text); }; + err = function(text) { post('^err^'+(emrun_http_sequence_number++)+'^'+encodeURIComponent(text)); prevErr(text); }; + + // Notify emrun web server that this browser has successfully launched the page. Note that we may need to + // wait for the server to be ready. + var tryToSendPageload = function() { + try { + post('^pageload^'); + } catch (e) { + setTimeout(tryToSendPageload, 50); + } + }; + tryToSendPageload(); + } + }; + + // POSTs the given binary data represented as a (typed) array data back to the emrun-based web server. + // To use from C code, call e.g. EM_ASM({emrun_file_dump("file.dat", HEAPU8.subarray($0, $0 + $1));}, my_data_pointer, my_data_pointer_byte_length); + var emrun_file_dump = function(filename, data) { + var http = new XMLHttpRequest(); + out('Dumping out file "' + filename + '" with ' + data.length + ' bytes of data.'); + http.open("POST", "stdio.html?file=" + filename, true); + http.send(data); // XXX this does not work in workers, for some odd reason (issue #2681) + }; + + if (typeof Module !== 'undefined' && typeof document !== 'undefined') emrun_register_handlers(); +} + diff --git a/hello.wasm b/hello.wasm new file mode 100644 index 0000000000000000000000000000000000000000..2822b92a22212914b2ff43a42a195e9d0366ec2d GIT binary patch literal 285504 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∓2-igtoCR|EX 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 K*iV5v6!?EC`6dtm literal 0 HcmV?d00001 diff --git a/init.js b/init.js new file mode 100644 index 0000000..646b48c --- /dev/null +++ b/init.js @@ -0,0 +1,57 @@ +var itest; + +function InitWrappers() { + // itest = Module.cwrap('itest', 'string'); + itest = (str) => { + const buffer = Module._malloc(str.length + 1) + console.log({buffer}) + Module.stringToUTF8(str, buffer, str.length + 1) + return Module.ccall('itest', 'string', ['number'], [buffer]) + } + + window.read_str_pass = Module.cwrap('read_str_pass', 'void', ['number']) +} + +window.cjs = new (class { + str_pass_size() { + return Module.ccall('str_pass_size', 'number') + } + + write_string(string) { + const buffer = Module._malloc(string.length + 1) + Module.stringToUTF8(string, buffer, string.length + 1) + return buffer + } + + set_string_pass(str_address, size, other = 0) { + const offset = Module._malloc(this.str_pass_size()) + Module.setValue(offset, str_address, 'i32') + Module.setValue(offset + 4, size, 'i32') + Module.setValue(offset + 8, other, 'i32') + return offset + } // [START, SIZE, 0] + + string_pass(string) { + const str_address = this.write_string(string) + return this.set_string_pass(str_address, string.length) + } + + receive(offset) { + const { str_address, str_length, other } = this.get_string_pass(offset) + const string = Module.UTF8ToString(str_address, str_length) + Module._free(offset, this.str_pass_size()) + return string + } + + get_string_pass(offset) { + const str_address = Module.getValue(offset, 'i32') + const str_length = Module.getValue(offset + 4, 'i32') + const other = Module.getValue(offset + 8, 'i32') + return { str_address, str_length, other } + } + + fire_event_bus(key) { + const key_pass = this.string_pass(key) + Module.ccall('fire_event_bus', null, ['number'], [key_pass]) + } +}) diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..3891ba3 --- /dev/null +++ b/main.cpp @@ -0,0 +1,41 @@ +#include +#include +#include + +#include "src/class/Element.h" +#include "src/proc/string.cpp" +#include "src/class/EventBus.h" +#include "src/proc/event.cpp" +#include "src/proc/uuid.cpp" + +extern "C" { + char* itest(); + int str_pass_size(); + void fire_event_bus(int key_pass); +} + +void say_aye() { + printf("Arrgh mates!\n"); +} + +char* itest() { + Element p_tag("#foo"); + p_tag.addEventListener("click", say_aye); + + return "Hi, there"; +} + +// These are REQUIRED. +int str_pass_size() { + return cjs::str::pass_size(); +} + +void fire_event_bus(int string_pass) { + return cjs::event::handle_bus_fire(string_pass); +} + +int main(int argc, char** argv) { + EM_ASM(InitWrappers()); + printf("C++.js has initialized!\n"); + return 0; +} diff --git a/shell_minimal.html b/shell_minimal.html new file mode 100644 index 0000000..cc120c2 --- /dev/null +++ b/shell_minimal.html @@ -0,0 +1,20 @@ + + + + + + Emscripten-Generated Code + + + + +

+

Hello, world!

+ + {{{ SCRIPT }}} + + + diff --git a/src/class/Component.cpp b/src/class/Component.cpp new file mode 100644 index 0000000..a7c3eb1 --- /dev/null +++ b/src/class/Component.cpp @@ -0,0 +1,5 @@ +// +// Created by garrettmills on 5/6/20. +// + +#include "Component.h" diff --git a/src/class/Component.h b/src/class/Component.h new file mode 100644 index 0000000..37b1460 --- /dev/null +++ b/src/class/Component.h @@ -0,0 +1,19 @@ +#ifndef CPPJS_COMPONENT_H +#define CPPJS_COMPONENT_H + + +class Component { +private: + +// =================== HTML TEMPLATE =================== // + char* tmpl = R"V0G0N( +

Hello, world!

+

This is a test hello message!

+)V0G0N"; +// ================= / HTML TEMPLATE =================== // + + +}; + + +#endif //CPPJS_COMPONENT_H diff --git a/src/class/Element.cpp b/src/class/Element.cpp new file mode 100644 index 0000000..073f529 --- /dev/null +++ b/src/class/Element.cpp @@ -0,0 +1,161 @@ +#include + +#include "Element.h" +#include "../proc/document.cpp" +#include "../proc/string.cpp" +#include "../proc/uuid.cpp" +#include "../class/EventBus.h" + +using namespace cjs; + +void Element::_identify_and_rebase() { + try { + std::string uuid = this->getUUID(); + this->rebase("[data-cjs-uuid='"+uuid+"']"); + } catch (std::runtime_error& e) { + std::string new_uuid = uuid::v4(); + this->setData("cjs-uuid", new_uuid); + this->rebase("[data-cjs-uuid='"+new_uuid+"']"); + } +} + +Element::Element(std::string selector, int nth_elem) { + this->_selector_ref = selector; + this->_selector_nth_elem = nth_elem; + this->_identify_and_rebase(); +} + +Element::Element(Element& parent, std::string innerHTML, std::string selector, int nth_elem) { + this->_selector_ref = selector; + this->_selector_nth_elem = nth_elem; + parent.append(innerHTML); + this->_identify_and_rebase(); +} + +std::string Element::getInnerHTML() { + cjs_str* html = doc::get_inner_html_of(this->_selector_ref, this->_selector_nth_elem); + std::string return_str = html->to_str(); + delete html; + return return_str; +} + +std::string Element::getInnerText() { + cjs_str* text = doc::get_inner_text_of(this->_selector_ref, this->_selector_nth_elem); + std::string return_str = text->to_str(); + delete text; + return return_str; +} + +std::string Element::getID() { + cjs_str* html = doc::get_id_of(this->_selector_ref, this->_selector_nth_elem); + std::string return_str = html->to_str(); + delete html; + return return_str; +} + +std::string Element::getUUID() { + return this->getData("cjs-uuid"); +} + +std::string Element::getClassRaw() { + cjs_str* html = doc::get_class_of(this->_selector_ref, this->_selector_nth_elem); + std::string return_str = html->to_str(); + delete html; + return return_str; +} + +std::vector Element::getClasses() { + cjs_str* html = doc::get_class_of(this->_selector_ref, this->_selector_nth_elem); + std::vector result = html->split(); + delete html; + return result; +} + +bool Element::hasClass(std::string cls) { + std::vector classes = this->getClasses(); + for ( std::string s : classes ) + if ( s == cls ) return true; + return false; +} + +std::string Element::getAttribute(std::string attr) { + cjs_str* value = doc::_query_select_attribute(attr, this->_selector_ref, this->_selector_nth_elem); + std::string return_str = value->to_str(); + delete value; + return return_str; +} + +std::string Element::getData(std::string key) { + return this->getAttribute("data-"+key); +} + +void Element::setInnerHTML(std::string html) { + doc::set_inner_html_of(this->_selector_ref, html, this->_selector_nth_elem); +} + +void Element::setInnerText(std::string text) { + doc::set_inner_text_of(this->_selector_ref, text, this->_selector_nth_elem); +} + +void Element::setID(std::string id) { + doc::set_id_of(this->_selector_ref, id, this->_selector_nth_elem); +} + +void Element::setClassRaw(std::string cls) { + doc::set_class_of(this->_selector_ref, cls, this->_selector_nth_elem); +} + +void Element::addClass(std::string cls) { + if ( !this->hasClass(cls) ) { + std::vector classes = this->getClasses(); + classes.push_back(cls); + this->setClassRaw(str::join(classes, " ")); + } +} + +void Element::removeClass(std::string cls) { + if ( this->hasClass(cls) ) { + std::vector old_classes = this->getClasses(); + std::vector new_classes; + + for ( std::string maybe_cls : old_classes ) { + if ( maybe_cls != cls ) + new_classes.push_back(maybe_cls); + } + + this->setClassRaw(str::join(new_classes, " ")); + } +} + +void Element::toggleClass(std::string cls) { + if ( this->hasClass(cls) ) this->removeClass(cls); + else this->addClass(cls); +} + +void Element::setAttribute(std::string attr, std::string value) { + doc::_query_set_attribute(attr, value, this->_selector_ref, this->_selector_nth_elem); +} + +void Element::setData(std::string key, std::string value) { + this->setAttribute("data-"+key, value); +} + +void Element::append(std::string html) { + this->setInnerHTML(this->getInnerHTML()+html); +} + +void Element::addEventListener(std::string dom_event, void(*func)()) { + // Generate the unique function key using the dom_event and uuid + std::string event_key = this->getUUID() + "-" + dom_event; + + // Add the function and the key to the event bus + g_event_bus.addHandler(event_key, func); + + // Add the event bus link to the element's dom event + doc::link_event_bus(dom_event, event_key, this->_selector_ref, this->_selector_nth_elem); +} + +void Element::rebase(std::string query_selector, int nth_elem) { + this->_selector_ref = query_selector; + this->_selector_nth_elem = nth_elem; +} diff --git a/src/class/Element.h b/src/class/Element.h new file mode 100644 index 0000000..32d8253 --- /dev/null +++ b/src/class/Element.h @@ -0,0 +1,44 @@ +#ifndef CPPJS_ELEMENT_H +#define CPPJS_ELEMENT_H + + +class Element { +private: + std::string _selector_ref = ""; + int _selector_nth_elem = 0; + void _identify_and_rebase(); + +public: + Element(std::string selector, int nth_elem = 0); + Element(Element& parent, std::string innerHTML, std::string selector, int nth_elem = 0); + + std::string getInnerHTML(); + std::string getInnerText(); + std::string getID(); + std::string getUUID(); + std::string getClassRaw(); + std::vector getClasses(); + bool hasClass(std::string cls); + std::string getAttribute(std::string attr); + std::string getData(std::string key); + + void setInnerHTML(std::string html); + void setInnerText(std::string text); + void setID(std::string id); + void setClassRaw(std::string cls); + void addClass(std::string cls); + void removeClass(std::string cls); + void toggleClass(std::string cls); + void setAttribute(std::string attr, std::string value); + void setData(std::string key, std::string value); + void append(std::string html); + + void addEventListener(std::string dom_event, void(*func)()); + + void rebase(std::string query_selector, int nth_elem = 0); +}; + +#include "Element.cpp" + + +#endif //CPPJS_ELEMENT_H diff --git a/src/class/EventBus.cpp b/src/class/EventBus.cpp new file mode 100644 index 0000000..4579fc4 --- /dev/null +++ b/src/class/EventBus.cpp @@ -0,0 +1,25 @@ +#include "EventBus.h" + +void EventBus::addHandler(std::string key, void (*func)()) { + // If the bus already has this key, add a handler + auto search = this->_bus.find(key); + if ( search != this->_bus.end() ) { + std::vector func_arr = this->_bus[key]; + func_arr.push_back(func); + this->_bus[key] = func_arr; + } else { + std::vector func_arr; + func_arr.push_back(func); + this->_bus[key] = func_arr; + } +} + +void EventBus::fire(std::string key) { + auto search = this->_bus.find(key); + if ( search != this->_bus.end() ) { + std::vector func_arr = this->_bus[key]; + for ( void(*func)() : func_arr ) { + (*func)(); + } + } +} diff --git a/src/class/EventBus.h b/src/class/EventBus.h new file mode 100644 index 0000000..3034bd9 --- /dev/null +++ b/src/class/EventBus.h @@ -0,0 +1,21 @@ +#ifndef CPPJS_EVENTBUS_H +#define CPPJS_EVENTBUS_H + +#include +#include + +class EventBus { +private: + std::map> _bus; + +public: + void addHandler(std::string key, void (*func)()); + void fire(std::string key); +}; + +extern EventBus g_event_bus; +EventBus g_event_bus; + +#include "EventBus.cpp" + +#endif //CPPJS_EVENTBUS_H diff --git a/src/proc/document.cpp b/src/proc/document.cpp new file mode 100644 index 0000000..bc623da --- /dev/null +++ b/src/proc/document.cpp @@ -0,0 +1,116 @@ +#ifndef CJS_PROC_DOCUMENT +#define CJS_PROC_DOCUMENT + +#include +#include +#include "string.cpp" + +namespace cjs { + namespace doc { + #include + + cjs_str* _query_select_property(std::string method, std::string query_selector, int nth_elem = 0) { + int method_pass = cjs::str::pass(cjs::str::cpp_to_c(method), method.length()); + int query_pass = cjs::str::pass(cjs::str::cpp_to_c(query_selector), query_selector.length()); + + int return_str_pass = EM_ASM_INT({ + try { + return cjs.string_pass(document.querySelectorAll(cjs.receive($1))[$2][cjs.receive($0)]); + } catch (e) { + return 0; + } + }, method_pass, query_pass, nth_elem); + + if ( return_str_pass == 0 ) { + throw std::runtime_error("The property or element is undefined."); + } + + cjs_str* return_str = cjs::str::receive(return_str_pass); + return return_str; + } + + cjs_str* _query_select_attribute(std::string attribute, std::string query_selector, int nth_elem = 0) { + int attribute_pass = cjs::str::pass(cjs::str::cpp_to_c(attribute), attribute.length()); + int query_pass = cjs::str::pass(cjs::str::cpp_to_c(query_selector), query_selector.length()); + + int return_str_pass = EM_ASM_INT({ + try { + return cjs.string_pass(document.querySelectorAll(cjs.receive($1))[$2].getAttribute(cjs.receive($0))); + } catch (e) { + return 0; + } + }, attribute_pass, query_pass, nth_elem); + + if ( return_str_pass == 0 ) { + throw std::runtime_error("The attribute or element is undefined."); + } + + cjs_str* return_str = cjs::str::receive(return_str_pass); + return return_str; + } + + void _query_set_property(std::string property, std::string value, std::string query_selector, int nth_elem = 0) { + int property_pass = cjs::str::pass(cjs::str::cpp_to_c(property), property.length()); + int value_pass = cjs::str::pass(cjs::str::cpp_to_c(value), value.length()); + int query_pass = cjs::str::pass(cjs::str::cpp_to_c(query_selector), query_selector.length()); + + EM_ASM({ + document.querySelectorAll(cjs.receive($2))[$3][cjs.receive($0)] = cjs.receive($1); + }, property_pass, value_pass, query_pass, nth_elem); + } + + void _query_set_attribute(std::string attribute, std::string value, std::string query_selector, int nth_elem = 0) { + int attribute_pass = cjs::str::pass(cjs::str::cpp_to_c(attribute), attribute.length()); + int value_pass = cjs::str::pass(cjs::str::cpp_to_c(value), value.length()); + int query_pass = cjs::str::pass(cjs::str::cpp_to_c(query_selector), query_selector.length()); + + EM_ASM({ + document.querySelectorAll(cjs.receive($2))[$3].setAttribute(cjs.receive($0), cjs.receive($1)); + }, attribute_pass, value_pass, query_pass, nth_elem); + } + + void link_event_bus(std::string dom_event, std::string event_bus_key, std::string query_selector, int nth_elem = 0) { + int dom_event_pass = cjs::str::pass(cjs::str::cpp_to_c(dom_event), dom_event.length()); + int event_bus_key_pass = cjs::str::pass(cjs::str::cpp_to_c(event_bus_key), event_bus_key.length()); + int query_pass = cjs::str::pass(cjs::str::cpp_to_c(query_selector), query_selector.length()); + + EM_ASM({ + document.querySelectorAll(cjs.receive($2))[$3].addEventListener(cjs.receive($0), () => cjs.fire_event_bus(cjs.receive($1))); + }, dom_event_pass, event_bus_key_pass, query_pass, nth_elem); + } + + cjs_str* get_inner_html_of(std::string query_selector, int nth_elem = 0) { + return _query_select_property("innerHTML", query_selector, nth_elem); + } + + void set_inner_html_of(std::string query_selector, std::string value, int nth_elem = 0) { + _query_set_property("innerHTML", value, query_selector, nth_elem); + } + + cjs_str* get_inner_text_of(std::string query_selector, int nth_elem = 0) { + return _query_select_property("innerText", query_selector, nth_elem); + } + + void set_inner_text_of(std::string query_selector, std::string value, int nth_elem = 0) { + _query_set_property("innerText", value, query_selector, nth_elem); + } + + cjs_str* get_id_of(std::string query_selector, int nth_elem = 0) { + return _query_select_property("id", query_selector, nth_elem); + } + + void set_id_of(std::string query_selector, std::string value, int nth_elem = 0) { + _query_set_property("id", value, query_selector, nth_elem); + } + + cjs_str* get_class_of(std::string query_selector, int nth_elem = 0) { + return _query_select_attribute("class", query_selector, nth_elem); + } + + void set_class_of(std::string query_selector, std::string cls, int nth_elem = 0) { + return _query_set_attribute("class", cls, query_selector, nth_elem); + } + } +} + +#endif //CJS_PROC_DOCUMENT diff --git a/src/proc/event.cpp b/src/proc/event.cpp new file mode 100644 index 0000000..6b6b4e0 --- /dev/null +++ b/src/proc/event.cpp @@ -0,0 +1,18 @@ +#ifndef CJS_PROC_EVENT +#define CJS_PROC_EVENT + +#include +#include "string.cpp" + +namespace cjs { + namespace event { + void handle_bus_fire(int key_pass) { + cjs_str* key_str = cjs::str::receive(key_pass); + std::string key = key_str->to_str(); + delete key_str; + g_event_bus.fire(key); + } + } +} + +#endif //CJS_PROC_EVENT diff --git a/src/proc/string.cpp b/src/proc/string.cpp new file mode 100644 index 0000000..72af4c7 --- /dev/null +++ b/src/proc/string.cpp @@ -0,0 +1,102 @@ +#ifndef CJS_PROC_STRING +#define CJS_PROC_STRING + +#include +#include +#include + +struct cjs_str { + int length; + char* string; + + std::string to_str() { + std::string str(this->string); + return str; + } + + void from_str(std::string str) { + this->length = str.length(); + char* cstr = new char[str.length() + 1]; + strcpy(cstr, str.c_str()); + this->string = cstr; + } + + std::string c_str() { + return this->to_str().c_str(); + } + + std::vector split() { + std::string s = this->to_str(); + std::vector result; + std::istringstream iss(s); + for(std::string s; iss >> s; ) + result.push_back(s); + return result; + } +}; + +namespace cjs { + namespace str { + int pass_size() { + return 3 * sizeof(int); + } + + char* cpp_to_c(std::string str) { + char* cstr = new char[str.length() + 1]; + strcpy(cstr, str.c_str()); + return cstr; + } + + std::string join(const std::vector strings, const char* by) { + if ( strings.size() < 1 ) return ""; + else if ( strings.size() == 1 ) return strings.front(); + else { + std::stringstream res; + copy(strings.begin(), strings.end() - 1, std::ostream_iterator(res, by)); + res << strings.back(); + return res.str(); + } + } + + cjs_str* cpp_to_cjs(std::string str) { + return new cjs_str{ (int) str.length(), cpp_to_c(str) }; + } + + cjs_str* c_to_cjs(char* string, int len) { + return new cjs_str{ len, string }; + } + + std::string c_to_cpp(char* string) { + std::string str(string); + return str; + } + + std::string cjs_to_cpp(cjs_str* cjs) { + return c_to_cpp(cjs->string); + } + + cjs_str* receive(int offset) { + // Get the string pass information + // Format: [ string offset, string length, (unused) ] + int* str_pass = reinterpret_cast(offset); + int length = str_pass[1]; + char* string = reinterpret_cast(str_pass[0]); + free(str_pass); + return new cjs_str{ length, string }; + } + + int set_pass(int address, int size, int other = 0) { + int* pass = new int[3]; + pass[0] = address; + pass[1] = size; + pass[2] = other; + return (int) pass; + } + + int pass(char* string, int length) { + return set_pass((int) string, length); + } + } +} + +#endif //CJS_PROC_STRING diff --git a/src/proc/uuid.cpp b/src/proc/uuid.cpp new file mode 100644 index 0000000..11af2e0 --- /dev/null +++ b/src/proc/uuid.cpp @@ -0,0 +1,44 @@ +#ifndef CJS_PROC_UUID +#define CJS_PROC_UUID + +#include +#include + +namespace cjs { + namespace uuid { + static std::random_device rd; + static std::mt19937 gen(rd()); + static std::uniform_int_distribution<> dis(0, 15); + static std::uniform_int_distribution<> dis2(8, 11); + + std::string v4() { + std::stringstream ss; + int i; + ss << std::hex; + for (i = 0; i < 8; i++) { + ss << dis(gen); + } + ss << "-"; + for (i = 0; i < 4; i++) { + ss << dis(gen); + } + ss << "-4"; + for (i = 0; i < 3; i++) { + ss << dis(gen); + } + ss << "-"; + ss << dis2(gen); + for (i = 0; i < 3; i++) { + ss << dis(gen); + } + ss << "-"; + for (i = 0; i < 12; i++) { + ss << dis(gen); + }; + return ss.str(); + } + } +} +// https://stackoverflow.com/questions/24365331/how-can-i-generate-uuid-in-c-without-using-boost-library + +#endif // CJS_PROC_UUID