From b8d0d5202d7b08d2248bbfcda12a660f1b3d83ac Mon Sep 17 00:00:00 2001 From: Surma Date: Mon, 17 Aug 2020 17:10:12 +0100 Subject: [PATCH] Update JXL library and build system --- codecs/jxl/.gitignore | 1 + codecs/jxl/Makefile | 63 + codecs/{jxl_dec => jxl/dec}/jxl_dec.cpp | 0 codecs/{jxl_dec => jxl/dec}/jxl_dec.d.ts | 0 codecs/jxl/dec/jxl_dec.js | 7569 ++++++++++++++++++++++ codecs/jxl/dec/jxl_dec.wasm | Bin 0 -> 1615187 bytes codecs/{jxl_enc => jxl/enc}/jxl_enc.cpp | 0 codecs/{jxl_enc => jxl/enc}/jxl_enc.d.ts | 0 codecs/jxl/enc/jxl_enc.js | 7075 ++++++++++++++++++++ codecs/jxl/enc/jxl_enc.wasm | Bin 0 -> 2770350 bytes codecs/jxl/package.json | 6 + codecs/jxl_dec/README.md | 18 - codecs/jxl_dec/build.sh | 69 - codecs/jxl_dec/example.html | 24 - codecs/jxl_dec/example.jxl | Bin 192675 -> 0 bytes codecs/jxl_dec/jxl_dec.js | 22 - codecs/jxl_dec/jxl_dec.wasm | Bin 1031741 -> 0 bytes codecs/jxl_dec/package-lock.json | 1211 ---- codecs/jxl_dec/package.json | 12 - codecs/jxl_enc/README.md | 18 - codecs/jxl_enc/build.sh | 74 - codecs/jxl_enc/example.js | 12 - codecs/jxl_enc/jxl_enc.js | 22 - codecs/jxl_enc/jxl_enc.wasm | Bin 2201568 -> 0 bytes codecs/jxl_enc/package-lock.json | 1211 ---- codecs/jxl_enc/package.json | 12 - src/codecs/jxl/decoder.ts | 4 +- src/codecs/jxl/encoder.ts | 4 +- 28 files changed, 14718 insertions(+), 2709 deletions(-) create mode 100644 codecs/jxl/.gitignore create mode 100644 codecs/jxl/Makefile rename codecs/{jxl_dec => jxl/dec}/jxl_dec.cpp (100%) rename codecs/{jxl_dec => jxl/dec}/jxl_dec.d.ts (100%) create mode 100644 codecs/jxl/dec/jxl_dec.js create mode 100644 codecs/jxl/dec/jxl_dec.wasm rename codecs/{jxl_enc => jxl/enc}/jxl_enc.cpp (100%) rename codecs/{jxl_enc => jxl/enc}/jxl_enc.d.ts (100%) create mode 100644 codecs/jxl/enc/jxl_enc.js create mode 100644 codecs/jxl/enc/jxl_enc.wasm create mode 100644 codecs/jxl/package.json delete mode 100644 codecs/jxl_dec/README.md delete mode 100755 codecs/jxl_dec/build.sh delete mode 100644 codecs/jxl_dec/example.html delete mode 100644 codecs/jxl_dec/example.jxl delete mode 100644 codecs/jxl_dec/jxl_dec.js delete mode 100644 codecs/jxl_dec/jxl_dec.wasm delete mode 100644 codecs/jxl_dec/package-lock.json delete mode 100644 codecs/jxl_dec/package.json delete mode 100644 codecs/jxl_enc/README.md delete mode 100755 codecs/jxl_enc/build.sh delete mode 100644 codecs/jxl_enc/example.js delete mode 100644 codecs/jxl_enc/jxl_enc.js delete mode 100644 codecs/jxl_enc/jxl_enc.wasm delete mode 100644 codecs/jxl_enc/package-lock.json delete mode 100644 codecs/jxl_enc/package.json diff --git a/codecs/jxl/.gitignore b/codecs/jxl/.gitignore new file mode 100644 index 00000000..3c3629e6 --- /dev/null +++ b/codecs/jxl/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/codecs/jxl/Makefile b/codecs/jxl/Makefile new file mode 100644 index 00000000..807ecf5d --- /dev/null +++ b/codecs/jxl/Makefile @@ -0,0 +1,63 @@ +CODEC_URL = https://gitlab.com/wg1/jpeg-xl.git +CODEC_VERSION = 7a2f362aba73f1f7b25347737304f80acf2490ed +CODEC_DIR = node_modules/jxl +CODEC_BUILD_DIR := $(CODEC_DIR)/build +CODEC_OUT := $(CODEC_BUILD_DIR)/libjpegxl-static.a + +OUT_JS = enc/jxl_enc.js dec/jxl_dec.js +OUT_WASM = $(OUT_JS:.js=.wasm) + +.PHONY: all clean + +all: $(OUT_JS) + +%.js: %.cpp $(LIBAOM_OUT) $(CODEC_OUT) + $(CXX) \ + -I $(CODEC_DIR) \ + -I $(CODEC_DIR)/third_party/highway \ + -I $(CODEC_DIR)/third_party/brunsli \ + -I $(CODEC_DIR)/third_party/brunsli/c/include \ + ${CXXFLAGS} \ + ${LDFLAGS} \ + --bind \ + --closure 1 \ + -s ALLOW_MEMORY_GROWTH=1 \ + -s MODULARIZE=1 \ + -s 'EXPORT_NAME="$(basename $(@F))"' \ + -o $@ \ + $+ \ + $(CODEC_BUILD_DIR)/artifacts/libbrunslienc-static.bc \ + $(CODEC_BUILD_DIR)/artifacts/libbrunslicommon-static.bc \ + $(CODEC_BUILD_DIR)/artifacts/libbrunslidec-static.bc \ + $(CODEC_BUILD_DIR)/third_party/brotli/libbrotlidec-static.a \ + $(CODEC_BUILD_DIR)/third_party/brotli/libbrotlienc-static.a \ + $(CODEC_BUILD_DIR)/third_party/brotli/libbrotlicommon-static.a \ + $(CODEC_BUILD_DIR)/third_party/liblcms2.a \ + $(CODEC_BUILD_DIR)/third_party/highway/libhwy.a + +$(CODEC_OUT): $(CODEC_DIR)/CMakeLists.txt + mkdir -p $(CODEC_BUILD_DIR) + cd $(CODEC_BUILD_DIR) && \ + emcmake cmake ../ && \ + $(MAKE) jpegxl-static + + +$(CODEC_DIR)/CMakeLists.txt: $(CODEC_DIR) + +$(CODEC_DIR): + # The JXL repository doesn’t have version tags or anything yet, + # so we have to pin to a specific commit for now. This implies we + # can’t use --recursive, as we will change commit after checkout (it + # seems you can’t clone a specific commit directly), and it also means + # we can’t use --depth 1 because we want to change commits. + # The JXL code base also relies on submodules so we can’t just download + # a .tar.gz from GitLab. + mkdir -p $@ + git clone $(CODEC_URL) $@ + cd $@ && \ + git checkout -b squoosh-build $(CODEC_VERSION) && \ + git submodule update --init --recursive + +clean: + $(RM) $(OUT_JS) $(OUT_WASM) + $(MAKE) -C $(CODEC_BUILD_DIR) clean diff --git a/codecs/jxl_dec/jxl_dec.cpp b/codecs/jxl/dec/jxl_dec.cpp similarity index 100% rename from codecs/jxl_dec/jxl_dec.cpp rename to codecs/jxl/dec/jxl_dec.cpp diff --git a/codecs/jxl_dec/jxl_dec.d.ts b/codecs/jxl/dec/jxl_dec.d.ts similarity index 100% rename from codecs/jxl_dec/jxl_dec.d.ts rename to codecs/jxl/dec/jxl_dec.d.ts diff --git a/codecs/jxl/dec/jxl_dec.js b/codecs/jxl/dec/jxl_dec.js new file mode 100644 index 00000000..760a6eaf --- /dev/null +++ b/codecs/jxl/dec/jxl_dec.js @@ -0,0 +1,7569 @@ + +var jxl_dec = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( +function(jxl_dec) { + jxl_dec = jxl_dec || {}; + +var Module = typeof jxl_dec !== "undefined" ? jxl_dec : {}; + +var readyPromiseResolve, readyPromiseReject; + +Module["ready"] = new Promise(function(resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_main")) { + Object.defineProperty(Module["ready"], "_main", { + configurable: true, + get: function() { + abort("You are getting _main on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_main", { + configurable: true, + set: function() { + abort("You are setting _main on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_malloc")) { + Object.defineProperty(Module["ready"], "_malloc", { + configurable: true, + get: function() { + abort("You are getting _malloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_malloc", { + configurable: true, + set: function() { + abort("You are setting _malloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_free")) { + Object.defineProperty(Module["ready"], "_free", { + configurable: true, + get: function() { + abort("You are getting _free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_free", { + configurable: true, + set: function() { + abort("You are setting _free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackSave")) { + Object.defineProperty(Module["ready"], "_stackSave", { + configurable: true, + get: function() { + abort("You are getting _stackSave on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_stackSave", { + configurable: true, + set: function() { + abort("You are setting _stackSave on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackRestore")) { + Object.defineProperty(Module["ready"], "_stackRestore", { + configurable: true, + get: function() { + abort("You are getting _stackRestore on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_stackRestore", { + configurable: true, + set: function() { + abort("You are setting _stackRestore on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackAlloc")) { + Object.defineProperty(Module["ready"], "_stackAlloc", { + configurable: true, + get: function() { + abort("You are getting _stackAlloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_stackAlloc", { + configurable: true, + set: function() { + abort("You are setting _stackAlloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "___data_end")) { + Object.defineProperty(Module["ready"], "___data_end", { + configurable: true, + get: function() { + abort("You are getting ___data_end on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "___data_end", { + configurable: true, + set: function() { + abort("You are setting ___data_end on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "___wasm_call_ctors")) { + Object.defineProperty(Module["ready"], "___wasm_call_ctors", { + configurable: true, + get: function() { + abort("You are getting ___wasm_call_ctors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "___wasm_call_ctors", { + configurable: true, + set: function() { + abort("You are setting ___wasm_call_ctors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_fflush")) { + Object.defineProperty(Module["ready"], "_fflush", { + configurable: true, + get: function() { + abort("You are getting _fflush on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_fflush", { + configurable: true, + set: function() { + abort("You are setting _fflush on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "___errno_location")) { + Object.defineProperty(Module["ready"], "___errno_location", { + configurable: true, + get: function() { + abort("You are getting ___errno_location on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "___errno_location", { + configurable: true, + set: function() { + abort("You are setting ___errno_location on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_setThrew")) { + Object.defineProperty(Module["ready"], "_setThrew", { + configurable: true, + get: function() { + abort("You are getting _setThrew on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_setThrew", { + configurable: true, + set: function() { + abort("You are setting _setThrew on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_tzname")) { + Object.defineProperty(Module["ready"], "__get_tzname", { + configurable: true, + get: function() { + abort("You are getting __get_tzname on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "__get_tzname", { + configurable: true, + set: function() { + abort("You are setting __get_tzname on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_daylight")) { + Object.defineProperty(Module["ready"], "__get_daylight", { + configurable: true, + get: function() { + abort("You are getting __get_daylight on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "__get_daylight", { + configurable: true, + set: function() { + abort("You are setting __get_daylight on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_timezone")) { + Object.defineProperty(Module["ready"], "__get_timezone", { + configurable: true, + get: function() { + abort("You are getting __get_timezone on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "__get_timezone", { + configurable: true, + set: function() { + abort("You are setting __get_timezone on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "onRuntimeInitialized")) { + Object.defineProperty(Module["ready"], "onRuntimeInitialized", { + configurable: true, + get: function() { + abort("You are getting onRuntimeInitialized on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "onRuntimeInitialized", { + configurable: true, + set: function() { + abort("You are setting onRuntimeInitialized on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +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; +}; + +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"; + +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)"); +} + +var scriptDirectory = ""; + +function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; +} + +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 + "/"; + } + 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); + process["on"]("uncaughtException", function(ex) { + 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") { + if (typeof console === "undefined") console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== "undefined" ? printErr : print; + } +} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href; + } else if (document.currentScript) { + scriptDirectory = document.currentScript.src; + } + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1); + } else { + scriptDirectory = ""; + } + { + 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(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) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + } + setWindowTitle = function(title) { + document.title = title; + }; +} else { + throw new Error("environment detection error"); +} + +var out = Module["print"] || console.log.bind(console); + +var err = Module["printErr"] || console.warn.bind(console); + +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} + +moduleOverrides = null; + +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_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (!Object.getOwnPropertyDescriptor(Module, "readAsync")) Object.defineProperty(Module, "readAsync", { + configurable: true, + get: function() { + abort("Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (!Object.getOwnPropertyDescriptor(Module, "readBinary")) Object.defineProperty(Module, "readBinary", { + configurable: true, + get: function() { + abort("Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (!Object.getOwnPropertyDescriptor(Module, "setWindowTitle")) Object.defineProperty(Module, "setWindowTitle", { + configurable: true, + get: function() { + abort("Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +var STACK_ALIGN = 16; + +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; + 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; + } 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); + } +} + +function convertJsFunctionToWasm(func, sig) { + 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); + } + var typeSection = [ 1, 0, 1, 96 ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + "i": 127, + "j": 126, + "f": 125, + "d": 124 + }; + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + if (sigRet == "v") { + typeSection.push(0); + } else { + typeSection = typeSection.concat([ 1, typeCodes[sigRet] ]); + } + typeSection[1] = typeSection.length - 2; + var bytes = new Uint8Array([ 0, 97, 115, 109, 1, 0, 0, 0 ].concat(typeSection, [ 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0 ])); + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + "e": { + "f": func + } + }); + var wrappedFunc = instance.exports["f"]; + return wrappedFunc; +} + +var freeTableIndexes = []; + +var functionsInTableMap; + +function addFunctionWasm(func, sig) { + var table = wasmTable; + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + for (var i = 0; i < table.length; i++) { + var item = table.get(i); + if (item) { + functionsInTableMap.set(item, i); + } + } + } + if (functionsInTableMap.has(func)) { + return functionsInTableMap.get(func); + } + var ret; + if (freeTableIndexes.length) { + ret = freeTableIndexes.pop(); + } else { + ret = table.length; + try { + table.grow(1); + } catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."; + } + } + try { + 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); +} + +var funcWrappers = {}; + +function dynCall(sig, ptr, args) { + if (args && args.length) { + 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 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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (typeof WebAssembly !== "object") { + abort("no native wasm support detected"); +} + +function setValue(ptr, value, type, noSafe) { + type = type || "i8"; + if (type.charAt(type.length - 1) === "*") type = "i32"; + 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 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 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); + } +} + +var wasmMemory; + +var wasmTable = new WebAssembly.Table({ + "initial": 1141, + "maximum": 1141 + 0, + "element": "anyfunc" +}); + +var ABORT = false; + +var EXITSTATUS = 0; + +function assert(condition, text) { + if (!condition) { + abort("Assertion failed: " + text); + } +} + +function getCFunc(ident) { + var func = Module["_" + ident]; + assert(func, "Cannot call unknown function " + ident + ", make sure it is exported"); + return func; +} + +function ccall(ident, returnType, argTypes, args, opts) { + var toC = { + "string": function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 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; +} + +var ALLOC_NONE = 3; + +var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined; + +function UTF8ArrayToString(heap, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr; + if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { + return UTF8Decoder.decode(heap.subarray(idx, endPtr)); + } else { + var str = ""; + while (idx < endPtr) { + var u0 = heap[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heap[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue; + } + var u2 = heap[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2; + } else { + if ((u0 & 248) != 240) 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 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } + } + } + return str; +} + +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; +} + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | u1 & 1023; + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | u >> 6; + heap[outIdx++] = 128 | u & 63; + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | u >> 12; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } else { + if (outIdx + 3 >= endIdx) break; + if (u >= 2097152) 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++] = 240 | u >> 18; + heap[outIdx++] = 128 | u >> 12 & 63; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } + } + heap[outIdx] = 0; + return outIdx - startIdx; +} + +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); +} + +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023; + if (u <= 127) ++len; else if (u <= 2047) len += 2; else if (u <= 65535) len += 3; else len += 4; + } + return len; +} + +var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined; + +function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!"); + var endPtr = ptr; + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + while (!(idx >= maxIdx) && HEAPU16[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 || i == maxBytesToRead / 2) return str; + ++i; + str += String.fromCharCode(codeUnit); + } + } +} + +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!"); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + HEAP16[outPtr >> 1] = codeUnit; + outPtr += 2; + } + HEAP16[outPtr >> 1] = 0; + return outPtr - startPtr; +} + +function lengthBytesUTF16(str) { + return str.length * 2; +} + +function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!"); + var i = 0; + var str = ""; + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[ptr + i * 4 >> 2]; + if (utf32 == 0) break; + ++i; + if (utf32 >= 65536) { + var ch = utf32 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } else { + str += String.fromCharCode(utf32); + } + } + return str; +} + +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!"); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023; + } + HEAP32[outPtr >> 2] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + HEAP32[outPtr >> 2] = 0; + return outPtr - startPtr; +} + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) ++i; + len += 4; + } + return len; +} + +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); +} + +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === str.charCodeAt(i) & 255); + HEAP8[buffer++ >> 0] = str.charCodeAt(i); + } + if (!dontAddNull) HEAP8[buffer >> 0] = 0; +} + +var WASM_PAGE_SIZE = 65536; + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - x % multiple; + } + return x; +} + +var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module["HEAP8"] = HEAP8 = new Int8Array(buf); + Module["HEAP16"] = HEAP16 = new Int16Array(buf); + Module["HEAP32"] = HEAP32 = new Int32Array(buf); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buf); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buf); +} + +var STACK_BASE = 5486272, STACK_MAX = 243392, DYNAMIC_BASE = 5486272, DYNAMICTOP_PTR = 243232; + +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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +assert(INITIAL_INITIAL_MEMORY >= TOTAL_STACK, "INITIAL_MEMORY should be larger than TOTAL_STACK, was " + INITIAL_INITIAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")"); + +assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, "JS engine does not provide full typed array support"); + +if (Module["wasmMemory"]) { + wasmMemory = Module["wasmMemory"]; +} else { + wasmMemory = new WebAssembly.Memory({ + "initial": INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE, + "maximum": 2147483648 / WASM_PAGE_SIZE + }); +} + +if (wasmMemory) { + buffer = wasmMemory.buffer; +} + +INITIAL_INITIAL_MEMORY = buffer.byteLength; + +assert(INITIAL_INITIAL_MEMORY % WASM_PAGE_SIZE === 0); + +assert(65536 % WASM_PAGE_SIZE === 0); + +updateGlobalBufferAndViews(buffer); + +HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE; + +function writeStackCookie() { + assert((STACK_MAX & 3) == 0); + HEAPU32[(STACK_MAX >> 2) + 1] = 34821223; + HEAPU32[(STACK_MAX >> 2) + 2] = 2310721022; + HEAP32[0] = 1668509029; +} + +function checkStackCookie() { + var cookie1 = HEAPU32[(STACK_MAX >> 2) + 1]; + var cookie2 = HEAPU32[(STACK_MAX >> 2) + 2]; + if (cookie1 != 34821223 || cookie2 != 2310721022) { + abort("Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" + cookie2.toString(16) + " " + cookie1.toString(16)); + } + if (HEAP32[0] !== 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!"); +} + +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 25459; + if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian!"; +})(); + +function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == "function") { + callback(Module); + 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__ = []; + +var __ATINIT__ = []; + +var __ATMAIN__ = []; + +var __ATPOSTRUN__ = []; + +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 addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +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_ceil = Math.ceil; + +var Math_floor = Math.floor; + +var Math_min = Math.min; + +var runDependencies = 0; + +var runDependencyWatcher = null; + +var dependenciesFulfilled = null; + +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") { + 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)"); + } + }, 1e4); + } + } 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(); + } + } +} + +Module["preloadedImages"] = {}; + +Module["preloadedAudios"] = {}; + +function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + what += ""; + err(what); + ABORT = true; + EXITSTATUS = 1; + var output = "abort(" + what + ") at " + stackTrace(); + what = output; + var e = new WebAssembly.RuntimeError(what); + readyPromiseReject(e); + throw e; +} + +function hasPrefix(str, prefix) { + return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0; +} + +var dataURIPrefix = "data:application/octet-stream;base64,"; + +function isDataURI(filename) { + return hasPrefix(filename, dataURIPrefix); +} + +var fileURIPrefix = "file://"; + +function isFileURI(filename) { + return hasPrefix(filename, fileURIPrefix); +} + +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module["asm"]; + } + assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization"); + assert(!runtimeExited, "native function `" + displayName + "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)"); + if (!asm[name]) { + assert(asm[name], "exported native function `" + displayName + "` not found"); + } + return asm[name].apply(null, arguments); + }; +} + +var wasmBinaryFile = "jxl_dec.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 (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function" && !isFileURI(wasmBinaryFile)) { + return fetch(wasmBinaryFile, { + credentials: "same-origin" + }).then(function(response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response["arrayBuffer"](); + }).catch(function() { + return getBinary(); + }); + } + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); +} + +function createWasm() { + var info = { + "env": asmLibraryArg, + "wasi_snapshot_preview1": asmLibraryArg + }; + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + removeRunDependency("wasm-instantiate"); + } + addRunDependency("wasm-instantiate"); + var trueModule = Module; + function receiveInstantiatedSource(output) { + assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"); + trueModule = null; + 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); + }); + } + function instantiateAsync() { + if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && !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) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + 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 {}; +} + +var tempDouble; + +var tempI64; + +__ATINIT__.push({ + func: function() { + ___wasm_call_ctors(); + } +}); + +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) { + 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)"); +} + +function ___cxa_atexit(a0, a1) { + return _atexit(a0, a1); +} + +var exceptionInfos = {}; + +var exceptionLast = 0; + +function __ZSt18uncaught_exceptionv() { + return __ZSt18uncaught_exceptionv.uncaught_exceptions > 0; +} + +function ___cxa_throw(ptr, type, destructor) { + exceptionInfos[ptr] = { + ptr: ptr, + adjusted: [ ptr ], + type: type, + destructor: destructor, + refcount: 0, + caught: false, + rethrown: false + }; + exceptionLast = ptr; + if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) { + __ZSt18uncaught_exceptionv.uncaught_exceptions = 1; + } else { + __ZSt18uncaught_exceptionv.uncaught_exceptions++; + } + throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch."; +} + +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; +} + +var PATH = { + splitPath: function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray: function(parts, allowAboveRoot) { + 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 (allowAboveRoot) { + for (;up; up--) { + parts.unshift(".."); + } + } + return parts; + }, + normalize: function(path) { + var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/"; + 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) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename: function(path) { + 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(); + if (typeof path !== "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charAt(0) === "/"; + } + 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() {}, + shutdown: function() {}, + 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) { + stream.tty.ops.flush(stream.tty); + }, + flush: function(stream) { + stream.tty.ops.flush(stream.tty); + }, + read: function(stream, buffer, offset, length, pos) { + 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) { + 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) { + 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") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + 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); + } + }, + 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, 0); + }, + createNode: function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + 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; + 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(); + 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; + } + return node.contents; + }, + getFileDataAsTypedArray: function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents); + }, + expandFileStorage: function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + return; + }, + resizeFileStorage: function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + return; + } + if (!node.contents || node.contents.subarray) { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); + } + node.usedBytes = newSize; + return; + } + 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 = {}; + 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); + 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 (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); + } + } + } + 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 | 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) { + 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) { + assert(!(buffer instanceof ArrayBuffer)); + if (buffer.buffer === HEAP8.buffer) { + if (canOwn) { + warnOnce("file packager has copied file data into memory, but in memory growth we are forced to copy it again (see --no-heap-copy)"); + } + canOwn = false; + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + 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) { + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) { + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek: 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, address, length, position, prot, flags) { + assert(address === 0); + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && contents.buffer === buffer) { + allocated = false; + ptr = contents.byteOffset; + } else { + 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; + ptr = FS.mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.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) { + return 0; + } + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + 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) { + throw new FS.ErrnoError(32); + } + var parts = PATH.normalizeArray(path.split("/").filter(function(p) { + return !!p; + }), false); + 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) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root; + } + } + 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) { + 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; + } + } + 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; + } + 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" || flags & 512) { + 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 = 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; + } + } + }; + } + 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); + stream.stream_ops = device.stream_ops; + 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 & 255; + }, + 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); + } + } + 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") { + 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; + 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: [] + }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + 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); + } + 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; + } + }); + node.mounted = null; + 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; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir: function(path, mode) { + mode = mode !== undefined ? mode : 511; + 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; + } + 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); + 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); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28); + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + 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 (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); + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + 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) { + 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() + }); + }, + 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 : 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) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + if (flags & 512) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false + }, fd_start, fd_end); + 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; + 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) { + 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, address, length, position, prot, flags) { + 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, address, 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() { + FS.mkdir("/dev"); + 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)); + 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)); + var random_device; + if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") { + var randomBuffer = new Uint8Array(1); + random_device = function() { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0]; + }; + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + random_device = function() { + return crypto_module["randomBytes"](1)[0]; + }; + } catch (e) {} + } else {} + if (!random_device) { + 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); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }, + createSpecialDirectories: function() { + 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, 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; + return ret; + } + }; + return node; + } + }, {}, "/proc/self/fd"); + }, + createStandardStreams: function() { + 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"); + } + 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 = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = 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]; + if (this.stack) { + 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; + [ 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(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }, + quit: function() { + FS.init.initialized = false; + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + 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) { + 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) {} + 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; + } + 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); + FS.registerDevice(dev, { + open: function(stream) { + stream.seekable = false; + }, + close: function(stream) { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: function(stream, buffer, offset, length, pos) { + 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_) { + try { + 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) { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = 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() { + 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; + if (!hasByteServing) chunkSize = datalength; + 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!"); + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + 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(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; + end = Math.min(end, datalength - 1); + 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) { + chunkSize = datalength = 1; + 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: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: 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); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, { + usedBytes: { + get: function() { + return this.contents.length; + } + } + }); + 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); + }; + }); + 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) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + 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(); + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + 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; + 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; + }, + mmapAlloc: function(size) { + var alignedSize = alignMemory(size, 16384); + var ptr = _malloc(alignedSize); + while (size < alignedSize) HEAP8[ptr + size++] = 0; + return ptr; + } +}; + +var SYSCALLS = { + mappings: {}, + DEFAULT_POLLMASK: 5, + umask: 511, + calculateAt: function(dirfd, path) { + if (path[0] !== "/") { + 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))) { + 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 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 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() / 1e3 | 0; + HEAP32[buf + 60 >> 2] = 0; + HEAP32[buf + 64 >> 2] = stat.mtime.getTime() / 1e3 | 0; + HEAP32[buf + 68 >> 2] = 0; + HEAP32[buf + 72 >> 2] = stat.ctime.getTime() / 1e3 | 0; + HEAP32[buf + 76 >> 2] = 0; + tempI64 = [ stat.ino >>> 0, (tempDouble = stat.ino, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 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) { + 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) { + 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); + HEAP8[buf + len] = endChar; + return len; + }, + doAccess: function(path, amode) { + if (amode & ~7) { + 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 && 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; + } + 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 ___sys_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: + { + if (!stream.tty) return -59; + return 0; + } + + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: + { + if (!stream.tty) return -59; + return 0; + } + + case 21519: + { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0; + } + + case 21520: + { + if (!stream.tty) return -59; + return -28; + } + + case 21531: + { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + + case 21523: + { + if (!stream.tty) return -59; + return 0; + } + + case 21524: + { + if (!stream.tty) return -59; + return 0; + } + + default: + abort("bad ioctl syscall " + op); + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} + +function syscallMunmap(addr, len) { + if ((addr | 0) === -1 || len === 0) { + return -28; + } + 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_rmdir(path) { + try { + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} + +function ___sys_unlink(path) { + try { + path = SYSCALLS.getStr(path); + FS.unlink(path); + return 0; + } 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); + 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); + } +} + +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) { + return !!wt; + }, + "toWireType": function(destructors, o) { + return o ? trueValue : falseValue; + }, + "argPackAdvance": 8, + "readValueFromPointer": function(pointer) { + 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 + }); +} + +function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + return leftClass === rightClass && left === right; +} + +function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType + }; +} + +function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + " instance already deleted"); +} + +var finalizationGroup = false; + +function detachFinalizer(handle) {} + +function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } +} + +function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$); + } +} + +function attachFinalizer(handle) { + if ("undefined" === typeof FinalizationGroup) { + attachFinalizer = function(handle) { + return handle; + }; + return handle; + } + finalizationGroup = new FinalizationGroup(function(iter) { + for (var result = iter.next(); !result.done; result = iter.next()) { + var $$ = result.value; + if (!$$.ptr) { + console.warn("object already deleted: " + $$.ptr); + } else { + releaseClassHandle($$); + } + } + }); + attachFinalizer = function(handle) { + finalizationGroup.register(handle, handle.$$, handle.$$); + return handle; + }; + detachFinalizer = function(handle) { + finalizationGroup.unregister(handle.$$); + }; + return attachFinalizer(handle); +} + +function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { + $$: { + value: shallowCopyInternalPointer(this.$$) + } + })); + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } +} + +function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + detachFinalizer(this); + releaseClassHandle(this.$$); + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined; + } +} + +function ClassHandle_isDeleted() { + return !this.$$.ptr; +} + +var delayFunction = undefined; + +var deletionQueue = []; + +function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj["delete"](); + } +} + +function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; +} + +function init_ClassHandle() { + ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf; + ClassHandle.prototype["clone"] = ClassHandle_clone; + ClassHandle.prototype["delete"] = ClassHandle_delete; + ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted; + ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater; +} + +function ClassHandle() {} + +var registeredPointers = {}; + +function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + proto[methodName] = function() { + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!"); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } +} + +function exposePublicSymbol(name, value, numArguments) { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) { + throwBindingError("Cannot register public name '" + name + "' twice"); + } + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!"); + } + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } +} + +function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; +} + +function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; +} + +function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; +} + +function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + if (this.isSmartPointer) { + if (undefined === handle.$$.smartPtr) { + throwBindingError("Passing raw pointer to smart pointer is illegal"); + } + switch (this.sharingPolicy) { + case 0: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name); + } + break; + + case 1: + ptr = handle.$$.smartPtr; + break; + + case 2: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle["clone"](); + ptr = this.rawShare(ptr, __emval_register(function() { + clonedHandle["delete"](); + })); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + + default: + throwBindingError("Unsupporting sharing policy"); + } + } + return ptr; +} + +function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (handle.$$.ptrType.isConst) { + throwBindingError("Cannot convert argument of type " + handle.$$.ptrType.name + " to parameter type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; +} + +function simpleReadValueFromPointer(pointer) { + return this["fromWireType"](HEAPU32[pointer >> 2]); +} + +function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; +} + +function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } +} + +function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle["delete"](); + } +} + +function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; + } + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); +} + +function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; +} + +function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (registeredInstances.hasOwnProperty(k)) { + rv.push(registeredInstances[k]); + } + } + return rv; +} + +function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } +} + +function init_embind() { + Module["getInheritedInstanceCount"] = getInheritedInstanceCount; + Module["getLiveInheritedInstances"] = getLiveInheritedInstances; + Module["flushPendingDeletes"] = flushPendingDeletes; + Module["setDelayFunction"] = setDelayFunction; +} + +var registeredInstances = {}; + +function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError("ptr should not be undefined"); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; +} + +function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; +} + +function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError("makeClassHandle requires ptr and ptrType"); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError("Both smartPtrType and smartPtr must be specified"); + } + record.count = { + value: 1 + }; + return attachFinalizer(Object.create(prototype, { + $$: { + value: record + } + })); +} + +function RegisteredPointer_fromWireType(ptr) { + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance["clone"](); + } else { + var rv = registeredInstance["clone"](); + this.destructor(ptr); + return rv; + } + } + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr + }); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr + }); + } + } + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr + }); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp + }); + } +} + +function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype["argPackAdvance"] = 8; + RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer; + RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType; +} + +function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this["toWireType"] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this["toWireType"] = genericPointerToWireType; + } +} + +function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError("Replacing nonexistant public symbol"); + } + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } +} + +function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + function makeDynCaller(dynCall) { + var args = []; + for (var i = 1; i < signature.length; ++i) { + args.push("a" + i); + } + var name = "dynCall_" + signature + "_" + rawFunction; + var body = "return function " + name + "(" + args.join(", ") + ") {\n"; + body += " return dynCall(rawFunction" + (args.length ? ", " : "") + args.join(", ") + ");\n"; + body += "};\n"; + return new Function("dynCall", "rawFunction", body)(dynCall, rawFunction); + } + var dc = Module["dynCall_" + signature]; + var fp = makeDynCaller(dc); + if (typeof fp !== "function") { + throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction); + } + return fp; +} + +var UnboundTypeError = undefined; + +function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; +} + +function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([ ", " ])); +} + +function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + exposePublicSymbol(legalFunctionName, function() { + throwUnboundTypeError("Cannot construct " + name + " due to unbound types", [ baseClassRawType ]); + }); + whenDependentTypesAreResolved([ rawType, rawPointerType, rawConstPointerType ], baseClassRawType ? [ baseClassRawType ] : [], function(base) { + base = base[0]; + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + var constructor = createNamedFunction(legalFunctionName, function() { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name); + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!"); + } + return body.apply(this, arguments); + }); + var instancePrototype = Object.create(basePrototype, { + constructor: { + value: constructor + } + }); + constructor.prototype = instancePrototype; + var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast); + var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false); + var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false); + var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false); + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter + }; + replacePublicSymbol(legalFunctionName, constructor); + return [ referenceConverter, pointerConverter, constPointerConverter ]; + }); +} + +function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } +} + +function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(humanName + ' with invalid "this": ' + this_); + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError(humanName + ' incompatible with "this" of type ' + this_.constructor.name); + } + if (!this_.$$.ptr) { + throwBindingError("cannot call emscripten binding method " + humanName + " on deleted object"); + } + return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass); +} + +function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + whenDependentTypesAreResolved([], [ classType ], function(classType) { + classType = classType[0]; + var humanName = classType.name + "." + fieldName; + var desc = { + get: function() { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [ getterReturnType, setterArgumentType ]); + }, + enumerable: true, + configurable: true + }; + if (setter) { + desc.set = function() { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [ getterReturnType, setterArgumentType ]); + }; + } else { + desc.set = function(v) { + throwBindingError(humanName + " is a read-only property"); + }; + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + whenDependentTypesAreResolved([], setter ? [ getterReturnType, setterArgumentType ] : [ getterReturnType ], function(types) { + var getterReturnType = types[0]; + var desc = { + get: function() { + var ptr = validateThis(this, classType, humanName + " getter"); + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, + enumerable: true + }; + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function(v) { + var ptr = validateThis(this, classType, humanName + " setter"); + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, v)); + runDestructors(destructors); + }; + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return []; + }); + return []; + }); +} + +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 __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 + }); +} + +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) { + 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 + }); +} + +function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function"); + } + var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {}); + dummy.prototype = constructor.prototype; + var obj = new dummy(); + var r = constructor.apply(obj, argumentList); + return r instanceof Object ? r : obj; +} + +function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + var isClassMethodFunc = argTypes[1] !== null && classType !== null; + var needsDestructorStack = false; + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + needsDestructorStack = true; + break; + } + } + var returns = argTypes[0].name !== "void"; + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i !== 0 ? ", " : "") + "arg" + i; + argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired"; + } + var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n"; + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = [ "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam" ]; + var args2 = [ throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1] ]; + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n"; + } + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n"; + args1.push("argType" + i); + args2.push(argTypes[i + 2]); + } + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired; + } + invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n"; + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired"; + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n"; + args1.push(paramName + "_dtor"); + args2.push(argTypes[i].destructorFunction); + } + } + } + if (returns) { + invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n"; + } else {} + invokerFnBody += "}\n"; + args1.push(invokerFnBody); + var invokerFunction = new_(Function, args1).apply(null, args2); + return invokerFunction; +} + +function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]); + } + return array; +} + +function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + rawInvoker = embind__requireFunction(signature, rawInvoker); + exposePublicSymbol(name, function() { + throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes); + }, argCount - 1); + whenDependentTypesAreResolved([], argTypes, function(argTypes) { + var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1)); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1); + return []; + }); +} + +function integerReadValueFromPointer(name, shift, signed) { + 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) { + 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) { + 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 + }); +} + +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]; + var data = heap[handle + 1]; + 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 = name === "std::string"; + registerType(rawType, { + name: name, + "fromWireType": function(value) { + var length = HEAPU32[value >> 2]; + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } 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; + }; + } + 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) { + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + _free(value); + return str; + }, + "toWireType": function(destructors, value) { + if (!(typeof value === "string")) { + throwBindingError("Cannot pass non-string to C++ string type " + name); + } + 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, + name: name, + "argPackAdvance": 0, + "fromWireType": function() { + return undefined; + }, + "toWireType": function(destructors, o) { + return undefined; + } + }); +} + +function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1; + } +} + +function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; +} + +function __emval_take_value(type, argv) { + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](argv); + return __emval_register(v); +} + +function _abort() { + abort(); +} + +function _emscripten_get_sbrk_ptr() { + return 243232; +} + +function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); +} + +function _emscripten_get_heap_size() { + return HEAPU8.length; +} + +function emscripten_realloc_buffer(size) { + try { + wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16); + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1; + } catch (e) { + console.error("emscripten_realloc_buffer: Attempted to grow heap from " + buffer.byteLength + " bytes to " + size + " bytes, but got error: " + e); + } +} + +function _emscripten_resize_heap(requestedSize) { + requestedSize = requestedSize >>> 0; + var oldSize = _emscripten_get_heap_size(); + assert(requestedSize > oldSize); + var PAGE_MULTIPLE = 65536; + var maxHeapSize = 2147483648; + if (requestedSize > maxHeapSize) { + err("Cannot enlarge memory, asked to go up to " + requestedSize + " bytes, but the limit is " + maxHeapSize + " bytes!"); + return false; + } + var minHeapSize = 16777216; + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), PAGE_MULTIPLE)); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true; + } + } + err("Failed to grow the heap from " + oldSize + " bytes to " + newSize + " bytes, not enough memory!"); + return false; +} + +var ENV = {}; + +function getExecutableName() { + return thisProgram || "./this.program"; +} + +function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8"; + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": lang, + "_": getExecutableName() + }; + 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_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doReadv(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 _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 4294967296; + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + var DOUBLE_LIMIT = 9007199254740992; + 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 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + HEAP32[newOffset >> 2] = tempI64[0], HEAP32[newOffset + 4 >> 2] = tempI64[1]; + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + 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; + } +} + +var ___tm_current = 243248; + +var ___tm_timezone = (stringToUTF8("GMT", 243296, 4), 243296); + +function _gmtime_r(time, tmPtr) { + var date = new Date(HEAP32[time >> 2] * 1e3); + HEAP32[tmPtr >> 2] = date.getUTCSeconds(); + HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes(); + HEAP32[tmPtr + 8 >> 2] = date.getUTCHours(); + HEAP32[tmPtr + 12 >> 2] = date.getUTCDate(); + HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth(); + HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900; + HEAP32[tmPtr + 24 >> 2] = date.getUTCDay(); + HEAP32[tmPtr + 36 >> 2] = 0; + HEAP32[tmPtr + 32 >> 2] = 0; + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0; + HEAP32[tmPtr + 28 >> 2] = yday; + HEAP32[tmPtr + 40 >> 2] = ___tm_timezone; + return tmPtr; +} + +function _gmtime(time) { + return _gmtime_r(time, ___tm_current); +} + +function _round(d) { + d = +d; + return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5); +} + +function _roundf(d) { + d = +d; + return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5); +} + +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++]) {} + 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()) { + 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 { + newDate.setDate(newDate.getDate() + days); + return newDate; + } + } + return newDate; +} + +function _strftime(s, maxsize, format, tm) { + 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); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + 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: + return new Date(janFourth.getFullYear() - 1, 11, 29); + + case 1: + return janFourth; + + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + + case 6: + 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) { + 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) { + 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) { + 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) { + 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); + if (compareByDay(firstSunday, endDate) < 0) { + 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) { + 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) { + return "53"; + } + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + return "01"; + } + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) { + daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate(); + } else { + daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate(); + } + return leadingNulls(Math.ceil(daysDifference / 7), 2); + }, + "%w": function(date) { + return date.tm_wday; + }, + "%W": function(date) { + 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); + 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) { + return (date.tm_year + 1900).toString().substring(2); + }, + "%Y": function(date) { + return date.tm_year + 1900; + }, + "%z": function(date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + 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); +} + +function _time(ptr) { + var ret = Date.now() / 1e3 | 0; + if (ptr) { + HEAP32[ptr >> 2] = ret; + } + return ret; +} + +var FSNode = function(parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + 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 | 73; + +var writeMode = 146; + +Object.defineProperties(FSNode.prototype, { + read: { + get: function() { + return (this.mode & readMode) === readMode; + }, + set: function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: function() { + return (this.mode & writeMode) === writeMode; + }, + set: function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: 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_ClassHandle(); + +init_RegisteredPointer(); + +init_embind(); + +UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError"); + +init_emval(); + +var ASSERTIONS = true; + +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +var asmLibraryArg = { + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_atexit": ___cxa_atexit, + "__cxa_throw": ___cxa_throw, + "__handle_stack_overflow": ___handle_stack_overflow, + "__map_file": ___map_file, + "__sys_ioctl": ___sys_ioctl, + "__sys_munmap": ___sys_munmap, + "__sys_open": ___sys_open, + "__sys_rmdir": ___sys_rmdir, + "__sys_unlink": ___sys_unlink, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_embind_register_class_property": __embind_register_class_property, + "_embind_register_emval": __embind_register_emval, + "_embind_register_float": __embind_register_float, + "_embind_register_function": __embind_register_function, + "_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, + "_emval_decref": __emval_decref, + "_emval_incref": __emval_incref, + "_emval_take_value": __emval_take_value, + "abort": _abort, + "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_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "gmtime": _gmtime, + "memory": wasmMemory, + "round": _round, + "roundf": _roundf, + "setTempRet0": _setTempRet0, + "strftime_l": _strftime_l, + "table": wasmTable, + "time": _time +}; + +var asm = createWasm(); + +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors"); + +var _malloc = Module["_malloc"] = createExportWrapper("malloc"); + +var _free = Module["_free"] = createExportWrapper("free"); + +var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location"); + +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); + +var ___getTypeName = Module["___getTypeName"] = createExportWrapper("__getTypeName"); + +var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = createExportWrapper("__embind_register_native_and_builtin_types"); + +var __get_tzname = Module["__get_tzname"] = createExportWrapper("_get_tzname"); + +var __get_daylight = Module["__get_daylight"] = createExportWrapper("_get_daylight"); + +var __get_timezone = Module["__get_timezone"] = createExportWrapper("_get_timezone"); + +var _setThrew = Module["_setThrew"] = createExportWrapper("setThrew"); + +var stackSave = Module["stackSave"] = createExportWrapper("stackSave"); + +var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore"); + +var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc"); + +var ___set_stack_limit = Module["___set_stack_limit"] = createExportWrapper("__set_stack_limit"); + +var __growWasmMemory = Module["__growWasmMemory"] = createExportWrapper("__growWasmMemory"); + +var dynCall_ii = Module["dynCall_ii"] = createExportWrapper("dynCall_ii"); + +var dynCall_vi = Module["dynCall_vi"] = createExportWrapper("dynCall_vi"); + +var dynCall_iii = Module["dynCall_iii"] = createExportWrapper("dynCall_iii"); + +var dynCall_viii = Module["dynCall_viii"] = createExportWrapper("dynCall_viii"); + +var dynCall_vii = Module["dynCall_vii"] = createExportWrapper("dynCall_vii"); + +var dynCall_v = Module["dynCall_v"] = createExportWrapper("dynCall_v"); + +var dynCall_iidiiii = Module["dynCall_iidiiii"] = createExportWrapper("dynCall_iidiiii"); + +var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = createExportWrapper("dynCall_iiiiiii"); + +var dynCall_iiii = Module["dynCall_iiii"] = createExportWrapper("dynCall_iiii"); + +var dynCall_iiiii = Module["dynCall_iiiii"] = createExportWrapper("dynCall_iiiii"); + +var dynCall_iiiiii = Module["dynCall_iiiiii"] = createExportWrapper("dynCall_iiiiii"); + +var dynCall_viiiiii = Module["dynCall_viiiiii"] = createExportWrapper("dynCall_viiiiii"); + +var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"); + +var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = createExportWrapper("dynCall_viiiiiii"); + +var dynCall_diid = Module["dynCall_diid"] = createExportWrapper("dynCall_diid"); + +var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = createExportWrapper("dynCall_iiiiiiii"); + +var dynCall_idi = Module["dynCall_idi"] = createExportWrapper("dynCall_idi"); + +var dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii"); + +var dynCall_viiii = Module["dynCall_viiii"] = createExportWrapper("dynCall_viiii"); + +var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = createExportWrapper("dynCall_iiiiiiiii"); + +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj"); + +var dynCall_iiiiij = Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij"); + +var dynCall_iiiiid = Module["dynCall_iiiiid"] = createExportWrapper("dynCall_iiiiid"); + +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj"); + +var dynCall_viiiii = Module["dynCall_viiiii"] = createExportWrapper("dynCall_viiiii"); + +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)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "ccall")) Module["ccall"] = function() { + abort("'ccall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "cwrap")) Module["cwrap"] = function() { + abort("'cwrap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "setValue")) Module["setValue"] = function() { + abort("'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "getValue")) Module["getValue"] = function() { + abort("'getValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +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)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString")) Module["UTF8ToString"] = function() { + abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = function() { + abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = function() { + abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +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)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = function() { + abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +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, "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, "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, "traverseStack")) Module["traverseStack"] = function() { + abort("'traverseStack' 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, "withBuiltinMalloc")) Module["withBuiltinMalloc"] = function() { + abort("'withBuiltinMalloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray")) Module["readAsmConstArgsArray"] = function() { + abort("'readAsmConstArgsArray' 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, "getExecutableName")) Module["getExecutableName"] = function() { + abort("'getExecutableName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "listenOnce")) Module["listenOnce"] = function() { + abort("'listenOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext")) Module["autoResumeAudioContext"] = function() { + abort("'autoResumeAudioContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "abortStackOverflow")) Module["abortStackOverflow"] = function() { + abort("'abortStackOverflow' 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, "maybeCStringToJsString")) Module["maybeCStringToJsString"] = function() { + abort("'maybeCStringToJsString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget")) Module["findEventTarget"] = function() { + abort("'findEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget")) Module["findCanvasEventTarget"] = function() { + abort("'findCanvasEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate")) Module["polyfillSetImmediate"] = function() { + abort("'polyfillSetImmediate' 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, "checkWasiClock")) Module["checkWasiClock"] = function() { + abort("'checkWasiClock' 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, "exceptionLast")) Module["exceptionLast"] = function() { + abort("'exceptionLast' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught")) Module["exceptionCaught"] = function() { + abort("'exceptionCaught' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exceptionInfos")) Module["exceptionInfos"] = function() { + abort("'exceptionInfos' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exception_deAdjust")) Module["exception_deAdjust"] = function() { + abort("'exception_deAdjust' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef")) Module["exception_addRef"] = function() { + abort("'exception_addRef' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef")) Module["exception_decRef"] = function() { + abort("'exception_decRef' 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, "tempFixedLengthArray")) Module["tempFixedLengthArray"] = function() { + abort("'tempFixedLengthArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers")) Module["miniTempWebGLFloatBuffers"] = function() { + abort("'miniTempWebGLFloatBuffers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType")) Module["heapObjectForWebGLType"] = function() { + abort("'heapObjectForWebGLType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap")) Module["heapAccessShiftForWebGLHeap"] = function() { + abort("'heapAccessShiftForWebGLHeap' 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, "computeUnpackAlignedImageSize")) Module["computeUnpackAlignedImageSize"] = function() { + abort("'computeUnpackAlignedImageSize' 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, "writeGLArray")) Module["writeGLArray"] = function() { + abort("'writeGLArray' 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; + +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; + +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +dependenciesFulfilled = function runCaller() { + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; +}; + +function run(args) { + args = args || arguments_; + if (runDependencies > 0) { + return; + } + writeStackCookie(); + preRun(); + if (runDependencies > 0) return; + function doRun() { + if (calledRun) return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + preMain(); + readyPromiseResolve(Module); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function() { + setTimeout(function() { + Module["setStatus"](""); + }, 1); + doRun(); + }, 1); + } else { + doRun(); + } + checkStackCookie(); +} + +Module["run"] = run; + +function checkUnflushedContent() { + var print = out; + var printErr = err; + var has = false; + out = err = function(x) { + has = true; + }; + try { + var flush = Module["_fflush"]; + if (flush) flush(0); + [ "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."); + } +} + +if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()(); + } +} + +noExitRuntime = true; + +run(); + + + return jxl_dec.ready +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = jxl_dec; + else if (typeof define === 'function' && define['amd']) + define([], function() { return jxl_dec; }); + else if (typeof exports === 'object') + exports["jxl_dec"] = jxl_dec; + \ No newline at end of file diff --git a/codecs/jxl/dec/jxl_dec.wasm b/codecs/jxl/dec/jxl_dec.wasm new file mode 100644 index 0000000000000000000000000000000000000000..b514dc160e3bf1d9217d8973b724055d71c18651 GIT binary patch literal 1615187 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≻J-8HgW*ttJsT_`a^vdAqtoGju$g13AW6aZA$Q&SLV z`$Mf$f$le~%lLi=p$Y5!9d+Mj$<+7CdZ<`LD0;g(#I15p|7#*_w5K)XN5(g=cx}6} zqur$N>@lap8w3)f8Hp3!&lP%EOKk_J#?)wx?s?PDW58m0F#~?UDF!WctAw-BhyfWRMV{o%py7n_*<|Sjw#Pr+WLyXX{ zJ!aBNl-{j`pm=KCW($JJJb}lGsai&eQ!C+CMMa02bG%M1+^PHeG~&nXAPNo?DS{#~ zoA#Y5*nBHj6215MRnI&APk%A>zGJRVs#o6t3KStb8kLf_)Y!gw|g&_?cn=F!zR}3IUK1V;f{0ShXy6gE5P$*oG>1vULMKC<81h zLx7#MVSrc60eD3TuuQ}V^yMzdrEYFG-1gOvAYB!N4 z-18XcUUglZqY{$rf>fWHc6(i1O2-q#irc5Y2;?cc*1)l zagtY`z(?)RS_Yi)zZpqM)2lxw6i8*D^6i%00EbSJIZ+1wRJCk5Pxu}PBsgG~X6#JH z_{v#W`Fbr^?*E^;cLBHSEbD#8Wv;m{W382uWUV&M3hkJ)rKFcMX$h+(DeW4eH(D+| z9NdR}w);Hw*&g+oE7hhAQO^VI;vS$IB2=yJs(~G~U~yL{ST0I{f(5GEN0t~3SI-8@}$+`ilUz2AHP-p`&l`kt>-8d`fkaZ523z9*Tcka41z zd6CIjo(jHL<98&g8zhgn#2kGIX(U2xKobPQqO~SFO6$|QlgbAr@x%GhU24g)Z=nM$ zjq4N2>k#>|>kXqn3B*VukhCdZ)gx8L*w1i93Vw&oEcBvCxr*w?KqfpEjIz&m-T8yZ zI>)vQ&;k+Xerr8e#sY~o*3g7HjH+uXp%HN=I?ujcQ5$R5jSjyp;Vtn~#3Vgh41jj@ zA*e*$Nxrn5vECj|gjc`^bY?WQeN0SBGTr+pS~S9*SQ!o;M0em54Yk6;+6 zUlqwaKPbpnA5Sj*pcj7U2Ya4=plx8%P`9cn9H$S#dz8rHVqi*IRL z+ZT&ety~QG{-?$VF23cb+sQ5Y2Z6Wx^|7}XcJ~g!)Cl~_MYr5?OLnQo^C~OH0jd2X zp;@nZ>HmSuly`pB$M{64e#pX++|2*#%YQc00kynx*EQ96&rF_(*JPnb5VH6!>W3v7 zhtaX0U)@=W;W0ECp#RLJDZo<#*8$ku9xu`H#d_ zWX~uP*JB&9_yHjVvb&_t57F3rl6XQrLOC6vu~rjDtS_lcGBU|D+EzGhdlDlFuQ^}J zSb23Mal5HL$~A1gGKb|WAU@@d;Z*kgabk2`0x)ZS1XOiWE&U@g1^nj~1QIiy$WLeU zgNPUYoE_|V^a8Zpryk{yFtbde(+VM6BX&b2{naggH`i+A9?3s0)JbHc#r;O#btMG= zuE7;dFc@tuF@T0_OA2BJjLncC$g1kd-IKFDKoC-taj2?G|%%DV@Q@_^t7)uD=x7fGJN4x8fx$;6#{Ex7ewfU|BN~zz2 zAN;9XK*ub*wadJQ7bcUWpl^pbprOO!V>#wFlP4Gf)8gl@(?5aH48&b9ayFGD|Guw* zgJQko>V$d4aHYdb4eX;%Snpe&|6}W3yW_uVYO8A~9?n@1l;%NNb2n7H>Qj}w;nVA@ z<37JWp1rhYN&^NOdW?wgp>F1L≀TK*!Ep@rs%N4J|8r)N4|&`LkFxSO{kZBAC?A zNFz08Ks(Ol70!O~dsTz`%z8L3cH}7ktU4~~Qz&d#I3^m*i@S69v5C;z#PxvK4V{|} zl98}2C!ah}jq*c<0oK2Z{JTtXbw6C5azl0&7u%C)*P2&yFeWplEU|A(-g~2-HvH+0 zyT)(awUWG&I79VLNw8wmRCYu(QAF|p$K{H+878%zG4r6+5wozc@RtY3l)p7*6rgvy zXLq@FAIGlp!IO3Z9;SMZzf?VO`6Tc04p2juox*{ne=nV_Yz`J)Y;TVBLO=I4LUx#~2Le@$5SzD?9PGpd0&|3~(fCiy=B>>>KA zO0&0wWrmzP*f5}|`%9mdC`_Iv8XWG);J5iZHkCISrS7c+yI|EH7XDC&vU8b`VK9Z| zRDR&5J;r2gagjijn=GSYYPvt-Ag~{*K{&XQ_{4FGA9+*GmKOwdKq@NI-ajy1*b{h` zcJd>-xd#(?s>@`!lchQdfwqQCOd+ljKvC?K`Zbo|e`UsnT!T9=!ZjG>zq=lypJmhP zwBhoftk34SbUI;=mKn>n*%o0Y9f68e{+Fb@^CtQJzF;D^dkSn^jqJHXMt0Un z!UdempJ3AUi@E9o#>10rt@Q&OqTk-K^(`(R{FESi<8eduj!!Y-A(-B6PxH6Ismpu( zi}AhXN(JTn^(f`MqE#UM0*QNxN!x@8lw#Jr&B$DrCxwBTjOnd zv914weY~W%OLa|FVouMlR*9?oOKi}yYxMS-{t}z?>^i-@u3KW)%F<1*L_TTcf4)Au zQquX2ARfvYexQrr*d~8v( zF$@hGdZX@94Gl;j#IW0;8XDyH+8Q_eUl=ryQ@6$wbxmDpOsT|Fe+h$zL3g^pgh7Ky zw5{=Mw?rQ_{_lDb`pR3WmL5o`HR;B#a^*%_kw8Y+8Scc1R>(k&!-SL2(~&; z7cp;2AubPmD-y18KfV_frk3)+V@CZuJ&X9E_1QdA(zl3NKiB%ngoCU2(1&dq|IP3+ zei4DvmW$UQTgb-WW)}QU7DpCFwXi8s< z!^5Lu92l&{IJ~}B4mDKvl~us@E1C48&A1 zPyzrMJE}rQ-ZmII^2jK#Zr)8g$jL1GrQ-+d=4-p|@<&Iy%ijhNag$15eSO z(*GtIHMukwCYR=pdvc#+lgpH1Y%)GB_D4lY{vq}_iHrHtiP0HZ10X0ysnw%mB&hSv zKVXj$zwQUfKh`oklIZb6S6dCzkHm6igl6CMyhZ` z5!nN+g;2z2Os)J(Z!7x7TFDlf&1%RmA>NVZNnFjpwDJS{w z;!%@qfOoW)7hV+yEHGp9YN1cxSBqD}p+E2c@_i?LXQ4mW*0m0b!H%cj9Eqpjs__(7 z@ifK&w*;^fHTW^~H?V3oxe)1?x)PAa*JufoDi4o2Zo<0C!xMfjj;0k^9&BQc1~p=k zT8x_NM6mUSPs){0)|jE;v2jSpXmLfmGG1!P{lxn0BTWqY)ClJ6$2bG((8B{Hp*a1XjJpVeVY>s@~yD+YrSab4odx`bnEDA7ev8qpHy^cVX-kE__>!D8QkT*VM- z`dj;dkE__>!D2spT*V~D_krZckE__>fnwbSzX}K;Y<yV?qA#V6k<_RcvK! zptXh3#Xv;xwvUV@U~Bp9RN*vTg7%0AnyifVBgBZf{8+;hVLFL4BV>7t=$N!(@UNd- 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 z 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

(A!e?WIxk|ZhG+{uX!_ mt#r%*bPV>|=dQw5@!$Uj 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

  • 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 literal 0 HcmV?d00001 diff --git a/codecs/jxl_enc/jxl_enc.cpp b/codecs/jxl/enc/jxl_enc.cpp similarity index 100% rename from codecs/jxl_enc/jxl_enc.cpp rename to codecs/jxl/enc/jxl_enc.cpp diff --git a/codecs/jxl_enc/jxl_enc.d.ts b/codecs/jxl/enc/jxl_enc.d.ts similarity index 100% rename from codecs/jxl_enc/jxl_enc.d.ts rename to codecs/jxl/enc/jxl_enc.d.ts diff --git a/codecs/jxl/enc/jxl_enc.js b/codecs/jxl/enc/jxl_enc.js new file mode 100644 index 00000000..4dfabcf0 --- /dev/null +++ b/codecs/jxl/enc/jxl_enc.js @@ -0,0 +1,7075 @@ + +var jxl_enc = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( +function(jxl_enc) { + jxl_enc = jxl_enc || {}; + +var Module = typeof jxl_enc !== "undefined" ? jxl_enc : {}; + +var readyPromiseResolve, readyPromiseReject; + +Module["ready"] = new Promise(function(resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; +}); + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_main")) { + Object.defineProperty(Module["ready"], "_main", { + configurable: true, + get: function() { + abort("You are getting _main on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_main", { + configurable: true, + set: function() { + abort("You are setting _main on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_malloc")) { + Object.defineProperty(Module["ready"], "_malloc", { + configurable: true, + get: function() { + abort("You are getting _malloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_malloc", { + configurable: true, + set: function() { + abort("You are setting _malloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_free")) { + Object.defineProperty(Module["ready"], "_free", { + configurable: true, + get: function() { + abort("You are getting _free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_free", { + configurable: true, + set: function() { + abort("You are setting _free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackSave")) { + Object.defineProperty(Module["ready"], "_stackSave", { + configurable: true, + get: function() { + abort("You are getting _stackSave on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_stackSave", { + configurable: true, + set: function() { + abort("You are setting _stackSave on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackRestore")) { + Object.defineProperty(Module["ready"], "_stackRestore", { + configurable: true, + get: function() { + abort("You are getting _stackRestore on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_stackRestore", { + configurable: true, + set: function() { + abort("You are setting _stackRestore on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackAlloc")) { + Object.defineProperty(Module["ready"], "_stackAlloc", { + configurable: true, + get: function() { + abort("You are getting _stackAlloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_stackAlloc", { + configurable: true, + set: function() { + abort("You are setting _stackAlloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "___data_end")) { + Object.defineProperty(Module["ready"], "___data_end", { + configurable: true, + get: function() { + abort("You are getting ___data_end on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "___data_end", { + configurable: true, + set: function() { + abort("You are setting ___data_end on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "___wasm_call_ctors")) { + Object.defineProperty(Module["ready"], "___wasm_call_ctors", { + configurable: true, + get: function() { + abort("You are getting ___wasm_call_ctors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "___wasm_call_ctors", { + configurable: true, + set: function() { + abort("You are setting ___wasm_call_ctors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_fflush")) { + Object.defineProperty(Module["ready"], "_fflush", { + configurable: true, + get: function() { + abort("You are getting _fflush on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_fflush", { + configurable: true, + set: function() { + abort("You are setting _fflush on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "___errno_location")) { + Object.defineProperty(Module["ready"], "___errno_location", { + configurable: true, + get: function() { + abort("You are getting ___errno_location on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "___errno_location", { + configurable: true, + set: function() { + abort("You are setting ___errno_location on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "_setThrew")) { + Object.defineProperty(Module["ready"], "_setThrew", { + configurable: true, + get: function() { + abort("You are getting _setThrew on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "_setThrew", { + configurable: true, + set: function() { + abort("You are setting _setThrew on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_tzname")) { + Object.defineProperty(Module["ready"], "__get_tzname", { + configurable: true, + get: function() { + abort("You are getting __get_tzname on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "__get_tzname", { + configurable: true, + set: function() { + abort("You are setting __get_tzname on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_daylight")) { + Object.defineProperty(Module["ready"], "__get_daylight", { + configurable: true, + get: function() { + abort("You are getting __get_daylight on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "__get_daylight", { + configurable: true, + set: function() { + abort("You are setting __get_daylight on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_timezone")) { + Object.defineProperty(Module["ready"], "__get_timezone", { + configurable: true, + get: function() { + abort("You are getting __get_timezone on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "__get_timezone", { + configurable: true, + set: function() { + abort("You are setting __get_timezone on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module["ready"], "onRuntimeInitialized")) { + Object.defineProperty(Module["ready"], "onRuntimeInitialized", { + configurable: true, + get: function() { + abort("You are getting onRuntimeInitialized on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); + Object.defineProperty(Module["ready"], "onRuntimeInitialized", { + configurable: true, + set: function() { + abort("You are setting onRuntimeInitialized on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"); + } + }); +} + +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; +}; + +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"; + +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)"); +} + +var scriptDirectory = ""; + +function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; +} + +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 + "/"; + } + 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); + process["on"]("uncaughtException", function(ex) { + 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") { + if (typeof console === "undefined") console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== "undefined" ? printErr : print; + } +} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href; + } else if (document.currentScript) { + scriptDirectory = document.currentScript.src; + } + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1); + } else { + scriptDirectory = ""; + } + { + 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(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) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + } + setWindowTitle = function(title) { + document.title = title; + }; +} else { + throw new Error("environment detection error"); +} + +var out = Module["print"] || console.log.bind(console); + +var err = Module["printErr"] || console.warn.bind(console); + +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} + +moduleOverrides = null; + +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_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (!Object.getOwnPropertyDescriptor(Module, "readAsync")) Object.defineProperty(Module, "readAsync", { + configurable: true, + get: function() { + abort("Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (!Object.getOwnPropertyDescriptor(Module, "readBinary")) Object.defineProperty(Module, "readBinary", { + configurable: true, + get: function() { + abort("Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (!Object.getOwnPropertyDescriptor(Module, "setWindowTitle")) Object.defineProperty(Module, "setWindowTitle", { + configurable: true, + get: function() { + abort("Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +var STACK_ALIGN = 16; + +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; + 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; + } 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); + } +} + +function convertJsFunctionToWasm(func, sig) { + 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); + } + var typeSection = [ 1, 0, 1, 96 ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + "i": 127, + "j": 126, + "f": 125, + "d": 124 + }; + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + if (sigRet == "v") { + typeSection.push(0); + } else { + typeSection = typeSection.concat([ 1, typeCodes[sigRet] ]); + } + typeSection[1] = typeSection.length - 2; + var bytes = new Uint8Array([ 0, 97, 115, 109, 1, 0, 0, 0 ].concat(typeSection, [ 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0 ])); + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + "e": { + "f": func + } + }); + var wrappedFunc = instance.exports["f"]; + return wrappedFunc; +} + +var freeTableIndexes = []; + +var functionsInTableMap; + +function addFunctionWasm(func, sig) { + var table = wasmTable; + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + for (var i = 0; i < table.length; i++) { + var item = table.get(i); + if (item) { + functionsInTableMap.set(item, i); + } + } + } + if (functionsInTableMap.has(func)) { + return functionsInTableMap.get(func); + } + var ret; + if (freeTableIndexes.length) { + ret = freeTableIndexes.pop(); + } else { + ret = table.length; + try { + table.grow(1); + } catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."; + } + } + try { + 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); +} + +var funcWrappers = {}; + +function dynCall(sig, ptr, args) { + if (args && args.length) { + 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 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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +if (typeof WebAssembly !== "object") { + abort("no native wasm support detected"); +} + +function setValue(ptr, value, type, noSafe) { + type = type || "i8"; + if (type.charAt(type.length - 1) === "*") type = "i32"; + 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 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 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); + } +} + +var wasmMemory; + +var wasmTable = new WebAssembly.Table({ + "initial": 1230, + "maximum": 1230 + 0, + "element": "anyfunc" +}); + +var ABORT = false; + +var EXITSTATUS = 0; + +function assert(condition, text) { + if (!condition) { + abort("Assertion failed: " + text); + } +} + +function getCFunc(ident) { + var func = Module["_" + ident]; + assert(func, "Cannot call unknown function " + ident + ", make sure it is exported"); + return func; +} + +function ccall(ident, returnType, argTypes, args, opts) { + var toC = { + "string": function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 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; +} + +var ALLOC_NONE = 3; + +var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined; + +function UTF8ArrayToString(heap, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr; + if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { + return UTF8Decoder.decode(heap.subarray(idx, endPtr)); + } else { + var str = ""; + while (idx < endPtr) { + var u0 = heap[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heap[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue; + } + var u2 = heap[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2; + } else { + if ((u0 & 248) != 240) 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 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } + } + } + return str; +} + +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; +} + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | u1 & 1023; + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | u >> 6; + heap[outIdx++] = 128 | u & 63; + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | u >> 12; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } else { + if (outIdx + 3 >= endIdx) break; + if (u >= 2097152) 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++] = 240 | u >> 18; + heap[outIdx++] = 128 | u >> 12 & 63; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } + } + heap[outIdx] = 0; + return outIdx - startIdx; +} + +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); +} + +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023; + if (u <= 127) ++len; else if (u <= 2047) len += 2; else if (u <= 65535) len += 3; else len += 4; + } + return len; +} + +var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined; + +function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!"); + var endPtr = ptr; + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + while (!(idx >= maxIdx) && HEAPU16[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 || i == maxBytesToRead / 2) return str; + ++i; + str += String.fromCharCode(codeUnit); + } + } +} + +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!"); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + HEAP16[outPtr >> 1] = codeUnit; + outPtr += 2; + } + HEAP16[outPtr >> 1] = 0; + return outPtr - startPtr; +} + +function lengthBytesUTF16(str) { + return str.length * 2; +} + +function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!"); + var i = 0; + var str = ""; + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[ptr + i * 4 >> 2]; + if (utf32 == 0) break; + ++i; + if (utf32 >= 65536) { + var ch = utf32 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } else { + str += String.fromCharCode(utf32); + } + } + return str; +} + +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!"); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023; + } + HEAP32[outPtr >> 2] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + HEAP32[outPtr >> 2] = 0; + return outPtr - startPtr; +} + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) ++i; + len += 4; + } + return len; +} + +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); +} + +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === str.charCodeAt(i) & 255); + HEAP8[buffer++ >> 0] = str.charCodeAt(i); + } + if (!dontAddNull) HEAP8[buffer >> 0] = 0; +} + +var WASM_PAGE_SIZE = 65536; + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - x % multiple; + } + return x; +} + +var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module["HEAP8"] = HEAP8 = new Int8Array(buf); + Module["HEAP16"] = HEAP16 = new Int16Array(buf); + Module["HEAP32"] = HEAP32 = new Int32Array(buf); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buf); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buf); +} + +var STACK_BASE = 5808864, STACK_MAX = 565984, DYNAMIC_BASE = 5808864, DYNAMICTOP_PTR = 565824; + +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 (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)"); + } +}); + +assert(INITIAL_INITIAL_MEMORY >= TOTAL_STACK, "INITIAL_MEMORY should be larger than TOTAL_STACK, was " + INITIAL_INITIAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")"); + +assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, "JS engine does not provide full typed array support"); + +if (Module["wasmMemory"]) { + wasmMemory = Module["wasmMemory"]; +} else { + wasmMemory = new WebAssembly.Memory({ + "initial": INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE, + "maximum": 2147483648 / WASM_PAGE_SIZE + }); +} + +if (wasmMemory) { + buffer = wasmMemory.buffer; +} + +INITIAL_INITIAL_MEMORY = buffer.byteLength; + +assert(INITIAL_INITIAL_MEMORY % WASM_PAGE_SIZE === 0); + +assert(65536 % WASM_PAGE_SIZE === 0); + +updateGlobalBufferAndViews(buffer); + +HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE; + +function writeStackCookie() { + assert((STACK_MAX & 3) == 0); + HEAPU32[(STACK_MAX >> 2) + 1] = 34821223; + HEAPU32[(STACK_MAX >> 2) + 2] = 2310721022; + HEAP32[0] = 1668509029; +} + +function checkStackCookie() { + var cookie1 = HEAPU32[(STACK_MAX >> 2) + 1]; + var cookie2 = HEAPU32[(STACK_MAX >> 2) + 2]; + if (cookie1 != 34821223 || cookie2 != 2310721022) { + abort("Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" + cookie2.toString(16) + " " + cookie1.toString(16)); + } + if (HEAP32[0] !== 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!"); +} + +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 25459; + if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian!"; +})(); + +function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == "function") { + callback(Module); + 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__ = []; + +var __ATINIT__ = []; + +var __ATMAIN__ = []; + +var __ATPOSTRUN__ = []; + +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 addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +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_ceil = Math.ceil; + +var Math_floor = Math.floor; + +var Math_min = Math.min; + +var runDependencies = 0; + +var runDependencyWatcher = null; + +var dependenciesFulfilled = null; + +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") { + 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)"); + } + }, 1e4); + } + } 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(); + } + } +} + +Module["preloadedImages"] = {}; + +Module["preloadedAudios"] = {}; + +function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + what += ""; + err(what); + ABORT = true; + EXITSTATUS = 1; + var output = "abort(" + what + ") at " + stackTrace(); + what = output; + var e = new WebAssembly.RuntimeError(what); + readyPromiseReject(e); + throw e; +} + +function hasPrefix(str, prefix) { + return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0; +} + +var dataURIPrefix = "data:application/octet-stream;base64,"; + +function isDataURI(filename) { + return hasPrefix(filename, dataURIPrefix); +} + +var fileURIPrefix = "file://"; + +function isFileURI(filename) { + return hasPrefix(filename, fileURIPrefix); +} + +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module["asm"]; + } + assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization"); + assert(!runtimeExited, "native function `" + displayName + "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)"); + if (!asm[name]) { + assert(asm[name], "exported native function `" + displayName + "` not found"); + } + return asm[name].apply(null, arguments); + }; +} + +var wasmBinaryFile = "jxl_enc.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 (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function" && !isFileURI(wasmBinaryFile)) { + return fetch(wasmBinaryFile, { + credentials: "same-origin" + }).then(function(response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response["arrayBuffer"](); + }).catch(function() { + return getBinary(); + }); + } + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); +} + +function createWasm() { + var info = { + "env": asmLibraryArg, + "wasi_snapshot_preview1": asmLibraryArg + }; + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + removeRunDependency("wasm-instantiate"); + } + addRunDependency("wasm-instantiate"); + var trueModule = Module; + function receiveInstantiatedSource(output) { + assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"); + trueModule = null; + 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); + }); + } + function instantiateAsync() { + if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && !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) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + 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 {}; +} + +var tempDouble; + +var tempI64; + +__ATINIT__.push({ + func: function() { + ___wasm_call_ctors(); + } +}); + +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) { + 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)"); +} + +function ___cxa_atexit(a0, a1) { + return _atexit(a0, a1); +} + +var exceptionInfos = {}; + +var exceptionLast = 0; + +function __ZSt18uncaught_exceptionv() { + return __ZSt18uncaught_exceptionv.uncaught_exceptions > 0; +} + +function ___cxa_throw(ptr, type, destructor) { + exceptionInfos[ptr] = { + ptr: ptr, + adjusted: [ ptr ], + type: type, + destructor: destructor, + refcount: 0, + caught: false, + rethrown: false + }; + exceptionLast = ptr; + if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) { + __ZSt18uncaught_exceptionv.uncaught_exceptions = 1; + } else { + __ZSt18uncaught_exceptionv.uncaught_exceptions++; + } + throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch."; +} + +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; +} + +var PATH = { + splitPath: function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray: function(parts, allowAboveRoot) { + 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 (allowAboveRoot) { + for (;up; up--) { + parts.unshift(".."); + } + } + return parts; + }, + normalize: function(path) { + var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/"; + 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) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename: function(path) { + 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(); + if (typeof path !== "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charAt(0) === "/"; + } + 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() {}, + shutdown: function() {}, + 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) { + stream.tty.ops.flush(stream.tty); + }, + flush: function(stream) { + stream.tty.ops.flush(stream.tty); + }, + read: function(stream, buffer, offset, length, pos) { + 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) { + 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) { + 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") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + 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); + } + }, + 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, 0); + }, + createNode: function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + 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; + 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(); + 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; + } + return node.contents; + }, + getFileDataAsTypedArray: function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents); + }, + expandFileStorage: function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + return; + }, + resizeFileStorage: function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + return; + } + if (!node.contents || node.contents.subarray) { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); + } + node.usedBytes = newSize; + return; + } + 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 = {}; + 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); + 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 (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); + } + } + } + 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 | 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) { + 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) { + assert(!(buffer instanceof ArrayBuffer)); + if (buffer.buffer === HEAP8.buffer) { + if (canOwn) { + warnOnce("file packager has copied file data into memory, but in memory growth we are forced to copy it again (see --no-heap-copy)"); + } + canOwn = false; + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + 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) { + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) { + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek: 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, address, length, position, prot, flags) { + assert(address === 0); + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && contents.buffer === buffer) { + allocated = false; + ptr = contents.byteOffset; + } else { + 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; + ptr = FS.mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.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) { + return 0; + } + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + 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) { + throw new FS.ErrnoError(32); + } + var parts = PATH.normalizeArray(path.split("/").filter(function(p) { + return !!p; + }), false); + 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) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root; + } + } + 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) { + 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; + } + } + 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; + } + 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" || flags & 512) { + 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 = 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; + } + } + }; + } + 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); + stream.stream_ops = device.stream_ops; + 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 & 255; + }, + 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); + } + } + 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") { + 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; + 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: [] + }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + 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); + } + 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; + } + }); + node.mounted = null; + 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; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir: function(path, mode) { + mode = mode !== undefined ? mode : 511; + 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; + } + 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); + 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); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28); + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + 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 (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); + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + 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) { + 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() + }); + }, + 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 : 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) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + if (flags & 512) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false + }, fd_start, fd_end); + 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; + 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) { + 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, address, length, position, prot, flags) { + 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, address, 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() { + FS.mkdir("/dev"); + 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)); + 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)); + var random_device; + if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") { + var randomBuffer = new Uint8Array(1); + random_device = function() { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0]; + }; + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + random_device = function() { + return crypto_module["randomBytes"](1)[0]; + }; + } catch (e) {} + } else {} + if (!random_device) { + 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); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }, + createSpecialDirectories: function() { + 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, 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; + return ret; + } + }; + return node; + } + }, {}, "/proc/self/fd"); + }, + createStandardStreams: function() { + 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"); + } + 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 = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = 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]; + if (this.stack) { + 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; + [ 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(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }, + quit: function() { + FS.init.initialized = false; + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + 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) { + 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) {} + 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; + } + 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); + FS.registerDevice(dev, { + open: function(stream) { + stream.seekable = false; + }, + close: function(stream) { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: function(stream, buffer, offset, length, pos) { + 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_) { + try { + 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) { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = 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() { + 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; + if (!hasByteServing) chunkSize = datalength; + 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!"); + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + 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(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; + end = Math.min(end, datalength - 1); + 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) { + chunkSize = datalength = 1; + 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: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: 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); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, { + usedBytes: { + get: function() { + return this.contents.length; + } + } + }); + 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); + }; + }); + 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) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + 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(); + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + 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; + 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; + }, + mmapAlloc: function(size) { + var alignedSize = alignMemory(size, 16384); + var ptr = _malloc(alignedSize); + while (size < alignedSize) HEAP8[ptr + size++] = 0; + return ptr; + } +}; + +var SYSCALLS = { + mappings: {}, + DEFAULT_POLLMASK: 5, + umask: 511, + calculateAt: function(dirfd, path) { + if (path[0] !== "/") { + 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))) { + 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 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 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() / 1e3 | 0; + HEAP32[buf + 60 >> 2] = 0; + HEAP32[buf + 64 >> 2] = stat.mtime.getTime() / 1e3 | 0; + HEAP32[buf + 68 >> 2] = 0; + HEAP32[buf + 72 >> 2] = stat.ctime.getTime() / 1e3 | 0; + HEAP32[buf + 76 >> 2] = 0; + tempI64 = [ stat.ino >>> 0, (tempDouble = stat.ino, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 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) { + 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) { + 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); + HEAP8[buf + len] = endChar; + return len; + }, + doAccess: function(path, amode) { + if (amode & ~7) { + 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 && 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; + } + 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 ___sys_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: + { + if (!stream.tty) return -59; + return 0; + } + + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: + { + if (!stream.tty) return -59; + return 0; + } + + case 21519: + { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0; + } + + case 21520: + { + if (!stream.tty) return -59; + return -28; + } + + case 21531: + { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + + case 21523: + { + if (!stream.tty) return -59; + return 0; + } + + case 21524: + { + if (!stream.tty) return -59; + return 0; + } + + default: + abort("bad ioctl syscall " + op); + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} + +function syscallMunmap(addr, len) { + if ((addr | 0) === -1 || len === 0) { + return -28; + } + 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_rmdir(path) { + try { + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} + +function ___sys_unlink(path) { + try { + path = SYSCALLS.getStr(path); + FS.unlink(path); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e); + return -e.errno; + } +} + +var structRegistrations = {}; + +function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } +} + +function simpleReadValueFromPointer(pointer) { + return this["fromWireType"](HEAPU32[pointer >> 2]); +} + +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); + 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 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); + } +} + +function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map(function(field) { + return field.getterReturnType; + }).concat(fieldRecords.map(function(field) { + return field.setterArgumentType; + })); + whenDependentTypesAreResolved([ structType ], fieldTypes, function(fieldTypes) { + var fields = {}; + fieldRecords.forEach(function(field, i) { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: function(ptr) { + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, + write: function(ptr, o) { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors); + } + }; + }); + return [ { + name: reg.name, + "fromWireType": function(ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + "toWireType": function(destructors, o) { + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError('Missing field: "' + fieldName + '"'); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + "argPackAdvance": 8, + "readValueFromPointer": simpleReadValueFromPointer, + destructorFunction: rawDestructor + } ]; + }); +} + +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 BindingError = undefined; + +function throwBindingError(message) { + throw new BindingError(message); +} + +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) { + return !!wt; + }, + "toWireType": function(destructors, o) { + return o ? trueValue : falseValue; + }, + "argPackAdvance": 8, + "readValueFromPointer": function(pointer) { + 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 + }); +} + +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 __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 + }); +} + +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) { + 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 + }); +} + +function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function"); + } + var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {}); + dummy.prototype = constructor.prototype; + var obj = new dummy(); + var r = constructor.apply(obj, argumentList); + return r instanceof Object ? r : obj; +} + +function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + var isClassMethodFunc = argTypes[1] !== null && classType !== null; + var needsDestructorStack = false; + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + needsDestructorStack = true; + break; + } + } + var returns = argTypes[0].name !== "void"; + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i !== 0 ? ", " : "") + "arg" + i; + argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired"; + } + var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n"; + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = [ "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam" ]; + var args2 = [ throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1] ]; + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n"; + } + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n"; + args1.push("argType" + i); + args2.push(argTypes[i + 2]); + } + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired; + } + invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n"; + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired"; + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n"; + args1.push(paramName + "_dtor"); + args2.push(argTypes[i].destructorFunction); + } + } + } + if (returns) { + invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n"; + } else {} + invokerFnBody += "}\n"; + args1.push(invokerFnBody); + var invokerFunction = new_(Function, args1).apply(null, args2); + return invokerFunction; +} + +function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + proto[methodName] = function() { + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!"); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } +} + +function exposePublicSymbol(name, value, numArguments) { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) { + throwBindingError("Cannot register public name '" + name + "' twice"); + } + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!"); + } + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } +} + +function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]); + } + return array; +} + +function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError("Replacing nonexistant public symbol"); + } + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } +} + +function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + function makeDynCaller(dynCall) { + var args = []; + for (var i = 1; i < signature.length; ++i) { + args.push("a" + i); + } + var name = "dynCall_" + signature + "_" + rawFunction; + var body = "return function " + name + "(" + args.join(", ") + ") {\n"; + body += " return dynCall(rawFunction" + (args.length ? ", " : "") + args.join(", ") + ");\n"; + body += "};\n"; + return new Function("dynCall", "rawFunction", body)(dynCall, rawFunction); + } + var dc = Module["dynCall_" + signature]; + var fp = makeDynCaller(dc); + if (typeof fp !== "function") { + throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction); + } + return fp; +} + +var UnboundTypeError = undefined; + +function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; +} + +function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([ ", " ])); +} + +function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + rawInvoker = embind__requireFunction(signature, rawInvoker); + exposePublicSymbol(name, function() { + throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes); + }, argCount - 1); + whenDependentTypesAreResolved([], argTypes, function(argTypes) { + var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1)); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1); + return []; + }); +} + +function integerReadValueFromPointer(name, shift, signed) { + 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) { + 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) { + 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 + }); +} + +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]; + var data = heap[handle + 1]; + 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 = name === "std::string"; + registerType(rawType, { + name: name, + "fromWireType": function(value) { + var length = HEAPU32[value >> 2]; + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } 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; + }; + } + 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) { + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + _free(value); + return str; + }, + "toWireType": function(destructors, value) { + if (!(typeof value === "string")) { + throwBindingError("Cannot pass non-string to C++ string type " + name); + } + 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_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [] + }; +} + +function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext + }); +} + +function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, + name: name, + "argPackAdvance": 0, + "fromWireType": function() { + return undefined; + }, + "toWireType": function(destructors, o) { + return undefined; + } + }); +} + +function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1; + } +} + +function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; +} + +function __emval_take_value(type, argv) { + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](argv); + return __emval_register(v); +} + +function _abort() { + abort(); +} + +function _emscripten_get_sbrk_ptr() { + return 565824; +} + +function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); +} + +function _emscripten_get_heap_size() { + return HEAPU8.length; +} + +function emscripten_realloc_buffer(size) { + try { + wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16); + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1; + } catch (e) { + console.error("emscripten_realloc_buffer: Attempted to grow heap from " + buffer.byteLength + " bytes to " + size + " bytes, but got error: " + e); + } +} + +function _emscripten_resize_heap(requestedSize) { + requestedSize = requestedSize >>> 0; + var oldSize = _emscripten_get_heap_size(); + assert(requestedSize > oldSize); + var PAGE_MULTIPLE = 65536; + var maxHeapSize = 2147483648; + if (requestedSize > maxHeapSize) { + err("Cannot enlarge memory, asked to go up to " + requestedSize + " bytes, but the limit is " + maxHeapSize + " bytes!"); + return false; + } + var minHeapSize = 16777216; + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), PAGE_MULTIPLE)); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true; + } + } + err("Failed to grow the heap from " + oldSize + " bytes to " + newSize + " bytes, not enough memory!"); + return false; +} + +var ENV = {}; + +function getExecutableName() { + return thisProgram || "./this.program"; +} + +function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8"; + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": lang, + "_": getExecutableName() + }; + 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 _exit(status) { + exit(status); +} + +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_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doReadv(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 _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 4294967296; + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + var DOUBLE_LIMIT = 9007199254740992; + 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 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], + HEAP32[newOffset >> 2] = tempI64[0], HEAP32[newOffset + 4 >> 2] = tempI64[1]; + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + 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; + } +} + +var ___tm_current = 565840; + +var ___tm_timezone = (stringToUTF8("GMT", 565888, 4), 565888); + +function _gmtime_r(time, tmPtr) { + var date = new Date(HEAP32[time >> 2] * 1e3); + HEAP32[tmPtr >> 2] = date.getUTCSeconds(); + HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes(); + HEAP32[tmPtr + 8 >> 2] = date.getUTCHours(); + HEAP32[tmPtr + 12 >> 2] = date.getUTCDate(); + HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth(); + HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900; + HEAP32[tmPtr + 24 >> 2] = date.getUTCDay(); + HEAP32[tmPtr + 36 >> 2] = 0; + HEAP32[tmPtr + 32 >> 2] = 0; + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0; + HEAP32[tmPtr + 28 >> 2] = yday; + HEAP32[tmPtr + 40 >> 2] = ___tm_timezone; + return tmPtr; +} + +function _gmtime(time) { + return _gmtime_r(time, ___tm_current); +} + +function _round(d) { + d = +d; + return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5); +} + +function _roundf(d) { + d = +d; + return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5); +} + +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++]) {} + 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()) { + 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 { + newDate.setDate(newDate.getDate() + days); + return newDate; + } + } + return newDate; +} + +function _strftime(s, maxsize, format, tm) { + 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); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + 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: + return new Date(janFourth.getFullYear() - 1, 11, 29); + + case 1: + return janFourth; + + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + + case 6: + 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) { + 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) { + 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) { + 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) { + 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); + if (compareByDay(firstSunday, endDate) < 0) { + 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) { + 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) { + return "53"; + } + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + return "01"; + } + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) { + daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate(); + } else { + daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate(); + } + return leadingNulls(Math.ceil(daysDifference / 7), 2); + }, + "%w": function(date) { + return date.tm_wday; + }, + "%W": function(date) { + 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); + 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) { + return (date.tm_year + 1900).toString().substring(2); + }, + "%Y": function(date) { + return date.tm_year + 1900; + }, + "%z": function(date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + 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); +} + +function _time(ptr) { + var ret = Date.now() / 1e3 | 0; + if (ptr) { + HEAP32[ptr >> 2] = ret; + } + return ret; +} + +var FSNode = function(parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + 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 | 73; + +var writeMode = 146; + +Object.defineProperties(FSNode.prototype, { + read: { + get: function() { + return (this.mode & readMode) === readMode; + }, + set: function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: function() { + return (this.mode & writeMode) === writeMode; + }, + set: function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: function() { + return FS.isChrdev(this.mode); + } + } +}); + +FS.FSNode = FSNode; + +FS.staticInit(); + +InternalError = Module["InternalError"] = extendError(Error, "InternalError"); + +embind_init_charCodes(); + +BindingError = Module["BindingError"] = extendError(Error, "BindingError"); + +init_emval(); + +UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError"); + +var ASSERTIONS = true; + +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +var asmLibraryArg = { + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_atexit": ___cxa_atexit, + "__cxa_throw": ___cxa_throw, + "__handle_stack_overflow": ___handle_stack_overflow, + "__map_file": ___map_file, + "__sys_ioctl": ___sys_ioctl, + "__sys_munmap": ___sys_munmap, + "__sys_open": ___sys_open, + "__sys_rmdir": ___sys_rmdir, + "__sys_unlink": ___sys_unlink, + "_embind_finalize_value_object": __embind_finalize_value_object, + "_embind_register_bool": __embind_register_bool, + "_embind_register_emval": __embind_register_emval, + "_embind_register_float": __embind_register_float, + "_embind_register_function": __embind_register_function, + "_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_value_object": __embind_register_value_object, + "_embind_register_value_object_field": __embind_register_value_object_field, + "_embind_register_void": __embind_register_void, + "_emval_decref": __emval_decref, + "_emval_incref": __emval_incref, + "_emval_take_value": __emval_take_value, + "abort": _abort, + "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, + "exit": _exit, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "gmtime": _gmtime, + "memory": wasmMemory, + "round": _round, + "roundf": _roundf, + "setTempRet0": _setTempRet0, + "strftime_l": _strftime_l, + "table": wasmTable, + "time": _time +}; + +var asm = createWasm(); + +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors"); + +var _malloc = Module["_malloc"] = createExportWrapper("malloc"); + +var _free = Module["_free"] = createExportWrapper("free"); + +var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location"); + +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); + +var ___getTypeName = Module["___getTypeName"] = createExportWrapper("__getTypeName"); + +var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = createExportWrapper("__embind_register_native_and_builtin_types"); + +var __get_tzname = Module["__get_tzname"] = createExportWrapper("_get_tzname"); + +var __get_daylight = Module["__get_daylight"] = createExportWrapper("_get_daylight"); + +var __get_timezone = Module["__get_timezone"] = createExportWrapper("_get_timezone"); + +var _setThrew = Module["_setThrew"] = createExportWrapper("setThrew"); + +var stackSave = Module["stackSave"] = createExportWrapper("stackSave"); + +var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore"); + +var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc"); + +var ___set_stack_limit = Module["___set_stack_limit"] = createExportWrapper("__set_stack_limit"); + +var __growWasmMemory = Module["__growWasmMemory"] = createExportWrapper("__growWasmMemory"); + +var dynCall_i = Module["dynCall_i"] = createExportWrapper("dynCall_i"); + +var dynCall_vi = Module["dynCall_vi"] = createExportWrapper("dynCall_vi"); + +var dynCall_iii = Module["dynCall_iii"] = createExportWrapper("dynCall_iii"); + +var dynCall_viii = Module["dynCall_viii"] = createExportWrapper("dynCall_viii"); + +var dynCall_iiiiii = Module["dynCall_iiiiii"] = createExportWrapper("dynCall_iiiiii"); + +var dynCall_viiiii = Module["dynCall_viiiii"] = createExportWrapper("dynCall_viiiii"); + +var dynCall_v = Module["dynCall_v"] = createExportWrapper("dynCall_v"); + +var dynCall_ii = Module["dynCall_ii"] = createExportWrapper("dynCall_ii"); + +var dynCall_iidiiii = Module["dynCall_iidiiii"] = createExportWrapper("dynCall_iidiiii"); + +var dynCall_vii = Module["dynCall_vii"] = createExportWrapper("dynCall_vii"); + +var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = createExportWrapper("dynCall_iiiiiii"); + +var dynCall_iiii = Module["dynCall_iiii"] = createExportWrapper("dynCall_iiii"); + +var dynCall_iiiii = Module["dynCall_iiiii"] = createExportWrapper("dynCall_iiiii"); + +var dynCall_viiiiii = Module["dynCall_viiiiii"] = createExportWrapper("dynCall_viiiiii"); + +var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"); + +var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = createExportWrapper("dynCall_viiiiiii"); + +var dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii"); + +var dynCall_viiii = Module["dynCall_viiii"] = createExportWrapper("dynCall_viiii"); + +var dynCall_fi = Module["dynCall_fi"] = createExportWrapper("dynCall_fi"); + +var dynCall_diid = Module["dynCall_diid"] = createExportWrapper("dynCall_diid"); + +var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = createExportWrapper("dynCall_iiiiiiii"); + +var dynCall_idi = Module["dynCall_idi"] = createExportWrapper("dynCall_idi"); + +var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = createExportWrapper("dynCall_iiiiiiiii"); + +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj"); + +var dynCall_iiiiij = Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij"); + +var dynCall_iiiiid = Module["dynCall_iiiiid"] = createExportWrapper("dynCall_iiiiid"); + +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj"); + +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)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "ccall")) Module["ccall"] = function() { + abort("'ccall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "cwrap")) Module["cwrap"] = function() { + abort("'cwrap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "setValue")) Module["setValue"] = function() { + abort("'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "getValue")) Module["getValue"] = function() { + abort("'getValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +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)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString")) Module["UTF8ToString"] = function() { + abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = function() { + abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = function() { + abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +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)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = function() { + abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +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, "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, "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, "traverseStack")) Module["traverseStack"] = function() { + abort("'traverseStack' 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, "withBuiltinMalloc")) Module["withBuiltinMalloc"] = function() { + abort("'withBuiltinMalloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray")) Module["readAsmConstArgsArray"] = function() { + abort("'readAsmConstArgsArray' 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, "getExecutableName")) Module["getExecutableName"] = function() { + abort("'getExecutableName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "listenOnce")) Module["listenOnce"] = function() { + abort("'listenOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext")) Module["autoResumeAudioContext"] = function() { + abort("'autoResumeAudioContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "abortStackOverflow")) Module["abortStackOverflow"] = function() { + abort("'abortStackOverflow' 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, "maybeCStringToJsString")) Module["maybeCStringToJsString"] = function() { + abort("'maybeCStringToJsString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget")) Module["findEventTarget"] = function() { + abort("'findEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget")) Module["findCanvasEventTarget"] = function() { + abort("'findCanvasEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate")) Module["polyfillSetImmediate"] = function() { + abort("'polyfillSetImmediate' 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, "checkWasiClock")) Module["checkWasiClock"] = function() { + abort("'checkWasiClock' 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, "exceptionLast")) Module["exceptionLast"] = function() { + abort("'exceptionLast' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught")) Module["exceptionCaught"] = function() { + abort("'exceptionCaught' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exceptionInfos")) Module["exceptionInfos"] = function() { + abort("'exceptionInfos' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exception_deAdjust")) Module["exception_deAdjust"] = function() { + abort("'exception_deAdjust' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef")) Module["exception_addRef"] = function() { + abort("'exception_addRef' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef")) Module["exception_decRef"] = function() { + abort("'exception_decRef' 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, "tempFixedLengthArray")) Module["tempFixedLengthArray"] = function() { + abort("'tempFixedLengthArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers")) Module["miniTempWebGLFloatBuffers"] = function() { + abort("'miniTempWebGLFloatBuffers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType")) Module["heapObjectForWebGLType"] = function() { + abort("'heapObjectForWebGLType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); +}; + +if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap")) Module["heapAccessShiftForWebGLHeap"] = function() { + abort("'heapAccessShiftForWebGLHeap' 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, "computeUnpackAlignedImageSize")) Module["computeUnpackAlignedImageSize"] = function() { + abort("'computeUnpackAlignedImageSize' 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, "writeGLArray")) Module["writeGLArray"] = function() { + abort("'writeGLArray' 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; + +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; + +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +dependenciesFulfilled = function runCaller() { + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; +}; + +function run(args) { + args = args || arguments_; + if (runDependencies > 0) { + return; + } + writeStackCookie(); + preRun(); + if (runDependencies > 0) return; + function doRun() { + if (calledRun) return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + preMain(); + readyPromiseResolve(Module); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function() { + setTimeout(function() { + Module["setStatus"](""); + }, 1); + doRun(); + }, 1); + } else { + doRun(); + } + checkStackCookie(); +} + +Module["run"] = run; + +function checkUnflushedContent() { + var print = out; + var printErr = err; + var has = false; + out = err = function(x) { + has = true; + }; + try { + var flush = Module["_fflush"]; + if (flush) flush(0); + [ "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."); + } +} + +function exit(status, implicit) { + checkUnflushedContent(); + if (implicit && noExitRuntime && status === 0) { + return; + } + if (noExitRuntime) { + if (!implicit) { + var msg = "program exited (with status: " + status + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)"; + readyPromiseReject(msg); + err(msg); + } + } 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()(); + } +} + +noExitRuntime = true; + +run(); + + + return jxl_enc.ready +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = jxl_enc; + else if (typeof define === 'function' && define['amd']) + define([], function() { return jxl_enc; }); + else if (typeof exports === 'object') + exports["jxl_enc"] = jxl_enc; + \ No newline at end of file diff --git a/codecs/jxl/enc/jxl_enc.wasm b/codecs/jxl/enc/jxl_enc.wasm new file mode 100644 index 0000000000000000000000000000000000000000..4a7664faadec5fdb71e2efb894b452fca30e45de GIT binary patch literal 2770350 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

    hK}BjHKm{8DkG`RNhMpMT|g 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%0Dsv^E65#99KxM5WQlY91 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 z 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