From 6bbe67587dd8cb5893bc6f8c21f6c4911bbb977c Mon Sep 17 00:00:00 2001 From: Jaifroid Date: Sat, 10 Dec 2022 18:17:41 +0000 Subject: [PATCH] Add binaries and source files Former-commit-id: 6c7f150fc962e2c890a77e6a9f12bd06cac9df72 --- www/js/lib/libzim-asm.dev.js.REMOVED.git-id | 2 +- www/js/lib/libzim-asm.js | 26 +- www/js/lib/libzim-wasm.electron.dev.js | 8382 +++++++++++++++++ ...bzim-wasm.electron.dev.wasm.REMOVED.git-id | 1 + www/js/lib/libzim-wasm.electron.js | 1 + www/js/lib/libzim-wasm.electron.wasm | Bin 0 -> 1357175 bytes www/js/lib/libzim-wasm.js | 2 +- www/libzim-wasm.electron.dev.js | 8376 ++++++++++++++++ ...bzim-wasm.electron.dev.wasm.REMOVED.git-id | 1 + 9 files changed, 16780 insertions(+), 11 deletions(-) create mode 100644 www/js/lib/libzim-wasm.electron.dev.js create mode 100644 www/js/lib/libzim-wasm.electron.dev.wasm.REMOVED.git-id create mode 100644 www/js/lib/libzim-wasm.electron.js create mode 100644 www/js/lib/libzim-wasm.electron.wasm create mode 100644 www/libzim-wasm.electron.dev.js create mode 100644 www/libzim-wasm.electron.dev.wasm.REMOVED.git-id diff --git a/www/js/lib/libzim-asm.dev.js.REMOVED.git-id b/www/js/lib/libzim-asm.dev.js.REMOVED.git-id index 51cb4e91..c73bd3a0 100644 --- a/www/js/lib/libzim-asm.dev.js.REMOVED.git-id +++ b/www/js/lib/libzim-asm.dev.js.REMOVED.git-id @@ -1 +1 @@ -53b98b61c5b5bec76098d41c35f2318e2cf5f89b \ No newline at end of file +57bb13626299e08db1320adfccae6ec9d206ea37 \ No newline at end of file diff --git a/www/js/lib/libzim-asm.js b/www/js/lib/libzim-asm.js index 250f42c4..87e9faf4 100644 --- a/www/js/lib/libzim-asm.js +++ b/www/js/lib/libzim-asm.js @@ -1,15 +1,23 @@ -var Module=typeof Module!="undefined"?Module:{};self.addEventListener("message",function(e){var action=e.data.action;var path=e.data.path;var outgoingMessagePort=e.ports[0];console.debug("WebWorker called with action="+action);if(action==="getEntryByPath"){var follow=e.data.follow;var entry=Module[action](path);if(entry){var item={};if(follow||!entry.isRedirect()){item=entry.getItem(follow);var blob=item.getData();var content=blob.getContent();var contentArray=new Uint8Array(content);outgoingMessagePort.postMessage({content:contentArray,mimetype:item.getMimetype(),isRedirect:entry.isRedirect()})}else{outgoingMessagePort.postMessage({content:new Uint8Array,isRedirect:true,redirectPath:entry.getRedirectEntry().getPath()})}}else{outgoingMessagePort.postMessage({content:new Uint8Array,mimetype:"unknown",isRedirect:false})}}else if(action==="search"){var text=e.data.text;var numResults=e.data.numResults||50;var entries=Module[action](text,numResults);console.debug("Found nb results = "+entries.size(),entries);var serializedEntries=[];for(var i=0;i .zim) + var baseZimFileName = files[0].name.replace(/\.zim..$/, '.zim'); + Module = {}; + Module["onRuntimeInitialized"] = function() { + Module.loadArchive("/work/" + baseZimFileName); + console.debug(assemblerType + " initialized"); + outgoingMessagePort.postMessage("runtime initialized"); + }; + Module["arguments"] = []; + for (let i = 0; i < files.length; i++) { + Module["arguments"].push("/work/" + files[i].name); + } + Module["preRun"] = function() { + FS.mkdir("/work"); + if (files[0].readMode === 'electron') { + FS.mount(NODEFS, { + root: './archives' + }, "/work"); + } else { + FS.mount(WORKERFS, { + files: files + }, "/work"); + } + }; + console.debug("baseZimFileName = " + baseZimFileName); + console.debug('Module["arguments"] = ' + Module["arguments"]) + + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (Module['ENVIRONMENT']) { + throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)'); +} + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +// Normally we don't log exceptions but instead let them bubble out the top +// level where the embedding environment (e.g. the browser) can handle +// them. +// However under v8 and node we sometimes exit the process direcly in which case +// its up to use us to log the exception before exiting. +// If we fix https://github.com/emscripten-core/emscripten/issues/15080 +// this may no longer be needed under node. +function logExceptionOnExit(e) { + if (e instanceof ExitStatus) return; + let toLog = e; + if (e && typeof e == 'object' && e.stack) { + toLog = [e, e.stack]; + } + err('exiting due to exception: ' + toLog); +} + +var fs; +var nodePath; +var requireNodeFS; + +if (ENVIRONMENT_IS_NODE) { + if (!(typeof process == 'object' && typeof require == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = require('path').dirname(scriptDirectory) + '/'; + } else { + scriptDirectory = __dirname + '/'; + } + +// include: node_shell_read.js + + +requireNodeFS = () => { + // Use nodePath as the indicator for these not being initialized, + // since in some environments a global fs may have already been + // created. + if (!nodePath) { + fs = require('fs'); + nodePath = require('path'); + } +}; + +read_ = function shell_read(filename, binary) { + requireNodeFS(); + filename = nodePath['normalize'](filename); + return fs.readFileSync(filename, binary ? undefined : 'utf8'); +}; + +readBinary = (filename) => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; +}; + +readAsync = (filename, onload, onerror) => { + requireNodeFS(); + filename = nodePath['normalize'](filename); + fs.readFile(filename, function(err, data) { + if (err) onerror(err); + else onload(data.buffer); + }); +}; + +// end include: node_shell_read.js + if (process['argv'].length > 1) { + thisProgram = process['argv'][1].replace(/\\/g, '/'); + } + + arguments_ = process['argv'].slice(2); + + if (typeof module != 'undefined') { + module['exports'] = Module; + } + + process['on']('uncaughtException', function(ex) { + // suppress ExitStatus exceptions from showing an error + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + + // Without this older versions of node (< v15) will log unhandled rejections + // but return 0, which is not normally the desired behaviour. This is + // not be needed with node v15 and about because it is now the default + // behaviour: + // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode + process['on']('unhandledRejection', function(reason) { throw reason; }); + + quit_ = (status, toThrow) => { + if (keepRuntimeAlive()) { + process['exitCode'] = status; + throw toThrow; + } + logExceptionOnExit(toThrow); + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; + +} else +if (ENVIRONMENT_IS_SHELL) { + + if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + let data; + if (typeof readbuffer == 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data == 'object'); + return data; + }; + + readAsync = function readAsync(f, onload, onerror) { + setTimeout(() => onload(readBinary(f)), 0); + }; + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit == 'function') { + quit_ = (status, toThrow) => { + logExceptionOnExit(toThrow); + quit(status); + }; + } + + if (typeof print != 'undefined') { + // Prefer to use print/printErr where they exist, as they usually work better. + if (typeof console == 'undefined') console = /** @type{!Console} */({}); + console.log = /** @type{!function(this:Console, ...*): undefined} */ (print); + console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print); + } + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { +// include: web_or_worker_shell_read.js + + + read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } + + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + +// end include: web_or_worker_shell_read.js + } + + setWindowTitle = (title) => document.title = title; +} else +{ + throw new Error('environment detection error'); +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = null; +checkIncomingModuleAPI(); + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_'); + +if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram'); + +if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_'); + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)'); +assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)'); +assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); +legacyModuleProp('read', 'read_'); +legacyModuleProp('readAsync', 'readAsync'); +legacyModuleProp('readBinary', 'readBinary'); +legacyModuleProp('setWindowTitle', 'setWindowTitle'); +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; +var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; + + + +assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable."); + + + + +var STACK_ALIGN = 16; +var POINTER_SIZE = 4; + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': case 'u8': return 1; + case 'i16': case 'u16': return 2; + case 'i32': case 'u32': return 4; + case 'i64': case 'u64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length - 1] === '*') { + return POINTER_SIZE; + } else if (type[0] === 'i') { + const 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); + } +} + +// include: runtime_functions.js + + +// This gives correct answers for everything less than 2^{14} = 16384 +// I hope nobody is contemplating functions with 16384 arguments... +function uleb128Encode(n) { + assert(n < 16384); + if (n < 128) { + return [n]; + } + return [(n % 128) | 128, n >> 7]; +} + +// Wraps a JS function as a wasm function with a given signature. +function convertJsFunctionToWasm(func, sig) { + + // If the type reflection proposal is available, use the new + // "WebAssembly.Function" constructor. + // Otherwise, construct a minimal wasm module importing the JS function and + // re-exporting it. + if (typeof WebAssembly.Function == "function") { + var typeNames = { + 'i': 'i32', + 'j': 'i64', + 'f': 'f32', + 'd': 'f64', + 'p': 'i32', + }; + var type = { + parameters: [], + results: sig[0] == 'v' ? [] : [typeNames[sig[0]]] + }; + for (var i = 1; i < sig.length; ++i) { + assert(sig[i] in typeNames, 'invalid signature char: ' + sig[i]); + type.parameters.push(typeNames[sig[i]]); + } + return new WebAssembly.Function(type, func); + } + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'p': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection = typeSection.concat(uleb128Encode(sigParam.length)); + for (var i = 0; i < sigParam.length; ++i) { + assert(sigParam[i] in typeCodes, 'invalid signature char: ' + sigParam[i]); + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the section code and overall length of the type section into the + // section header + typeSection = [0x01 /* Type section code */].concat( + uleb128Encode(typeSection.length), + typeSection + ); + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + 'e': { + 'f': func + } + }); + var wrappedFunc = instance.exports['f']; + return wrappedFunc; +} + +var freeTableIndexes = []; + +// Weak map of functions in the table to their indexes, created on first use. +var functionsInTableMap; + +function getEmptyTableSlot() { + // Reuse a free index if there is one, otherwise grow. + if (freeTableIndexes.length) { + return freeTableIndexes.pop(); + } + // Grow the table + try { + wasmTable.grow(1); + } catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.'; + } + return wasmTable.length - 1; +} + +function updateTableMap(offset, count) { + for (var i = offset; i < offset + count; i++) { + var item = getWasmTableEntry(i); + // Ignore null values. + if (item) { + functionsInTableMap.set(item, i); + } + } +} + +/** + * Add a function to the table. + * 'sig' parameter is required if the function being added is a JS function. + * @param {string=} sig + */ +function addFunction(func, sig) { + assert(typeof func != 'undefined'); + + // Check if the function is already in the table, to ensure each function + // gets a unique index. First, create the map if this is the first use. + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + updateTableMap(0, wasmTable.length); + } + if (functionsInTableMap.has(func)) { + return functionsInTableMap.get(func); + } + + // It's not in the table, add it now. + + var ret = getEmptyTableSlot(); + + // Set the new value. + try { + // Attempting to call this with JS function will cause of table.set() to fail + setWasmTableEntry(ret, func); + } catch (err) { + if (!(err instanceof TypeError)) { + throw err; + } + assert(typeof sig != 'undefined', 'Missing signature argument to addFunction: ' + func); + var wrapped = convertJsFunctionToWasm(func, sig); + setWasmTableEntry(ret, wrapped); + } + + functionsInTableMap.set(func, ret); + + return ret; +} + +function removeFunction(index) { + functionsInTableMap.delete(getWasmTableEntry(index)); + freeTableIndexes.push(index); +} + +// end include: runtime_functions.js +// include: runtime_debug.js + + +function legacyModuleProp(prop, newName) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get: function() { + abort('Module.' + prop + ' has been replaced with plain ' + newName + ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)'); + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort('`Module.' + prop + '` was supplied but `' + prop + '` not included in INCOMING_MODULE_JS_API'); + } +} + +function unexportedMessage(sym, isFSSybol) { + var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"; + if (isFSSybol) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + return msg; +} + +function unexportedRuntimeSymbol(sym, isFSSybol) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get: function() { + abort(unexportedMessage(sym, isFSSybol)); + } + }); + } +} + +function unexportedRuntimeFunction(sym, isFSSybol) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Module[sym] = () => abort(unexportedMessage(sym, isFSSybol)); + } +} + +// end include: runtime_debug.js +var tempRet0 = 0; +var setTempRet0 = (value) => { tempRet0 = value; }; +var getTempRet0 = () => tempRet0; + + + +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary'); +var noExitRuntime = Module['noExitRuntime'] || true;legacyModuleProp('noExitRuntime', 'noExitRuntime'); + +if (typeof WebAssembly != 'object') { + abort('no native wasm support detected'); +} + +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed' + (text ? ': ' + text : '')); + } +} + +// Returns the C function with a specified identifier (for C++, you need to do manual name mangling) +function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; +} + +// C calling interface. +/** @param {string|null=} returnType + @param {Array=} argTypes + @param {Arguments|Array=} args + @param {Object=} opts */ +function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') { + + return UTF8ToString(ret); + } + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + assert(returnType !== 'array', 'Return type should not be "array".'); + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret); + } + + ret = onDone(ret); + return ret; +} + +/** @param {string=} returnType + @param {Array=} argTypes + @param {Object=} opts */ +function cwrap(ident, returnType, argTypes, opts) { + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +// We used to include malloc/free by default in the past. Show a helpful error in +// builds with assertions. + +// include: runtime_legacy.js + + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call + +/** + * allocate(): This function is no longer used by emscripten but is kept around to avoid + * breaking external users. + * You should normally not use allocate(), and instead allocate + * memory using _malloc()/stackAlloc(), initialize it with + * setValue(), and so forth. + * @param {(Uint8Array|Array)} slab: An array of data. + * @param {number=} allocator : How to allocate memory, see ALLOC_* + */ +function allocate(slab, allocator) { + var ret; + assert(typeof allocator == 'number', 'allocate no longer takes a type argument') + assert(typeof slab != 'number', 'allocate no longer takes a number as arg0') + + if (allocator == ALLOC_STACK) { + ret = stackAlloc(slab.length); + } else { + ret = _malloc(slab.length); + } + + if (!slab.subarray && !slab.slice) { + slab = new Uint8Array(slab); + } + HEAPU8.set(slab, ret); + return ret; +} + +// end include: runtime_legacy.js +// include: runtime_strings.js + + +// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime. + +var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns +// a copy of that string as a Javascript String object. +/** + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; +} + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a +// copy of that string as a Javascript String object. +// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit +// this parameter to scan the string until the first \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will +// not produce a string of exact length [ptr, ptr+maxBytesToRead[) +// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may +// throw JS JIT optimizations off, so it is worth to consider consistently using one +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; +} + +// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', +// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. +// This count should include the null terminator, +// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. +// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 0x10FFFF) warnOnce('Invalid Unicode code point 0x' + u.toString(16) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).'); + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + +// end include: runtime_strings.js +// include: runtime_strings_extra.js + + +// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime. + +// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + +function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + +// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined; + +function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var str = ''; + + // If maxBytesToRead is not passed explicitly, it will be undefined, and the for-loop's condition + // will always evaluate to true. The loop is then terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return str; + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. +// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. +// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF16(str, outPtr, maxBytesToWrite) { + assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); + var i = 0; + + var str = ''; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. +// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. +// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF32(str, outPtr, maxBytesToWrite) { + assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// a maximum length limit of how many bytes it is allowed to write. Prefer calling the +// function stringToUTF8Array() instead, which takes in a maximum length that can be used +// to be secure from out of bounds writes. +/** @deprecated + @param {boolean=} dontAddNull */ +function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +function writeArrayToMemory(array, buffer) { + assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') + HEAP8.set(array, buffer); +} + +/** @param {boolean=} dontAddNull */ +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff)); + HEAP8[((buffer++)>>0)] = str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)] = 0; +} + +// end include: runtime_strings_extra.js +// Memory management + +var HEAP, +/** @type {!ArrayBuffer} */ + buffer, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); +} + +var 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_MEMORY = Module['INITIAL_MEMORY'] || 83886080;legacyModuleProp('INITIAL_MEMORY', 'INITIAL_MEMORY'); + +assert(INITIAL_MEMORY >= TOTAL_STACK, 'INITIAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); + +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) +assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, + 'JS engine does not provide full typed array support'); + +// If memory is defined in wasm, the user can't provide it. +assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'); +assert(INITIAL_MEMORY == 83886080, 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'); + +// include: runtime_init_table.js +// In regular non-RELOCATABLE mode the table is exported +// from the wasm module and this will be assigned once +// the exports are available. +var wasmTable; + +// end include: runtime_init_table.js +// include: runtime_stack_check.js + + +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + // The stack grow downwards towards _emscripten_stack_get_end. + // We write cookies to the final two words in the stack and detect if they are + // ever overwritten. + HEAP32[((max)>>2)] = 0x2135467; + HEAP32[(((max)+(4))>>2)] = 0x89BACDFE; + // Also test the global address 0 for integrity. + HEAPU32[0] = 0x63736d65; /* 'emsc' */ +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + var cookie1 = HEAPU32[((max)>>2)]; + var cookie2 = HEAPU32[(((max)+(4))>>2)]; + if (cookie1 != 0x2135467 || cookie2 != 0x89BACDFE) { + abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x' + cookie2.toString(16) + ' 0x' + cookie1.toString(16)); + } + // Also test the global address 0 for integrity. + if (HEAPU32[0] !== 0x63736d65 /* 'emsc' */) abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); +} + +// end include: runtime_stack_check.js +// include: runtime_assertions.js + + +// Endianness check +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 0x6373; + if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)'; +})(); + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +function keepRuntimeAlive() { + return noExitRuntime; +} + +function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + checkStackCookie(); + assert(!runtimeInitialized); + runtimeInitialized = true; + + +if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + checkStackCookie(); + + callRuntimeCallbacks(__ATMAIN__); +} + +function postRun() { + checkStackCookie(); + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js + + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); + +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(function() { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err('still waiting on run dependencies:'); + } + err('dependency: ' + dep); + } + if (shown) { + err('(end of list)'); + } + }, 10000); + } + } else { + err('warning: run dependency added without ID'); + } +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + { + if (Module['onAbort']) { + Module['onAbort'](what); + } + } + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // defintion for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// {{MEM_INITIALIZER}} + +// include: memoryprofiler.js + + +// end include: memoryprofiler.js +// include: URIUtils.js + + +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + // Prefix of data URIs emitted by SINGLE_FILE and related options. + return filename.startsWith(dataURIPrefix); +} + +// Indicates whether filename is delivered via file protocol (as opposed to http/https) +function isFileURI(filename) { + return filename.startsWith('file://'); +} + +// end include: URIUtils.js +/** @param {boolean=} fixedasm */ +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module['asm']; + } + assert(runtimeInitialized, 'native function `' + displayName + '` called before runtime initialization'); + if (!asm[name]) { + assert(asm[name], 'exported native function `' + displayName + '` not found'); + } + return asm[name].apply(null, arguments); + }; +} + +var wasmBinaryFile; + wasmBinaryFile = 'libzim-wasm.electron.dev.wasm'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise() { + // If we don't have the binary yet, try to to load it asynchronously. + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use fetch if it is available and the url is not a file, otherwise fall back to XHR. + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == 'function' + && !isFileURI(wasmBinaryFile) + ) { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(wasmBinaryFile); + }); + } + else { + if (readAsync) { + // fetch is not available or url is file => try XHR (readAsync uses XHR internally) + return new Promise(function(resolve, reject) { + readAsync(wasmBinaryFile, function(response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))) }, reject) + }); + } + } + } + + // Otherwise, getBinary should be able to get it synchronously + return Promise.resolve().then(function() { return getBinary(wasmBinaryFile); }); +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': asmLibraryArg, + 'wasi_snapshot_preview1': asmLibraryArg, + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + var exports = instance.exports; + + Module['asm'] = exports; + + wasmMemory = Module['asm']['memory']; + assert(wasmMemory, "memory not found in wasm exports"); + // This assertion doesn't hold when emscripten is run in --post-link + // mode. + // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode. + //assert(wasmMemory.buffer.byteLength === 83886080); + updateGlobalBufferAndViews(wasmMemory.buffer); + + wasmTable = Module['asm']['__indirect_function_table']; + assert(wasmTable, "table not found in wasm exports"); + + addOnInit(Module['asm']['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(function (instance) { + return instance; + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + + // Warn on some common problems. + if (isFileURI(wasmBinaryFile)) { + err('warning: Loading from a file URI (' + wasmBinaryFile + ') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing'); + } + abort(reason); + }); + } + + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(wasmBinaryFile) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(wasmBinaryFile) && + typeof fetch == 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, info); + + return result.then( + receiveInstantiationResult, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(receiveInstantiationResult); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiationResult); + } + } + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel + // to any other async startup actions they are performing. + // Also pthreads and wasm workers initialize the wasm instance through this path. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + instantiateAsync(); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = { + +}; + + + + + + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(Module); // Pass the module as the first argument. + continue; + } + var func = callback.func; + if (typeof func == 'number') { + if (callback.arg === undefined) { + // Run the wasm function ptr with signature 'v'. If no function + // with such signature was exported, this call does not need + // to be emitted (and would confuse Closure) + getWasmTableEntry(func)(); + } else { + // If any function with signature 'vi' was exported, run + // the callback with that signature. + getWasmTableEntry(func)(callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } + } + + function withStackSave(f) { + var stack = stackSave(); + var ret = f(); + stackRestore(stack); + return ret; + } + function demangle(func) { + // If demangle has failed before, stop demangling any further function names + // This avoids an infinite recursion with malloc()->abort()->stackTrace()->demangle()->malloc()->... + demangle.recursionGuard = (demangle.recursionGuard|0)+1; + if (demangle.recursionGuard > 1) return func; + var __cxa_demangle_func = Module['___cxa_demangle'] || Module['__cxa_demangle']; + assert(__cxa_demangle_func); + return withStackSave(function() { + try { + var s = func; + if (s.startsWith('__Z')) + s = s.substr(1); + var len = lengthBytesUTF8(s)+1; + var buf = stackAlloc(len); + stringToUTF8(s, buf, len); + var status = stackAlloc(4); + var ret = __cxa_demangle_func(buf, 0, 0, status); + if (HEAP32[((status)>>2)] === 0 && ret) { + return UTF8ToString(ret); + } + // otherwise, libcxxabi failed + } catch(e) { + } finally { + _free(ret); + if (demangle.recursionGuard < 2) --demangle.recursionGuard; + } + // failure when using libcxxabi, don't demangle + 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 + ']'); + }); + } + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = 'i32'; + switch (type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return Number(HEAPF64[((ptr)>>3)]); + default: abort('invalid type for getValue: ' + type); + } + return null; + } + + var wasmTableMirror = []; + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!"); + return func; + } + + function handleException(e) { + // Certain exception types we do not treat as errors since they are used for + // internal control flow. + // 1. ExitStatus, which is thrown by exit() + // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others + // that wish to return to JS event loop. + if (e instanceof ExitStatus || e == 'unwind') { + return EXITSTATUS; + } + quit_(1, e); + } + + function jsStackTrace() { + var error = new Error(); + if (!error.stack) { + // IE10+ special cases: It does have callstack info, but it is only + // populated if an Error object is thrown, so try that as a special-case. + try { + throw new Error(); + } catch(e) { + error = e; + } + if (!error.stack) { + return '(no stack trace available)'; + } + } + return error.stack.toString(); + } + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) 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.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + default: abort('invalid type for setValue: ' + type); + } + } + + function setWasmTableEntry(idx, func) { + wasmTable.set(idx, func); + // With ABORT_ON_WASM_EXCEPTIONS wasmTable.get is overriden to return wrapped + // functions so we need to call it here to retrieve the potential wrapper correctly + // instead of just storing 'func' directly into wasmTableMirror + wasmTableMirror[idx] = wasmTable.get(idx); + } + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + + function ___assert_fail(condition, filename, line, func) { + abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + } + + function ___call_sighandler(fp, sig) { + getWasmTableEntry(fp)(sig); + } + + function ___cxa_allocate_exception(size) { + // Thrown object is prepended by exception metadata block + return _malloc(size + 24) + 24; + } + + var exceptionCaught = []; + + function exception_addRef(info) { + info.add_ref(); + } + + var uncaughtExceptionCount = 0; + function ___cxa_begin_catch(ptr) { + var info = new ExceptionInfo(ptr); + if (!info.get_caught()) { + info.set_caught(true); + uncaughtExceptionCount--; + } + info.set_rethrown(false); + exceptionCaught.push(info); + exception_addRef(info); + return info.get_exception_ptr(); + } + + /** @constructor */ + function ExceptionInfo(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + + this.set_type = function(type) { + HEAPU32[(((this.ptr)+(4))>>2)] = type; + }; + + this.get_type = function() { + return HEAPU32[(((this.ptr)+(4))>>2)]; + }; + + this.set_destructor = function(destructor) { + HEAPU32[(((this.ptr)+(8))>>2)] = destructor; + }; + + this.get_destructor = function() { + return HEAPU32[(((this.ptr)+(8))>>2)]; + }; + + this.set_refcount = function(refcount) { + HEAP32[((this.ptr)>>2)] = refcount; + }; + + this.set_caught = function (caught) { + caught = caught ? 1 : 0; + HEAP8[(((this.ptr)+(12))>>0)] = caught; + }; + + this.get_caught = function () { + return HEAP8[(((this.ptr)+(12))>>0)] != 0; + }; + + this.set_rethrown = function (rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(((this.ptr)+(13))>>0)] = rethrown; + }; + + this.get_rethrown = function () { + return HEAP8[(((this.ptr)+(13))>>0)] != 0; + }; + + // Initialize native structure fields. Should be called once after allocated. + this.init = function(type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + this.set_refcount(0); + this.set_caught(false); + this.set_rethrown(false); + } + + this.add_ref = function() { + var value = HEAP32[((this.ptr)>>2)]; + HEAP32[((this.ptr)>>2)] = value + 1; + }; + + // Returns true if last reference released. + this.release_ref = function() { + var prev = HEAP32[((this.ptr)>>2)]; + HEAP32[((this.ptr)>>2)] = prev - 1; + assert(prev > 0); + return prev === 1; + }; + + this.set_adjusted_ptr = function(adjustedPtr) { + HEAPU32[(((this.ptr)+(16))>>2)] = adjustedPtr; + }; + + this.get_adjusted_ptr = function() { + return HEAPU32[(((this.ptr)+(16))>>2)]; + }; + + // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted + // when the pointer is casted to some of the exception object base classes (e.g. when virtual + // inheritance is used). When a pointer is thrown this method should return the thrown pointer + // itself. + this.get_exception_ptr = function() { + // Work around a fastcomp bug, this code is still included for some reason in a build without + // exceptions support. + var isPointer = ___cxa_is_pointer_type(this.get_type()); + if (isPointer) { + return HEAPU32[((this.excPtr)>>2)]; + } + var adjusted = this.get_adjusted_ptr(); + if (adjusted !== 0) return adjusted; + return this.excPtr; + }; + } + function ___cxa_free_exception(ptr) { + try { + return _free(new ExceptionInfo(ptr).ptr); + } catch(e) { + err('exception during __cxa_free_exception: ' + e); + } + } + function exception_decRef(info) { + // A rethrown exception can reach refcount 0; it must not be discarded + // Its next handler will clear the rethrown flag and addRef it, prior to + // final decRef and destruction here + if (info.release_ref() && !info.get_rethrown()) { + var destructor = info.get_destructor(); + if (destructor) { + // In Wasm, destructors return 'this' as in ARM + getWasmTableEntry(destructor)(info.excPtr); + } + ___cxa_free_exception(info.excPtr); + } + } + function ___cxa_decrement_exception_refcount(ptr) { + if (!ptr) return; + exception_decRef(new ExceptionInfo(ptr)); + } + + var exceptionLast = 0; + function ___cxa_end_catch() { + // Clear state flag. + _setThrew(0); + assert(exceptionCaught.length > 0); + // Call destructor if one is registered then clear it. + var info = exceptionCaught.pop(); + + exception_decRef(info); + exceptionLast = 0; // XXX in decRef? + } + + function ___resumeException(ptr) { + if (!exceptionLast) { exceptionLast = ptr; } + throw ptr; + } + function ___cxa_find_matching_catch_2() { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + var typeArray = Array.prototype.slice.call(arguments); + + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + var caughtType = typeArray[i]; + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; + } + + function ___cxa_find_matching_catch_3() { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + var typeArray = Array.prototype.slice.call(arguments); + + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + var caughtType = typeArray[i]; + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; + } + + function ___cxa_find_matching_catch_4() { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + var typeArray = Array.prototype.slice.call(arguments); + + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + var caughtType = typeArray[i]; + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; + } + + + function ___cxa_increment_exception_refcount(ptr) { + if (!ptr) return; + exception_addRef(new ExceptionInfo(ptr)); + } + + function ___cxa_rethrow() { + var info = exceptionCaught.pop(); + if (!info) { + abort('no exception to throw'); + } + var ptr = info.excPtr; + if (!info.get_rethrown()) { + // Only pop if the corresponding push was through rethrow_primary_exception + exceptionCaught.push(info); + info.set_rethrown(true); + info.set_caught(false); + uncaughtExceptionCount++; + } + exceptionLast = ptr; + throw ptr; + } + + function ___cxa_rethrow_primary_exception(ptr) { + if (!ptr) return; + var info = new ExceptionInfo(ptr); + exceptionCaught.push(info); + info.set_rethrown(true); + ___cxa_rethrow(); + } + + function ___cxa_throw(ptr, type, destructor) { + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw ptr; + } + + function ___cxa_uncaught_exceptions() { + return uncaughtExceptionCount; + } + + + var PATH = {isAbs:(path) => path.charAt(0) === '/',splitPath:(filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:(parts, allowAboveRoot) => { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:(path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter((p) => !!p), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:(path) => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:(path) => { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },join:function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:(l, r) => { + return PATH.normalize(l + '/' + r); + }}; + + function getRandomDevice() { + if (typeof crypto == 'object' && typeof crypto['getRandomValues'] == 'function') { + // for modern web browsers + var randomBuffer = new Uint8Array(1); + return function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; }; + } else + if (ENVIRONMENT_IS_NODE) { + // for nodejs with or without crypto support included + try { + var crypto_module = require('crypto'); + // nodejs has crypto support + return function() { return crypto_module['randomBytes'](1)[0]; }; + } catch (e) { + // nodejs doesn't have crypto support + } + } + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + return function() { abort("no cryptographic support found for randomDevice. 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 } };"); }; + } + + var PATH_FS = {resolve:function() { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path != 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter((p) => !!p), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + },relative:(from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }}; + + var TTY = {ttys:[],init:function () { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process['stdin']['setEncoding']('utf8'); + // } + },shutdown:function() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process['stdin']['pause'](); + // } + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + // flush any pending line data + stream.tty.ops.flush(stream.tty); + },flush:function(stream) { + stream.tty.ops.flush(stream.tty); + },read:function(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + },write:function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes, + // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0. + if (e.toString().includes('EOF')) bytesRead = 0; + else throw e; + } + + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString('utf-8'); + } else { + result = null; + } + } else + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + if (result !== null) { + result += '\n'; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + },put_char:function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }},default_tty1_ops:{put_char:function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + } + + function alignMemory(size, alignment) { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + size = alignMemory(size, 65536); + var ptr = _emscripten_builtin_memalign(65536, size); + if (!ptr) return 0; + zeroMemory(ptr, size); + return ptr; + } + var MEMFS = {ops_table:null,mount:function(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + },createNode:function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + }; + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + },getFileDataAsTypedArray:function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + },expandFileStorage:function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + },resizeFileStorage:function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + } + },node_ops:{getattr:function(node) { + var attr = {}; + // device numbers reuse inode numbers. + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + },setattr:function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + },lookup:function(parent, name) { + throw FS.genericErrors[44]; + },mknod:function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + },rename:function(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + // do the internal rewiring + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now() + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + },unlink:function(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + },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]; + parent.timestamp = Date.now(); + },readdir:function(node) { + var entries = ['.', '..']; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue; + } + entries.push(key); + } + return entries; + },symlink:function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + },readlink:function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }},stream_ops:{read:function(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + assert(size >= 0); + if (size > 8 && contents.subarray) { // non-trivial, and typed array + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + },write:function(stream, buffer, offset, length, position, canOwn) { + // The data buffer should be a typed array view + assert(!(buffer instanceof ArrayBuffer)); + // If the buffer is located in main memory (HEAP), and if + // memory can grow, we can't hold on to references of the + // memory buffer, as they may get invalidated. That means we + // need to do copy its contents. + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + if (canOwn) { + assert(position === 0, 'canOwn must imply no weird position inside the file'); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) { + // Use typed array write which is available. + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + },llseek:function(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + },allocate:function(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + },mmap:function(stream, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + // Only make a new copy when MAP_PRIVATE is specified. + if (!(flags & 2) && contents.buffer === buffer) { + // We can't emulate MAP_SHARED when the file is not backed by the buffer + // we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + // Try to avoid unnecessary slices. + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = 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) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }}}; + + /** @param {boolean=} noRunDep */ + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : ''; + readAsync(url, function(arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, function(event) { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }); + if (dep) addRunDependency(dep); + } + + var ERRNO_CODES = {}; + var NODEFS = {isWindows:false,staticInit:() => { + NODEFS.isWindows = !!process.platform.match(/^win/); + var flags = process["binding"]("constants"); + // Node.js 4 compatibility: it has no namespaces for constants + if (flags["fs"]) { + flags = flags["fs"]; + } + NODEFS.flagsForNodeMap = { + "1024": flags["O_APPEND"], + "64": flags["O_CREAT"], + "128": flags["O_EXCL"], + "256": flags["O_NOCTTY"], + "0": flags["O_RDONLY"], + "2": flags["O_RDWR"], + "4096": flags["O_SYNC"], + "512": flags["O_TRUNC"], + "1": flags["O_WRONLY"], + "131072": flags["O_NOFOLLOW"], + }; + // The 0 define must match on both sides, as otherwise we would not + // know to add it. + assert(NODEFS.flagsForNodeMap["0"] === 0); + },convertNodeCode:(e) => { + var code = e.code; + assert(code in ERRNO_CODES, 'unexpected node error code: ' + code + ' (' + e + ')'); + return ERRNO_CODES[code]; + },mount:(mount) => { + assert(ENVIRONMENT_IS_NODE); + return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0); + },createNode:(parent, name, mode, dev) => { + if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) { + throw new FS.ErrnoError(28); + } + var node = FS.createNode(parent, name, mode); + node.node_ops = NODEFS.node_ops; + node.stream_ops = NODEFS.stream_ops; + return node; + },getMode:(path) => { + var stat; + try { + stat = fs.lstatSync(path); + if (NODEFS.isWindows) { + // Node.js on Windows never represents permission bit 'x', so + // propagate read bits to execute bits + stat.mode = stat.mode | ((stat.mode & 292) >> 2); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + return stat.mode; + },realPath:(node) => { + var parts = []; + while (node.parent !== node) { + parts.push(node.name); + node = node.parent; + } + parts.push(node.mount.opts.root); + parts.reverse(); + return PATH.join.apply(null, parts); + },flagsForNode:(flags) => { + flags &= ~2097152; // Ignore this flag from musl, otherwise node.js fails to open the file. + flags &= ~2048; // Ignore this flag from musl, otherwise node.js fails to open the file. + flags &= ~32768; // Ignore this flag from musl, otherwise node.js fails to open the file. + flags &= ~524288; // Some applications may pass it; it makes no sense for a single process. + flags &= ~65536; // Node.js doesn't need this passed in, it errors. + var newFlags = 0; + for (var k in NODEFS.flagsForNodeMap) { + if (flags & k) { + newFlags |= NODEFS.flagsForNodeMap[k]; + flags ^= k; + } + } + if (!flags) { + return newFlags; + } else { + throw new FS.ErrnoError(28); + } + },node_ops:{getattr:(node) => { + var path = NODEFS.realPath(node); + var stat; + try { + stat = fs.lstatSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096. + // See http://support.microsoft.com/kb/140365 + if (NODEFS.isWindows && !stat.blksize) { + stat.blksize = 4096; + } + if (NODEFS.isWindows && !stat.blocks) { + stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0; + } + return { + dev: stat.dev, + ino: stat.ino, + mode: stat.mode, + nlink: stat.nlink, + uid: stat.uid, + gid: stat.gid, + rdev: stat.rdev, + size: stat.size, + atime: stat.atime, + mtime: stat.mtime, + ctime: stat.ctime, + blksize: stat.blksize, + blocks: stat.blocks + }; + },setattr:(node, attr) => { + var path = NODEFS.realPath(node); + try { + if (attr.mode !== undefined) { + fs.chmodSync(path, attr.mode); + // update the common node structure mode as well + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + var date = new Date(attr.timestamp); + fs.utimesSync(path, date, date); + } + if (attr.size !== undefined) { + fs.truncateSync(path, attr.size); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },lookup:(parent, name) => { + var path = PATH.join2(NODEFS.realPath(parent), name); + var mode = NODEFS.getMode(path); + return NODEFS.createNode(parent, name, mode); + },mknod:(parent, name, mode, dev) => { + var node = NODEFS.createNode(parent, name, mode, dev); + // create the backing node for this in the fs root as well + var path = NODEFS.realPath(node); + try { + if (FS.isDir(node.mode)) { + fs.mkdirSync(path, node.mode); + } else { + fs.writeFileSync(path, '', { mode: node.mode }); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + return node; + },rename:(oldNode, newDir, newName) => { + var oldPath = NODEFS.realPath(oldNode); + var newPath = PATH.join2(NODEFS.realPath(newDir), newName); + try { + fs.renameSync(oldPath, newPath); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + oldNode.name = newName; + },unlink:(parent, name) => { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.unlinkSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },rmdir:(parent, name) => { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.rmdirSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },readdir:(node) => { + var path = NODEFS.realPath(node); + try { + return fs.readdirSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },symlink:(parent, newName, oldPath) => { + var newPath = PATH.join2(NODEFS.realPath(parent), newName); + try { + fs.symlinkSync(oldPath, newPath); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },readlink:(node) => { + var path = NODEFS.realPath(node); + try { + path = fs.readlinkSync(path); + path = nodePath.relative(nodePath.resolve(node.mount.opts.root), path); + return path; + } catch (e) { + if (!e.code) throw e; + // node under windows can return code 'UNKNOWN' here: + // https://github.com/emscripten-core/emscripten/issues/15468 + if (e.code === 'UNKNOWN') throw new FS.ErrnoError(28); + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + }},stream_ops:{open:(stream) => { + var path = NODEFS.realPath(stream.node); + try { + if (FS.isFile(stream.node.mode)) { + stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags)); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },close:(stream) => { + try { + if (FS.isFile(stream.node.mode) && stream.nfd) { + fs.closeSync(stream.nfd); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },read:(stream, buffer, offset, length, position) => { + // Node.js < 6 compatibility: node errors on 0 length reads + if (length === 0) return 0; + try { + return fs.readSync(stream.nfd, Buffer.from(buffer.buffer), offset, length, position); + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },write:(stream, buffer, offset, length, position) => { + try { + return fs.writeSync(stream.nfd, Buffer.from(buffer.buffer), offset, length, position); + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },llseek:(stream, offset, whence) => { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + try { + var stat = fs.fstatSync(stream.nfd); + position += stat.size; + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + } + } + + if (position < 0) { + throw new FS.ErrnoError(28); + } + + return position; + },mmap:(stream, length, position, prot, flags) => { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + + var ptr = mmapAlloc(length); + + NODEFS.stream_ops.read(stream, HEAP8, ptr, length, position); + return { ptr: ptr, allocated: true }; + },msync:(stream, buffer, offset, length, mmapFlags) => { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (mmapFlags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + + var bytesWritten = NODEFS.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 FS = {root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path, opts = {}) => { + path = PATH_FS.resolve(FS.cwd(), path); + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + opts = Object.assign(defaults, opts) + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the path + var parts = PATH.normalizeArray(path.split('/').filter((p) => !!p), false); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },getPath:(node) => { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path; + } + path = path ? node.name + '/' + path : node.name; + node = node.parent; + } + },hashName:(parentid, name) => { + var hash = 0; + + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + },hashAddNode:(node) => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + },hashRemoveNode:(node) => { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + },lookupNode:(parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + },createNode:(parent, name, mode, rdev) => { + assert(typeof parent == 'object') + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + },destroyNode:(node) => { + FS.hashRemoveNode(node); + },isRoot:(node) => { + return node === node.parent; + },isMountpoint:(node) => { + return !!node.mounted; + },isFile:(mode) => { + return (mode & 61440) === 32768; + },isDir:(mode) => { + return (mode & 61440) === 16384; + },isLink:(mode) => { + return (mode & 61440) === 40960; + },isChrdev:(mode) => { + return (mode & 61440) === 8192; + },isBlkdev:(mode) => { + return (mode & 61440) === 24576; + },isFIFO:(mode) => { + return (mode & 61440) === 4096; + },isSocket:(mode) => { + return (mode & 49152) === 49152; + },flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:(str) => { + var flags = FS.flagModes[str]; + if (typeof flags == 'undefined') { + throw new Error('Unknown file open mode: ' + str); + } + return flags; + },flagsToPermissionString:(flag) => { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + },nodePermissions:(node, perms) => { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.includes('r') && !(node.mode & 292)) { + return 2; + } else if (perms.includes('w') && !(node.mode & 146)) { + return 2; + } else if (perms.includes('x') && !(node.mode & 73)) { + return 2; + } + return 0; + },mayLookup:(dir) => { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:(dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + },mayDelete:(dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + },mayOpen:(node, flags) => { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:(fd_start = 0, 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:(fd) => FS.streams[fd],createStream:(stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = /** @constructor */ function() { + this.shared = { }; + }; + 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); } + }, + flags: { + get: function() { return this.shared.flags; }, + set: function(val) { this.shared.flags = val; }, + }, + position : { + get function() { return this.shared.position; }, + set: function(val) { this.shared.position = val; }, + }, + }; + } + // clone it, so we can return an instance of FSStream + stream = Object.assign(new FS.FSStream(), stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:(fd) => { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:(stream) => { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + },llseek:() => { + throw new FS.ErrnoError(70); + }},major:(dev) => ((dev) >> 8),minor:(dev) => ((dev) & 0xff),makedev:(ma, mi) => ((ma) << 8 | (mi)),registerDevice:(dev, ops) => { + FS.devices[dev] = { stream_ops: ops }; + },getDevice:(dev) => FS.devices[dev],getMounts:(mount) => { + var mounts = []; + var check = [mount]; + + while (check.length) { + var m = check.pop(); + + mounts.push(m); + + check.push.apply(check, m.mounts); + } + + return mounts; + },syncfs:(populate, callback) => { + if (typeof populate == 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work'); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + },mount:(type, opts, mountpoint) => { + if (typeof type == 'string') { + // The filesystem was not included, and instead we have an error + // message stored in the variable. + throw type; + } + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:(mountpoint) => { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + + current = next; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + },lookup:(parent, name) => { + return parent.node_ops.lookup(parent, name); + },mknod:(path, mode, dev) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:(path, mode) => { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:(path, mode) => { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:(path, mode) => { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:(path, mode, dev) => { + if (typeof dev == 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:(oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:(old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + + // let the errors from non existant directories percolate up + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + // if we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + FS.hashAddNode(old_node); + } + },rmdir:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + },readdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + },readlink:(path) => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:(path, dontFollow) => { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:(path) => { + return FS.stat(path, true); + },chmod:(path, mode, dontFollow) => { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:(path, mode) => { + FS.chmod(path, mode, true); + },fchmod:(fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:(path, uid, gid, dontFollow) => { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + },lchown:(path, uid, gid) => { + FS.chown(path, uid, gid, true); + },fchown:(fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:(path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:(fd, len) => { + var stream = FS.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:(path, atime, mtime) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + },open:(path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == 'string' ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512) && !created) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), // we want the absolute path to the node + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + },close:(stream) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:(stream) => { + return stream.fd === null; + },llseek:(stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:(stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:(stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + },allocate:(stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:(stream, length, position, prot, flags) => { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + },msync:(stream, buffer, offset, length, mmapFlags) => { + if (!stream || !stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:(stream) => 0,ioctl:(stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:(path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || 'binary'; + if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === 'utf8') { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + },writeFile:(path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + },cwd:() => FS.currentPath,chdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:() => { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:() => { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using err() rather than out() + // so we register a second tty just for it. + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + // setup /dev/[u]random + var random_device = getRandomDevice(); + FS.createDevice('/dev', 'random', random_device); + FS.createDevice('/dev', 'urandom', random_device); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + },createSpecialDirectories:() => { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: () => { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup: (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: () => stream.path }, + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:() => { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 0); + var stdout = FS.open('/dev/stdout', 1); + var stderr = FS.open('/dev/stderr', 1); + 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:() => { + if (FS.ErrnoError) return; + FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) { + this.node = node; + this.setErrno = /** @this{Object} */ function(errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + + // Try to get a maximally helpful stack trace. On Node.js, getting Error.stack + // now ensures it shows what we want. + if (this.stack) { + // Define the stack property for Node.js 4, which otherwise errors on the next line. + Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:() => { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + 'NODEFS': NODEFS, + }; + },init:(input, output, error) => { + assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'); + FS.init.initialized = true; + + FS.ensureErrnoError(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:() => { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + _fflush(0); + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },getMode:(canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + },findObject:(path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + return null; + } + },analyzePath:(path, dontResolveLastLink) => { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createPath:(parent, path, canRead, canWrite) => { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + },createFile:(parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + },createDataFile:(parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:(parent, name, input, output) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open: (stream) => { + stream.seekable = false; + }, + close: (stream) => { + // flush any pending line data + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos /* ignored */) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },forceLoadFile:(obj) => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != 'undefined') { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + },createLazyFile:(parent, name, url, canRead, canWrite) => { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + /** @constructor */ + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(/** @type{Array} */(xhr.response || [])); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }; + var lazyArray = this; + lazyArray.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof lazyArray.chunks[chunkNum] == 'undefined') { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray.chunks[chunkNum] == 'undefined') throw new Error('doXHR failed!'); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest != 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: /** @this {FSNode} */ function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + // use a custom read function + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + }; + node.stream_ops = stream_ops; + return node; + },createPreloadedFile:(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, (byteArray) => processData(byteArray), onerror); + } else { + processData(url); + } + },indexedDB:() => { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + },DB_NAME:() => { + return 'EM_FS_' + window.location.pathname; + },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = () => { + out('creating db'); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + 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((path) => { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = () => { ok++; if (ok + fail == total) finish() }; + putRequest.onerror = () => { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },loadFilesFromDB:(paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; // no database to load from + openRequest.onsuccess = () => { + 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((path) => { + var getRequest = files.get(path); + 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 = () => { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },absolutePath:() => { + abort('FS.absolutePath has been removed; use PATH_FS.resolve instead'); + },createFolder:() => { + abort('FS.createFolder has been removed; use FS.mkdir instead'); + },createLink:() => { + abort('FS.createLink has been removed; use FS.symlink instead'); + },joinPath:() => { + abort('FS.joinPath has been removed; use PATH.join instead'); + },mmapAlloc:() => { + abort('FS.mmapAlloc has been replaced by the top level function mmapAlloc'); + },standardizePath:() => { + abort('FS.standardizePath has been removed; use PATH.normalize instead'); + }}; + var SYSCALLS = {DEFAULT_POLLMASK:5,calculateAt:function(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + // relative path + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) throw new FS.ErrnoError(8); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44);; + } + return dir; + } + return PATH.join2(dir, path); + },doStat:function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + // an error occurred while trying to look up the path; we should just report ENOTDIR + return -54; + } + throw e; + } + HEAP32[((buf)>>2)] = stat.dev; + HEAP32[(((buf)+(4))>>2)] = 0; + HEAP32[(((buf)+(8))>>2)] = stat.ino; + HEAP32[(((buf)+(12))>>2)] = stat.mode; + HEAP32[(((buf)+(16))>>2)] = stat.nlink; + HEAP32[(((buf)+(20))>>2)] = stat.uid; + HEAP32[(((buf)+(24))>>2)] = stat.gid; + HEAP32[(((buf)+(28))>>2)] = stat.rdev; + HEAP32[(((buf)+(32))>>2)] = 0; + (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]); + HEAP32[(((buf)+(48))>>2)] = 4096; + HEAP32[(((buf)+(52))>>2)] = stat.blocks; + HEAP32[(((buf)+(56))>>2)] = (stat.atime.getTime() / 1000)|0; + HEAP32[(((buf)+(60))>>2)] = 0; + HEAP32[(((buf)+(64))>>2)] = (stat.mtime.getTime() / 1000)|0; + HEAP32[(((buf)+(68))>>2)] = 0; + HEAP32[(((buf)+(72))>>2)] = (stat.ctime.getTime() / 1000)|0; + HEAP32[(((buf)+(76))>>2)] = 0; + (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(80))>>2)] = tempI64[0],HEAP32[(((buf)+(84))>>2)] = tempI64[1]); + return 0; + },doMsync:function(addr, stream, len, flags, offset) { + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + },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; + }}; + function ___syscall_fadvise64(fd, offset, len, advice) { + return 0; // your advice is important to us (but we can't use it) + } + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)] = value; + return value; + } + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; // FD_CLOEXEC makes no sense for a single process. + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 5: + /* case 5: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ { + + var arg = SYSCALLS.get(); + var offset = 0; + // We're always unlocked. + HEAP16[(((arg)+(offset))>>1)] = 2; + return 0; + } + case 6: + case 7: + /* case 6: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + /* case 7: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + + + return 0; // Pretend that the locking is successful. + case 16: + case 8: + return -28; // These are for sockets. We don't have them fully implemented yet. + case 9: + // musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fcntl() returns that, and we set errno ourselves. + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_fstat64(fd, buf) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_lstat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & (~4352); + assert(!flags, flags); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_stat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_unlinkat(dirfd, path, flags) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path); + } else if (flags === 512) { + FS.rmdir(path); + } else { + abort('Invalid flags passed to unlinkat'); + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + + 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; + } + return name; + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + /*jshint evil:true*/ + return new Function( + "body", + "return function " + name + "() {\n" + + " \"use strict\";" + + " return body.apply(this, arguments);\n" + + "};\n" + )(body); + } + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return this.name + ': ' + this.message; + } + }; + + return errorClass; + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options = {}) { + 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((cb) => cb()); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': function(pointer) { + // TODO: if heap is fixed (like in asm.js) this could be executed outside + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this['fromWireType'](heap[pointer >> shift]); + }, + destructorFunction: null, // This type does not need a destructor + }); + } + + 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 finalizationRegistry = 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 downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; // no conversion + } + + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + + var registeredPointers = {}; + + 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; + } + + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj['delete'](); + } + } + + var delayFunction = undefined; + 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) { + // ptr is a raw pointer (or a raw smartpointer) + + // rawPointer is a maybe-null raw pointer + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + // JS object has been neutered, time to repopulate it + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance['clone'](); + } else { + // else, just increment reference count on existing object + // it already has a reference to the smart pointer + 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 attachFinalizer(handle) { + if ('undefined' === typeof FinalizationRegistry) { + attachFinalizer = (handle) => handle; + return handle; + } + // If the running environment has a FinalizationRegistry (see + // https://github.com/tc39/proposal-weakrefs), then attach finalizers + // for class handles. We check for the presence of FinalizationRegistry + // at run-time, not build-time. + finalizationRegistry = new FinalizationRegistry((info) => { + console.warn(info.leakWarning.stack.replace(/^Error: /, '')); + releaseClassHandle(info.$$); + }); + attachFinalizer = (handle) => { + var $$ = handle.$$; + var hasSmartPtr = !!$$.smartPtr; + if (hasSmartPtr) { + // We should not call the destructor on raw pointers in case other code expects the pointee to live + var info = { $$: $$ }; + // Create a warning as an Error instance in advance so that we can store + // the current stacktrace and point to it when / if a leak is detected. + // This is more useful than the empty stacktrace of `FinalizationRegistry` + // callback. + var cls = $$.ptrType.registeredClass; + info.leakWarning = new Error("Embind found a leaked C++ instance " + cls.name + " <0x" + $$.ptr.toString(16) + ">.\n" + + "We'll free it automatically in this case, but this functionality is not reliable across various environments.\n" + + "Make sure to invoke .delete() manually once you're done with the instance instead.\n" + + "Originally allocated"); // `.stack` will add "at ..." after this sentence + if ('captureStackTrace' in Error) { + Error.captureStackTrace(info.leakWarning, RegisteredPointer_fromWireType); + } + finalizationRegistry.register(handle, info, handle); + } + return handle; + }; + detachFinalizer = (handle) => finalizationRegistry.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; + } + + 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() { + } + + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function() { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + 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); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + /** @param {number=} numArguments */ + 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"); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!"); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + + /** @constructor */ + 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) { + // TODO: this is not strictly true + // We could support BY_EMVAL conversions from raw pointers to smart pointers + // because the smart pointer can hold a reference to the handle + if (undefined === handle.$$.smartPtr) { + throwBindingError('Passing raw pointer to smart pointer is illegal'); + } + + switch (this.sharingPolicy) { + case 0: // NONE + // no upcasting + 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: // INTRUSIVE + ptr = handle.$$.smartPtr; + break; + + case 2: // BY_EMVAL + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle['clone'](); + ptr = this.rawShare( + ptr, + Emval.toHandle(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 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; + } + /** @constructor + @param {*=} pointeeType, + @param {*=} sharingPolicy, + @param {*=} rawGetPointee, + @param {*=} rawConstructor, + @param {*=} rawShare, + @param {*=} rawDestructor, + */ + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + + // smart pointer properties + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + + // smart pointer properties + 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; + // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns + // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time. + // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in + // craftInvokerFunction altogether. + } + } + + /** @param {number=} numArguments */ + function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistant public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + + function dynCallLegacy(sig, ptr, args) { + assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); + if (args && args.length) { + // j (64-bit integer) must be passed in as two numbers [low 32, high 32]. + assert(args.length === sig.substring(1).replace(/j/g, '--').length); + } else { + assert(sig.length == 1); + } + var f = Module["dynCall_" + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + /** @param {Object=} args */ + function dynCall(sig, ptr, args) { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of thier signature, so we rely the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), 'missing table entry in dynCall: ' + ptr); + return getWasmTableEntry(ptr).apply(null, args) + } + function getDynCaller(sig, ptr) { + assert(sig.includes('j'), 'getDynCaller should only be called with i64 sigs') + var argCache = []; + return function() { + argCache.length = 0; + Object.assign(argCache, arguments); + return dynCall(sig, ptr, argCache); + }; + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + 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() { + // this code cannot run if baseClassRawType is zero + 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 heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]); + } + return array; + } + + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + var args = [rawConstructor]; + var destructors = []; + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = 'constructor ' + classType.name; + + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount-1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!"); + } + classType.registeredClass.constructor_body[argCount - 1] = () => { + throwUnboundTypeError('Cannot construct ' + classType.name + ' due to unbound types', rawArgTypes); + }; + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Insert empty slot for context type (argTypes[1]). + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); + return []; + }); + return []; + }); + } + + function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError('new_ called with constructor type ' + typeof(constructor) + " which is not a function"); + } + /* + * Previously, the following line was just: + * function dummy() {}; + * Unfortunately, Chrome was preserving 'dummy' as the object's name, even + * though at creation, the 'dummy' has the correct constructor name. Thus, + * objects created with IMVU.new would show up in the debugger as 'dummy', + * which isn't very helpful. Using IMVU.createNamedFunction addresses the + * issue. Doublely-unfortunately, there's no way to write a test for this + * behavior. -NRD 2013.02.22 + */ + 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) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + 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); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = false; + + for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack + 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) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + 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 __embind_register_class_function(rawClassType, + methodName, + argCount, + rawArgTypesAddr, // [ReturnType, ThisType, Args...] + invokerSignature, + rawInvoker, + context, + isPureVirtual) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = classType.name + '.' + methodName; + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + + function unboundTypesHandler() { + throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes); + } + + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (undefined === method || (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)) { + // This is the first overload to be registered, OR we are replacing a + // function in the base class with a function in the derived class. + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up + // a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context); + + // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types + // are resolved. If multiple overloads are registered for this function, the function goes into an overload table. + if (undefined === proto[methodName].overloadTable) { + // Set argCount in case an overload is registered later + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + + 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; + } + var Emval = {toValue:(handle) => { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + return emval_handle_array[handle].value; + },toHandle:(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.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': function(destructors, value) { + return Emval.toHandle(value); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }); + } + + function _embind_repr(v) { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + } + + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: return function(pointer) { + return this['fromWireType'](HEAPF32[pointer >> 2]); + }; + case 3: return function(pointer) { + return this['fromWireType'](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + return value; + }, + 'toWireType': function(destructors, value) { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': floatReadValueFromPointer(name, shift), + destructorFunction: null, // This type does not need a destructor + }); + } + + 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] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn), argCount - 1); + return []; + }); + } + + function integerReadValueFromPointer(name, shift, signed) { + // integers are quite common, so generate very specialized functions + switch (shift) { + case 0: return signed ? + function readS8FromPointer(pointer) { return HEAP8[pointer]; } : + function readU8FromPointer(pointer) { return HEAPU8[pointer]; }; + case 1: return signed ? + function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : + function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; }; + case 2: return signed ? + function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : + function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come out as 'i32 -1'. Always treat those as max u32. + maxRange = 4294967295; + } + + var shift = getShiftFromSize(size); + + var fromWireType = (value) => value; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + + var isUnsignedType = (name.includes('unsigned')); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + toTypeName); + } + 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 + ']!'); + } + } + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + } + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + } + } + registerType(primitiveType, { + name: name, + 'fromWireType': fromWireType, + 'toWireType': toWireType, + 'argPackAdvance': 8, + 'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + } + + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; // in elements + var data = heap[handle + 1]; // byte offset into emscripten heap + return new TA(buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': 8, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + } + + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + var length = HEAPU32[value >> 2]; + + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (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 = () => lengthBytesUTF8(value); + } else { + getLength = () => value.length; + } + + // assumes 4-byte alignment + var length = getLength(); + var ptr = _malloc(4 + length + 1); + HEAPU32[ptr >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr + 4, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + 4 + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + 4 + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = () => HEAPU16; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = () => HEAPU32; + shift = 2; + } + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (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); + } + + // assumes 4-byte alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name: name, + 'argPackAdvance': 0, + 'fromWireType': function() { + return undefined; + }, + 'toWireType': function(destructors, o) { + // TODO: assert if anything else is given? + return undefined; + }, + }); + } + + + function __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.toHandle(v); + } + + function __mmap_js(len, prot, flags, fd, off, allocated) { + try { + + var stream = FS.getStream(fd); + if (!stream) return -8; + var res = FS.mmap(stream, len, off, prot, flags); + var ptr = res.ptr; + HEAP32[((allocated)>>2)] = res.allocated; + return ptr; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function __munmap_js(addr, len, prot, flags, fd, offset) { + try { + + var stream = FS.getStream(fd); + if (stream) { + if (prot & 2) { + SYSCALLS.doMsync(addr, stream, len, flags, offset); + } + FS.munmap(stream); + } + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function _abort() { + abort('native code called abort()'); + } + + function _emscripten_console_error(str) { + assert(typeof str == 'number'); + console.error(UTF8ToString(str)); + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + function getHeapMax() { + // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate + // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side + // for any code that deals with heap sizes, which would require special + // casing all heap size related code to treat 0 specially. + return 2147483648; + } + + function emscripten_realloc_buffer(size) { + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1 /*success*/; + } catch(e) { + err('emscripten_realloc_buffer: Attempted to grow heap from ' + buffer.byteLength + ' bytes to ' + size + ' bytes, but got error: ' + e); + } + // implicit 0 return to save code size (caller will cast "undefined" into 0 + // anyhow) + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + assert(requestedSize > oldSize); + + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err('Cannot enlarge memory, asked to go up to ' + requestedSize + ' bytes, but the limit is ' + maxHeapSize + ' bytes!'); + return false; + } + + let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + 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) { + // Default values. + // Browser language detection #8751 + var lang = ((typeof navigator == 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8'; + var env = { + 'USER': 'web_user', + 'LOGNAME': 'web_user', + 'PATH': '/', + 'PWD': '/', + 'HOME': '/home/web_user', + 'LANG': lang, + '_': getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + // x is a key in ENV; if ENV[x] is undefined, that means it was + // explicitly set to be so. We allow user code to do that to + // force variables with default values to remain unset. + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + '=' + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAPU32[(((__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(); + HEAPU32[((penviron_count)>>2)] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAPU32[((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)) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + } + return ret; + } + + function convertI32PairToI53Checked(lo, hi) { + assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32 + assert(hi === (hi|0)); // hi should be a i32 + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + } + function _fd_pread(fd, iov, iovcnt, offset_low, offset_high, pnum) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd) + var num = doReadv(stream, iov, iovcnt, offset); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + } + function _fd_pwrite(fd, iov, iovcnt, offset_low, offset_high, pnum) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd) + var num = doWritev(stream, iov, iovcnt, offset); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _getTempRet0() { + return getTempRet0(); + } + + function _llvm_eh_typeid_for(type) { + return type; + } + + function _setTempRet0(val) { + setTempRet0(val); + } + + function __isLeapYear(year) { + return year%4 === 0 && (year%100 !== 0 || year%400 === 0); + } + + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) { + // no-op + } + return sum; + } + + var __MONTH_DAYS_LEAP = [31,29,31,30,31,30,31,31,30,31,30,31]; + + var __MONTH_DAYS_REGULAR = [31,28,31,30,31,30,31,31,30,31,30,31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + + if (days > daysInCurrentMonth-newDate.getDate()) { + // we spill over to next month + days -= (daysInCurrentMonth-newDate.getDate()+1); + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth+1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear()+1); + } + } else { + // we stay in current month + newDate.setDate(newDate.getDate()+days); + return newDate; + } + } + + return newDate; + } + function _strftime(s, maxsize, format, tm) { + // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html + + var tm_zone = HEAP32[(((tm)+(40))>>2)]; + + var date = { + tm_sec: HEAP32[((tm)>>2)], + tm_min: HEAP32[(((tm)+(4))>>2)], + tm_hour: HEAP32[(((tm)+(8))>>2)], + tm_mday: HEAP32[(((tm)+(12))>>2)], + tm_mon: HEAP32[(((tm)+(16))>>2)], + tm_year: HEAP32[(((tm)+(20))>>2)], + tm_wday: HEAP32[(((tm)+(24))>>2)], + tm_yday: HEAP32[(((tm)+(28))>>2)], + tm_isdst: HEAP32[(((tm)+(32))>>2)], + tm_gmtoff: HEAP32[(((tm)+(36))>>2)], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : '' + }; + + var pattern = UTF8ToString(format); + + // expand format + var EXPANSION_RULES_1 = { + '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013 + '%D': '%m/%d/%y', // Equivalent to %m / %d / %y + '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d + '%h': '%b', // Equivalent to %b + '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation + '%R': '%H:%M', // Replaced by the time in 24-hour notation + '%T': '%H:%M:%S', // Replaced by the time + '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation + '%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation + // Modified Conversion Specifiers + '%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation. + '%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation. + '%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation. + '%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation. + '%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation. + '%EY': '%Y', // Replaced by the full alternative year representation. + '%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading characters. + '%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading characters. + '%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols. + '%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols. + '%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols. + '%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols. + '%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols. + '%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1). + '%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols. + '%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols. + '%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols. + '%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols. + '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols. + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]); + } + + var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; + var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; + + function leadingSomething(value, digits, character) { + var str = typeof value == 'number' ? value.toString() : (value || ''); + while (str.length < digits) { + str = character[0]+str; + } + return str; + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, '0'); + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : (value > 0 ? 1 : 0); + } + + var compare; + if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) { + compare = sgn(date1.getDate()-date2.getDate()); + } + } + return compare; + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: // Sunday + return new Date(janFourth.getFullYear()-1, 11, 29); + case 1: // Monday + return janFourth; + case 2: // Tuesday + return new Date(janFourth.getFullYear(), 0, 3); + case 3: // Wednesday + return new Date(janFourth.getFullYear(), 0, 2); + case 4: // Thursday + return new Date(janFourth.getFullYear(), 0, 1); + case 5: // Friday + return new Date(janFourth.getFullYear()-1, 11, 31); + case 6: // Saturday + return new Date(janFourth.getFullYear()-1, 11, 30); + } + } + + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + // this date is after the start of the first week of this year + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear()+1; + } else { + return thisDate.getFullYear(); + } + } else { + return thisDate.getFullYear()-1; + } + } + + var EXPANSION_RULES_2 = { + '%a': function(date) { + return WEEKDAYS[date.tm_wday].substring(0,3); + }, + '%A': function(date) { + return WEEKDAYS[date.tm_wday]; + }, + '%b': function(date) { + return MONTHS[date.tm_mon].substring(0,3); + }, + '%B': function(date) { + return MONTHS[date.tm_mon]; + }, + '%C': function(date) { + var year = date.tm_year+1900; + return leadingNulls((year/100)|0,2); + }, + '%d': function(date) { + return leadingNulls(date.tm_mday, 2); + }, + '%e': function(date) { + return leadingSomething(date.tm_mday, 2, ' '); + }, + '%g': function(date) { + // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year. + // In this system, weeks begin on a Monday and week 1 of the year is the week that includes + // January 4th, which is also the week that includes the first Thursday of the year, and + // is also the first week that contains at least four days in the year. + // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of + // the last week of the preceding year; thus, for Saturday 2nd January 1999, + // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th, + // or 31st is a Monday, it and any following days are part of week 1 of the following year. + // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01. + + return getWeekBasedYear(date).toString().substring(2); + }, + '%G': function(date) { + return getWeekBasedYear(date); + }, + '%H': function(date) { + return leadingNulls(date.tm_hour, 2); + }, + '%I': function(date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + '%j': function(date) { + // Day of the year (001-366) + return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3); + }, + '%m': function(date) { + return leadingNulls(date.tm_mon+1, 2); + }, + '%M': function(date) { + return leadingNulls(date.tm_min, 2); + }, + '%n': function() { + return '\n'; + }, + '%p': function(date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return 'AM'; + } else { + return 'PM'; + } + }, + '%S': function(date) { + return leadingNulls(date.tm_sec, 2); + }, + '%t': function() { + return '\t'; + }, + '%u': function(date) { + return date.tm_wday || 7; + }, + '%U': function(date) { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2); + }, + '%V': function(date) { + // Replaced by the week number of the year (Monday as the first day of the week) + // as a decimal number [01,53]. If the week containing 1 January has four + // or more days in the new year, then it is considered week 1. + // Otherwise, it is the last week of the previous year, and the next week is week 1. + // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday] + var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7 ) / 7); + // If 1 Jan is just 1-3 days past Monday, the previous week + // is also in this year. + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++; + } + if (!val) { + val = 52; + // If 31 December of prev year a Thursday, or Friday of a + // leap year, then the prev year has 53 weeks. + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || (dec31 == 5 && __isLeapYear(date.tm_year%400-1))) { + val++; + } + } else if (val == 53) { + // If 1 January is not a Thursday, and not a Wednesday of a + // leap year, then this year has only 52 weeks. + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) + val = 1; + } + return leadingNulls(val, 2); + }, + '%w': function(date) { + return date.tm_wday; + }, + '%W': function(date) { + var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7); + return leadingNulls(Math.floor(days / 7), 2); + }, + '%y': function(date) { + // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year] + return (date.tm_year+1900).toString().substring(2); + }, + '%Y': function(date) { + // Replaced by the year as a decimal number (for example, 1997). [ tm_year] + return date.tm_year+1900; + }, + '%z': function(date) { + // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ). + // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich). + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + // convert from minutes into hhmm format (which means 60 minutes = 100 units) + off = (off / 60)*100 + (off % 60); + return (ahead ? '+' : '-') + String("0000" + off).slice(-4); + }, + '%Z': function(date) { + return date.tm_zone; + }, + '%%': function() { + return '%'; + } + }; + + // Replace %% with a pair of NULLs (which cannot occur in a C string), then + // re-inject them after processing. + pattern = pattern.replace(/%%/g, '\0\0') + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date)); + } + } + pattern = pattern.replace(/\0\0/g, '%') + + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + + writeArrayToMemory(bytes, s); + return bytes.length-1; + } + function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm); // no locale support yet + } + + var FSNode = /** @constructor */ function(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292/*292*/ | 73/*73*/; + var writeMode = 146/*146*/; + Object.defineProperties(FSNode.prototype, { + read: { + get: /** @this{FSNode} */function() { + return (this.mode & readMode) === readMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: /** @this{FSNode} */function() { + return (this.mode & writeMode) === writeMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: /** @this{FSNode} */function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: /** @this{FSNode} */function() { + return FS.isChrdev(this.mode); + } + } + }); + FS.FSNode = FSNode; + FS.staticInit();; +if (ENVIRONMENT_IS_NODE) { requireNodeFS(); NODEFS.staticInit(); }; +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, + };; +embind_init_charCodes(); +BindingError = Module['BindingError'] = extendError(Error, 'BindingError');; +InternalError = Module['InternalError'] = extendError(Error, 'InternalError');; +init_ClassHandle(); +init_embind();; +init_RegisteredPointer(); +UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');; +init_emval();; +var ASSERTIONS = true; + + + +/** @type {function(string, boolean=, number=)} */ +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} + + +function checkIncomingModuleAPI() { + ignoredModuleProp('fetchSettings'); +} +var asmLibraryArg = { + "__assert_fail": ___assert_fail, + "__call_sighandler": ___call_sighandler, + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_begin_catch": ___cxa_begin_catch, + "__cxa_decrement_exception_refcount": ___cxa_decrement_exception_refcount, + "__cxa_end_catch": ___cxa_end_catch, + "__cxa_find_matching_catch_2": ___cxa_find_matching_catch_2, + "__cxa_find_matching_catch_3": ___cxa_find_matching_catch_3, + "__cxa_find_matching_catch_4": ___cxa_find_matching_catch_4, + "__cxa_free_exception": ___cxa_free_exception, + "__cxa_increment_exception_refcount": ___cxa_increment_exception_refcount, + "__cxa_rethrow": ___cxa_rethrow, + "__cxa_rethrow_primary_exception": ___cxa_rethrow_primary_exception, + "__cxa_throw": ___cxa_throw, + "__cxa_uncaught_exceptions": ___cxa_uncaught_exceptions, + "__resumeException": ___resumeException, + "__syscall_fadvise64": ___syscall_fadvise64, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_fstat64": ___syscall_fstat64, + "__syscall_lstat64": ___syscall_lstat64, + "__syscall_newfstatat": ___syscall_newfstatat, + "__syscall_openat": ___syscall_openat, + "__syscall_stat64": ___syscall_stat64, + "__syscall_unlinkat": ___syscall_unlinkat, + "_embind_register_bigint": __embind_register_bigint, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_embind_register_class_constructor": __embind_register_class_constructor, + "_embind_register_class_function": __embind_register_class_function, + "_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, + "_mmap_js": __mmap_js, + "_munmap_js": __munmap_js, + "abort": _abort, + "emscripten_console_error": _emscripten_console_error, + "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_pread": _fd_pread, + "fd_pwrite": _fd_pwrite, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "getTempRet0": _getTempRet0, + "invoke_diii": invoke_diii, + "invoke_fiii": invoke_fiii, + "invoke_i": invoke_i, + "invoke_ii": invoke_ii, + "invoke_iii": invoke_iii, + "invoke_iiii": invoke_iiii, + "invoke_iiiii": invoke_iiiii, + "invoke_iiiiii": invoke_iiiiii, + "invoke_iiiiiii": invoke_iiiiiii, + "invoke_iiiiiiii": invoke_iiiiiiii, + "invoke_iiiiiiiiiii": invoke_iiiiiiiiiii, + "invoke_iiiiiiiiiiii": invoke_iiiiiiiiiiii, + "invoke_iiiiiiiiiiiii": invoke_iiiiiiiiiiiii, + "invoke_iiiiij": invoke_iiiiij, + "invoke_jiiii": invoke_jiiii, + "invoke_v": invoke_v, + "invoke_vi": invoke_vi, + "invoke_vii": invoke_vii, + "invoke_viii": invoke_viii, + "invoke_viiii": invoke_viiii, + "invoke_viiiiiii": invoke_viiiiiii, + "invoke_viiiiiiiiii": invoke_viiiiiiiiii, + "invoke_viiiiiiiiiiiiiii": invoke_viiiiiiiiiiiiiii, + "llvm_eh_typeid_for": _llvm_eh_typeid_for, + "setTempRet0": _setTempRet0, + "strftime_l": _strftime_l +}; +var asm = createWasm(); +/** @type {function(...*):?} */ +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors"); + +/** @type {function(...*):?} */ +var _main = Module["_main"] = createExportWrapper("main"); + +/** @type {function(...*):?} */ +var _malloc = Module["_malloc"] = createExportWrapper("malloc"); + +/** @type {function(...*):?} */ +var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location"); + +/** @type {function(...*):?} */ +var _free = Module["_free"] = createExportWrapper("free"); + +/** @type {function(...*):?} */ +var ___getTypeName = Module["___getTypeName"] = createExportWrapper("__getTypeName"); + +/** @type {function(...*):?} */ +var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = createExportWrapper("__embind_register_native_and_builtin_types"); + +/** @type {function(...*):?} */ +var ___dl_seterr = Module["___dl_seterr"] = createExportWrapper("__dl_seterr"); + +/** @type {function(...*):?} */ +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); + +/** @type {function(...*):?} */ +var _emscripten_builtin_memalign = Module["_emscripten_builtin_memalign"] = createExportWrapper("emscripten_builtin_memalign"); + +/** @type {function(...*):?} */ +var _setThrew = Module["_setThrew"] = createExportWrapper("setThrew"); + +/** @type {function(...*):?} */ +var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() { + return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() { + return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() { + return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() { + return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackSave = Module["stackSave"] = createExportWrapper("stackSave"); + +/** @type {function(...*):?} */ +var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore"); + +/** @type {function(...*):?} */ +var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc"); + +/** @type {function(...*):?} */ +var ___cxa_demangle = Module["___cxa_demangle"] = createExportWrapper("__cxa_demangle"); + +/** @type {function(...*):?} */ +var ___cxa_can_catch = Module["___cxa_can_catch"] = createExportWrapper("__cxa_can_catch"); + +/** @type {function(...*):?} */ +var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = createExportWrapper("__cxa_is_pointer_type"); + +/** @type {function(...*):?} */ +var dynCall_ji = Module["dynCall_ji"] = createExportWrapper("dynCall_ji"); + +/** @type {function(...*):?} */ +var dynCall_viijj = Module["dynCall_viijj"] = createExportWrapper("dynCall_viijj"); + +/** @type {function(...*):?} */ +var dynCall_iij = Module["dynCall_iij"] = createExportWrapper("dynCall_iij"); + +/** @type {function(...*):?} */ +var dynCall_iijj = Module["dynCall_iijj"] = createExportWrapper("dynCall_iijj"); + +/** @type {function(...*):?} */ +var dynCall_viij = Module["dynCall_viij"] = createExportWrapper("dynCall_viij"); + +/** @type {function(...*):?} */ +var dynCall_ij = Module["dynCall_ij"] = createExportWrapper("dynCall_ij"); + +/** @type {function(...*):?} */ +var dynCall_iiiji = Module["dynCall_iiiji"] = createExportWrapper("dynCall_iiiji"); + +/** @type {function(...*):?} */ +var dynCall_iiiij = Module["dynCall_iiiij"] = createExportWrapper("dynCall_iiiij"); + +/** @type {function(...*):?} */ +var dynCall_vij = Module["dynCall_vij"] = createExportWrapper("dynCall_vij"); + +/** @type {function(...*):?} */ +var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"); + +/** @type {function(...*):?} */ +var dynCall_iiiiij = Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij"); + +/** @type {function(...*):?} */ +var dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii"); + +/** @type {function(...*):?} */ +var dynCall_jiiii = Module["dynCall_jiiii"] = createExportWrapper("dynCall_jiiii"); + +/** @type {function(...*):?} */ +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj"); + +/** @type {function(...*):?} */ +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj"); + + +function invoke_iii(index,a1,a2) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index,a1,a2,a3) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index,a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_v(index) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vii(index,a1,a2) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiii(index,a1,a2,a3,a4,a5,a6) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index,a1) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_i(index) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiii(index,a1,a2,a3,a4,a5) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiii(index,a1,a2,a3,a4,a5,a6,a7) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_diii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiij(index,a1,a2,a3,a4,a5,a6) { + var sp = stackSave(); + try { + return dynCall_iiiiij(index,a1,a2,a3,a4,a5,a6); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return dynCall_jiiii(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + + + + +// === Auto-generated postamble setup entry stuff === + +unexportedRuntimeFunction('ccall', false); +unexportedRuntimeFunction('cwrap', false); +unexportedRuntimeFunction('allocate', false); +unexportedRuntimeFunction('UTF8ArrayToString', false); +unexportedRuntimeFunction('UTF8ToString', false); +unexportedRuntimeFunction('stringToUTF8Array', false); +unexportedRuntimeFunction('stringToUTF8', false); +unexportedRuntimeFunction('lengthBytesUTF8', false); +unexportedRuntimeFunction('addOnPreRun', false); +unexportedRuntimeFunction('addOnInit', false); +unexportedRuntimeFunction('addOnPreMain', false); +unexportedRuntimeFunction('addOnExit', false); +unexportedRuntimeFunction('addOnPostRun', false); +unexportedRuntimeFunction('addRunDependency', true); +unexportedRuntimeFunction('removeRunDependency', true); +unexportedRuntimeFunction('FS_createFolder', false); +unexportedRuntimeFunction('FS_createPath', true); +unexportedRuntimeFunction('FS_createDataFile', true); +unexportedRuntimeFunction('FS_createPreloadedFile', true); +unexportedRuntimeFunction('FS_createLazyFile', true); +unexportedRuntimeFunction('FS_createLink', false); +unexportedRuntimeFunction('FS_createDevice', true); +unexportedRuntimeFunction('FS_unlink', true); +unexportedRuntimeFunction('getLEB', false); +unexportedRuntimeFunction('getFunctionTables', false); +unexportedRuntimeFunction('alignFunctionTables', false); +unexportedRuntimeFunction('registerFunctions', false); +unexportedRuntimeFunction('addFunction', false); +unexportedRuntimeFunction('removeFunction', false); +unexportedRuntimeFunction('prettyPrint', false); +unexportedRuntimeFunction('getCompilerSetting', false); +Module["print"] = out; +Module["printErr"] = err; +unexportedRuntimeFunction('getTempRet0', false); +unexportedRuntimeFunction('setTempRet0', false); +unexportedRuntimeFunction('callMain', false); +unexportedRuntimeFunction('abort', false); +unexportedRuntimeFunction('keepRuntimeAlive', false); +unexportedRuntimeFunction('wasmMemory', false); +unexportedRuntimeFunction('warnOnce', false); +unexportedRuntimeFunction('stackSave', false); +unexportedRuntimeFunction('stackRestore', false); +unexportedRuntimeFunction('stackAlloc', false); +unexportedRuntimeFunction('AsciiToString', false); +unexportedRuntimeFunction('stringToAscii', false); +unexportedRuntimeFunction('UTF16ToString', false); +unexportedRuntimeFunction('stringToUTF16', false); +unexportedRuntimeFunction('lengthBytesUTF16', false); +unexportedRuntimeFunction('UTF32ToString', false); +unexportedRuntimeFunction('stringToUTF32', false); +unexportedRuntimeFunction('lengthBytesUTF32', false); +unexportedRuntimeFunction('allocateUTF8', false); +unexportedRuntimeFunction('allocateUTF8OnStack', false); +unexportedRuntimeFunction('ExitStatus', false); +unexportedRuntimeFunction('intArrayFromString', false); +unexportedRuntimeFunction('intArrayToString', false); +unexportedRuntimeFunction('writeStringToMemory', false); +unexportedRuntimeFunction('writeArrayToMemory', false); +unexportedRuntimeFunction('writeAsciiToMemory', false); +Module["writeStackCookie"] = writeStackCookie; +Module["checkStackCookie"] = checkStackCookie; +unexportedRuntimeFunction('ptrToString', false); +unexportedRuntimeFunction('zeroMemory', false); +unexportedRuntimeFunction('stringToNewUTF8', false); +unexportedRuntimeFunction('getHeapMax', false); +unexportedRuntimeFunction('emscripten_realloc_buffer', false); +unexportedRuntimeFunction('ENV', false); +unexportedRuntimeFunction('ERRNO_CODES', false); +unexportedRuntimeFunction('ERRNO_MESSAGES', false); +unexportedRuntimeFunction('setErrNo', false); +unexportedRuntimeFunction('inetPton4', false); +unexportedRuntimeFunction('inetNtop4', false); +unexportedRuntimeFunction('inetPton6', false); +unexportedRuntimeFunction('inetNtop6', false); +unexportedRuntimeFunction('readSockaddr', false); +unexportedRuntimeFunction('writeSockaddr', false); +unexportedRuntimeFunction('DNS', false); +unexportedRuntimeFunction('getHostByName', false); +unexportedRuntimeFunction('Protocols', false); +unexportedRuntimeFunction('Sockets', false); +unexportedRuntimeFunction('getRandomDevice', false); +unexportedRuntimeFunction('traverseStack', false); +unexportedRuntimeFunction('UNWIND_CACHE', false); +unexportedRuntimeFunction('convertPCtoSourceLocation', false); +unexportedRuntimeFunction('readAsmConstArgsArray', false); +unexportedRuntimeFunction('readAsmConstArgs', false); +unexportedRuntimeFunction('mainThreadEM_ASM', false); +unexportedRuntimeFunction('jstoi_q', false); +unexportedRuntimeFunction('jstoi_s', false); +unexportedRuntimeFunction('getExecutableName', false); +unexportedRuntimeFunction('listenOnce', false); +unexportedRuntimeFunction('autoResumeAudioContext', false); +unexportedRuntimeFunction('dynCallLegacy', false); +unexportedRuntimeFunction('getDynCaller', false); +unexportedRuntimeFunction('dynCall', false); +unexportedRuntimeFunction('handleException', false); +unexportedRuntimeFunction('runtimeKeepalivePush', false); +unexportedRuntimeFunction('runtimeKeepalivePop', false); +unexportedRuntimeFunction('callUserCallback', false); +unexportedRuntimeFunction('maybeExit', false); +unexportedRuntimeFunction('safeSetTimeout', false); +unexportedRuntimeFunction('asmjsMangle', false); +unexportedRuntimeFunction('asyncLoad', false); +unexportedRuntimeFunction('alignMemory', false); +unexportedRuntimeFunction('mmapAlloc', false); +unexportedRuntimeFunction('writeI53ToI64', false); +unexportedRuntimeFunction('writeI53ToI64Clamped', false); +unexportedRuntimeFunction('writeI53ToI64Signaling', false); +unexportedRuntimeFunction('writeI53ToU64Clamped', false); +unexportedRuntimeFunction('writeI53ToU64Signaling', false); +unexportedRuntimeFunction('readI53FromI64', false); +unexportedRuntimeFunction('readI53FromU64', false); +unexportedRuntimeFunction('convertI32PairToI53', false); +unexportedRuntimeFunction('convertI32PairToI53Checked', false); +unexportedRuntimeFunction('convertU32PairToI53', false); +unexportedRuntimeFunction('reallyNegative', false); +unexportedRuntimeFunction('unSign', false); +unexportedRuntimeFunction('strLen', false); +unexportedRuntimeFunction('reSign', false); +unexportedRuntimeFunction('formatString', false); +unexportedRuntimeFunction('setValue', false); +unexportedRuntimeFunction('getValue', false); +unexportedRuntimeFunction('PATH', false); +unexportedRuntimeFunction('PATH_FS', false); +unexportedRuntimeFunction('SYSCALLS', false); +unexportedRuntimeFunction('getSocketFromFD', false); +unexportedRuntimeFunction('getSocketAddress', false); +unexportedRuntimeFunction('JSEvents', false); +unexportedRuntimeFunction('registerKeyEventCallback', false); +unexportedRuntimeFunction('specialHTMLTargets', false); +unexportedRuntimeFunction('maybeCStringToJsString', false); +unexportedRuntimeFunction('findEventTarget', false); +unexportedRuntimeFunction('findCanvasEventTarget', false); +unexportedRuntimeFunction('getBoundingClientRect', false); +unexportedRuntimeFunction('fillMouseEventData', false); +unexportedRuntimeFunction('registerMouseEventCallback', false); +unexportedRuntimeFunction('registerWheelEventCallback', false); +unexportedRuntimeFunction('registerUiEventCallback', false); +unexportedRuntimeFunction('registerFocusEventCallback', false); +unexportedRuntimeFunction('fillDeviceOrientationEventData', false); +unexportedRuntimeFunction('registerDeviceOrientationEventCallback', false); +unexportedRuntimeFunction('fillDeviceMotionEventData', false); +unexportedRuntimeFunction('registerDeviceMotionEventCallback', false); +unexportedRuntimeFunction('screenOrientation', false); +unexportedRuntimeFunction('fillOrientationChangeEventData', false); +unexportedRuntimeFunction('registerOrientationChangeEventCallback', false); +unexportedRuntimeFunction('fillFullscreenChangeEventData', false); +unexportedRuntimeFunction('registerFullscreenChangeEventCallback', false); +unexportedRuntimeFunction('JSEvents_requestFullscreen', false); +unexportedRuntimeFunction('JSEvents_resizeCanvasForFullscreen', false); +unexportedRuntimeFunction('registerRestoreOldStyle', false); +unexportedRuntimeFunction('hideEverythingExceptGivenElement', false); +unexportedRuntimeFunction('restoreHiddenElements', false); +unexportedRuntimeFunction('setLetterbox', false); +unexportedRuntimeFunction('currentFullscreenStrategy', false); +unexportedRuntimeFunction('restoreOldWindowedStyle', false); +unexportedRuntimeFunction('softFullscreenResizeWebGLRenderTarget', false); +unexportedRuntimeFunction('doRequestFullscreen', false); +unexportedRuntimeFunction('fillPointerlockChangeEventData', false); +unexportedRuntimeFunction('registerPointerlockChangeEventCallback', false); +unexportedRuntimeFunction('registerPointerlockErrorEventCallback', false); +unexportedRuntimeFunction('requestPointerLock', false); +unexportedRuntimeFunction('fillVisibilityChangeEventData', false); +unexportedRuntimeFunction('registerVisibilityChangeEventCallback', false); +unexportedRuntimeFunction('registerTouchEventCallback', false); +unexportedRuntimeFunction('fillGamepadEventData', false); +unexportedRuntimeFunction('registerGamepadEventCallback', false); +unexportedRuntimeFunction('registerBeforeUnloadEventCallback', false); +unexportedRuntimeFunction('fillBatteryEventData', false); +unexportedRuntimeFunction('battery', false); +unexportedRuntimeFunction('registerBatteryEventCallback', false); +unexportedRuntimeFunction('setCanvasElementSize', false); +unexportedRuntimeFunction('getCanvasElementSize', false); +unexportedRuntimeFunction('demangle', false); +unexportedRuntimeFunction('demangleAll', false); +unexportedRuntimeFunction('jsStackTrace', false); +unexportedRuntimeFunction('stackTrace', false); +unexportedRuntimeFunction('getEnvStrings', false); +unexportedRuntimeFunction('checkWasiClock', false); +unexportedRuntimeFunction('doReadv', false); +unexportedRuntimeFunction('doWritev', false); +unexportedRuntimeFunction('dlopenMissingError', false); +unexportedRuntimeFunction('setImmediateWrapped', false); +unexportedRuntimeFunction('clearImmediateWrapped', false); +unexportedRuntimeFunction('polyfillSetImmediate', false); +unexportedRuntimeFunction('uncaughtExceptionCount', false); +unexportedRuntimeFunction('exceptionLast', false); +unexportedRuntimeFunction('exceptionCaught', false); +unexportedRuntimeFunction('ExceptionInfo', false); +unexportedRuntimeFunction('exception_addRef', false); +unexportedRuntimeFunction('exception_decRef', false); +unexportedRuntimeFunction('getExceptionMessage', false); +unexportedRuntimeFunction('Browser', false); +unexportedRuntimeFunction('setMainLoop', false); +unexportedRuntimeFunction('wget', false); +unexportedRuntimeFunction('FS', false); +unexportedRuntimeFunction('MEMFS', false); +unexportedRuntimeFunction('TTY', false); +unexportedRuntimeFunction('PIPEFS', false); +unexportedRuntimeFunction('SOCKFS', false); +unexportedRuntimeFunction('_setNetworkCallback', false); +unexportedRuntimeFunction('tempFixedLengthArray', false); +unexportedRuntimeFunction('miniTempWebGLFloatBuffers', false); +unexportedRuntimeFunction('heapObjectForWebGLType', false); +unexportedRuntimeFunction('heapAccessShiftForWebGLHeap', false); +unexportedRuntimeFunction('GL', false); +unexportedRuntimeFunction('emscriptenWebGLGet', false); +unexportedRuntimeFunction('computeUnpackAlignedImageSize', false); +unexportedRuntimeFunction('emscriptenWebGLGetTexPixelData', false); +unexportedRuntimeFunction('emscriptenWebGLGetUniform', false); +unexportedRuntimeFunction('webglGetUniformLocation', false); +unexportedRuntimeFunction('webglPrepareUniformLocationsBeforeFirstUse', false); +unexportedRuntimeFunction('webglGetLeftBracePos', false); +unexportedRuntimeFunction('emscriptenWebGLGetVertexAttrib', false); +unexportedRuntimeFunction('writeGLArray', false); +unexportedRuntimeFunction('AL', false); +unexportedRuntimeFunction('SDL_unicode', false); +unexportedRuntimeFunction('SDL_ttfContext', false); +unexportedRuntimeFunction('SDL_audio', false); +unexportedRuntimeFunction('SDL', false); +unexportedRuntimeFunction('SDL_gfx', false); +unexportedRuntimeFunction('GLUT', false); +unexportedRuntimeFunction('EGL', false); +unexportedRuntimeFunction('GLFW_Window', false); +unexportedRuntimeFunction('GLFW', false); +unexportedRuntimeFunction('GLEW', false); +unexportedRuntimeFunction('IDBStore', false); +unexportedRuntimeFunction('runAndAbortIfError', false); +unexportedRuntimeFunction('InternalError', false); +unexportedRuntimeFunction('BindingError', false); +unexportedRuntimeFunction('UnboundTypeError', false); +unexportedRuntimeFunction('PureVirtualError', false); +unexportedRuntimeFunction('init_embind', false); +unexportedRuntimeFunction('throwInternalError', false); +unexportedRuntimeFunction('throwBindingError', false); +unexportedRuntimeFunction('throwUnboundTypeError', false); +unexportedRuntimeFunction('ensureOverloadTable', false); +unexportedRuntimeFunction('exposePublicSymbol', false); +unexportedRuntimeFunction('replacePublicSymbol', false); +unexportedRuntimeFunction('extendError', false); +unexportedRuntimeFunction('createNamedFunction', false); +unexportedRuntimeFunction('registeredInstances', false); +unexportedRuntimeFunction('getBasestPointer', false); +unexportedRuntimeFunction('registerInheritedInstance', false); +unexportedRuntimeFunction('unregisterInheritedInstance', false); +unexportedRuntimeFunction('getInheritedInstance', false); +unexportedRuntimeFunction('getInheritedInstanceCount', false); +unexportedRuntimeFunction('getLiveInheritedInstances', false); +unexportedRuntimeFunction('registeredTypes', false); +unexportedRuntimeFunction('awaitingDependencies', false); +unexportedRuntimeFunction('typeDependencies', false); +unexportedRuntimeFunction('registeredPointers', false); +unexportedRuntimeFunction('registerType', false); +unexportedRuntimeFunction('whenDependentTypesAreResolved', false); +unexportedRuntimeFunction('embind_charCodes', false); +unexportedRuntimeFunction('embind_init_charCodes', false); +unexportedRuntimeFunction('readLatin1String', false); +unexportedRuntimeFunction('getTypeName', false); +unexportedRuntimeFunction('heap32VectorToArray', false); +unexportedRuntimeFunction('requireRegisteredType', false); +unexportedRuntimeFunction('getShiftFromSize', false); +unexportedRuntimeFunction('integerReadValueFromPointer', false); +unexportedRuntimeFunction('enumReadValueFromPointer', false); +unexportedRuntimeFunction('floatReadValueFromPointer', false); +unexportedRuntimeFunction('simpleReadValueFromPointer', false); +unexportedRuntimeFunction('runDestructors', false); +unexportedRuntimeFunction('new_', false); +unexportedRuntimeFunction('craftInvokerFunction', false); +unexportedRuntimeFunction('embind__requireFunction', false); +unexportedRuntimeFunction('tupleRegistrations', false); +unexportedRuntimeFunction('structRegistrations', false); +unexportedRuntimeFunction('genericPointerToWireType', false); +unexportedRuntimeFunction('constNoSmartPtrRawPointerToWireType', false); +unexportedRuntimeFunction('nonConstNoSmartPtrRawPointerToWireType', false); +unexportedRuntimeFunction('init_RegisteredPointer', false); +unexportedRuntimeFunction('RegisteredPointer', false); +unexportedRuntimeFunction('RegisteredPointer_getPointee', false); +unexportedRuntimeFunction('RegisteredPointer_destructor', false); +unexportedRuntimeFunction('RegisteredPointer_deleteObject', false); +unexportedRuntimeFunction('RegisteredPointer_fromWireType', false); +unexportedRuntimeFunction('runDestructor', false); +unexportedRuntimeFunction('releaseClassHandle', false); +unexportedRuntimeFunction('finalizationRegistry', false); +unexportedRuntimeFunction('detachFinalizer_deps', false); +unexportedRuntimeFunction('detachFinalizer', false); +unexportedRuntimeFunction('attachFinalizer', false); +unexportedRuntimeFunction('makeClassHandle', false); +unexportedRuntimeFunction('init_ClassHandle', false); +unexportedRuntimeFunction('ClassHandle', false); +unexportedRuntimeFunction('ClassHandle_isAliasOf', false); +unexportedRuntimeFunction('throwInstanceAlreadyDeleted', false); +unexportedRuntimeFunction('ClassHandle_clone', false); +unexportedRuntimeFunction('ClassHandle_delete', false); +unexportedRuntimeFunction('deletionQueue', false); +unexportedRuntimeFunction('ClassHandle_isDeleted', false); +unexportedRuntimeFunction('ClassHandle_deleteLater', false); +unexportedRuntimeFunction('flushPendingDeletes', false); +unexportedRuntimeFunction('delayFunction', false); +unexportedRuntimeFunction('setDelayFunction', false); +unexportedRuntimeFunction('RegisteredClass', false); +unexportedRuntimeFunction('shallowCopyInternalPointer', false); +unexportedRuntimeFunction('downcastPointer', false); +unexportedRuntimeFunction('upcastPointer', false); +unexportedRuntimeFunction('validateThis', false); +unexportedRuntimeFunction('char_0', false); +unexportedRuntimeFunction('char_9', false); +unexportedRuntimeFunction('makeLegalFunctionName', false); +unexportedRuntimeFunction('emval_handle_array', false); +unexportedRuntimeFunction('emval_free_list', false); +unexportedRuntimeFunction('emval_symbols', false); +unexportedRuntimeFunction('init_emval', false); +unexportedRuntimeFunction('count_emval_handles', false); +unexportedRuntimeFunction('get_first_emval', false); +unexportedRuntimeFunction('getStringOrSymbol', false); +unexportedRuntimeFunction('Emval', false); +unexportedRuntimeFunction('emval_newers', false); +unexportedRuntimeFunction('craftEmvalAllocator', false); +unexportedRuntimeFunction('emval_get_global', false); +unexportedRuntimeFunction('emval_methodCallers', false); +unexportedRuntimeFunction('emval_registeredMethods', false); +unexportedRuntimeFunction('NODEFS', false); +Module["ALLOC_NORMAL"] = ALLOC_NORMAL; +Module["ALLOC_STACK"] = ALLOC_STACK; + +var calledRun; + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function callMain(args) { + assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])'); + assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called'); + + var entryFunction = Module['_main']; + + args = args || []; + args.unshift(thisProgram); + + var argc = args.length; + var argv = stackAlloc((argc + 1) * 4); + var argv_ptr = argv >> 2; + args.forEach((arg) => { + HEAP32[argv_ptr++] = allocateUTF8OnStack(arg); + }); + HEAP32[argv_ptr] = 0; + + try { + + var ret = entryFunction(argc, argv); + + // In PROXY_TO_PTHREAD builds, we should never exit the runtime below, as + // execution is asynchronously handed off to a pthread. + // if we're not running an evented main loop, it's time to exit + exit(ret, /* implicit = */ true); + return ret; + } + catch (e) { + return handleException(e); + } finally { + calledMain = true; + + } +} + +function stackCheckInit() { + // This is normally called automatically during __wasm_call_ctors but need to + // get these values before even running any of the ctors so we call it redundantly + // here. + // TODO(sbc): Move writeStackCookie to native to to avoid this. + _emscripten_stack_init(); + writeStackCookie(); +} + +/** @type {function(Array=)} */ +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + stackCheckInit(); + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + if (shouldRunNow) callMain(args); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} +Module['run'] = run; + +function checkUnflushedContent() { + // Compiler settings do not allow exiting the runtime, so flushing + // the streams is not possible. but in ASSERTIONS mode we check + // if there was something to flush, and if so tell the user they + // should request that the runtime be exitable. + // Normally we would not even include flush() at all, but in ASSERTIONS + // builds we do so just for this check, and here we see if there is any + // content to flush, that is, we check if there would have been + // something a non-ASSERTIONS build would have not seen. + // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 + // mode (which has its own special function for this; otherwise, all + // the code is inside libc) + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + } + try { // it doesn't matter if it fails + _fflush(0); + // also flush in the JS FS layer + ['stdout', 'stderr'].forEach(function(name) { + var info = FS.analyzePath('/dev/' + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty && tty.output && tty.output.length) { + has = true; + } + }); + } catch(e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.'); + } +} + +/** @param {boolean|number=} implicit */ +function exit(status, implicit) { + EXITSTATUS = status; + + checkUnflushedContent(); + + // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down + if (keepRuntimeAlive() && !implicit) { + var msg = 'program exited (with status: ' + status + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)'; + err(msg); + } + + procExit(status); +} + +function procExit(code) { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + if (Module['onExit']) Module['onExit'](code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +// shouldRunNow refers to calling main(), not run(). +var shouldRunNow = true; + +if (Module['noInitialRun']) shouldRunNow = false; + +run(); + + + + + + } + else { + console.error("Invalid action : " + action); + outgoingMessagePort.postMessage("invalid action"); + } +},false); + diff --git a/www/js/lib/libzim-wasm.electron.dev.wasm.REMOVED.git-id b/www/js/lib/libzim-wasm.electron.dev.wasm.REMOVED.git-id new file mode 100644 index 00000000..3684c7d4 --- /dev/null +++ b/www/js/lib/libzim-wasm.electron.dev.wasm.REMOVED.git-id @@ -0,0 +1 @@ +1277c10d1092ef012f15d750bd6109c86a22c24d \ No newline at end of file diff --git a/www/js/lib/libzim-wasm.electron.js b/www/js/lib/libzim-wasm.electron.js new file mode 100644 index 00000000..343b2b33 --- /dev/null +++ b/www/js/lib/libzim-wasm.electron.js @@ -0,0 +1 @@ +var Module=typeof Module!="undefined"?Module:{};self.addEventListener("message",function(e){var action=e.data.action;var path=e.data.path;var outgoingMessagePort=e.ports[0];console.debug("WebWorker called with action="+action);if(action==="getEntryByPath"){var follow=e.data.follow;var entry=Module[action](path);if(entry){var item={};if(follow||!entry.isRedirect()){item=entry.getItem(follow);var blob=item.getData();var content=blob.getContent();var contentArray=new Uint8Array(content);outgoingMessagePort.postMessage({content:contentArray,mimetype:item.getMimetype(),isRedirect:entry.isRedirect()})}else{outgoingMessagePort.postMessage({content:new Uint8Array,isRedirect:true,redirectPath:entry.getRedirectEntry().getPath()})}}else{outgoingMessagePort.postMessage({content:new Uint8Array,mimetype:"unknown",isRedirect:false})}}else if(action==="search"){var text=e.data.text;var numResults=e.data.numResults||50;var entries=Module[action](text,numResults);console.debug("Found nb results = "+entries.size(),entries);var serializedEntries=[];for(var i=0;i0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)()}else{getWasmTableEntry(func)(callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}function handleException(e){if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)}function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+UTF8ToString(condition)+", at: "+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}function ___call_sighandler(fp,sig){getWasmTableEntry(fp)(sig)}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false)};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}var exceptionLast=0;var uncaughtExceptionCount=0;function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=ptr;uncaughtExceptionCount++;throw ptr}var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(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:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:function(){var paths=Array.prototype.slice.call(arguments,0);return PATH.normalize(paths.join("/"))},join2:(l,r)=>{return PATH.normalize(l+"/"+r)}};function getRandomDevice(){if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){var randomBuffer=new Uint8Array(1);return function(){crypto.getRandomValues(randomBuffer);return randomBuffer[0]}}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");return function(){return crypto_module["randomBytes"](1)[0]}}catch(e){}}return function(){abort("randomDevice")}}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.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=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;i0){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=[]}}}};function zeroMemory(address,size){HEAPU8.fill(0,address,address+size)}function alignMemory(size,alignment){return Math.ceil(size/alignment)*alignment}function mmapAlloc(size){size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(!ptr)return 0;zeroMemory(ptr,size);return ptr}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;parent.timestamp=node.timestamp}return node},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>>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)},resizeFileStorage:function(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{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}},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.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;old_node.parent=new_dir},unlink:function(parent,name){delete parent.contents[name];parent.timestamp=Date.now()},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];parent.timestamp=Date.now()},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);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length{NODEFS.isWindows=!!process.platform.match(/^win/);var flags=process["binding"]("constants");if(flags["fs"]){flags=flags["fs"]}NODEFS.flagsForNodeMap={1024:flags["O_APPEND"],64:flags["O_CREAT"],128:flags["O_EXCL"],256:flags["O_NOCTTY"],0:flags["O_RDONLY"],2:flags["O_RDWR"],4096:flags["O_SYNC"],512:flags["O_TRUNC"],1:flags["O_WRONLY"],131072:flags["O_NOFOLLOW"]}},convertNodeCode:e=>{var code=e.code;return ERRNO_CODES[code]},mount:mount=>{return NODEFS.createNode(null,"/",NODEFS.getMode(mount.opts.root),0)},createNode:(parent,name,mode,dev)=>{if(!FS.isDir(mode)&&!FS.isFile(mode)&&!FS.isLink(mode)){throw new FS.ErrnoError(28)}var node=FS.createNode(parent,name,mode);node.node_ops=NODEFS.node_ops;node.stream_ops=NODEFS.stream_ops;return node},getMode:path=>{var stat;try{stat=fs.lstatSync(path);if(NODEFS.isWindows){stat.mode=stat.mode|(stat.mode&292)>>2}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}return stat.mode},realPath:node=>{var parts=[];while(node.parent!==node){parts.push(node.name);node=node.parent}parts.push(node.mount.opts.root);parts.reverse();return PATH.join.apply(null,parts)},flagsForNode:flags=>{flags&=~2097152;flags&=~2048;flags&=~32768;flags&=~524288;flags&=~65536;var newFlags=0;for(var k in NODEFS.flagsForNodeMap){if(flags&k){newFlags|=NODEFS.flagsForNodeMap[k];flags^=k}}if(!flags){return newFlags}else{throw new FS.ErrnoError(28)}},node_ops:{getattr:node=>{var path=NODEFS.realPath(node);var stat;try{stat=fs.lstatSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}if(NODEFS.isWindows&&!stat.blksize){stat.blksize=4096}if(NODEFS.isWindows&&!stat.blocks){stat.blocks=(stat.size+stat.blksize-1)/stat.blksize|0}return{dev:stat.dev,ino:stat.ino,mode:stat.mode,nlink:stat.nlink,uid:stat.uid,gid:stat.gid,rdev:stat.rdev,size:stat.size,atime:stat.atime,mtime:stat.mtime,ctime:stat.ctime,blksize:stat.blksize,blocks:stat.blocks}},setattr:(node,attr)=>{var path=NODEFS.realPath(node);try{if(attr.mode!==undefined){fs.chmodSync(path,attr.mode);node.mode=attr.mode}if(attr.timestamp!==undefined){var date=new Date(attr.timestamp);fs.utimesSync(path,date,date)}if(attr.size!==undefined){fs.truncateSync(path,attr.size)}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},lookup:(parent,name)=>{var path=PATH.join2(NODEFS.realPath(parent),name);var mode=NODEFS.getMode(path);return NODEFS.createNode(parent,name,mode)},mknod:(parent,name,mode,dev)=>{var node=NODEFS.createNode(parent,name,mode,dev);var path=NODEFS.realPath(node);try{if(FS.isDir(node.mode)){fs.mkdirSync(path,node.mode)}else{fs.writeFileSync(path,"",{mode:node.mode})}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}return node},rename:(oldNode,newDir,newName)=>{var oldPath=NODEFS.realPath(oldNode);var newPath=PATH.join2(NODEFS.realPath(newDir),newName);try{fs.renameSync(oldPath,newPath)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}oldNode.name=newName},unlink:(parent,name)=>{var path=PATH.join2(NODEFS.realPath(parent),name);try{fs.unlinkSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},rmdir:(parent,name)=>{var path=PATH.join2(NODEFS.realPath(parent),name);try{fs.rmdirSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},readdir:node=>{var path=NODEFS.realPath(node);try{return fs.readdirSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},symlink:(parent,newName,oldPath)=>{var newPath=PATH.join2(NODEFS.realPath(parent),newName);try{fs.symlinkSync(oldPath,newPath)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},readlink:node=>{var path=NODEFS.realPath(node);try{path=fs.readlinkSync(path);path=nodePath.relative(nodePath.resolve(node.mount.opts.root),path);return path}catch(e){if(!e.code)throw e;if(e.code==="UNKNOWN")throw new FS.ErrnoError(28);throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}}},stream_ops:{open:stream=>{var path=NODEFS.realPath(stream.node);try{if(FS.isFile(stream.node.mode)){stream.nfd=fs.openSync(path,NODEFS.flagsForNode(stream.flags))}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},close:stream=>{try{if(FS.isFile(stream.node.mode)&&stream.nfd){fs.closeSync(stream.nfd)}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},read:(stream,buffer,offset,length,position)=>{if(length===0)return 0;try{return fs.readSync(stream.nfd,Buffer.from(buffer.buffer),offset,length,position)}catch(e){throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},write:(stream,buffer,offset,length,position)=>{try{return fs.writeSync(stream.nfd,Buffer.from(buffer.buffer),offset,length,position)}catch(e){throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}},llseek:(stream,offset,whence)=>{var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){try{var stat=fs.fstatSync(stream.nfd);position+=stat.size}catch(e){throw new FS.ErrnoError(NODEFS.convertNodeCode(e))}}}if(position<0){throw new FS.ErrnoError(28)}return position},mmap:(stream,length,position,prot,flags)=>{if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}var ptr=mmapAlloc(length);NODEFS.stream_ops.read(stream,HEAP8,ptr,length,position);return{ptr:ptr,allocated:true}},msync:(stream,buffer,offset,length,mmapFlags)=>{if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(mmapFlags&2){return 0}var bytesWritten=NODEFS.stream_ops.write(stream,buffer,0,length,offset,false);return 0}}};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path,opts={})=>{path=PATH_FS.resolve(FS.cwd(),path);if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=PATH.normalizeArray(path.split("/").filter(p=>!!p),false);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return{path:current_path,node:current}},getPath:node=>{var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?mount+"/"+path:mount+path}path=path?node.name+"/"+path:node.name;node=node.parent}},hashName:(parentid,name)=>{var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode:node=>{var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode:node=>{var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode:(parent,name)=>{var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode,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:(parent,name,mode,rdev)=>{var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode:node=>{FS.hashRemoveNode(node)},isRoot:node=>{return node===node.parent},isMountpoint:node=>{return!!node.mounted},isFile:mode=>{return(mode&61440)===32768},isDir:mode=>{return(mode&61440)===16384},isLink:mode=>{return(mode&61440)===40960},isChrdev:mode=>{return(mode&61440)===8192},isBlkdev:mode=>{return(mode&61440)===24576},isFIFO:mode=>{return(mode&61440)===4096},isSocket:mode=>{return(mode&49152)===49152},flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:str=>{var flags=FS.flagModes[str];if(typeof flags=="undefined"){throw new Error("Unknown file open mode: "+str)}return flags},flagsToPermissionString:flag=>{var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions:(node,perms)=>{if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup:dir=>{var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate:(dir,name)=>{try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete:(dir,name,isdir)=>{var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen:(node,flags)=>{if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd:(fd_start=0,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:fd=>FS.streams[fd],createStream:(stream,fd_start,fd_end)=>{if(!FS.FSStream){FS.FSStream=function(){this.shared={}};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}},flags:{get:function(){return this.shared.flags},set:function(val){this.shared.flags=val}},position:{get function(){return this.shared.position},set:function(val){this.shared.position=val}}}}stream=Object.assign(new FS.FSStream,stream);var fd=FS.nextfd(fd_start,fd_end);stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream:fd=>{FS.streams[fd]=null},chrdev_stream_ops:{open: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:()=>{throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice:(dev,ops)=>{FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts:mount=>{var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push.apply(check,m.mounts)}return mounts},syncfs:(populate,callback)=>{if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err("warning: "+FS.syncFSRequests+" FS.syncfs operations in flight at once, probably just doing extra work")}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount:(type,opts,mountpoint)=>{var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;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: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(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup:(parent,name)=>{return parent.node_ops.lookup(parent,name)},mknod:(path,mode,dev)=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create:(path,mode)=>{mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir:(path,mode)=>{mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree:(path,mode)=>{var dirs=path.split("/");var d="";for(var i=0;i{if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink:(oldpath,newpath)=>{if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename:(old_path,new_path)=>{var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);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)}}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)}},rmdir:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir:path=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node.node_ops.readdir){throw new FS.ErrnoError(54)}return node.node_ops.readdir(node)},unlink:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink:path=>{var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return PATH_FS.resolve(FS.getPath(link.parent),link.node_ops.readlink(link))},stat:(path,dontFollow)=>{var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;if(!node){throw new FS.ErrnoError(44)}if(!node.node_ops.getattr){throw new FS.ErrnoError(63)}return node.node_ops.getattr(node)},lstat:path=>{return FS.stat(path,true)},chmod:(path,mode,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{mode:mode&4095|node.mode&~4095,timestamp:Date.now()})},lchmod:(path,mode)=>{FS.chmod(path,mode,true)},fchmod:(fd,mode)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chmod(stream.node,mode)},chown:(path,uid,gid,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{timestamp:Date.now()})},lchown:(path,uid,gid)=>{FS.chown(path,uid,gid,true)},fchown:(fd,uid,gid)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chown(stream.node,uid,gid)},truncate:(path,len)=>{if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}node.node_ops.setattr(node,{size:len,timestamp:Date.now()})},ftruncate:(fd,len)=>{var stream=FS.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:(path,atime,mtime)=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;node.node_ops.setattr(node,{timestamp:Math.max(atime,mtime)})},open:(path,flags,mode)=>{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&&!created){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});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}}return stream},close: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:stream=>{return stream.fd===null},llseek:(stream,offset,whence)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read:(stream,buffer,offset,length,position)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write:(stream,buffer,offset,length,position,canOwn)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},allocate:(stream,offset,length)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(offset<0||length<=0){throw new FS.ErrnoError(28)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(43)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(138)}stream.stream_ops.allocate(stream,offset,length)},mmap:(stream,length,position,prot,flags)=>{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,length,position,prot,flags)},msync:(stream,buffer,offset,length,mmapFlags)=>{if(!stream||!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},munmap:stream=>0,ioctl:(stream,cmd,arg)=>{if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile:(path,opts={})=>{opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){throw new Error('Invalid encoding type "'+opts.encoding+'"')}var ret;var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){ret=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile:(path,data,opts={})=>{opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir:path=>{var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories:()=>{FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices:()=>{FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>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=getRandomDevice();FS.createDevice("/dev","random",random_device);FS.createDevice("/dev","urandom",random_device);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories:()=>{FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount:()=>{var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup:(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:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams:()=>{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",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},ensureErrnoError:()=>{if(FS.ErrnoError)return;FS.ErrnoError=function ErrnoError(errno,node){this.node=node;this.setErrno=function(errno){this.errno=errno};this.setErrno(errno);this.message="FS error"};FS.ErrnoError.prototype=new Error;FS.ErrnoError.prototype.constructor=FS.ErrnoError;[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack=""})},staticInit:()=>{FS.ensureErrnoError();FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS,"NODEFS":NODEFS}},init:(input,output,error)=>{FS.init.initialized=true;FS.ensureErrnoError();Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit:()=>{FS.init.initialized=false;for(var i=0;i{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode},findObject:(path,dontResolveLastLink)=>{var ret=FS.analyzePath(path,dontResolveLastLink);if(ret.exists){return ret.object}else{return null}},analyzePath:(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},createPath:(parent,path,canRead,canWrite)=>{parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){}parent=current}return current},createFile:(parent,name,properties,canRead,canWrite)=>{var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile:(parent,name,data,canRead,canWrite,canOwn)=>{var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS.getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i{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:stream=>{stream.seekable=false},close:stream=>{if(output&&output.buffer&&output.buffer.length){output(10)}},read:(stream,buffer,offset,length,pos)=>{var bytesRead=0;for(var i=0;i{for(var i=0;i{if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(typeof XMLHttpRequest!="undefined"){throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else if(read_){try{obj.contents=intArrayFromString(read_(obj.url),true);obj.usedBytes=obj.contents.length}catch(e){throw new FS.ErrnoError(29)}}else{throw new Error("Cannot load without read() or XMLHttpRequest.")}},createLazyFile:(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=(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);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(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(key=>{var fn=node.stream_ops[key];stream_ops[key]=function forceLoadLazyFile(){FS.forceLoadFile(node);return fn.apply(null,arguments)}});stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{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)}if(Browser.handledByPreloadPlugin(byteArray,fullname,finish,()=>{if(onerror)onerror();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url,byteArray=>processData(byteArray),onerror)}else{processData(url)}},indexedDB:()=>{return window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB},DB_NAME:()=>{return"EM_FS_"+window.location.pathname},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths,onload,onerror)=>{onload=onload||(()=>{});onerror=onerror||(()=>{});var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=()=>{out("creating db");var db=openRequest.result;db.createObjectStore(FS.DB_STORE_NAME)};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(path=>{var putRequest=files.put(FS.analyzePath(path).object.contents,path);putRequest.onsuccess=()=>{ok++;if(ok+fail==total)finish()};putRequest.onerror=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror},loadFilesFromDB:(paths,onload,onerror)=>{onload=onload||(()=>{});onerror=onerror||(()=>{});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=()=>{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(path=>{var getRequest=files.get(path);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=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt:function(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=FS.getStream(dirfd);if(!dirstream)throw new FS.ErrnoError(8);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,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)},varargs:undefined,get:function(){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}};function ___syscall_fadvise64(fd,offset,len,advice){return 0}function setErrNo(value){HEAP32[___errno_location()>>2]=value;return value}function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=SYSCALLS.get();if(arg<0){return-28}var newStream;newStream=FS.createStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=SYSCALLS.get();stream.flags|=arg;return 0}case 5:{var arg=SYSCALLS.get();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 6:case 7:return 0;case 16:case 8:return-28;case 9:setErrNo(28);return-1;default:{return-28}}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{var stream=SYSCALLS.getStreamFromFD(fd);return SYSCALLS.doStat(FS.stat,stream.path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.lstat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~4352;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.doStat(nofollow?FS.lstat:FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?SYSCALLS.get():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(flags===0){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{abort("Invalid flags passed to unlinkat")}return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}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}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{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function registerType(rawType,registeredInstance,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(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 finalizationRegistry=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 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)}var registeredPointers={};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}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}var delayFunction=undefined;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 attachFinalizer(handle){if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.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}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(){}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.toHandle(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 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&®isteredClass.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 dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();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 heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i])}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName="constructor "+classType.name;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError("Cannot register multiple constructors with identical number of parameters ("+(argCount-1)+") for class '"+classType.name+"'! Overload resolution is currently only performed using the parameter count, not actual type info!")}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError("Cannot construct "+classType.name+" due to unbound types",rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}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;i0?", ":"")+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;i4&&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{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handle_array[handle].value},toHandle: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.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(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){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}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=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"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;ilengthBytesUTF8(value)}else{getLength=()=>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;i255){_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;iHEAPU16;shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>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.toHandle(v)}function __mmap_js(len,prot,flags,fd,off,allocated){try{var stream=FS.getStream(fd);if(!stream)return-8;var res=FS.mmap(stream,len,off,prot,flags);var ptr=res.ptr;HEAP32[allocated>>2]=res.allocated;return ptr}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function __munmap_js(addr,len,prot,flags,fd,offset){try{var stream=FS.getStream(fd);if(stream){if(prot&2){SYSCALLS.doMsync(addr,stream,len,flags,offset)}FS.munmap(stream)}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function getHeapMax(){return 2147483648}function emscripten_realloc_buffer(size){try{wasmMemory.grow(size-buffer.byteLength+65535>>>16);updateGlobalBufferAndViews(wasmMemory.buffer);return 1}catch(e){}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}let alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;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(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}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){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(x+"="+env[x])}getEnvStrings.strings=strings}return getEnvStrings.strings}function _environ_get(__environ,environ_buf){var bufSize=0;getEnvStrings().forEach(function(string,i){var ptr=environ_buf+bufSize;HEAPU32[__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();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(function(string){bufSize+=string.length+1});HEAPU32[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))throw e;return e.errno}}function doReadv(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN}function _fd_pread(fd,iov,iovcnt,offset_low,offset_high,pnum){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt,offset);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function doWritev(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr}return ret}function _fd_pwrite(fd,iov,iovcnt,offset_low,offset_high,pnum){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt,offset);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_read(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?(Math.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))throw e;return e.errno}}function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _setTempRet0(val){setTempRet0(val)}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.length0?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 days=date.tm_yday+7-date.tm_wday;return leadingNulls(Math.floor(days/7),2)},"%V":function(date){var val=Math.floor((date.tm_yday+7-(date.tm_wday+6)%7)/7);if((date.tm_wday+371-date.tm_yday-2)%7<=2){val++}if(!val){val=52;var dec31=(date.tm_wday+7-date.tm_yday-1)%7;if(dec31==4||dec31==5&&__isLeapYear(date.tm_year%400-1)){val++}}else if(val==53){var jan1=(date.tm_wday+371-date.tm_yday)%7;if(jan1!=4&&(jan1!=3||!__isLeapYear(date.tm_year)))val=1}return leadingNulls(val,2)},"%w":function(date){return date.tm_wday},"%W":function(date){var days=date.tm_yday+7-(date.tm_wday+6)%7;return leadingNulls(Math.floor(days/7),2)},"%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"%"}};pattern=pattern.replace(/%%/g,"\0\0");for(var rule in EXPANSION_RULES_2){if(pattern.includes(rule)){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_2[rule](date))}}pattern=pattern.replace(/\0\0/g,"%");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)}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();if(ENVIRONMENT_IS_NODE){requireNodeFS();NODEFS.staticInit()}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};embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();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={"g":___assert_fail,"D":___call_sighandler,"a":___cxa_allocate_exception,"b":___cxa_throw,"x":___syscall_fadvise64,"f":___syscall_fcntl64,"K":___syscall_fstat64,"H":___syscall_lstat64,"I":___syscall_newfstatat,"E":___syscall_openat,"J":___syscall_stat64,"C":___syscall_unlinkat,"z":__embind_register_bigint,"P":__embind_register_bool,"i":__embind_register_class,"s":__embind_register_class_constructor,"c":__embind_register_class_function,"O":__embind_register_emval,"u":__embind_register_float,"j":__embind_register_function,"e":__embind_register_integer,"d":__embind_register_memory_view,"t":__embind_register_std_string,"n":__embind_register_std_wstring,"Q":__embind_register_void,"o":__emval_decref,"p":__emval_incref,"k":__emval_take_value,"F":__mmap_js,"G":__munmap_js,"h":_abort,"N":_emscripten_memcpy_big,"B":_emscripten_resize_heap,"L":_environ_get,"M":_environ_sizes_get,"m":_fd_close,"w":_fd_pread,"v":_fd_pwrite,"r":_fd_read,"y":_fd_seek,"l":_fd_write,"q":_setTempRet0,"A":_strftime_l};var asm=createWasm();var ___wasm_call_ctors=Module["___wasm_call_ctors"]=function(){return(___wasm_call_ctors=Module["___wasm_call_ctors"]=Module["asm"]["S"]).apply(null,arguments)};var _main=Module["_main"]=function(){return(_main=Module["_main"]=Module["asm"]["T"]).apply(null,arguments)};var _malloc=Module["_malloc"]=function(){return(_malloc=Module["_malloc"]=Module["asm"]["U"]).apply(null,arguments)};var ___errno_location=Module["___errno_location"]=function(){return(___errno_location=Module["___errno_location"]=Module["asm"]["W"]).apply(null,arguments)};var _free=Module["_free"]=function(){return(_free=Module["_free"]=Module["asm"]["X"]).apply(null,arguments)};var ___getTypeName=Module["___getTypeName"]=function(){return(___getTypeName=Module["___getTypeName"]=Module["asm"]["Y"]).apply(null,arguments)};var ___embind_register_native_and_builtin_types=Module["___embind_register_native_and_builtin_types"]=function(){return(___embind_register_native_and_builtin_types=Module["___embind_register_native_and_builtin_types"]=Module["asm"]["Z"]).apply(null,arguments)};var _emscripten_builtin_memalign=Module["_emscripten_builtin_memalign"]=function(){return(_emscripten_builtin_memalign=Module["_emscripten_builtin_memalign"]=Module["asm"]["_"]).apply(null,arguments)};var stackAlloc=Module["stackAlloc"]=function(){return(stackAlloc=Module["stackAlloc"]=Module["asm"]["$"]).apply(null,arguments)};var ___cxa_is_pointer_type=Module["___cxa_is_pointer_type"]=function(){return(___cxa_is_pointer_type=Module["___cxa_is_pointer_type"]=Module["asm"]["aa"]).apply(null,arguments)};var dynCall_ji=Module["dynCall_ji"]=function(){return(dynCall_ji=Module["dynCall_ji"]=Module["asm"]["ba"]).apply(null,arguments)};var dynCall_viijj=Module["dynCall_viijj"]=function(){return(dynCall_viijj=Module["dynCall_viijj"]=Module["asm"]["ca"]).apply(null,arguments)};var dynCall_iij=Module["dynCall_iij"]=function(){return(dynCall_iij=Module["dynCall_iij"]=Module["asm"]["da"]).apply(null,arguments)};var dynCall_iijj=Module["dynCall_iijj"]=function(){return(dynCall_iijj=Module["dynCall_iijj"]=Module["asm"]["ea"]).apply(null,arguments)};var dynCall_viij=Module["dynCall_viij"]=function(){return(dynCall_viij=Module["dynCall_viij"]=Module["asm"]["fa"]).apply(null,arguments)};var dynCall_ij=Module["dynCall_ij"]=function(){return(dynCall_ij=Module["dynCall_ij"]=Module["asm"]["ga"]).apply(null,arguments)};var dynCall_iiiji=Module["dynCall_iiiji"]=function(){return(dynCall_iiiji=Module["dynCall_iiiji"]=Module["asm"]["ha"]).apply(null,arguments)};var dynCall_iiiij=Module["dynCall_iiiij"]=function(){return(dynCall_iiiij=Module["dynCall_iiiij"]=Module["asm"]["ia"]).apply(null,arguments)};var dynCall_vij=Module["dynCall_vij"]=function(){return(dynCall_vij=Module["dynCall_vij"]=Module["asm"]["ja"]).apply(null,arguments)};var dynCall_jiji=Module["dynCall_jiji"]=function(){return(dynCall_jiji=Module["dynCall_jiji"]=Module["asm"]["ka"]).apply(null,arguments)};var dynCall_viijii=Module["dynCall_viijii"]=function(){return(dynCall_viijii=Module["dynCall_viijii"]=Module["asm"]["la"]).apply(null,arguments)};var dynCall_iiiiij=Module["dynCall_iiiiij"]=function(){return(dynCall_iiiiij=Module["dynCall_iiiiij"]=Module["asm"]["ma"]).apply(null,arguments)};var dynCall_iiiiijj=Module["dynCall_iiiiijj"]=function(){return(dynCall_iiiiijj=Module["dynCall_iiiiijj"]=Module["asm"]["na"]).apply(null,arguments)};var dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=function(){return(dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=Module["asm"]["oa"]).apply(null,arguments)};Module["print"]=out;Module["printErr"]=err;Module["ALLOC_NORMAL"]=ALLOC_NORMAL;Module["ALLOC_STACK"]=ALLOC_STACK;var calledRun;function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}var calledMain=false;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function callMain(args){var entryFunction=Module["_main"];args=args||[];args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*4);var argv_ptr=argv>>2;args.forEach(arg=>{HEAP32[argv_ptr++]=allocateUTF8OnStack(arg)});HEAP32[argv_ptr]=0;try{var ret=entryFunction(argc,argv);exit(ret,true);return ret}catch(e){return handleException(e)}finally{calledMain=true}}function run(args){args=args||arguments_;if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();if(shouldRunNow)callMain(args);postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}Module["run"]=run;function exit(status,implicit){EXITSTATUS=status;procExit(status)}function procExit(code){EXITSTATUS=code;if(!keepRuntimeAlive()){if(Module["onExit"])Module["onExit"](code);ABORT=true}quit_(code,new ExitStatus(code))}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}var shouldRunNow=true;if(Module["noInitialRun"])shouldRunNow=false;run()}else{console.error("Invalid action : "+action);outgoingMessagePort.postMessage("invalid action")}},false); diff --git a/www/js/lib/libzim-wasm.electron.wasm b/www/js/lib/libzim-wasm.electron.wasm new file mode 100644 index 0000000000000000000000000000000000000000..a286cad5ea85e11bd8d1f52aff5c3421cfadf4ca GIT binary patch literal 1357175 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

c-SR<}v}s96 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

Y`f$JvP}4x6=45LUgNQ7g_J=@s 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 z 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%0D{V{u>Qk?U)OcZB; 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 literal 0 HcmV?d00001 diff --git a/www/js/lib/libzim-wasm.js b/www/js/lib/libzim-wasm.js index 89a20761..5a991d6f 100644 --- a/www/js/lib/libzim-wasm.js +++ b/www/js/lib/libzim-wasm.js @@ -1 +1 @@ -var Module=typeof Module!="undefined"?Module:{};self.addEventListener("message",function(e){var action=e.data.action;var path=e.data.path;var outgoingMessagePort=e.ports[0];console.debug("WebWorker called with action="+action);if(action==="getEntryByPath"){var follow=e.data.follow;var entry=Module[action](path);if(entry){var item={};if(follow||!entry.isRedirect()){item=entry.getItem(follow);var blob=item.getData();var content=blob.getContent();var contentArray=new Uint8Array(content);outgoingMessagePort.postMessage({content:contentArray,mimetype:item.getMimetype(),isRedirect:entry.isRedirect()})}else{outgoingMessagePort.postMessage({content:new Uint8Array,isRedirect:true,redirectPath:entry.getRedirectEntry().getPath()})}}else{outgoingMessagePort.postMessage({content:new Uint8Array,mimetype:"unknown",isRedirect:false})}}else if(action==="search"){var text=e.data.text;var numResults=e.data.numResults||50;var entries=Module[action](text,numResults);console.debug("Found nb results = "+entries.size(),entries);var serializedEntries=[];for(var i=0;i0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)()}else{getWasmTableEntry(func)(callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}function handleException(e){if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)}function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+UTF8ToString(condition)+", at: "+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}function ___call_sighandler(fp,sig){getWasmTableEntry(fp)(sig)}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false)};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}var exceptionLast=0;var uncaughtExceptionCount=0;function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=ptr;uncaughtExceptionCount++;throw ptr}var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(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:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:function(){var paths=Array.prototype.slice.call(arguments,0);return PATH.normalize(paths.join("/"))},join2:(l,r)=>{return PATH.normalize(l+"/"+r)}};function getRandomDevice(){if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){var randomBuffer=new Uint8Array(1);return function(){crypto.getRandomValues(randomBuffer);return randomBuffer[0]}}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");return function(){return crypto_module["randomBytes"](1)[0]}}catch(e){}}return function(){abort("randomDevice")}}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.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=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;i0){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=[]}}}};function zeroMemory(address,size){HEAPU8.fill(0,address,address+size)}function alignMemory(size,alignment){return Math.ceil(size/alignment)*alignment}function mmapAlloc(size){size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(!ptr)return 0;zeroMemory(ptr,size);return ptr}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;parent.timestamp=node.timestamp}return node},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>>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)},resizeFileStorage:function(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{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}},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.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;old_node.parent=new_dir},unlink:function(parent,name){delete parent.contents[name];parent.timestamp=Date.now()},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];parent.timestamp=Date.now()},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);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length=stream.node.size)return 0;var chunk=stream.node.contents.slice(position,position+length);var ab=WORKERFS.reader.readAsArrayBuffer(chunk);buffer.set(new Uint8Array(ab),offset);return chunk.size},write:function(stream,buffer,offset,length,position){throw new FS.ErrnoError(29)},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.size}}if(position<0){throw new FS.ErrnoError(28)}return position}}};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path,opts={})=>{path=PATH_FS.resolve(FS.cwd(),path);if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=PATH.normalizeArray(path.split("/").filter(p=>!!p),false);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return{path:current_path,node:current}},getPath:node=>{var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?mount+"/"+path:mount+path}path=path?node.name+"/"+path:node.name;node=node.parent}},hashName:(parentid,name)=>{var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode:node=>{var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode:node=>{var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode:(parent,name)=>{var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode,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:(parent,name,mode,rdev)=>{var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode:node=>{FS.hashRemoveNode(node)},isRoot:node=>{return node===node.parent},isMountpoint:node=>{return!!node.mounted},isFile:mode=>{return(mode&61440)===32768},isDir:mode=>{return(mode&61440)===16384},isLink:mode=>{return(mode&61440)===40960},isChrdev:mode=>{return(mode&61440)===8192},isBlkdev:mode=>{return(mode&61440)===24576},isFIFO:mode=>{return(mode&61440)===4096},isSocket:mode=>{return(mode&49152)===49152},flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:str=>{var flags=FS.flagModes[str];if(typeof flags=="undefined"){throw new Error("Unknown file open mode: "+str)}return flags},flagsToPermissionString:flag=>{var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions:(node,perms)=>{if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup:dir=>{var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate:(dir,name)=>{try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete:(dir,name,isdir)=>{var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen:(node,flags)=>{if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd:(fd_start=0,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:fd=>FS.streams[fd],createStream:(stream,fd_start,fd_end)=>{if(!FS.FSStream){FS.FSStream=function(){this.shared={}};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}},flags:{get:function(){return this.shared.flags},set:function(val){this.shared.flags=val}},position:{get function(){return this.shared.position},set:function(val){this.shared.position=val}}}}stream=Object.assign(new FS.FSStream,stream);var fd=FS.nextfd(fd_start,fd_end);stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream:fd=>{FS.streams[fd]=null},chrdev_stream_ops:{open: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:()=>{throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice:(dev,ops)=>{FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts:mount=>{var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push.apply(check,m.mounts)}return mounts},syncfs:(populate,callback)=>{if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err("warning: "+FS.syncFSRequests+" FS.syncfs operations in flight at once, probably just doing extra work")}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount:(type,opts,mountpoint)=>{var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;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: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(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup:(parent,name)=>{return parent.node_ops.lookup(parent,name)},mknod:(path,mode,dev)=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create:(path,mode)=>{mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir:(path,mode)=>{mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree:(path,mode)=>{var dirs=path.split("/");var d="";for(var i=0;i{if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink:(oldpath,newpath)=>{if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename:(old_path,new_path)=>{var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);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)}}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)}},rmdir:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir:path=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node.node_ops.readdir){throw new FS.ErrnoError(54)}return node.node_ops.readdir(node)},unlink:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink:path=>{var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return PATH_FS.resolve(FS.getPath(link.parent),link.node_ops.readlink(link))},stat:(path,dontFollow)=>{var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;if(!node){throw new FS.ErrnoError(44)}if(!node.node_ops.getattr){throw new FS.ErrnoError(63)}return node.node_ops.getattr(node)},lstat:path=>{return FS.stat(path,true)},chmod:(path,mode,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{mode:mode&4095|node.mode&~4095,timestamp:Date.now()})},lchmod:(path,mode)=>{FS.chmod(path,mode,true)},fchmod:(fd,mode)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chmod(stream.node,mode)},chown:(path,uid,gid,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{timestamp:Date.now()})},lchown:(path,uid,gid)=>{FS.chown(path,uid,gid,true)},fchown:(fd,uid,gid)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chown(stream.node,uid,gid)},truncate:(path,len)=>{if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}node.node_ops.setattr(node,{size:len,timestamp:Date.now()})},ftruncate:(fd,len)=>{var stream=FS.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:(path,atime,mtime)=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;node.node_ops.setattr(node,{timestamp:Math.max(atime,mtime)})},open:(path,flags,mode)=>{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&&!created){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});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}}return stream},close: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:stream=>{return stream.fd===null},llseek:(stream,offset,whence)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read:(stream,buffer,offset,length,position)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write:(stream,buffer,offset,length,position,canOwn)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},allocate:(stream,offset,length)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(offset<0||length<=0){throw new FS.ErrnoError(28)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(43)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(138)}stream.stream_ops.allocate(stream,offset,length)},mmap:(stream,length,position,prot,flags)=>{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,length,position,prot,flags)},msync:(stream,buffer,offset,length,mmapFlags)=>{if(!stream||!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},munmap:stream=>0,ioctl:(stream,cmd,arg)=>{if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile:(path,opts={})=>{opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){throw new Error('Invalid encoding type "'+opts.encoding+'"')}var ret;var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){ret=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile:(path,data,opts={})=>{opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir:path=>{var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories:()=>{FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices:()=>{FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>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=getRandomDevice();FS.createDevice("/dev","random",random_device);FS.createDevice("/dev","urandom",random_device);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories:()=>{FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount:()=>{var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup:(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:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams:()=>{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",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},ensureErrnoError:()=>{if(FS.ErrnoError)return;FS.ErrnoError=function ErrnoError(errno,node){this.node=node;this.setErrno=function(errno){this.errno=errno};this.setErrno(errno);this.message="FS error"};FS.ErrnoError.prototype=new Error;FS.ErrnoError.prototype.constructor=FS.ErrnoError;[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack=""})},staticInit:()=>{FS.ensureErrnoError();FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS,"WORKERFS":WORKERFS}},init:(input,output,error)=>{FS.init.initialized=true;FS.ensureErrnoError();Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit:()=>{FS.init.initialized=false;for(var i=0;i{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode},findObject:(path,dontResolveLastLink)=>{var ret=FS.analyzePath(path,dontResolveLastLink);if(ret.exists){return ret.object}else{return null}},analyzePath:(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},createPath:(parent,path,canRead,canWrite)=>{parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){}parent=current}return current},createFile:(parent,name,properties,canRead,canWrite)=>{var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile:(parent,name,data,canRead,canWrite,canOwn)=>{var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS.getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i{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:stream=>{stream.seekable=false},close:stream=>{if(output&&output.buffer&&output.buffer.length){output(10)}},read:(stream,buffer,offset,length,pos)=>{var bytesRead=0;for(var i=0;i{for(var i=0;i{if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(typeof XMLHttpRequest!="undefined"){throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else if(read_){try{obj.contents=intArrayFromString(read_(obj.url),true);obj.usedBytes=obj.contents.length}catch(e){throw new FS.ErrnoError(29)}}else{throw new Error("Cannot load without read() or XMLHttpRequest.")}},createLazyFile:(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=(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);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(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(key=>{var fn=node.stream_ops[key];stream_ops[key]=function forceLoadLazyFile(){FS.forceLoadFile(node);return fn.apply(null,arguments)}});stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{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)}if(Browser.handledByPreloadPlugin(byteArray,fullname,finish,()=>{if(onerror)onerror();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url,byteArray=>processData(byteArray),onerror)}else{processData(url)}},indexedDB:()=>{return window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB},DB_NAME:()=>{return"EM_FS_"+window.location.pathname},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths,onload,onerror)=>{onload=onload||(()=>{});onerror=onerror||(()=>{});var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=()=>{out("creating db");var db=openRequest.result;db.createObjectStore(FS.DB_STORE_NAME)};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(path=>{var putRequest=files.put(FS.analyzePath(path).object.contents,path);putRequest.onsuccess=()=>{ok++;if(ok+fail==total)finish()};putRequest.onerror=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror},loadFilesFromDB:(paths,onload,onerror)=>{onload=onload||(()=>{});onerror=onerror||(()=>{});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=()=>{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(path=>{var getRequest=files.get(path);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=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt:function(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=FS.getStream(dirfd);if(!dirstream)throw new FS.ErrnoError(8);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,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)},varargs:undefined,get:function(){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}};function ___syscall_fadvise64(fd,offset,len,advice){return 0}function setErrNo(value){HEAP32[___errno_location()>>2]=value;return value}function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=SYSCALLS.get();if(arg<0){return-28}var newStream;newStream=FS.createStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=SYSCALLS.get();stream.flags|=arg;return 0}case 5:{var arg=SYSCALLS.get();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 6:case 7:return 0;case 16:case 8:return-28;case 9:setErrNo(28);return-1;default:{return-28}}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{var stream=SYSCALLS.getStreamFromFD(fd);return SYSCALLS.doStat(FS.stat,stream.path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.lstat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~4352;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.doStat(nofollow?FS.lstat:FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?SYSCALLS.get():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(flags===0){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{abort("Invalid flags passed to unlinkat")}return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}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}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{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function registerType(rawType,registeredInstance,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(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 finalizationRegistry=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 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)}var registeredPointers={};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}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}var delayFunction=undefined;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 attachFinalizer(handle){if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.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}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(){}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.toHandle(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 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&®isteredClass.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 dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();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 heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i])}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName="constructor "+classType.name;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError("Cannot register multiple constructors with identical number of parameters ("+(argCount-1)+") for class '"+classType.name+"'! Overload resolution is currently only performed using the parameter count, not actual type info!")}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError("Cannot construct "+classType.name+" due to unbound types",rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}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;i0?", ":"")+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;i4&&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{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handle_array[handle].value},toHandle: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.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(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){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}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=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"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;ilengthBytesUTF8(value)}else{getLength=()=>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;i255){_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;iHEAPU16;shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>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.toHandle(v)}function __mmap_js(len,prot,flags,fd,off,allocated){try{var stream=FS.getStream(fd);if(!stream)return-8;var res=FS.mmap(stream,len,off,prot,flags);var ptr=res.ptr;HEAP32[allocated>>2]=res.allocated;return ptr}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function __munmap_js(addr,len,prot,flags,fd,offset){try{var stream=FS.getStream(fd);if(stream){if(prot&2){SYSCALLS.doMsync(addr,stream,len,flags,offset)}FS.munmap(stream)}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function getHeapMax(){return 2147483648}function emscripten_realloc_buffer(size){try{wasmMemory.grow(size-buffer.byteLength+65535>>>16);updateGlobalBufferAndViews(wasmMemory.buffer);return 1}catch(e){}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}let alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;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(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}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){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(x+"="+env[x])}getEnvStrings.strings=strings}return getEnvStrings.strings}function _environ_get(__environ,environ_buf){var bufSize=0;getEnvStrings().forEach(function(string,i){var ptr=environ_buf+bufSize;HEAPU32[__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();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(function(string){bufSize+=string.length+1});HEAPU32[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))throw e;return e.errno}}function doReadv(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN}function _fd_pread(fd,iov,iovcnt,offset_low,offset_high,pnum){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt,offset);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function doWritev(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr}return ret}function _fd_pwrite(fd,iov,iovcnt,offset_low,offset_high,pnum){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt,offset);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_read(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?(Math.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))throw e;return e.errno}}function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _setTempRet0(val){setTempRet0(val)}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.length0?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 days=date.tm_yday+7-date.tm_wday;return leadingNulls(Math.floor(days/7),2)},"%V":function(date){var val=Math.floor((date.tm_yday+7-(date.tm_wday+6)%7)/7);if((date.tm_wday+371-date.tm_yday-2)%7<=2){val++}if(!val){val=52;var dec31=(date.tm_wday+7-date.tm_yday-1)%7;if(dec31==4||dec31==5&&__isLeapYear(date.tm_year%400-1)){val++}}else if(val==53){var jan1=(date.tm_wday+371-date.tm_yday)%7;if(jan1!=4&&(jan1!=3||!__isLeapYear(date.tm_year)))val=1}return leadingNulls(val,2)},"%w":function(date){return date.tm_wday},"%W":function(date){var days=date.tm_yday+7-(date.tm_wday+6)%7;return leadingNulls(Math.floor(days/7),2)},"%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"%"}};pattern=pattern.replace(/%%/g,"\0\0");for(var rule in EXPANSION_RULES_2){if(pattern.includes(rule)){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_2[rule](date))}}pattern=pattern.replace(/\0\0/g,"%");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)}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_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();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={"g":___assert_fail,"D":___call_sighandler,"a":___cxa_allocate_exception,"b":___cxa_throw,"x":___syscall_fadvise64,"f":___syscall_fcntl64,"K":___syscall_fstat64,"H":___syscall_lstat64,"I":___syscall_newfstatat,"E":___syscall_openat,"J":___syscall_stat64,"C":___syscall_unlinkat,"z":__embind_register_bigint,"P":__embind_register_bool,"i":__embind_register_class,"s":__embind_register_class_constructor,"c":__embind_register_class_function,"O":__embind_register_emval,"u":__embind_register_float,"j":__embind_register_function,"e":__embind_register_integer,"d":__embind_register_memory_view,"t":__embind_register_std_string,"n":__embind_register_std_wstring,"Q":__embind_register_void,"o":__emval_decref,"p":__emval_incref,"k":__emval_take_value,"F":__mmap_js,"G":__munmap_js,"h":_abort,"N":_emscripten_memcpy_big,"B":_emscripten_resize_heap,"L":_environ_get,"M":_environ_sizes_get,"m":_fd_close,"w":_fd_pread,"v":_fd_pwrite,"r":_fd_read,"y":_fd_seek,"l":_fd_write,"q":_setTempRet0,"A":_strftime_l};var asm=createWasm();var ___wasm_call_ctors=Module["___wasm_call_ctors"]=function(){return(___wasm_call_ctors=Module["___wasm_call_ctors"]=Module["asm"]["S"]).apply(null,arguments)};var _main=Module["_main"]=function(){return(_main=Module["_main"]=Module["asm"]["T"]).apply(null,arguments)};var _malloc=Module["_malloc"]=function(){return(_malloc=Module["_malloc"]=Module["asm"]["U"]).apply(null,arguments)};var ___errno_location=Module["___errno_location"]=function(){return(___errno_location=Module["___errno_location"]=Module["asm"]["W"]).apply(null,arguments)};var _free=Module["_free"]=function(){return(_free=Module["_free"]=Module["asm"]["X"]).apply(null,arguments)};var ___getTypeName=Module["___getTypeName"]=function(){return(___getTypeName=Module["___getTypeName"]=Module["asm"]["Y"]).apply(null,arguments)};var ___embind_register_native_and_builtin_types=Module["___embind_register_native_and_builtin_types"]=function(){return(___embind_register_native_and_builtin_types=Module["___embind_register_native_and_builtin_types"]=Module["asm"]["Z"]).apply(null,arguments)};var _emscripten_builtin_memalign=Module["_emscripten_builtin_memalign"]=function(){return(_emscripten_builtin_memalign=Module["_emscripten_builtin_memalign"]=Module["asm"]["_"]).apply(null,arguments)};var stackAlloc=Module["stackAlloc"]=function(){return(stackAlloc=Module["stackAlloc"]=Module["asm"]["$"]).apply(null,arguments)};var ___cxa_is_pointer_type=Module["___cxa_is_pointer_type"]=function(){return(___cxa_is_pointer_type=Module["___cxa_is_pointer_type"]=Module["asm"]["aa"]).apply(null,arguments)};var dynCall_ji=Module["dynCall_ji"]=function(){return(dynCall_ji=Module["dynCall_ji"]=Module["asm"]["ba"]).apply(null,arguments)};var dynCall_viijj=Module["dynCall_viijj"]=function(){return(dynCall_viijj=Module["dynCall_viijj"]=Module["asm"]["ca"]).apply(null,arguments)};var dynCall_iij=Module["dynCall_iij"]=function(){return(dynCall_iij=Module["dynCall_iij"]=Module["asm"]["da"]).apply(null,arguments)};var dynCall_iijj=Module["dynCall_iijj"]=function(){return(dynCall_iijj=Module["dynCall_iijj"]=Module["asm"]["ea"]).apply(null,arguments)};var dynCall_viij=Module["dynCall_viij"]=function(){return(dynCall_viij=Module["dynCall_viij"]=Module["asm"]["fa"]).apply(null,arguments)};var dynCall_ij=Module["dynCall_ij"]=function(){return(dynCall_ij=Module["dynCall_ij"]=Module["asm"]["ga"]).apply(null,arguments)};var dynCall_iiiji=Module["dynCall_iiiji"]=function(){return(dynCall_iiiji=Module["dynCall_iiiji"]=Module["asm"]["ha"]).apply(null,arguments)};var dynCall_iiiij=Module["dynCall_iiiij"]=function(){return(dynCall_iiiij=Module["dynCall_iiiij"]=Module["asm"]["ia"]).apply(null,arguments)};var dynCall_vij=Module["dynCall_vij"]=function(){return(dynCall_vij=Module["dynCall_vij"]=Module["asm"]["ja"]).apply(null,arguments)};var dynCall_jiji=Module["dynCall_jiji"]=function(){return(dynCall_jiji=Module["dynCall_jiji"]=Module["asm"]["ka"]).apply(null,arguments)};var dynCall_viijii=Module["dynCall_viijii"]=function(){return(dynCall_viijii=Module["dynCall_viijii"]=Module["asm"]["la"]).apply(null,arguments)};var dynCall_iiiiij=Module["dynCall_iiiiij"]=function(){return(dynCall_iiiiij=Module["dynCall_iiiiij"]=Module["asm"]["ma"]).apply(null,arguments)};var dynCall_iiiiijj=Module["dynCall_iiiiijj"]=function(){return(dynCall_iiiiijj=Module["dynCall_iiiiijj"]=Module["asm"]["na"]).apply(null,arguments)};var dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=function(){return(dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=Module["asm"]["oa"]).apply(null,arguments)};Module["print"]=out;Module["printErr"]=err;Module["ALLOC_NORMAL"]=ALLOC_NORMAL;Module["ALLOC_STACK"]=ALLOC_STACK;var calledRun;function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}var calledMain=false;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function callMain(args){var entryFunction=Module["_main"];args=args||[];args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*4);var argv_ptr=argv>>2;args.forEach(arg=>{HEAP32[argv_ptr++]=allocateUTF8OnStack(arg)});HEAP32[argv_ptr]=0;try{var ret=entryFunction(argc,argv);exit(ret,true);return ret}catch(e){return handleException(e)}finally{calledMain=true}}function run(args){args=args||arguments_;if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();if(shouldRunNow)callMain(args);postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}Module["run"]=run;function exit(status,implicit){EXITSTATUS=status;procExit(status)}function procExit(code){EXITSTATUS=code;if(!keepRuntimeAlive()){if(Module["onExit"])Module["onExit"](code);ABORT=true}quit_(code,new ExitStatus(code))}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}var shouldRunNow=true;if(Module["noInitialRun"])shouldRunNow=false;run()}else{console.error("Invalid action : "+action);outgoingMessagePort.postMessage("invalid action")}},false); +var Module=typeof Module!="undefined"?Module:{};self.addEventListener("message",function(e){var action=e.data.action;var path=e.data.path;var outgoingMessagePort=e.ports[0];console.debug("WebWorker called with action="+action);if(action==="getEntryByPath"){var follow=e.data.follow;var entry=Module[action](path);if(entry){var item={};if(follow||!entry.isRedirect()){item=entry.getItem(follow);var blob=item.getData();var content=blob.getContent();var contentArray=new Uint8Array(content);outgoingMessagePort.postMessage({content:contentArray,mimetype:item.getMimetype(),isRedirect:entry.isRedirect()})}else{outgoingMessagePort.postMessage({content:new Uint8Array,isRedirect:true,redirectPath:entry.getRedirectEntry().getPath()})}}else{outgoingMessagePort.postMessage({content:new Uint8Array,mimetype:"unknown",isRedirect:false})}}else if(action==="search"){var text=e.data.text;var numResults=e.data.numResults||50;var entries=Module[action](text,numResults);console.debug("Found nb results = "+entries.size(),entries);var serializedEntries=[];for(var i=0;i0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)()}else{getWasmTableEntry(func)(callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}function handleException(e){if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)}function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+UTF8ToString(condition)+", at: "+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}function ___call_sighandler(fp,sig){getWasmTableEntry(fp)(sig)}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false)};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}var exceptionLast=0;var uncaughtExceptionCount=0;function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=ptr;uncaughtExceptionCount++;throw ptr}var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(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:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:function(){var paths=Array.prototype.slice.call(arguments,0);return PATH.normalize(paths.join("/"))},join2:(l,r)=>{return PATH.normalize(l+"/"+r)}};function getRandomDevice(){if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){var randomBuffer=new Uint8Array(1);return function(){crypto.getRandomValues(randomBuffer);return randomBuffer[0]}}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");return function(){return crypto_module["randomBytes"](1)[0]}}catch(e){}}return function(){abort("randomDevice")}}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.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=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;i0){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=[]}}}};function zeroMemory(address,size){HEAPU8.fill(0,address,address+size)}function alignMemory(size,alignment){return Math.ceil(size/alignment)*alignment}function mmapAlloc(size){size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(!ptr)return 0;zeroMemory(ptr,size);return ptr}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;parent.timestamp=node.timestamp}return node},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>>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)},resizeFileStorage:function(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{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}},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.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;old_node.parent=new_dir},unlink:function(parent,name){delete parent.contents[name];parent.timestamp=Date.now()},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];parent.timestamp=Date.now()},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);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length=stream.node.size)return 0;var chunk=stream.node.contents.slice(position,position+length);var ab=WORKERFS.reader.readAsArrayBuffer(chunk);buffer.set(new Uint8Array(ab),offset);return chunk.size},write:function(stream,buffer,offset,length,position){throw new FS.ErrnoError(29)},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.size}}if(position<0){throw new FS.ErrnoError(28)}return position}}};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path,opts={})=>{path=PATH_FS.resolve(FS.cwd(),path);if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=PATH.normalizeArray(path.split("/").filter(p=>!!p),false);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return{path:current_path,node:current}},getPath:node=>{var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?mount+"/"+path:mount+path}path=path?node.name+"/"+path:node.name;node=node.parent}},hashName:(parentid,name)=>{var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode:node=>{var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode:node=>{var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode:(parent,name)=>{var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode,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:(parent,name,mode,rdev)=>{var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode:node=>{FS.hashRemoveNode(node)},isRoot:node=>{return node===node.parent},isMountpoint:node=>{return!!node.mounted},isFile:mode=>{return(mode&61440)===32768},isDir:mode=>{return(mode&61440)===16384},isLink:mode=>{return(mode&61440)===40960},isChrdev:mode=>{return(mode&61440)===8192},isBlkdev:mode=>{return(mode&61440)===24576},isFIFO:mode=>{return(mode&61440)===4096},isSocket:mode=>{return(mode&49152)===49152},flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:str=>{var flags=FS.flagModes[str];if(typeof flags=="undefined"){throw new Error("Unknown file open mode: "+str)}return flags},flagsToPermissionString:flag=>{var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions:(node,perms)=>{if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup:dir=>{var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate:(dir,name)=>{try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete:(dir,name,isdir)=>{var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen:(node,flags)=>{if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd:(fd_start=0,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:fd=>FS.streams[fd],createStream:(stream,fd_start,fd_end)=>{if(!FS.FSStream){FS.FSStream=function(){this.shared={}};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}},flags:{get:function(){return this.shared.flags},set:function(val){this.shared.flags=val}},position:{get function(){return this.shared.position},set:function(val){this.shared.position=val}}}}stream=Object.assign(new FS.FSStream,stream);var fd=FS.nextfd(fd_start,fd_end);stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream:fd=>{FS.streams[fd]=null},chrdev_stream_ops:{open: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:()=>{throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice:(dev,ops)=>{FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts:mount=>{var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push.apply(check,m.mounts)}return mounts},syncfs:(populate,callback)=>{if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err("warning: "+FS.syncFSRequests+" FS.syncfs operations in flight at once, probably just doing extra work")}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount:(type,opts,mountpoint)=>{var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;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: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(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup:(parent,name)=>{return parent.node_ops.lookup(parent,name)},mknod:(path,mode,dev)=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create:(path,mode)=>{mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir:(path,mode)=>{mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree:(path,mode)=>{var dirs=path.split("/");var d="";for(var i=0;i{if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink:(oldpath,newpath)=>{if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename:(old_path,new_path)=>{var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);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)}}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)}},rmdir:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir:path=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node.node_ops.readdir){throw new FS.ErrnoError(54)}return node.node_ops.readdir(node)},unlink:path=>{var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink:path=>{var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return PATH_FS.resolve(FS.getPath(link.parent),link.node_ops.readlink(link))},stat:(path,dontFollow)=>{var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;if(!node){throw new FS.ErrnoError(44)}if(!node.node_ops.getattr){throw new FS.ErrnoError(63)}return node.node_ops.getattr(node)},lstat:path=>{return FS.stat(path,true)},chmod:(path,mode,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{mode:mode&4095|node.mode&~4095,timestamp:Date.now()})},lchmod:(path,mode)=>{FS.chmod(path,mode,true)},fchmod:(fd,mode)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chmod(stream.node,mode)},chown:(path,uid,gid,dontFollow)=>{var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}node.node_ops.setattr(node,{timestamp:Date.now()})},lchown:(path,uid,gid)=>{FS.chown(path,uid,gid,true)},fchown:(fd,uid,gid)=>{var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}FS.chown(stream.node,uid,gid)},truncate:(path,len)=>{if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(63)}if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}node.node_ops.setattr(node,{size:len,timestamp:Date.now()})},ftruncate:(fd,len)=>{var stream=FS.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:(path,atime,mtime)=>{var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;node.node_ops.setattr(node,{timestamp:Math.max(atime,mtime)})},open:(path,flags,mode)=>{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&&!created){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});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}}return stream},close: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:stream=>{return stream.fd===null},llseek:(stream,offset,whence)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read:(stream,buffer,offset,length,position)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write:(stream,buffer,offset,length,position,canOwn)=>{if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},allocate:(stream,offset,length)=>{if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(offset<0||length<=0){throw new FS.ErrnoError(28)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(43)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(138)}stream.stream_ops.allocate(stream,offset,length)},mmap:(stream,length,position,prot,flags)=>{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,length,position,prot,flags)},msync:(stream,buffer,offset,length,mmapFlags)=>{if(!stream||!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},munmap:stream=>0,ioctl:(stream,cmd,arg)=>{if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile:(path,opts={})=>{opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){throw new Error('Invalid encoding type "'+opts.encoding+'"')}var ret;var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){ret=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile:(path,data,opts={})=>{opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir:path=>{var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories:()=>{FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices:()=>{FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>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=getRandomDevice();FS.createDevice("/dev","random",random_device);FS.createDevice("/dev","urandom",random_device);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories:()=>{FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount:()=>{var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup:(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:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams:()=>{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",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},ensureErrnoError:()=>{if(FS.ErrnoError)return;FS.ErrnoError=function ErrnoError(errno,node){this.node=node;this.setErrno=function(errno){this.errno=errno};this.setErrno(errno);this.message="FS error"};FS.ErrnoError.prototype=new Error;FS.ErrnoError.prototype.constructor=FS.ErrnoError;[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack=""})},staticInit:()=>{FS.ensureErrnoError();FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS,"WORKERFS":WORKERFS}},init:(input,output,error)=>{FS.init.initialized=true;FS.ensureErrnoError();Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit:()=>{FS.init.initialized=false;for(var i=0;i{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode},findObject:(path,dontResolveLastLink)=>{var ret=FS.analyzePath(path,dontResolveLastLink);if(ret.exists){return ret.object}else{return null}},analyzePath:(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},createPath:(parent,path,canRead,canWrite)=>{parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){}parent=current}return current},createFile:(parent,name,properties,canRead,canWrite)=>{var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile:(parent,name,data,canRead,canWrite,canOwn)=>{var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS.getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i{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:stream=>{stream.seekable=false},close:stream=>{if(output&&output.buffer&&output.buffer.length){output(10)}},read:(stream,buffer,offset,length,pos)=>{var bytesRead=0;for(var i=0;i{for(var i=0;i{if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(typeof XMLHttpRequest!="undefined"){throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else if(read_){try{obj.contents=intArrayFromString(read_(obj.url),true);obj.usedBytes=obj.contents.length}catch(e){throw new FS.ErrnoError(29)}}else{throw new Error("Cannot load without read() or XMLHttpRequest.")}},createLazyFile:(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=(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);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(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(key=>{var fn=node.stream_ops[key];stream_ops[key]=function forceLoadLazyFile(){FS.forceLoadFile(node);return fn.apply(null,arguments)}});stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{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)}if(Browser.handledByPreloadPlugin(byteArray,fullname,finish,()=>{if(onerror)onerror();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url,byteArray=>processData(byteArray),onerror)}else{processData(url)}},indexedDB:()=>{return window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB},DB_NAME:()=>{return"EM_FS_"+window.location.pathname},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths,onload,onerror)=>{onload=onload||(()=>{});onerror=onerror||(()=>{});var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=()=>{out("creating db");var db=openRequest.result;db.createObjectStore(FS.DB_STORE_NAME)};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(path=>{var putRequest=files.put(FS.analyzePath(path).object.contents,path);putRequest.onsuccess=()=>{ok++;if(ok+fail==total)finish()};putRequest.onerror=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror},loadFilesFromDB:(paths,onload,onerror)=>{onload=onload||(()=>{});onerror=onerror||(()=>{});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=()=>{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(path=>{var getRequest=files.get(path);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=()=>{fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt:function(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=FS.getStream(dirfd);if(!dirstream)throw new FS.ErrnoError(8);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,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)},varargs:undefined,get:function(){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}};function ___syscall_fadvise64(fd,offset,len,advice){return 0}function setErrNo(value){HEAP32[___errno_location()>>2]=value;return value}function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=SYSCALLS.get();if(arg<0){return-28}var newStream;newStream=FS.createStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=SYSCALLS.get();stream.flags|=arg;return 0}case 5:{var arg=SYSCALLS.get();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 6:case 7:return 0;case 16:case 8:return-28;case 9:setErrNo(28);return-1;default:{return-28}}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{var stream=SYSCALLS.getStreamFromFD(fd);return SYSCALLS.doStat(FS.stat,stream.path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.lstat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~4352;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.doStat(nofollow?FS.lstat:FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?SYSCALLS.get():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(flags===0){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{abort("Invalid flags passed to unlinkat")}return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}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}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{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function registerType(rawType,registeredInstance,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(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 finalizationRegistry=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 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)}var registeredPointers={};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}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}var delayFunction=undefined;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 attachFinalizer(handle){if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.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}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(){}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.toHandle(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 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&®isteredClass.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 dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();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 heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i])}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName="constructor "+classType.name;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError("Cannot register multiple constructors with identical number of parameters ("+(argCount-1)+") for class '"+classType.name+"'! Overload resolution is currently only performed using the parameter count, not actual type info!")}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError("Cannot construct "+classType.name+" due to unbound types",rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}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;i0?", ":"")+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;i4&&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{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handle_array[handle].value},toHandle: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.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(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){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}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=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"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;ilengthBytesUTF8(value)}else{getLength=()=>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;i255){_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;iHEAPU16;shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>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.toHandle(v)}function __mmap_js(len,prot,flags,fd,off,allocated){try{var stream=FS.getStream(fd);if(!stream)return-8;var res=FS.mmap(stream,len,off,prot,flags);var ptr=res.ptr;HEAP32[allocated>>2]=res.allocated;return ptr}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function __munmap_js(addr,len,prot,flags,fd,offset){try{var stream=FS.getStream(fd);if(stream){if(prot&2){SYSCALLS.doMsync(addr,stream,len,flags,offset)}FS.munmap(stream)}}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return-e.errno}}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function getHeapMax(){return 2147483648}function emscripten_realloc_buffer(size){try{wasmMemory.grow(size-buffer.byteLength+65535>>>16);updateGlobalBufferAndViews(wasmMemory.buffer);return 1}catch(e){}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}let alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;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(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}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){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(x+"="+env[x])}getEnvStrings.strings=strings}return getEnvStrings.strings}function _environ_get(__environ,environ_buf){var bufSize=0;getEnvStrings().forEach(function(string,i){var ptr=environ_buf+bufSize;HEAPU32[__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();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(function(string){bufSize+=string.length+1});HEAPU32[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))throw e;return e.errno}}function doReadv(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN}function _fd_pread(fd,iov,iovcnt,offset_low,offset_high,pnum){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt,offset);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function doWritev(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr}return ret}function _fd_pwrite(fd,iov,iovcnt,offset_low,offset_high,pnum){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt,offset);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_read(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);HEAP32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){try{var offset=convertI32PairToI53Checked(offset_low,offset_high);if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?(Math.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))throw e;return e.errno}}function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e instanceof FS.ErrnoError))throw e;return e.errno}}function _setTempRet0(val){setTempRet0(val)}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.length0?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 days=date.tm_yday+7-date.tm_wday;return leadingNulls(Math.floor(days/7),2)},"%V":function(date){var val=Math.floor((date.tm_yday+7-(date.tm_wday+6)%7)/7);if((date.tm_wday+371-date.tm_yday-2)%7<=2){val++}if(!val){val=52;var dec31=(date.tm_wday+7-date.tm_yday-1)%7;if(dec31==4||dec31==5&&__isLeapYear(date.tm_year%400-1)){val++}}else if(val==53){var jan1=(date.tm_wday+371-date.tm_yday)%7;if(jan1!=4&&(jan1!=3||!__isLeapYear(date.tm_year)))val=1}return leadingNulls(val,2)},"%w":function(date){return date.tm_wday},"%W":function(date){var days=date.tm_yday+7-(date.tm_wday+6)%7;return leadingNulls(Math.floor(days/7),2)},"%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"%"}};pattern=pattern.replace(/%%/g,"\0\0");for(var rule in EXPANSION_RULES_2){if(pattern.includes(rule)){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_2[rule](date))}}pattern=pattern.replace(/\0\0/g,"%");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)}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_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();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={"g":___assert_fail,"D":___call_sighandler,"a":___cxa_allocate_exception,"b":___cxa_throw,"x":___syscall_fadvise64,"f":___syscall_fcntl64,"K":___syscall_fstat64,"H":___syscall_lstat64,"I":___syscall_newfstatat,"E":___syscall_openat,"J":___syscall_stat64,"C":___syscall_unlinkat,"z":__embind_register_bigint,"P":__embind_register_bool,"i":__embind_register_class,"s":__embind_register_class_constructor,"c":__embind_register_class_function,"O":__embind_register_emval,"u":__embind_register_float,"j":__embind_register_function,"e":__embind_register_integer,"d":__embind_register_memory_view,"t":__embind_register_std_string,"n":__embind_register_std_wstring,"Q":__embind_register_void,"o":__emval_decref,"p":__emval_incref,"k":__emval_take_value,"F":__mmap_js,"G":__munmap_js,"h":_abort,"N":_emscripten_memcpy_big,"B":_emscripten_resize_heap,"L":_environ_get,"M":_environ_sizes_get,"m":_fd_close,"w":_fd_pread,"v":_fd_pwrite,"r":_fd_read,"y":_fd_seek,"l":_fd_write,"q":_setTempRet0,"A":_strftime_l};var asm=createWasm();var ___wasm_call_ctors=Module["___wasm_call_ctors"]=function(){return(___wasm_call_ctors=Module["___wasm_call_ctors"]=Module["asm"]["S"]).apply(null,arguments)};var _main=Module["_main"]=function(){return(_main=Module["_main"]=Module["asm"]["T"]).apply(null,arguments)};var _malloc=Module["_malloc"]=function(){return(_malloc=Module["_malloc"]=Module["asm"]["U"]).apply(null,arguments)};var ___errno_location=Module["___errno_location"]=function(){return(___errno_location=Module["___errno_location"]=Module["asm"]["W"]).apply(null,arguments)};var _free=Module["_free"]=function(){return(_free=Module["_free"]=Module["asm"]["X"]).apply(null,arguments)};var ___getTypeName=Module["___getTypeName"]=function(){return(___getTypeName=Module["___getTypeName"]=Module["asm"]["Y"]).apply(null,arguments)};var ___embind_register_native_and_builtin_types=Module["___embind_register_native_and_builtin_types"]=function(){return(___embind_register_native_and_builtin_types=Module["___embind_register_native_and_builtin_types"]=Module["asm"]["Z"]).apply(null,arguments)};var _emscripten_builtin_memalign=Module["_emscripten_builtin_memalign"]=function(){return(_emscripten_builtin_memalign=Module["_emscripten_builtin_memalign"]=Module["asm"]["_"]).apply(null,arguments)};var stackAlloc=Module["stackAlloc"]=function(){return(stackAlloc=Module["stackAlloc"]=Module["asm"]["$"]).apply(null,arguments)};var ___cxa_is_pointer_type=Module["___cxa_is_pointer_type"]=function(){return(___cxa_is_pointer_type=Module["___cxa_is_pointer_type"]=Module["asm"]["aa"]).apply(null,arguments)};var dynCall_ji=Module["dynCall_ji"]=function(){return(dynCall_ji=Module["dynCall_ji"]=Module["asm"]["ba"]).apply(null,arguments)};var dynCall_viijj=Module["dynCall_viijj"]=function(){return(dynCall_viijj=Module["dynCall_viijj"]=Module["asm"]["ca"]).apply(null,arguments)};var dynCall_iij=Module["dynCall_iij"]=function(){return(dynCall_iij=Module["dynCall_iij"]=Module["asm"]["da"]).apply(null,arguments)};var dynCall_iijj=Module["dynCall_iijj"]=function(){return(dynCall_iijj=Module["dynCall_iijj"]=Module["asm"]["ea"]).apply(null,arguments)};var dynCall_viij=Module["dynCall_viij"]=function(){return(dynCall_viij=Module["dynCall_viij"]=Module["asm"]["fa"]).apply(null,arguments)};var dynCall_ij=Module["dynCall_ij"]=function(){return(dynCall_ij=Module["dynCall_ij"]=Module["asm"]["ga"]).apply(null,arguments)};var dynCall_iiiji=Module["dynCall_iiiji"]=function(){return(dynCall_iiiji=Module["dynCall_iiiji"]=Module["asm"]["ha"]).apply(null,arguments)};var dynCall_iiiij=Module["dynCall_iiiij"]=function(){return(dynCall_iiiij=Module["dynCall_iiiij"]=Module["asm"]["ia"]).apply(null,arguments)};var dynCall_vij=Module["dynCall_vij"]=function(){return(dynCall_vij=Module["dynCall_vij"]=Module["asm"]["ja"]).apply(null,arguments)};var dynCall_jiji=Module["dynCall_jiji"]=function(){return(dynCall_jiji=Module["dynCall_jiji"]=Module["asm"]["ka"]).apply(null,arguments)};var dynCall_viijii=Module["dynCall_viijii"]=function(){return(dynCall_viijii=Module["dynCall_viijii"]=Module["asm"]["la"]).apply(null,arguments)};var dynCall_iiiiij=Module["dynCall_iiiiij"]=function(){return(dynCall_iiiiij=Module["dynCall_iiiiij"]=Module["asm"]["ma"]).apply(null,arguments)};var dynCall_iiiiijj=Module["dynCall_iiiiijj"]=function(){return(dynCall_iiiiijj=Module["dynCall_iiiiijj"]=Module["asm"]["na"]).apply(null,arguments)};var dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=function(){return(dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=Module["asm"]["oa"]).apply(null,arguments)};Module["print"]=out;Module["printErr"]=err;Module["ALLOC_NORMAL"]=ALLOC_NORMAL;Module["ALLOC_STACK"]=ALLOC_STACK;var calledRun;function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}var calledMain=false;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function callMain(args){var entryFunction=Module["_main"];args=args||[];args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*4);var argv_ptr=argv>>2;args.forEach(arg=>{HEAP32[argv_ptr++]=allocateUTF8OnStack(arg)});HEAP32[argv_ptr]=0;try{var ret=entryFunction(argc,argv);exit(ret,true);return ret}catch(e){return handleException(e)}finally{calledMain=true}}function run(args){args=args||arguments_;if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();if(shouldRunNow)callMain(args);postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}Module["run"]=run;function exit(status,implicit){EXITSTATUS=status;procExit(status)}function procExit(code){EXITSTATUS=code;if(!keepRuntimeAlive()){if(Module["onExit"])Module["onExit"](code);ABORT=true}quit_(code,new ExitStatus(code))}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}var shouldRunNow=true;if(Module["noInitialRun"])shouldRunNow=false;run()}else{console.error("Invalid action : "+action);outgoingMessagePort.postMessage("invalid action")}},false); diff --git a/www/libzim-wasm.electron.dev.js b/www/libzim-wasm.electron.dev.js new file mode 100644 index 00000000..7de21768 --- /dev/null +++ b/www/libzim-wasm.electron.dev.js @@ -0,0 +1,8376 @@ + + +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(Module) { ..generated code.. } +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof Module != 'undefined' ? Module : {}; + +// See https://caniuse.com/mdn-javascript_builtins_object_assign + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +self.addEventListener("message", function(e) { + var action = e.data.action; + var path = e.data.path; + var outgoingMessagePort = e.ports[0]; + console.debug("WebWorker called with action=" + action); + if (action === "getEntryByPath") { + var follow = e.data.follow; + var entry = Module[action](path); + if (entry) { + var item = {}; + if (follow || !entry.isRedirect()) { + item = entry.getItem(follow); + // It's necessary to keep an instance of the blob till the end of this block, + // to ensure that the corresponding content is not deleted on the C side. + var blob = item.getData(); + var content = blob.getContent(); + // TODO : is there a more efficient way to make the Array detachable? So that it can be transfered back from the WebWorker without a copy? + var contentArray = new Uint8Array(content); + outgoingMessagePort.postMessage({ content: contentArray, mimetype: item.getMimetype(), isRedirect: entry.isRedirect()}); + } + else { + outgoingMessagePort.postMessage({ content: new Uint8Array(), isRedirect: true, redirectPath: entry.getRedirectEntry().getPath()}); + } + } + else { + outgoingMessagePort.postMessage({ content: new Uint8Array(), mimetype: "unknown", isRedirect: false}); + } + } + else if (action === "search") { + var text = e.data.text; + var numResults = e.data.numResults || 50; + var entries = Module[action](text, numResults); + console.debug("Found nb results = " + entries.size(), entries); + var serializedEntries = []; + for (var i=0; i .zim) + var baseZimFileName = files[0].name.replace(/\.zim..$/, '.zim'); + Module = {}; + Module["onRuntimeInitialized"] = function() { + Module.loadArchive("/work/" + baseZimFileName); + console.debug(assemblerType + " initialized"); + outgoingMessagePort.postMessage("runtime initialized"); + }; + Module["arguments"] = []; + for (let i = 0; i < files.length; i++) { + Module["arguments"].push("/work/" + files[i].name); + } + Module["preRun"] = function() { + FS.mkdir("/work"); + FS.mount(WORKERFS, { + files: files + }, "/work"); + }; + console.debug("baseZimFileName = " + baseZimFileName); + console.debug('Module["arguments"] = ' + Module["arguments"]) + + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (Module['ENVIRONMENT']) { + throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)'); +} + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +// Normally we don't log exceptions but instead let them bubble out the top +// level where the embedding environment (e.g. the browser) can handle +// them. +// However under v8 and node we sometimes exit the process direcly in which case +// its up to use us to log the exception before exiting. +// If we fix https://github.com/emscripten-core/emscripten/issues/15080 +// this may no longer be needed under node. +function logExceptionOnExit(e) { + if (e instanceof ExitStatus) return; + let toLog = e; + if (e && typeof e == 'object' && e.stack) { + toLog = [e, e.stack]; + } + err('exiting due to exception: ' + toLog); +} + +var fs; +var nodePath; +var requireNodeFS; + +if (ENVIRONMENT_IS_NODE) { + if (!(typeof process == 'object' && typeof require == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = require('path').dirname(scriptDirectory) + '/'; + } else { + scriptDirectory = __dirname + '/'; + } + +// include: node_shell_read.js + + +requireNodeFS = () => { + // Use nodePath as the indicator for these not being initialized, + // since in some environments a global fs may have already been + // created. + if (!nodePath) { + fs = require('fs'); + nodePath = require('path'); + } +}; + +read_ = function shell_read(filename, binary) { + requireNodeFS(); + filename = nodePath['normalize'](filename); + return fs.readFileSync(filename, binary ? undefined : 'utf8'); +}; + +readBinary = (filename) => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; +}; + +readAsync = (filename, onload, onerror) => { + requireNodeFS(); + filename = nodePath['normalize'](filename); + fs.readFile(filename, function(err, data) { + if (err) onerror(err); + else onload(data.buffer); + }); +}; + +// end include: node_shell_read.js + if (process['argv'].length > 1) { + thisProgram = process['argv'][1].replace(/\\/g, '/'); + } + + arguments_ = process['argv'].slice(2); + + if (typeof module != 'undefined') { + module['exports'] = Module; + } + + process['on']('uncaughtException', function(ex) { + // suppress ExitStatus exceptions from showing an error + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + + // Without this older versions of node (< v15) will log unhandled rejections + // but return 0, which is not normally the desired behaviour. This is + // not be needed with node v15 and about because it is now the default + // behaviour: + // See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode + process['on']('unhandledRejection', function(reason) { throw reason; }); + + quit_ = (status, toThrow) => { + if (keepRuntimeAlive()) { + process['exitCode'] = status; + throw toThrow; + } + logExceptionOnExit(toThrow); + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; + +} else +if (ENVIRONMENT_IS_SHELL) { + + if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + let data; + if (typeof readbuffer == 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data == 'object'); + return data; + }; + + readAsync = function readAsync(f, onload, onerror) { + setTimeout(() => onload(readBinary(f)), 0); + }; + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit == 'function') { + quit_ = (status, toThrow) => { + logExceptionOnExit(toThrow); + quit(status); + }; + } + + if (typeof print != 'undefined') { + // Prefer to use print/printErr where they exist, as they usually work better. + if (typeof console == 'undefined') console = /** @type{!Console} */({}); + console.log = /** @type{!function(this:Console, ...*): undefined} */ (print); + console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print); + } + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { +// include: web_or_worker_shell_read.js + + + read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } + + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + +// end include: web_or_worker_shell_read.js + } + + setWindowTitle = (title) => document.title = title; +} else +{ + throw new Error('environment detection error'); +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = null; +checkIncomingModuleAPI(); + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_'); + +if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram'); + +if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_'); + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)'); +assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)'); +assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); +legacyModuleProp('read', 'read_'); +legacyModuleProp('readAsync', 'readAsync'); +legacyModuleProp('readBinary', 'readBinary'); +legacyModuleProp('setWindowTitle', 'setWindowTitle'); +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; +var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; + + + +assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable."); + + + + +var STACK_ALIGN = 16; +var POINTER_SIZE = 4; + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': case 'u8': return 1; + case 'i16': case 'u16': return 2; + case 'i32': case 'u32': return 4; + case 'i64': case 'u64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length - 1] === '*') { + return POINTER_SIZE; + } else if (type[0] === 'i') { + const 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); + } +} + +// include: runtime_functions.js + + +// This gives correct answers for everything less than 2^{14} = 16384 +// I hope nobody is contemplating functions with 16384 arguments... +function uleb128Encode(n) { + assert(n < 16384); + if (n < 128) { + return [n]; + } + return [(n % 128) | 128, n >> 7]; +} + +// Wraps a JS function as a wasm function with a given signature. +function convertJsFunctionToWasm(func, sig) { + + // If the type reflection proposal is available, use the new + // "WebAssembly.Function" constructor. + // Otherwise, construct a minimal wasm module importing the JS function and + // re-exporting it. + if (typeof WebAssembly.Function == "function") { + var typeNames = { + 'i': 'i32', + 'j': 'i64', + 'f': 'f32', + 'd': 'f64', + 'p': 'i32', + }; + var type = { + parameters: [], + results: sig[0] == 'v' ? [] : [typeNames[sig[0]]] + }; + for (var i = 1; i < sig.length; ++i) { + assert(sig[i] in typeNames, 'invalid signature char: ' + sig[i]); + type.parameters.push(typeNames[sig[i]]); + } + return new WebAssembly.Function(type, func); + } + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'p': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection = typeSection.concat(uleb128Encode(sigParam.length)); + for (var i = 0; i < sigParam.length; ++i) { + assert(sigParam[i] in typeCodes, 'invalid signature char: ' + sigParam[i]); + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the section code and overall length of the type section into the + // section header + typeSection = [0x01 /* Type section code */].concat( + uleb128Encode(typeSection.length), + typeSection + ); + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + 'e': { + 'f': func + } + }); + var wrappedFunc = instance.exports['f']; + return wrappedFunc; +} + +var freeTableIndexes = []; + +// Weak map of functions in the table to their indexes, created on first use. +var functionsInTableMap; + +function getEmptyTableSlot() { + // Reuse a free index if there is one, otherwise grow. + if (freeTableIndexes.length) { + return freeTableIndexes.pop(); + } + // Grow the table + try { + wasmTable.grow(1); + } catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.'; + } + return wasmTable.length - 1; +} + +function updateTableMap(offset, count) { + for (var i = offset; i < offset + count; i++) { + var item = getWasmTableEntry(i); + // Ignore null values. + if (item) { + functionsInTableMap.set(item, i); + } + } +} + +/** + * Add a function to the table. + * 'sig' parameter is required if the function being added is a JS function. + * @param {string=} sig + */ +function addFunction(func, sig) { + assert(typeof func != 'undefined'); + + // Check if the function is already in the table, to ensure each function + // gets a unique index. First, create the map if this is the first use. + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + updateTableMap(0, wasmTable.length); + } + if (functionsInTableMap.has(func)) { + return functionsInTableMap.get(func); + } + + // It's not in the table, add it now. + + var ret = getEmptyTableSlot(); + + // Set the new value. + try { + // Attempting to call this with JS function will cause of table.set() to fail + setWasmTableEntry(ret, func); + } catch (err) { + if (!(err instanceof TypeError)) { + throw err; + } + assert(typeof sig != 'undefined', 'Missing signature argument to addFunction: ' + func); + var wrapped = convertJsFunctionToWasm(func, sig); + setWasmTableEntry(ret, wrapped); + } + + functionsInTableMap.set(func, ret); + + return ret; +} + +function removeFunction(index) { + functionsInTableMap.delete(getWasmTableEntry(index)); + freeTableIndexes.push(index); +} + +// end include: runtime_functions.js +// include: runtime_debug.js + + +function legacyModuleProp(prop, newName) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get: function() { + abort('Module.' + prop + ' has been replaced with plain ' + newName + ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)'); + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort('`Module.' + prop + '` was supplied but `' + prop + '` not included in INCOMING_MODULE_JS_API'); + } +} + +function unexportedMessage(sym, isFSSybol) { + var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"; + if (isFSSybol) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + return msg; +} + +function unexportedRuntimeSymbol(sym, isFSSybol) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get: function() { + abort(unexportedMessage(sym, isFSSybol)); + } + }); + } +} + +function unexportedRuntimeFunction(sym, isFSSybol) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Module[sym] = () => abort(unexportedMessage(sym, isFSSybol)); + } +} + +// end include: runtime_debug.js +var tempRet0 = 0; +var setTempRet0 = (value) => { tempRet0 = value; }; +var getTempRet0 = () => tempRet0; + + + +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary'); +var noExitRuntime = Module['noExitRuntime'] || true;legacyModuleProp('noExitRuntime', 'noExitRuntime'); + +if (typeof WebAssembly != 'object') { + abort('no native wasm support detected'); +} + +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed' + (text ? ': ' + text : '')); + } +} + +// Returns the C function with a specified identifier (for C++, you need to do manual name mangling) +function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; +} + +// C calling interface. +/** @param {string|null=} returnType + @param {Array=} argTypes + @param {Arguments|Array=} args + @param {Object=} opts */ +function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') { + + return UTF8ToString(ret); + } + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + assert(returnType !== 'array', 'Return type should not be "array".'); + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret); + } + + ret = onDone(ret); + return ret; +} + +/** @param {string=} returnType + @param {Array=} argTypes + @param {Object=} opts */ +function cwrap(ident, returnType, argTypes, opts) { + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +// We used to include malloc/free by default in the past. Show a helpful error in +// builds with assertions. + +// include: runtime_legacy.js + + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call + +/** + * allocate(): This function is no longer used by emscripten but is kept around to avoid + * breaking external users. + * You should normally not use allocate(), and instead allocate + * memory using _malloc()/stackAlloc(), initialize it with + * setValue(), and so forth. + * @param {(Uint8Array|Array)} slab: An array of data. + * @param {number=} allocator : How to allocate memory, see ALLOC_* + */ +function allocate(slab, allocator) { + var ret; + assert(typeof allocator == 'number', 'allocate no longer takes a type argument') + assert(typeof slab != 'number', 'allocate no longer takes a number as arg0') + + if (allocator == ALLOC_STACK) { + ret = stackAlloc(slab.length); + } else { + ret = _malloc(slab.length); + } + + if (!slab.subarray && !slab.slice) { + slab = new Uint8Array(slab); + } + HEAPU8.set(slab, ret); + return ret; +} + +// end include: runtime_legacy.js +// include: runtime_strings.js + + +// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime. + +var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns +// a copy of that string as a Javascript String object. +/** + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; +} + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a +// copy of that string as a Javascript String object. +// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit +// this parameter to scan the string until the first \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will +// not produce a string of exact length [ptr, ptr+maxBytesToRead[) +// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may +// throw JS JIT optimizations off, so it is worth to consider consistently using one +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; +} + +// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', +// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. +// This count should include the null terminator, +// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. +// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 0x10FFFF) warnOnce('Invalid Unicode code point 0x' + u.toString(16) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).'); + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + +// end include: runtime_strings.js +// include: runtime_strings_extra.js + + +// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime. + +// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + +function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + +// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined; + +function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var str = ''; + + // If maxBytesToRead is not passed explicitly, it will be undefined, and the for-loop's condition + // will always evaluate to true. The loop is then terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return str; + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. +// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. +// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF16(str, outPtr, maxBytesToWrite) { + assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); + var i = 0; + + var str = ''; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. +// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. +// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF32(str, outPtr, maxBytesToWrite) { + assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// a maximum length limit of how many bytes it is allowed to write. Prefer calling the +// function stringToUTF8Array() instead, which takes in a maximum length that can be used +// to be secure from out of bounds writes. +/** @deprecated + @param {boolean=} dontAddNull */ +function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +function writeArrayToMemory(array, buffer) { + assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') + HEAP8.set(array, buffer); +} + +/** @param {boolean=} dontAddNull */ +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff)); + HEAP8[((buffer++)>>0)] = str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)] = 0; +} + +// end include: runtime_strings_extra.js +// Memory management + +var HEAP, +/** @type {!ArrayBuffer} */ + buffer, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); +} + +var 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_MEMORY = Module['INITIAL_MEMORY'] || 83886080;legacyModuleProp('INITIAL_MEMORY', 'INITIAL_MEMORY'); + +assert(INITIAL_MEMORY >= TOTAL_STACK, 'INITIAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); + +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) +assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, + 'JS engine does not provide full typed array support'); + +// If memory is defined in wasm, the user can't provide it. +assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'); +assert(INITIAL_MEMORY == 83886080, 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'); + +// include: runtime_init_table.js +// In regular non-RELOCATABLE mode the table is exported +// from the wasm module and this will be assigned once +// the exports are available. +var wasmTable; + +// end include: runtime_init_table.js +// include: runtime_stack_check.js + + +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + // The stack grow downwards towards _emscripten_stack_get_end. + // We write cookies to the final two words in the stack and detect if they are + // ever overwritten. + HEAP32[((max)>>2)] = 0x2135467; + HEAP32[(((max)+(4))>>2)] = 0x89BACDFE; + // Also test the global address 0 for integrity. + HEAPU32[0] = 0x63736d65; /* 'emsc' */ +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + var cookie1 = HEAPU32[((max)>>2)]; + var cookie2 = HEAPU32[(((max)+(4))>>2)]; + if (cookie1 != 0x2135467 || cookie2 != 0x89BACDFE) { + abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x' + cookie2.toString(16) + ' 0x' + cookie1.toString(16)); + } + // Also test the global address 0 for integrity. + if (HEAPU32[0] !== 0x63736d65 /* 'emsc' */) abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); +} + +// end include: runtime_stack_check.js +// include: runtime_assertions.js + + +// Endianness check +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 0x6373; + if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)'; +})(); + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +function keepRuntimeAlive() { + return noExitRuntime; +} + +function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + checkStackCookie(); + assert(!runtimeInitialized); + runtimeInitialized = true; + + +if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); +FS.ignorePermissions = false; + +TTY.init(); + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + checkStackCookie(); + + callRuntimeCallbacks(__ATMAIN__); +} + +function postRun() { + checkStackCookie(); + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js + + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); + +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(function() { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err('still waiting on run dependencies:'); + } + err('dependency: ' + dep); + } + if (shown) { + err('(end of list)'); + } + }, 10000); + } + } else { + err('warning: run dependency added without ID'); + } +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + { + if (Module['onAbort']) { + Module['onAbort'](what); + } + } + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // defintion for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// {{MEM_INITIALIZER}} + +// include: memoryprofiler.js + + +// end include: memoryprofiler.js +// include: URIUtils.js + + +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + // Prefix of data URIs emitted by SINGLE_FILE and related options. + return filename.startsWith(dataURIPrefix); +} + +// Indicates whether filename is delivered via file protocol (as opposed to http/https) +function isFileURI(filename) { + return filename.startsWith('file://'); +} + +// end include: URIUtils.js +/** @param {boolean=} fixedasm */ +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module['asm']; + } + assert(runtimeInitialized, 'native function `' + displayName + '` called before runtime initialization'); + if (!asm[name]) { + assert(asm[name], 'exported native function `' + displayName + '` not found'); + } + return asm[name].apply(null, arguments); + }; +} + +var wasmBinaryFile; + wasmBinaryFile = 'libzim-wasm.electron.dev.wasm'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + +function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise() { + // If we don't have the binary yet, try to to load it asynchronously. + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use fetch if it is available and the url is not a file, otherwise fall back to XHR. + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == 'function' + && !isFileURI(wasmBinaryFile) + ) { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(wasmBinaryFile); + }); + } + else { + if (readAsync) { + // fetch is not available or url is file => try XHR (readAsync uses XHR internally) + return new Promise(function(resolve, reject) { + readAsync(wasmBinaryFile, function(response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))) }, reject) + }); + } + } + } + + // Otherwise, getBinary should be able to get it synchronously + return Promise.resolve().then(function() { return getBinary(wasmBinaryFile); }); +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': asmLibraryArg, + 'wasi_snapshot_preview1': asmLibraryArg, + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + var exports = instance.exports; + + Module['asm'] = exports; + + wasmMemory = Module['asm']['memory']; + assert(wasmMemory, "memory not found in wasm exports"); + // This assertion doesn't hold when emscripten is run in --post-link + // mode. + // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode. + //assert(wasmMemory.buffer.byteLength === 83886080); + updateGlobalBufferAndViews(wasmMemory.buffer); + + wasmTable = Module['asm']['__indirect_function_table']; + assert(wasmTable, "table not found in wasm exports"); + + addOnInit(Module['asm']['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(function (instance) { + return instance; + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + + // Warn on some common problems. + if (isFileURI(wasmBinaryFile)) { + err('warning: Loading from a file URI (' + wasmBinaryFile + ') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing'); + } + abort(reason); + }); + } + + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(wasmBinaryFile) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(wasmBinaryFile) && + typeof fetch == 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, info); + + return result.then( + receiveInstantiationResult, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(receiveInstantiationResult); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiationResult); + } + } + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel + // to any other async startup actions they are performing. + // Also pthreads and wasm workers initialize the wasm instance through this path. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + instantiateAsync(); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = { + +}; + + + + + + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(Module); // Pass the module as the first argument. + continue; + } + var func = callback.func; + if (typeof func == 'number') { + if (callback.arg === undefined) { + // Run the wasm function ptr with signature 'v'. If no function + // with such signature was exported, this call does not need + // to be emitted (and would confuse Closure) + getWasmTableEntry(func)(); + } else { + // If any function with signature 'vi' was exported, run + // the callback with that signature. + getWasmTableEntry(func)(callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } + } + + function withStackSave(f) { + var stack = stackSave(); + var ret = f(); + stackRestore(stack); + return ret; + } + function demangle(func) { + // If demangle has failed before, stop demangling any further function names + // This avoids an infinite recursion with malloc()->abort()->stackTrace()->demangle()->malloc()->... + demangle.recursionGuard = (demangle.recursionGuard|0)+1; + if (demangle.recursionGuard > 1) return func; + var __cxa_demangle_func = Module['___cxa_demangle'] || Module['__cxa_demangle']; + assert(__cxa_demangle_func); + return withStackSave(function() { + try { + var s = func; + if (s.startsWith('__Z')) + s = s.substr(1); + var len = lengthBytesUTF8(s)+1; + var buf = stackAlloc(len); + stringToUTF8(s, buf, len); + var status = stackAlloc(4); + var ret = __cxa_demangle_func(buf, 0, 0, status); + if (HEAP32[((status)>>2)] === 0 && ret) { + return UTF8ToString(ret); + } + // otherwise, libcxxabi failed + } catch(e) { + } finally { + _free(ret); + if (demangle.recursionGuard < 2) --demangle.recursionGuard; + } + // failure when using libcxxabi, don't demangle + 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 + ']'); + }); + } + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = 'i32'; + switch (type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return Number(HEAPF64[((ptr)>>3)]); + default: abort('invalid type for getValue: ' + type); + } + return null; + } + + var wasmTableMirror = []; + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!"); + return func; + } + + function handleException(e) { + // Certain exception types we do not treat as errors since they are used for + // internal control flow. + // 1. ExitStatus, which is thrown by exit() + // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others + // that wish to return to JS event loop. + if (e instanceof ExitStatus || e == 'unwind') { + return EXITSTATUS; + } + quit_(1, e); + } + + function jsStackTrace() { + var error = new Error(); + if (!error.stack) { + // IE10+ special cases: It does have callstack info, but it is only + // populated if an Error object is thrown, so try that as a special-case. + try { + throw new Error(); + } catch(e) { + error = e; + } + if (!error.stack) { + return '(no stack trace available)'; + } + } + return error.stack.toString(); + } + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) 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.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + default: abort('invalid type for setValue: ' + type); + } + } + + function setWasmTableEntry(idx, func) { + wasmTable.set(idx, func); + // With ABORT_ON_WASM_EXCEPTIONS wasmTable.get is overriden to return wrapped + // functions so we need to call it here to retrieve the potential wrapper correctly + // instead of just storing 'func' directly into wasmTableMirror + wasmTableMirror[idx] = wasmTable.get(idx); + } + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + + function ___assert_fail(condition, filename, line, func) { + abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + } + + function ___call_sighandler(fp, sig) { + getWasmTableEntry(fp)(sig); + } + + function ___cxa_allocate_exception(size) { + // Thrown object is prepended by exception metadata block + return _malloc(size + 24) + 24; + } + + var exceptionCaught = []; + + function exception_addRef(info) { + info.add_ref(); + } + + var uncaughtExceptionCount = 0; + function ___cxa_begin_catch(ptr) { + var info = new ExceptionInfo(ptr); + if (!info.get_caught()) { + info.set_caught(true); + uncaughtExceptionCount--; + } + info.set_rethrown(false); + exceptionCaught.push(info); + exception_addRef(info); + return info.get_exception_ptr(); + } + + /** @constructor */ + function ExceptionInfo(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + + this.set_type = function(type) { + HEAPU32[(((this.ptr)+(4))>>2)] = type; + }; + + this.get_type = function() { + return HEAPU32[(((this.ptr)+(4))>>2)]; + }; + + this.set_destructor = function(destructor) { + HEAPU32[(((this.ptr)+(8))>>2)] = destructor; + }; + + this.get_destructor = function() { + return HEAPU32[(((this.ptr)+(8))>>2)]; + }; + + this.set_refcount = function(refcount) { + HEAP32[((this.ptr)>>2)] = refcount; + }; + + this.set_caught = function (caught) { + caught = caught ? 1 : 0; + HEAP8[(((this.ptr)+(12))>>0)] = caught; + }; + + this.get_caught = function () { + return HEAP8[(((this.ptr)+(12))>>0)] != 0; + }; + + this.set_rethrown = function (rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(((this.ptr)+(13))>>0)] = rethrown; + }; + + this.get_rethrown = function () { + return HEAP8[(((this.ptr)+(13))>>0)] != 0; + }; + + // Initialize native structure fields. Should be called once after allocated. + this.init = function(type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + this.set_refcount(0); + this.set_caught(false); + this.set_rethrown(false); + } + + this.add_ref = function() { + var value = HEAP32[((this.ptr)>>2)]; + HEAP32[((this.ptr)>>2)] = value + 1; + }; + + // Returns true if last reference released. + this.release_ref = function() { + var prev = HEAP32[((this.ptr)>>2)]; + HEAP32[((this.ptr)>>2)] = prev - 1; + assert(prev > 0); + return prev === 1; + }; + + this.set_adjusted_ptr = function(adjustedPtr) { + HEAPU32[(((this.ptr)+(16))>>2)] = adjustedPtr; + }; + + this.get_adjusted_ptr = function() { + return HEAPU32[(((this.ptr)+(16))>>2)]; + }; + + // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted + // when the pointer is casted to some of the exception object base classes (e.g. when virtual + // inheritance is used). When a pointer is thrown this method should return the thrown pointer + // itself. + this.get_exception_ptr = function() { + // Work around a fastcomp bug, this code is still included for some reason in a build without + // exceptions support. + var isPointer = ___cxa_is_pointer_type(this.get_type()); + if (isPointer) { + return HEAPU32[((this.excPtr)>>2)]; + } + var adjusted = this.get_adjusted_ptr(); + if (adjusted !== 0) return adjusted; + return this.excPtr; + }; + } + function ___cxa_free_exception(ptr) { + try { + return _free(new ExceptionInfo(ptr).ptr); + } catch(e) { + err('exception during __cxa_free_exception: ' + e); + } + } + function exception_decRef(info) { + // A rethrown exception can reach refcount 0; it must not be discarded + // Its next handler will clear the rethrown flag and addRef it, prior to + // final decRef and destruction here + if (info.release_ref() && !info.get_rethrown()) { + var destructor = info.get_destructor(); + if (destructor) { + // In Wasm, destructors return 'this' as in ARM + getWasmTableEntry(destructor)(info.excPtr); + } + ___cxa_free_exception(info.excPtr); + } + } + function ___cxa_decrement_exception_refcount(ptr) { + if (!ptr) return; + exception_decRef(new ExceptionInfo(ptr)); + } + + var exceptionLast = 0; + function ___cxa_end_catch() { + // Clear state flag. + _setThrew(0); + assert(exceptionCaught.length > 0); + // Call destructor if one is registered then clear it. + var info = exceptionCaught.pop(); + + exception_decRef(info); + exceptionLast = 0; // XXX in decRef? + } + + function ___resumeException(ptr) { + if (!exceptionLast) { exceptionLast = ptr; } + throw ptr; + } + function ___cxa_find_matching_catch_2() { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + var typeArray = Array.prototype.slice.call(arguments); + + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + var caughtType = typeArray[i]; + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; + } + + function ___cxa_find_matching_catch_3() { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + var typeArray = Array.prototype.slice.call(arguments); + + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + var caughtType = typeArray[i]; + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; + } + + function ___cxa_find_matching_catch_4() { + var thrown = exceptionLast; + if (!thrown) { + // just pass through the null ptr + setTempRet0(0); + return 0; + } + var info = new ExceptionInfo(thrown); + info.set_adjusted_ptr(thrown); + var thrownType = info.get_type(); + if (!thrownType) { + // just pass through the thrown ptr + setTempRet0(0); + return thrown; + } + var typeArray = Array.prototype.slice.call(arguments); + + // can_catch receives a **, add indirection + // The different catch blocks are denoted by different types. + // Due to inheritance, those types may not precisely match the + // type of the thrown object. Find one which matches, and + // return the type of the catch block which should be called. + for (var i = 0; i < typeArray.length; i++) { + var caughtType = typeArray[i]; + if (caughtType === 0 || caughtType === thrownType) { + // Catch all clause matched or exactly the same type is caught + break; + } + var adjusted_ptr_addr = info.ptr + 16; + if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) { + setTempRet0(caughtType); + return thrown; + } + } + setTempRet0(thrownType); + return thrown; + } + + + function ___cxa_increment_exception_refcount(ptr) { + if (!ptr) return; + exception_addRef(new ExceptionInfo(ptr)); + } + + function ___cxa_rethrow() { + var info = exceptionCaught.pop(); + if (!info) { + abort('no exception to throw'); + } + var ptr = info.excPtr; + if (!info.get_rethrown()) { + // Only pop if the corresponding push was through rethrow_primary_exception + exceptionCaught.push(info); + info.set_rethrown(true); + info.set_caught(false); + uncaughtExceptionCount++; + } + exceptionLast = ptr; + throw ptr; + } + + function ___cxa_rethrow_primary_exception(ptr) { + if (!ptr) return; + var info = new ExceptionInfo(ptr); + exceptionCaught.push(info); + info.set_rethrown(true); + ___cxa_rethrow(); + } + + function ___cxa_throw(ptr, type, destructor) { + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw ptr; + } + + function ___cxa_uncaught_exceptions() { + return uncaughtExceptionCount; + } + + + var PATH = {isAbs:(path) => path.charAt(0) === '/',splitPath:(filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:(parts, allowAboveRoot) => { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:(path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter((p) => !!p), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:(path) => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:(path) => { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },join:function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:(l, r) => { + return PATH.normalize(l + '/' + r); + }}; + + function getRandomDevice() { + if (typeof crypto == 'object' && typeof crypto['getRandomValues'] == 'function') { + // for modern web browsers + var randomBuffer = new Uint8Array(1); + return function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; }; + } else + if (ENVIRONMENT_IS_NODE) { + // for nodejs with or without crypto support included + try { + var crypto_module = require('crypto'); + // nodejs has crypto support + return function() { return crypto_module['randomBytes'](1)[0]; }; + } catch (e) { + // nodejs doesn't have crypto support + } + } + // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096 + return function() { abort("no cryptographic support found for randomDevice. 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 } };"); }; + } + + var PATH_FS = {resolve:function() { + var resolvedPath = '', + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : FS.cwd(); + // Skip empty and invalid entries + if (typeof path != 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + return ''; // an invalid portion invalidates the whole thing + } + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter((p) => !!p), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + },relative:(from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }}; + + var TTY = {ttys:[],init:function () { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process['stdin']['setEncoding']('utf8'); + // } + },shutdown:function() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process['stdin']['pause'](); + // } + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + // flush any pending line data + stream.tty.ops.flush(stream.tty); + },flush:function(stream) { + stream.tty.ops.flush(stream.tty); + },read:function(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + },write:function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes, + // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0. + if (e.toString().includes('EOF')) bytesRead = 0; + else throw e; + } + + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString('utf-8'); + } else { + result = null; + } + } else + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); // returns null on cancel + if (result !== null) { + result += '\n'; + } + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + if (result !== null) { + result += '\n'; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + },put_char:function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }},default_tty1_ops:{put_char:function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + },flush:function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + } + + function alignMemory(size, alignment) { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + size = alignMemory(size, 65536); + var ptr = _emscripten_builtin_memalign(65536, size); + if (!ptr) return 0; + zeroMemory(ptr, size); + return ptr; + } + var MEMFS = {ops_table:null,mount:function(mount) { + return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); + },createNode:function(parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + // no supported + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + }; + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity. + // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred + // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size + // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + // add the new node to the parent + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + },getFileDataAsTypedArray:function(node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. + return new Uint8Array(node.contents); + },expandFileStorage:function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. + // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. + // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to + // avoid overshooting the allocation cap by a very large margin. + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); // Allocate new storage. + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. + },resizeFileStorage:function(node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; // Fully decommit when requesting a resize to zero. + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); // Allocate new storage. + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. + } + node.usedBytes = newSize; + } + },node_ops:{getattr:function(node) { + var attr = {}; + // device numbers reuse inode numbers. + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), + // but this is not required by the standard. + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + },setattr:function(node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + },lookup:function(parent, name) { + throw FS.genericErrors[44]; + },mknod:function(parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + },rename:function(old_node, new_dir, new_name) { + // if we're overwriting a directory at new_name, make sure it's empty. + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + // do the internal rewiring + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now() + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + },unlink:function(parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + },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]; + parent.timestamp = Date.now(); + },readdir:function(node) { + var entries = ['.', '..']; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue; + } + entries.push(key); + } + return entries; + },symlink:function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); + node.link = oldpath; + return node; + },readlink:function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }},stream_ops:{read:function(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + assert(size >= 0); + if (size > 8 && contents.subarray) { // non-trivial, and typed array + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + },write:function(stream, buffer, offset, length, position, canOwn) { + // The data buffer should be a typed array view + assert(!(buffer instanceof ArrayBuffer)); + // If the buffer is located in main memory (HEAP), and if + // memory can grow, we can't hold on to references of the + // memory buffer, as they may get invalidated. That means we + // need to do copy its contents. + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + + if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? + if (canOwn) { + assert(position === 0, 'canOwn must imply no weird position inside the file'); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + + // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. + MEMFS.expandFileStorage(node, position+length); + if (node.contents.subarray && buffer.subarray) { + // Use typed array write which is available. + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + },llseek:function(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + },allocate:function(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + },mmap:function(stream, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + // Only make a new copy when MAP_PRIVATE is specified. + if (!(flags & 2) && contents.buffer === buffer) { + // We can't emulate MAP_SHARED when the file is not backed by the buffer + // we're mapping to (e.g. the HEAP buffer). + allocated = false; + ptr = contents.byteOffset; + } else { + // Try to avoid unnecessary slices. + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = 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) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + + var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + // should we check if bytesWritten and length are the same? + return 0; + }}}; + + /** @param {boolean=} noRunDep */ + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : ''; + readAsync(url, function(arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, function(event) { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }); + if (dep) addRunDependency(dep); + } + + var ERRNO_CODES = {}; + var NODEFS = {isWindows:false,staticInit:() => { + NODEFS.isWindows = !!process.platform.match(/^win/); + var flags = process["binding"]("constants"); + // Node.js 4 compatibility: it has no namespaces for constants + if (flags["fs"]) { + flags = flags["fs"]; + } + NODEFS.flagsForNodeMap = { + "1024": flags["O_APPEND"], + "64": flags["O_CREAT"], + "128": flags["O_EXCL"], + "256": flags["O_NOCTTY"], + "0": flags["O_RDONLY"], + "2": flags["O_RDWR"], + "4096": flags["O_SYNC"], + "512": flags["O_TRUNC"], + "1": flags["O_WRONLY"], + "131072": flags["O_NOFOLLOW"], + }; + // The 0 define must match on both sides, as otherwise we would not + // know to add it. + assert(NODEFS.flagsForNodeMap["0"] === 0); + },convertNodeCode:(e) => { + var code = e.code; + assert(code in ERRNO_CODES, 'unexpected node error code: ' + code + ' (' + e + ')'); + return ERRNO_CODES[code]; + },mount:(mount) => { + assert(ENVIRONMENT_IS_NODE); + return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0); + },createNode:(parent, name, mode, dev) => { + if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) { + throw new FS.ErrnoError(28); + } + var node = FS.createNode(parent, name, mode); + node.node_ops = NODEFS.node_ops; + node.stream_ops = NODEFS.stream_ops; + return node; + },getMode:(path) => { + var stat; + try { + stat = fs.lstatSync(path); + if (NODEFS.isWindows) { + // Node.js on Windows never represents permission bit 'x', so + // propagate read bits to execute bits + stat.mode = stat.mode | ((stat.mode & 292) >> 2); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + return stat.mode; + },realPath:(node) => { + var parts = []; + while (node.parent !== node) { + parts.push(node.name); + node = node.parent; + } + parts.push(node.mount.opts.root); + parts.reverse(); + return PATH.join.apply(null, parts); + },flagsForNode:(flags) => { + flags &= ~2097152; // Ignore this flag from musl, otherwise node.js fails to open the file. + flags &= ~2048; // Ignore this flag from musl, otherwise node.js fails to open the file. + flags &= ~32768; // Ignore this flag from musl, otherwise node.js fails to open the file. + flags &= ~524288; // Some applications may pass it; it makes no sense for a single process. + flags &= ~65536; // Node.js doesn't need this passed in, it errors. + var newFlags = 0; + for (var k in NODEFS.flagsForNodeMap) { + if (flags & k) { + newFlags |= NODEFS.flagsForNodeMap[k]; + flags ^= k; + } + } + if (!flags) { + return newFlags; + } else { + throw new FS.ErrnoError(28); + } + },node_ops:{getattr:(node) => { + var path = NODEFS.realPath(node); + var stat; + try { + stat = fs.lstatSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096. + // See http://support.microsoft.com/kb/140365 + if (NODEFS.isWindows && !stat.blksize) { + stat.blksize = 4096; + } + if (NODEFS.isWindows && !stat.blocks) { + stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0; + } + return { + dev: stat.dev, + ino: stat.ino, + mode: stat.mode, + nlink: stat.nlink, + uid: stat.uid, + gid: stat.gid, + rdev: stat.rdev, + size: stat.size, + atime: stat.atime, + mtime: stat.mtime, + ctime: stat.ctime, + blksize: stat.blksize, + blocks: stat.blocks + }; + },setattr:(node, attr) => { + var path = NODEFS.realPath(node); + try { + if (attr.mode !== undefined) { + fs.chmodSync(path, attr.mode); + // update the common node structure mode as well + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + var date = new Date(attr.timestamp); + fs.utimesSync(path, date, date); + } + if (attr.size !== undefined) { + fs.truncateSync(path, attr.size); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },lookup:(parent, name) => { + var path = PATH.join2(NODEFS.realPath(parent), name); + var mode = NODEFS.getMode(path); + return NODEFS.createNode(parent, name, mode); + },mknod:(parent, name, mode, dev) => { + var node = NODEFS.createNode(parent, name, mode, dev); + // create the backing node for this in the fs root as well + var path = NODEFS.realPath(node); + try { + if (FS.isDir(node.mode)) { + fs.mkdirSync(path, node.mode); + } else { + fs.writeFileSync(path, '', { mode: node.mode }); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + return node; + },rename:(oldNode, newDir, newName) => { + var oldPath = NODEFS.realPath(oldNode); + var newPath = PATH.join2(NODEFS.realPath(newDir), newName); + try { + fs.renameSync(oldPath, newPath); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + oldNode.name = newName; + },unlink:(parent, name) => { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.unlinkSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },rmdir:(parent, name) => { + var path = PATH.join2(NODEFS.realPath(parent), name); + try { + fs.rmdirSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },readdir:(node) => { + var path = NODEFS.realPath(node); + try { + return fs.readdirSync(path); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },symlink:(parent, newName, oldPath) => { + var newPath = PATH.join2(NODEFS.realPath(parent), newName); + try { + fs.symlinkSync(oldPath, newPath); + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },readlink:(node) => { + var path = NODEFS.realPath(node); + try { + path = fs.readlinkSync(path); + path = nodePath.relative(nodePath.resolve(node.mount.opts.root), path); + return path; + } catch (e) { + if (!e.code) throw e; + // node under windows can return code 'UNKNOWN' here: + // https://github.com/emscripten-core/emscripten/issues/15468 + if (e.code === 'UNKNOWN') throw new FS.ErrnoError(28); + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + }},stream_ops:{open:(stream) => { + var path = NODEFS.realPath(stream.node); + try { + if (FS.isFile(stream.node.mode)) { + stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags)); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },close:(stream) => { + try { + if (FS.isFile(stream.node.mode) && stream.nfd) { + fs.closeSync(stream.nfd); + } + } catch (e) { + if (!e.code) throw e; + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },read:(stream, buffer, offset, length, position) => { + // Node.js < 6 compatibility: node errors on 0 length reads + if (length === 0) return 0; + try { + return fs.readSync(stream.nfd, Buffer.from(buffer.buffer), offset, length, position); + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },write:(stream, buffer, offset, length, position) => { + try { + return fs.writeSync(stream.nfd, Buffer.from(buffer.buffer), offset, length, position); + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + },llseek:(stream, offset, whence) => { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + try { + var stat = fs.fstatSync(stream.nfd); + position += stat.size; + } catch (e) { + throw new FS.ErrnoError(NODEFS.convertNodeCode(e)); + } + } + } + + if (position < 0) { + throw new FS.ErrnoError(28); + } + + return position; + },mmap:(stream, length, position, prot, flags) => { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + + var ptr = mmapAlloc(length); + + NODEFS.stream_ops.read(stream, HEAP8, ptr, length, position); + return { ptr: ptr, allocated: true }; + },msync:(stream, buffer, offset, length, mmapFlags) => { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (mmapFlags & 2) { + // MAP_PRIVATE calls need not to be synced back to underlying fs + return 0; + } + + var bytesWritten = NODEFS.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 FS = {root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:(path, opts = {}) => { + path = PATH_FS.resolve(FS.cwd(), path); + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + opts = Object.assign(defaults, opts) + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the path + var parts = PATH.normalizeArray(path.split('/').filter((p) => !!p), false); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },getPath:(node) => { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path; + } + path = path ? node.name + '/' + path : node.name; + node = node.parent; + } + },hashName:(parentid, name) => { + var hash = 0; + + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + },hashAddNode:(node) => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + },hashRemoveNode:(node) => { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + },lookupNode:(parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + },createNode:(parent, name, mode, rdev) => { + assert(typeof parent == 'object') + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + },destroyNode:(node) => { + FS.hashRemoveNode(node); + },isRoot:(node) => { + return node === node.parent; + },isMountpoint:(node) => { + return !!node.mounted; + },isFile:(mode) => { + return (mode & 61440) === 32768; + },isDir:(mode) => { + return (mode & 61440) === 16384; + },isLink:(mode) => { + return (mode & 61440) === 40960; + },isChrdev:(mode) => { + return (mode & 61440) === 8192; + },isBlkdev:(mode) => { + return (mode & 61440) === 24576; + },isFIFO:(mode) => { + return (mode & 61440) === 4096; + },isSocket:(mode) => { + return (mode & 49152) === 49152; + },flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:(str) => { + var flags = FS.flagModes[str]; + if (typeof flags == 'undefined') { + throw new Error('Unknown file open mode: ' + str); + } + return flags; + },flagsToPermissionString:(flag) => { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + },nodePermissions:(node, perms) => { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.includes('r') && !(node.mode & 292)) { + return 2; + } else if (perms.includes('w') && !(node.mode & 146)) { + return 2; + } else if (perms.includes('x') && !(node.mode & 73)) { + return 2; + } + return 0; + },mayLookup:(dir) => { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:(dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + },mayDelete:(dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + },mayOpen:(node, flags) => { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:(fd_start = 0, 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:(fd) => FS.streams[fd],createStream:(stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = /** @constructor */ function() { + this.shared = { }; + }; + 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); } + }, + flags: { + get: function() { return this.shared.flags; }, + set: function(val) { this.shared.flags = val; }, + }, + position : { + get function() { return this.shared.position; }, + set: function(val) { this.shared.position = val; }, + }, + }; + } + // clone it, so we can return an instance of FSStream + stream = Object.assign(new FS.FSStream(), stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:(fd) => { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:(stream) => { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + },llseek:() => { + throw new FS.ErrnoError(70); + }},major:(dev) => ((dev) >> 8),minor:(dev) => ((dev) & 0xff),makedev:(ma, mi) => ((ma) << 8 | (mi)),registerDevice:(dev, ops) => { + FS.devices[dev] = { stream_ops: ops }; + },getDevice:(dev) => FS.devices[dev],getMounts:(mount) => { + var mounts = []; + var check = [mount]; + + while (check.length) { + var m = check.pop(); + + mounts.push(m); + + check.push.apply(check, m.mounts); + } + + return mounts; + },syncfs:(populate, callback) => { + if (typeof populate == 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work'); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + },mount:(type, opts, mountpoint) => { + if (typeof type == 'string') { + // The filesystem was not included, and instead we have an error + // message stored in the variable. + throw type; + } + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:(mountpoint) => { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + + current = next; + } + }); + + // no longer a mountpoint + node.mounted = null; + + // remove this mount from the child mounts + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + },lookup:(parent, name) => { + return parent.node_ops.lookup(parent, name); + },mknod:(path, mode, dev) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:(path, mode) => { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:(path, mode) => { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:(path, mode) => { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:(path, mode, dev) => { + if (typeof dev == 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:(oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:(old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + + // let the errors from non existant directories percolate up + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + // need to be part of the same mount + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + // source must exist + var old_node = FS.lookupNode(old_dir, old_name); + // old path should not be an ancestor of the new path + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(28); + } + // new path should not be an ancestor of the old path + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== '.') { + throw new FS.ErrnoError(55); + } + // see if the new path already exists + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + // not fatal + } + // early out if nothing needs to change + if (old_node === new_node) { + return; + } + // we'll need to delete the old entry + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + // need delete permissions if we'll be overwriting. + // need create permissions if new doesn't already exist. + errCode = new_node ? + FS.mayDelete(new_dir, new_name, isdir) : + FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + // if we are going to change the parent, check write permissions + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // remove the node from the lookup hash + FS.hashRemoveNode(old_node); + // do the underlying fs rename + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + // add the node back to the hash (in case node_ops.rename + // changed its name) + FS.hashAddNode(old_node); + } + },rmdir:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + },readdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:(path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + // According to POSIX, we should map EISDIR to EPERM, but + // we instead do what Linux does (and we must, as we use + // the musl linux libc). + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + },readlink:(path) => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:(path, dontFollow) => { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:(path) => { + return FS.stat(path, true); + },chmod:(path, mode, dontFollow) => { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:(path, mode) => { + FS.chmod(path, mode, true); + },fchmod:(fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:(path, uid, gid, dontFollow) => { + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + },lchown:(path, uid, gid) => { + FS.chown(path, uid, gid, true); + },fchown:(fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:(path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:(fd, len) => { + var stream = FS.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:(path, atime, mtime) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + },open:(path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == 'string' ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512) && !created) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), // we want the absolute path to the node + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + },close:(stream) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:(stream) => { + return stream.fd === null; + },llseek:(stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:(stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:(stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + },allocate:(stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:(stream, length, position, prot, flags) => { + // User requests writing to file (prot & PROT_WRITE != 0). + // Checking if we have permissions to write to the file unless + // MAP_PRIVATE flag is set. According to POSIX spec it is possible + // to write to file opened in read-only mode with MAP_PRIVATE flag, + // as all modifications will be visible only in the memory of + // the current process. + if ((prot & 2) !== 0 + && (flags & 2) === 0 + && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + },msync:(stream, buffer, offset, length, mmapFlags) => { + if (!stream || !stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:(stream) => 0,ioctl:(stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:(path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || 'binary'; + if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === 'utf8') { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === 'binary') { + ret = buf; + } + FS.close(stream); + return ret; + },writeFile:(path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == 'string') { + var buf = new Uint8Array(lengthBytesUTF8(data)+1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error('Unsupported data type'); + } + FS.close(stream); + },cwd:() => FS.currentPath,chdir:(path) => { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:() => { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:() => { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using err() rather than out() + // so we register a second tty just for it. + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev('/dev/tty', FS.makedev(5, 0)); + FS.mkdev('/dev/tty1', FS.makedev(6, 0)); + // setup /dev/[u]random + var random_device = getRandomDevice(); + FS.createDevice('/dev', 'random', random_device); + FS.createDevice('/dev', 'urandom', random_device); + // we're not going to emulate the actual shm device, + // just create the tmp dirs that reside in it commonly + FS.mkdir('/dev/shm'); + FS.mkdir('/dev/shm/tmp'); + },createSpecialDirectories:() => { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: () => { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup: (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: () => stream.path }, + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:() => { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 0); + var stdout = FS.open('/dev/stdout', 1); + var stderr = FS.open('/dev/stderr', 1); + 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:() => { + if (FS.ErrnoError) return; + FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) { + this.node = node; + this.setErrno = /** @this{Object} */ function(errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + + // Try to get a maximally helpful stack trace. On Node.js, getting Error.stack + // now ensures it shows what we want. + if (this.stack) { + // Define the stack property for Node.js 4, which otherwise errors on the next line. + Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:() => { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + 'NODEFS': NODEFS, + }; + },init:(input, output, error) => { + assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'); + FS.init.initialized = true; + + FS.ensureErrnoError(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:() => { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + _fflush(0); + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },getMode:(canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + },findObject:(path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + return null; + } + },analyzePath:(path, dontResolveLastLink) => { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createPath:(parent, path, canRead, canWrite) => { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + },createFile:(parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + },createDataFile:(parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == 'string' ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:(parent, name, input, output) => { + var path = PATH.join2(typeof parent == 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open: (stream) => { + stream.seekable = false; + }, + close: (stream) => { + // flush any pending line data + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos /* ignored */) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },forceLoadFile:(obj) => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != 'undefined') { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + },createLazyFile:(parent, name, url, canRead, canWrite) => { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + /** @constructor */ + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(/** @type{Array} */(xhr.response || [])); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }; + var lazyArray = this; + lazyArray.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof lazyArray.chunks[chunkNum] == 'undefined') { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray.chunks[chunkNum] == 'undefined') throw new Error('doXHR failed!'); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest != 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: /** @this {FSNode} */ function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + // use a custom read function + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { // normal array + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + buffer[offset + i] = contents.get(position + i); + } + } + return size; + }; + node.stream_ops = stream_ops; + return node; + },createPreloadedFile:(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + })) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, (byteArray) => processData(byteArray), onerror); + } else { + processData(url); + } + },indexedDB:() => { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + },DB_NAME:() => { + return 'EM_FS_' + window.location.pathname; + },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = () => { + out('creating db'); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + 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((path) => { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = () => { ok++; if (ok + fail == total) finish() }; + putRequest.onerror = () => { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },loadFilesFromDB:(paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; // no database to load from + openRequest.onsuccess = () => { + 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((path) => { + var getRequest = files.get(path); + 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 = () => { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },absolutePath:() => { + abort('FS.absolutePath has been removed; use PATH_FS.resolve instead'); + },createFolder:() => { + abort('FS.createFolder has been removed; use FS.mkdir instead'); + },createLink:() => { + abort('FS.createLink has been removed; use FS.symlink instead'); + },joinPath:() => { + abort('FS.joinPath has been removed; use PATH.join instead'); + },mmapAlloc:() => { + abort('FS.mmapAlloc has been replaced by the top level function mmapAlloc'); + },standardizePath:() => { + abort('FS.standardizePath has been removed; use PATH.normalize instead'); + }}; + var SYSCALLS = {DEFAULT_POLLMASK:5,calculateAt:function(dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + // relative path + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) throw new FS.ErrnoError(8); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44);; + } + return dir; + } + return PATH.join2(dir, path); + },doStat:function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + // an error occurred while trying to look up the path; we should just report ENOTDIR + return -54; + } + throw e; + } + HEAP32[((buf)>>2)] = stat.dev; + HEAP32[(((buf)+(4))>>2)] = 0; + HEAP32[(((buf)+(8))>>2)] = stat.ino; + HEAP32[(((buf)+(12))>>2)] = stat.mode; + HEAP32[(((buf)+(16))>>2)] = stat.nlink; + HEAP32[(((buf)+(20))>>2)] = stat.uid; + HEAP32[(((buf)+(24))>>2)] = stat.gid; + HEAP32[(((buf)+(28))>>2)] = stat.rdev; + HEAP32[(((buf)+(32))>>2)] = 0; + (tempI64 = [stat.size>>>0,(tempDouble=stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]); + HEAP32[(((buf)+(48))>>2)] = 4096; + HEAP32[(((buf)+(52))>>2)] = stat.blocks; + HEAP32[(((buf)+(56))>>2)] = (stat.atime.getTime() / 1000)|0; + HEAP32[(((buf)+(60))>>2)] = 0; + HEAP32[(((buf)+(64))>>2)] = (stat.mtime.getTime() / 1000)|0; + HEAP32[(((buf)+(68))>>2)] = 0; + HEAP32[(((buf)+(72))>>2)] = (stat.ctime.getTime() / 1000)|0; + HEAP32[(((buf)+(76))>>2)] = 0; + (tempI64 = [stat.ino>>>0,(tempDouble=stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[(((buf)+(80))>>2)] = tempI64[0],HEAP32[(((buf)+(84))>>2)] = tempI64[1]); + return 0; + },doMsync:function(addr, stream, len, flags, offset) { + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + },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; + }}; + function ___syscall_fadvise64(fd, offset, len, advice) { + return 0; // your advice is important to us (but we can't use it) + } + + function setErrNo(value) { + HEAP32[((___errno_location())>>2)] = value; + return value; + } + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; // FD_CLOEXEC makes no sense for a single process. + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 5: + /* case 5: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ { + + var arg = SYSCALLS.get(); + var offset = 0; + // We're always unlocked. + HEAP16[(((arg)+(offset))>>1)] = 2; + return 0; + } + case 6: + case 7: + /* case 6: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + /* case 7: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ + + + return 0; // Pretend that the locking is successful. + case 16: + case 8: + return -28; // These are for sockets. We don't have them fully implemented yet. + case 9: + // musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fcntl() returns that, and we set errno ourselves. + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_fstat64(fd, buf) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_lstat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & (~4352); + assert(!flags, flags); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_stat64(path, buf) { + try { + + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function ___syscall_unlinkat(dirfd, path, flags) { + try { + + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path); + } else if (flags === 512) { + FS.rmdir(path); + } else { + abort('Invalid flags passed to unlinkat'); + } + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + + 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; + } + return name; + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + /*jshint evil:true*/ + return new Function( + "body", + "return function " + name + "() {\n" + + " \"use strict\";" + + " return body.apply(this, arguments);\n" + + "};\n" + )(body); + } + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return this.name + ': ' + this.message; + } + }; + + return errorClass; + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options = {}) { + 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((cb) => cb()); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': function(pointer) { + // TODO: if heap is fixed (like in asm.js) this could be executed outside + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this['fromWireType'](heap[pointer >> shift]); + }, + destructorFunction: null, // This type does not need a destructor + }); + } + + 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 finalizationRegistry = 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 downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; // no conversion + } + + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + + var registeredPointers = {}; + + 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; + } + + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj['delete'](); + } + } + + var delayFunction = undefined; + 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) { + // ptr is a raw pointer (or a raw smartpointer) + + // rawPointer is a maybe-null raw pointer + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + // JS object has been neutered, time to repopulate it + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance['clone'](); + } else { + // else, just increment reference count on existing object + // it already has a reference to the smart pointer + 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 attachFinalizer(handle) { + if ('undefined' === typeof FinalizationRegistry) { + attachFinalizer = (handle) => handle; + return handle; + } + // If the running environment has a FinalizationRegistry (see + // https://github.com/tc39/proposal-weakrefs), then attach finalizers + // for class handles. We check for the presence of FinalizationRegistry + // at run-time, not build-time. + finalizationRegistry = new FinalizationRegistry((info) => { + console.warn(info.leakWarning.stack.replace(/^Error: /, '')); + releaseClassHandle(info.$$); + }); + attachFinalizer = (handle) => { + var $$ = handle.$$; + var hasSmartPtr = !!$$.smartPtr; + if (hasSmartPtr) { + // We should not call the destructor on raw pointers in case other code expects the pointee to live + var info = { $$: $$ }; + // Create a warning as an Error instance in advance so that we can store + // the current stacktrace and point to it when / if a leak is detected. + // This is more useful than the empty stacktrace of `FinalizationRegistry` + // callback. + var cls = $$.ptrType.registeredClass; + info.leakWarning = new Error("Embind found a leaked C++ instance " + cls.name + " <0x" + $$.ptr.toString(16) + ">.\n" + + "We'll free it automatically in this case, but this functionality is not reliable across various environments.\n" + + "Make sure to invoke .delete() manually once you're done with the instance instead.\n" + + "Originally allocated"); // `.stack` will add "at ..." after this sentence + if ('captureStackTrace' in Error) { + Error.captureStackTrace(info.leakWarning, RegisteredPointer_fromWireType); + } + finalizationRegistry.register(handle, info, handle); + } + return handle; + }; + detachFinalizer = (handle) => finalizationRegistry.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; + } + + 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() { + } + + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function() { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + 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); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + /** @param {number=} numArguments */ + 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"); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!"); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + + /** @constructor */ + 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) { + // TODO: this is not strictly true + // We could support BY_EMVAL conversions from raw pointers to smart pointers + // because the smart pointer can hold a reference to the handle + if (undefined === handle.$$.smartPtr) { + throwBindingError('Passing raw pointer to smart pointer is illegal'); + } + + switch (this.sharingPolicy) { + case 0: // NONE + // no upcasting + 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: // INTRUSIVE + ptr = handle.$$.smartPtr; + break; + + case 2: // BY_EMVAL + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle['clone'](); + ptr = this.rawShare( + ptr, + Emval.toHandle(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 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; + } + /** @constructor + @param {*=} pointeeType, + @param {*=} sharingPolicy, + @param {*=} rawGetPointee, + @param {*=} rawConstructor, + @param {*=} rawShare, + @param {*=} rawDestructor, + */ + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + + // smart pointer properties + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + + // smart pointer properties + 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; + // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns + // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time. + // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in + // craftInvokerFunction altogether. + } + } + + /** @param {number=} numArguments */ + function replacePublicSymbol(name, value, numArguments) { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistant public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + + function dynCallLegacy(sig, ptr, args) { + assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); + if (args && args.length) { + // j (64-bit integer) must be passed in as two numbers [low 32, high 32]. + assert(args.length === sig.substring(1).replace(/j/g, '--').length); + } else { + assert(sig.length == 1); + } + var f = Module["dynCall_" + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + /** @param {Object=} args */ + function dynCall(sig, ptr, args) { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of thier signature, so we rely the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), 'missing table entry in dynCall: ' + ptr); + return getWasmTableEntry(ptr).apply(null, args) + } + function getDynCaller(sig, ptr) { + assert(sig.includes('j'), 'getDynCaller should only be called with i64 sigs') + var argCache = []; + return function() { + argCache.length = 0; + Object.assign(argCache, arguments); + return dynCall(sig, ptr, argCache); + }; + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + 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() { + // this code cannot run if baseClassRawType is zero + 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 heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]); + } + return array; + } + + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + var args = [rawConstructor]; + var destructors = []; + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = 'constructor ' + classType.name; + + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount-1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!"); + } + classType.registeredClass.constructor_body[argCount - 1] = () => { + throwUnboundTypeError('Cannot construct ' + classType.name + ' due to unbound types', rawArgTypes); + }; + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + // Insert empty slot for context type (argTypes[1]). + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor); + return []; + }); + return []; + }); + } + + function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError('new_ called with constructor type ' + typeof(constructor) + " which is not a function"); + } + /* + * Previously, the following line was just: + * function dummy() {}; + * Unfortunately, Chrome was preserving 'dummy' as the object's name, even + * though at creation, the 'dummy' has the correct constructor name. Thus, + * objects created with IMVU.new would show up in the debugger as 'dummy', + * which isn't very helpful. Using IMVU.createNamedFunction addresses the + * issue. Doublely-unfortunately, there's no way to write a test for this + * behavior. -NRD 2013.02.22 + */ + 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) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + 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); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = false; + + for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack + 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) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + 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 __embind_register_class_function(rawClassType, + methodName, + argCount, + rawArgTypesAddr, // [ReturnType, ThisType, Args...] + invokerSignature, + rawInvoker, + context, + isPureVirtual) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = classType.name + '.' + methodName; + + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + + function unboundTypesHandler() { + throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes); + } + + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (undefined === method || (undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2)) { + // This is the first overload to be registered, OR we are replacing a + // function in the base class with a function in the derived class. + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + // There was an existing function with the same name registered. Set up + // a function overload routing table. + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context); + + // Replace the initial unbound-handler-stub function with the appropriate member function, now that all types + // are resolved. If multiple overloads are registered for this function, the function goes into an overload table. + if (undefined === proto[methodName].overloadTable) { + // Set argCount in case an overload is registered later + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + + 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; + } + var Emval = {toValue:(handle) => { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + return emval_handle_array[handle].value; + },toHandle:(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.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': function(destructors, value) { + return Emval.toHandle(value); + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }); + } + + function _embind_repr(v) { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + } + + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: return function(pointer) { + return this['fromWireType'](HEAPF32[pointer >> 2]); + }; + case 3: return function(pointer) { + return this['fromWireType'](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + return value; + }, + 'toWireType': function(destructors, value) { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': floatReadValueFromPointer(name, shift), + destructorFunction: null, // This type does not need a destructor + }); + } + + 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] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn), argCount - 1); + return []; + }); + } + + function integerReadValueFromPointer(name, shift, signed) { + // integers are quite common, so generate very specialized functions + switch (shift) { + case 0: return signed ? + function readS8FromPointer(pointer) { return HEAP8[pointer]; } : + function readU8FromPointer(pointer) { return HEAPU8[pointer]; }; + case 1: return signed ? + function readS16FromPointer(pointer) { return HEAP16[pointer >> 1]; } : + function readU16FromPointer(pointer) { return HEAPU16[pointer >> 1]; }; + case 2: return signed ? + function readS32FromPointer(pointer) { return HEAP32[pointer >> 2]; } : + function readU32FromPointer(pointer) { return HEAPU32[pointer >> 2]; }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come out as 'i32 -1'. Always treat those as max u32. + maxRange = 4294967295; + } + + var shift = getShiftFromSize(size); + + var fromWireType = (value) => value; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + + var isUnsignedType = (name.includes('unsigned')); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + toTypeName); + } + 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 + ']!'); + } + } + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + } + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + } + } + registerType(primitiveType, { + name: name, + 'fromWireType': fromWireType, + 'toWireType': toWireType, + 'argPackAdvance': 8, + 'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + } + + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; // in elements + var data = heap[handle + 1]; // byte offset into emscripten heap + return new TA(buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name: name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': 8, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + } + + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + var length = HEAPU32[value >> 2]; + + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (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 = () => lengthBytesUTF8(value); + } else { + getLength = () => value.length; + } + + // assumes 4-byte alignment + var length = getLength(); + var ptr = _malloc(4 + length + 1); + HEAPU32[ptr >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr + 4, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + 4 + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + 4 + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = () => HEAPU16; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = () => HEAPU32; + shift = 2; + } + registerType(rawType, { + name: name, + 'fromWireType': function(value) { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (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); + } + + // assumes 4-byte alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': 8, + 'readValueFromPointer': simpleReadValueFromPointer, + destructorFunction: function(ptr) { _free(ptr); }, + }); + } + + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name: name, + 'argPackAdvance': 0, + 'fromWireType': function() { + return undefined; + }, + 'toWireType': function(destructors, o) { + // TODO: assert if anything else is given? + return undefined; + }, + }); + } + + + function __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.toHandle(v); + } + + function __mmap_js(len, prot, flags, fd, off, allocated) { + try { + + var stream = FS.getStream(fd); + if (!stream) return -8; + var res = FS.mmap(stream, len, off, prot, flags); + var ptr = res.ptr; + HEAP32[((allocated)>>2)] = res.allocated; + return ptr; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function __munmap_js(addr, len, prot, flags, fd, offset) { + try { + + var stream = FS.getStream(fd); + if (stream) { + if (prot & 2) { + SYSCALLS.doMsync(addr, stream, len, flags, offset); + } + FS.munmap(stream); + } + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + + function _abort() { + abort('native code called abort()'); + } + + function _emscripten_console_error(str) { + assert(typeof str == 'number'); + console.error(UTF8ToString(str)); + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + function getHeapMax() { + // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate + // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side + // for any code that deals with heap sizes, which would require special + // casing all heap size related code to treat 0 specially. + return 2147483648; + } + + function emscripten_realloc_buffer(size) { + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1 /*success*/; + } catch(e) { + err('emscripten_realloc_buffer: Attempted to grow heap from ' + buffer.byteLength + ' bytes to ' + size + ' bytes, but got error: ' + e); + } + // implicit 0 return to save code size (caller will cast "undefined" into 0 + // anyhow) + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + assert(requestedSize > oldSize); + + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err('Cannot enlarge memory, asked to go up to ' + requestedSize + ' bytes, but the limit is ' + maxHeapSize + ' bytes!'); + return false; + } + + let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 ); + + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + + 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) { + // Default values. + // Browser language detection #8751 + var lang = ((typeof navigator == 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8'; + var env = { + 'USER': 'web_user', + 'LOGNAME': 'web_user', + 'PATH': '/', + 'PWD': '/', + 'HOME': '/home/web_user', + 'LANG': lang, + '_': getExecutableName() + }; + // Apply the user-provided values, if any. + for (var x in ENV) { + // x is a key in ENV; if ENV[x] is undefined, that means it was + // explicitly set to be so. We allow user code to do that to + // force variables with default values to remain unset. + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + '=' + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAPU32[(((__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(); + HEAPU32[((penviron_count)>>2)] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAPU32[((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)) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + } + return ret; + } + + function convertI32PairToI53Checked(lo, hi) { + assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32 + assert(hi === (hi|0)); // hi should be a i32 + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + } + function _fd_pread(fd, iov, iovcnt, offset_low, offset_high, pnum) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd) + var num = doReadv(stream, iov, iovcnt, offset); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + /** @param {number=} offset */ + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + } + function _fd_pwrite(fd, iov, iovcnt, offset_low, offset_high, pnum) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd) + var num = doWritev(stream, iov, iovcnt, offset); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + + var offset = convertI32PairToI53Checked(offset_low, offset_high); if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS == 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _getTempRet0() { + return getTempRet0(); + } + + function _llvm_eh_typeid_for(type) { + return type; + } + + function _setTempRet0(val) { + setTempRet0(val); + } + + function __isLeapYear(year) { + return year%4 === 0 && (year%100 !== 0 || year%400 === 0); + } + + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) { + // no-op + } + return sum; + } + + var __MONTH_DAYS_LEAP = [31,29,31,30,31,30,31,31,30,31,30,31]; + + var __MONTH_DAYS_REGULAR = [31,28,31,30,31,30,31,31,30,31,30,31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + + if (days > daysInCurrentMonth-newDate.getDate()) { + // we spill over to next month + days -= (daysInCurrentMonth-newDate.getDate()+1); + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth+1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear()+1); + } + } else { + // we stay in current month + newDate.setDate(newDate.getDate()+days); + return newDate; + } + } + + return newDate; + } + function _strftime(s, maxsize, format, tm) { + // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html + + var tm_zone = HEAP32[(((tm)+(40))>>2)]; + + var date = { + tm_sec: HEAP32[((tm)>>2)], + tm_min: HEAP32[(((tm)+(4))>>2)], + tm_hour: HEAP32[(((tm)+(8))>>2)], + tm_mday: HEAP32[(((tm)+(12))>>2)], + tm_mon: HEAP32[(((tm)+(16))>>2)], + tm_year: HEAP32[(((tm)+(20))>>2)], + tm_wday: HEAP32[(((tm)+(24))>>2)], + tm_yday: HEAP32[(((tm)+(28))>>2)], + tm_isdst: HEAP32[(((tm)+(32))>>2)], + tm_gmtoff: HEAP32[(((tm)+(36))>>2)], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : '' + }; + + var pattern = UTF8ToString(format); + + // expand format + var EXPANSION_RULES_1 = { + '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013 + '%D': '%m/%d/%y', // Equivalent to %m / %d / %y + '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d + '%h': '%b', // Equivalent to %b + '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation + '%R': '%H:%M', // Replaced by the time in 24-hour notation + '%T': '%H:%M:%S', // Replaced by the time + '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation + '%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation + // Modified Conversion Specifiers + '%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation. + '%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation. + '%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation. + '%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation. + '%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation. + '%EY': '%Y', // Replaced by the full alternative year representation. + '%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading characters. + '%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading characters. + '%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols. + '%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols. + '%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols. + '%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols. + '%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols. + '%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1). + '%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols. + '%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols. + '%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols. + '%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols. + '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols. + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]); + } + + var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; + var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; + + function leadingSomething(value, digits, character) { + var str = typeof value == 'number' ? value.toString() : (value || ''); + while (str.length < digits) { + str = character[0]+str; + } + return str; + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, '0'); + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : (value > 0 ? 1 : 0); + } + + var compare; + if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) { + compare = sgn(date1.getDate()-date2.getDate()); + } + } + return compare; + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: // Sunday + return new Date(janFourth.getFullYear()-1, 11, 29); + case 1: // Monday + return janFourth; + case 2: // Tuesday + return new Date(janFourth.getFullYear(), 0, 3); + case 3: // Wednesday + return new Date(janFourth.getFullYear(), 0, 2); + case 4: // Thursday + return new Date(janFourth.getFullYear(), 0, 1); + case 5: // Friday + return new Date(janFourth.getFullYear()-1, 11, 31); + case 6: // Saturday + return new Date(janFourth.getFullYear()-1, 11, 30); + } + } + + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + // this date is after the start of the first week of this year + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear()+1; + } else { + return thisDate.getFullYear(); + } + } else { + return thisDate.getFullYear()-1; + } + } + + var EXPANSION_RULES_2 = { + '%a': function(date) { + return WEEKDAYS[date.tm_wday].substring(0,3); + }, + '%A': function(date) { + return WEEKDAYS[date.tm_wday]; + }, + '%b': function(date) { + return MONTHS[date.tm_mon].substring(0,3); + }, + '%B': function(date) { + return MONTHS[date.tm_mon]; + }, + '%C': function(date) { + var year = date.tm_year+1900; + return leadingNulls((year/100)|0,2); + }, + '%d': function(date) { + return leadingNulls(date.tm_mday, 2); + }, + '%e': function(date) { + return leadingSomething(date.tm_mday, 2, ' '); + }, + '%g': function(date) { + // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year. + // In this system, weeks begin on a Monday and week 1 of the year is the week that includes + // January 4th, which is also the week that includes the first Thursday of the year, and + // is also the first week that contains at least four days in the year. + // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of + // the last week of the preceding year; thus, for Saturday 2nd January 1999, + // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th, + // or 31st is a Monday, it and any following days are part of week 1 of the following year. + // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01. + + return getWeekBasedYear(date).toString().substring(2); + }, + '%G': function(date) { + return getWeekBasedYear(date); + }, + '%H': function(date) { + return leadingNulls(date.tm_hour, 2); + }, + '%I': function(date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + '%j': function(date) { + // Day of the year (001-366) + return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3); + }, + '%m': function(date) { + return leadingNulls(date.tm_mon+1, 2); + }, + '%M': function(date) { + return leadingNulls(date.tm_min, 2); + }, + '%n': function() { + return '\n'; + }, + '%p': function(date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return 'AM'; + } else { + return 'PM'; + } + }, + '%S': function(date) { + return leadingNulls(date.tm_sec, 2); + }, + '%t': function() { + return '\t'; + }, + '%u': function(date) { + return date.tm_wday || 7; + }, + '%U': function(date) { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2); + }, + '%V': function(date) { + // Replaced by the week number of the year (Monday as the first day of the week) + // as a decimal number [01,53]. If the week containing 1 January has four + // or more days in the new year, then it is considered week 1. + // Otherwise, it is the last week of the previous year, and the next week is week 1. + // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday] + var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7 ) / 7); + // If 1 Jan is just 1-3 days past Monday, the previous week + // is also in this year. + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++; + } + if (!val) { + val = 52; + // If 31 December of prev year a Thursday, or Friday of a + // leap year, then the prev year has 53 weeks. + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || (dec31 == 5 && __isLeapYear(date.tm_year%400-1))) { + val++; + } + } else if (val == 53) { + // If 1 January is not a Thursday, and not a Wednesday of a + // leap year, then this year has only 52 weeks. + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) + val = 1; + } + return leadingNulls(val, 2); + }, + '%w': function(date) { + return date.tm_wday; + }, + '%W': function(date) { + var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7); + return leadingNulls(Math.floor(days / 7), 2); + }, + '%y': function(date) { + // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year] + return (date.tm_year+1900).toString().substring(2); + }, + '%Y': function(date) { + // Replaced by the year as a decimal number (for example, 1997). [ tm_year] + return date.tm_year+1900; + }, + '%z': function(date) { + // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ). + // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich). + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + // convert from minutes into hhmm format (which means 60 minutes = 100 units) + off = (off / 60)*100 + (off % 60); + return (ahead ? '+' : '-') + String("0000" + off).slice(-4); + }, + '%Z': function(date) { + return date.tm_zone; + }, + '%%': function() { + return '%'; + } + }; + + // Replace %% with a pair of NULLs (which cannot occur in a C string), then + // re-inject them after processing. + pattern = pattern.replace(/%%/g, '\0\0') + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date)); + } + } + pattern = pattern.replace(/\0\0/g, '%') + + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + + writeArrayToMemory(bytes, s); + return bytes.length-1; + } + function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm); // no locale support yet + } + + var FSNode = /** @constructor */ function(parent, name, mode, rdev) { + if (!parent) { + parent = this; // root node sets parent to itself + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292/*292*/ | 73/*73*/; + var writeMode = 146/*146*/; + Object.defineProperties(FSNode.prototype, { + read: { + get: /** @this{FSNode} */function() { + return (this.mode & readMode) === readMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + } + }, + write: { + get: /** @this{FSNode} */function() { + return (this.mode & writeMode) === writeMode; + }, + set: /** @this{FSNode} */function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + } + }, + isFolder: { + get: /** @this{FSNode} */function() { + return FS.isDir(this.mode); + } + }, + isDevice: { + get: /** @this{FSNode} */function() { + return FS.isChrdev(this.mode); + } + } + }); + FS.FSNode = FSNode; + FS.staticInit();; +if (ENVIRONMENT_IS_NODE) { requireNodeFS(); NODEFS.staticInit(); }; +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, + };; +embind_init_charCodes(); +BindingError = Module['BindingError'] = extendError(Error, 'BindingError');; +InternalError = Module['InternalError'] = extendError(Error, 'InternalError');; +init_ClassHandle(); +init_embind();; +init_RegisteredPointer(); +UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');; +init_emval();; +var ASSERTIONS = true; + + + +/** @type {function(string, boolean=, number=)} */ +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} + + +function checkIncomingModuleAPI() { + ignoredModuleProp('fetchSettings'); +} +var asmLibraryArg = { + "__assert_fail": ___assert_fail, + "__call_sighandler": ___call_sighandler, + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_begin_catch": ___cxa_begin_catch, + "__cxa_decrement_exception_refcount": ___cxa_decrement_exception_refcount, + "__cxa_end_catch": ___cxa_end_catch, + "__cxa_find_matching_catch_2": ___cxa_find_matching_catch_2, + "__cxa_find_matching_catch_3": ___cxa_find_matching_catch_3, + "__cxa_find_matching_catch_4": ___cxa_find_matching_catch_4, + "__cxa_free_exception": ___cxa_free_exception, + "__cxa_increment_exception_refcount": ___cxa_increment_exception_refcount, + "__cxa_rethrow": ___cxa_rethrow, + "__cxa_rethrow_primary_exception": ___cxa_rethrow_primary_exception, + "__cxa_throw": ___cxa_throw, + "__cxa_uncaught_exceptions": ___cxa_uncaught_exceptions, + "__resumeException": ___resumeException, + "__syscall_fadvise64": ___syscall_fadvise64, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_fstat64": ___syscall_fstat64, + "__syscall_lstat64": ___syscall_lstat64, + "__syscall_newfstatat": ___syscall_newfstatat, + "__syscall_openat": ___syscall_openat, + "__syscall_stat64": ___syscall_stat64, + "__syscall_unlinkat": ___syscall_unlinkat, + "_embind_register_bigint": __embind_register_bigint, + "_embind_register_bool": __embind_register_bool, + "_embind_register_class": __embind_register_class, + "_embind_register_class_constructor": __embind_register_class_constructor, + "_embind_register_class_function": __embind_register_class_function, + "_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, + "_mmap_js": __mmap_js, + "_munmap_js": __munmap_js, + "abort": _abort, + "emscripten_console_error": _emscripten_console_error, + "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_pread": _fd_pread, + "fd_pwrite": _fd_pwrite, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "getTempRet0": _getTempRet0, + "invoke_diii": invoke_diii, + "invoke_fiii": invoke_fiii, + "invoke_i": invoke_i, + "invoke_ii": invoke_ii, + "invoke_iii": invoke_iii, + "invoke_iiii": invoke_iiii, + "invoke_iiiii": invoke_iiiii, + "invoke_iiiiii": invoke_iiiiii, + "invoke_iiiiiii": invoke_iiiiiii, + "invoke_iiiiiiii": invoke_iiiiiiii, + "invoke_iiiiiiiiiii": invoke_iiiiiiiiiii, + "invoke_iiiiiiiiiiii": invoke_iiiiiiiiiiii, + "invoke_iiiiiiiiiiiii": invoke_iiiiiiiiiiiii, + "invoke_iiiiij": invoke_iiiiij, + "invoke_jiiii": invoke_jiiii, + "invoke_v": invoke_v, + "invoke_vi": invoke_vi, + "invoke_vii": invoke_vii, + "invoke_viii": invoke_viii, + "invoke_viiii": invoke_viiii, + "invoke_viiiiiii": invoke_viiiiiii, + "invoke_viiiiiiiiii": invoke_viiiiiiiiii, + "invoke_viiiiiiiiiiiiiii": invoke_viiiiiiiiiiiiiii, + "llvm_eh_typeid_for": _llvm_eh_typeid_for, + "setTempRet0": _setTempRet0, + "strftime_l": _strftime_l +}; +var asm = createWasm(); +/** @type {function(...*):?} */ +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors"); + +/** @type {function(...*):?} */ +var _main = Module["_main"] = createExportWrapper("main"); + +/** @type {function(...*):?} */ +var _malloc = Module["_malloc"] = createExportWrapper("malloc"); + +/** @type {function(...*):?} */ +var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location"); + +/** @type {function(...*):?} */ +var _free = Module["_free"] = createExportWrapper("free"); + +/** @type {function(...*):?} */ +var ___getTypeName = Module["___getTypeName"] = createExportWrapper("__getTypeName"); + +/** @type {function(...*):?} */ +var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = createExportWrapper("__embind_register_native_and_builtin_types"); + +/** @type {function(...*):?} */ +var ___dl_seterr = Module["___dl_seterr"] = createExportWrapper("__dl_seterr"); + +/** @type {function(...*):?} */ +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); + +/** @type {function(...*):?} */ +var _emscripten_builtin_memalign = Module["_emscripten_builtin_memalign"] = createExportWrapper("emscripten_builtin_memalign"); + +/** @type {function(...*):?} */ +var _setThrew = Module["_setThrew"] = createExportWrapper("setThrew"); + +/** @type {function(...*):?} */ +var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() { + return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() { + return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() { + return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() { + return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var stackSave = Module["stackSave"] = createExportWrapper("stackSave"); + +/** @type {function(...*):?} */ +var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore"); + +/** @type {function(...*):?} */ +var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc"); + +/** @type {function(...*):?} */ +var ___cxa_demangle = Module["___cxa_demangle"] = createExportWrapper("__cxa_demangle"); + +/** @type {function(...*):?} */ +var ___cxa_can_catch = Module["___cxa_can_catch"] = createExportWrapper("__cxa_can_catch"); + +/** @type {function(...*):?} */ +var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = createExportWrapper("__cxa_is_pointer_type"); + +/** @type {function(...*):?} */ +var dynCall_ji = Module["dynCall_ji"] = createExportWrapper("dynCall_ji"); + +/** @type {function(...*):?} */ +var dynCall_viijj = Module["dynCall_viijj"] = createExportWrapper("dynCall_viijj"); + +/** @type {function(...*):?} */ +var dynCall_iij = Module["dynCall_iij"] = createExportWrapper("dynCall_iij"); + +/** @type {function(...*):?} */ +var dynCall_iijj = Module["dynCall_iijj"] = createExportWrapper("dynCall_iijj"); + +/** @type {function(...*):?} */ +var dynCall_viij = Module["dynCall_viij"] = createExportWrapper("dynCall_viij"); + +/** @type {function(...*):?} */ +var dynCall_ij = Module["dynCall_ij"] = createExportWrapper("dynCall_ij"); + +/** @type {function(...*):?} */ +var dynCall_iiiji = Module["dynCall_iiiji"] = createExportWrapper("dynCall_iiiji"); + +/** @type {function(...*):?} */ +var dynCall_iiiij = Module["dynCall_iiiij"] = createExportWrapper("dynCall_iiiij"); + +/** @type {function(...*):?} */ +var dynCall_vij = Module["dynCall_vij"] = createExportWrapper("dynCall_vij"); + +/** @type {function(...*):?} */ +var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji"); + +/** @type {function(...*):?} */ +var dynCall_iiiiij = Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij"); + +/** @type {function(...*):?} */ +var dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii"); + +/** @type {function(...*):?} */ +var dynCall_jiiii = Module["dynCall_jiiii"] = createExportWrapper("dynCall_jiiii"); + +/** @type {function(...*):?} */ +var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj"); + +/** @type {function(...*):?} */ +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj"); + + +function invoke_iii(index,a1,a2) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viii(index,a1,a2,a3) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_ii(index,a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_v(index) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vii(index,a1,a2) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiii(index,a1,a2,a3,a4,a5,a6) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_vi(index,a1) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_i(index) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiii(index,a1,a2,a3,a4,a5) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiii(index,a1,a2,a3,a4,a5,a6,a7) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_fiii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_diii(index,a1,a2,a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_viiiiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_iiiiij(index,a1,a2,a3,a4,a5,a6) { + var sp = stackSave(); + try { + return dynCall_iiiiij(index,a1,a2,a3,a4,a5,a6); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + +function invoke_jiiii(index,a1,a2,a3,a4) { + var sp = stackSave(); + try { + return dynCall_jiiii(index,a1,a2,a3,a4); + } catch(e) { + stackRestore(sp); + if (e !== e+0) throw e; + _setThrew(1, 0); + } +} + + + + +// === Auto-generated postamble setup entry stuff === + +unexportedRuntimeFunction('ccall', false); +unexportedRuntimeFunction('cwrap', false); +unexportedRuntimeFunction('allocate', false); +unexportedRuntimeFunction('UTF8ArrayToString', false); +unexportedRuntimeFunction('UTF8ToString', false); +unexportedRuntimeFunction('stringToUTF8Array', false); +unexportedRuntimeFunction('stringToUTF8', false); +unexportedRuntimeFunction('lengthBytesUTF8', false); +unexportedRuntimeFunction('addOnPreRun', false); +unexportedRuntimeFunction('addOnInit', false); +unexportedRuntimeFunction('addOnPreMain', false); +unexportedRuntimeFunction('addOnExit', false); +unexportedRuntimeFunction('addOnPostRun', false); +unexportedRuntimeFunction('addRunDependency', true); +unexportedRuntimeFunction('removeRunDependency', true); +unexportedRuntimeFunction('FS_createFolder', false); +unexportedRuntimeFunction('FS_createPath', true); +unexportedRuntimeFunction('FS_createDataFile', true); +unexportedRuntimeFunction('FS_createPreloadedFile', true); +unexportedRuntimeFunction('FS_createLazyFile', true); +unexportedRuntimeFunction('FS_createLink', false); +unexportedRuntimeFunction('FS_createDevice', true); +unexportedRuntimeFunction('FS_unlink', true); +unexportedRuntimeFunction('getLEB', false); +unexportedRuntimeFunction('getFunctionTables', false); +unexportedRuntimeFunction('alignFunctionTables', false); +unexportedRuntimeFunction('registerFunctions', false); +unexportedRuntimeFunction('addFunction', false); +unexportedRuntimeFunction('removeFunction', false); +unexportedRuntimeFunction('prettyPrint', false); +unexportedRuntimeFunction('getCompilerSetting', false); +Module["print"] = out; +Module["printErr"] = err; +unexportedRuntimeFunction('getTempRet0', false); +unexportedRuntimeFunction('setTempRet0', false); +unexportedRuntimeFunction('callMain', false); +unexportedRuntimeFunction('abort', false); +unexportedRuntimeFunction('keepRuntimeAlive', false); +unexportedRuntimeFunction('wasmMemory', false); +unexportedRuntimeFunction('warnOnce', false); +unexportedRuntimeFunction('stackSave', false); +unexportedRuntimeFunction('stackRestore', false); +unexportedRuntimeFunction('stackAlloc', false); +unexportedRuntimeFunction('AsciiToString', false); +unexportedRuntimeFunction('stringToAscii', false); +unexportedRuntimeFunction('UTF16ToString', false); +unexportedRuntimeFunction('stringToUTF16', false); +unexportedRuntimeFunction('lengthBytesUTF16', false); +unexportedRuntimeFunction('UTF32ToString', false); +unexportedRuntimeFunction('stringToUTF32', false); +unexportedRuntimeFunction('lengthBytesUTF32', false); +unexportedRuntimeFunction('allocateUTF8', false); +unexportedRuntimeFunction('allocateUTF8OnStack', false); +unexportedRuntimeFunction('ExitStatus', false); +unexportedRuntimeFunction('intArrayFromString', false); +unexportedRuntimeFunction('intArrayToString', false); +unexportedRuntimeFunction('writeStringToMemory', false); +unexportedRuntimeFunction('writeArrayToMemory', false); +unexportedRuntimeFunction('writeAsciiToMemory', false); +Module["writeStackCookie"] = writeStackCookie; +Module["checkStackCookie"] = checkStackCookie; +unexportedRuntimeFunction('ptrToString', false); +unexportedRuntimeFunction('zeroMemory', false); +unexportedRuntimeFunction('stringToNewUTF8', false); +unexportedRuntimeFunction('getHeapMax', false); +unexportedRuntimeFunction('emscripten_realloc_buffer', false); +unexportedRuntimeFunction('ENV', false); +unexportedRuntimeFunction('ERRNO_CODES', false); +unexportedRuntimeFunction('ERRNO_MESSAGES', false); +unexportedRuntimeFunction('setErrNo', false); +unexportedRuntimeFunction('inetPton4', false); +unexportedRuntimeFunction('inetNtop4', false); +unexportedRuntimeFunction('inetPton6', false); +unexportedRuntimeFunction('inetNtop6', false); +unexportedRuntimeFunction('readSockaddr', false); +unexportedRuntimeFunction('writeSockaddr', false); +unexportedRuntimeFunction('DNS', false); +unexportedRuntimeFunction('getHostByName', false); +unexportedRuntimeFunction('Protocols', false); +unexportedRuntimeFunction('Sockets', false); +unexportedRuntimeFunction('getRandomDevice', false); +unexportedRuntimeFunction('traverseStack', false); +unexportedRuntimeFunction('UNWIND_CACHE', false); +unexportedRuntimeFunction('convertPCtoSourceLocation', false); +unexportedRuntimeFunction('readAsmConstArgsArray', false); +unexportedRuntimeFunction('readAsmConstArgs', false); +unexportedRuntimeFunction('mainThreadEM_ASM', false); +unexportedRuntimeFunction('jstoi_q', false); +unexportedRuntimeFunction('jstoi_s', false); +unexportedRuntimeFunction('getExecutableName', false); +unexportedRuntimeFunction('listenOnce', false); +unexportedRuntimeFunction('autoResumeAudioContext', false); +unexportedRuntimeFunction('dynCallLegacy', false); +unexportedRuntimeFunction('getDynCaller', false); +unexportedRuntimeFunction('dynCall', false); +unexportedRuntimeFunction('handleException', false); +unexportedRuntimeFunction('runtimeKeepalivePush', false); +unexportedRuntimeFunction('runtimeKeepalivePop', false); +unexportedRuntimeFunction('callUserCallback', false); +unexportedRuntimeFunction('maybeExit', false); +unexportedRuntimeFunction('safeSetTimeout', false); +unexportedRuntimeFunction('asmjsMangle', false); +unexportedRuntimeFunction('asyncLoad', false); +unexportedRuntimeFunction('alignMemory', false); +unexportedRuntimeFunction('mmapAlloc', false); +unexportedRuntimeFunction('writeI53ToI64', false); +unexportedRuntimeFunction('writeI53ToI64Clamped', false); +unexportedRuntimeFunction('writeI53ToI64Signaling', false); +unexportedRuntimeFunction('writeI53ToU64Clamped', false); +unexportedRuntimeFunction('writeI53ToU64Signaling', false); +unexportedRuntimeFunction('readI53FromI64', false); +unexportedRuntimeFunction('readI53FromU64', false); +unexportedRuntimeFunction('convertI32PairToI53', false); +unexportedRuntimeFunction('convertI32PairToI53Checked', false); +unexportedRuntimeFunction('convertU32PairToI53', false); +unexportedRuntimeFunction('reallyNegative', false); +unexportedRuntimeFunction('unSign', false); +unexportedRuntimeFunction('strLen', false); +unexportedRuntimeFunction('reSign', false); +unexportedRuntimeFunction('formatString', false); +unexportedRuntimeFunction('setValue', false); +unexportedRuntimeFunction('getValue', false); +unexportedRuntimeFunction('PATH', false); +unexportedRuntimeFunction('PATH_FS', false); +unexportedRuntimeFunction('SYSCALLS', false); +unexportedRuntimeFunction('getSocketFromFD', false); +unexportedRuntimeFunction('getSocketAddress', false); +unexportedRuntimeFunction('JSEvents', false); +unexportedRuntimeFunction('registerKeyEventCallback', false); +unexportedRuntimeFunction('specialHTMLTargets', false); +unexportedRuntimeFunction('maybeCStringToJsString', false); +unexportedRuntimeFunction('findEventTarget', false); +unexportedRuntimeFunction('findCanvasEventTarget', false); +unexportedRuntimeFunction('getBoundingClientRect', false); +unexportedRuntimeFunction('fillMouseEventData', false); +unexportedRuntimeFunction('registerMouseEventCallback', false); +unexportedRuntimeFunction('registerWheelEventCallback', false); +unexportedRuntimeFunction('registerUiEventCallback', false); +unexportedRuntimeFunction('registerFocusEventCallback', false); +unexportedRuntimeFunction('fillDeviceOrientationEventData', false); +unexportedRuntimeFunction('registerDeviceOrientationEventCallback', false); +unexportedRuntimeFunction('fillDeviceMotionEventData', false); +unexportedRuntimeFunction('registerDeviceMotionEventCallback', false); +unexportedRuntimeFunction('screenOrientation', false); +unexportedRuntimeFunction('fillOrientationChangeEventData', false); +unexportedRuntimeFunction('registerOrientationChangeEventCallback', false); +unexportedRuntimeFunction('fillFullscreenChangeEventData', false); +unexportedRuntimeFunction('registerFullscreenChangeEventCallback', false); +unexportedRuntimeFunction('JSEvents_requestFullscreen', false); +unexportedRuntimeFunction('JSEvents_resizeCanvasForFullscreen', false); +unexportedRuntimeFunction('registerRestoreOldStyle', false); +unexportedRuntimeFunction('hideEverythingExceptGivenElement', false); +unexportedRuntimeFunction('restoreHiddenElements', false); +unexportedRuntimeFunction('setLetterbox', false); +unexportedRuntimeFunction('currentFullscreenStrategy', false); +unexportedRuntimeFunction('restoreOldWindowedStyle', false); +unexportedRuntimeFunction('softFullscreenResizeWebGLRenderTarget', false); +unexportedRuntimeFunction('doRequestFullscreen', false); +unexportedRuntimeFunction('fillPointerlockChangeEventData', false); +unexportedRuntimeFunction('registerPointerlockChangeEventCallback', false); +unexportedRuntimeFunction('registerPointerlockErrorEventCallback', false); +unexportedRuntimeFunction('requestPointerLock', false); +unexportedRuntimeFunction('fillVisibilityChangeEventData', false); +unexportedRuntimeFunction('registerVisibilityChangeEventCallback', false); +unexportedRuntimeFunction('registerTouchEventCallback', false); +unexportedRuntimeFunction('fillGamepadEventData', false); +unexportedRuntimeFunction('registerGamepadEventCallback', false); +unexportedRuntimeFunction('registerBeforeUnloadEventCallback', false); +unexportedRuntimeFunction('fillBatteryEventData', false); +unexportedRuntimeFunction('battery', false); +unexportedRuntimeFunction('registerBatteryEventCallback', false); +unexportedRuntimeFunction('setCanvasElementSize', false); +unexportedRuntimeFunction('getCanvasElementSize', false); +unexportedRuntimeFunction('demangle', false); +unexportedRuntimeFunction('demangleAll', false); +unexportedRuntimeFunction('jsStackTrace', false); +unexportedRuntimeFunction('stackTrace', false); +unexportedRuntimeFunction('getEnvStrings', false); +unexportedRuntimeFunction('checkWasiClock', false); +unexportedRuntimeFunction('doReadv', false); +unexportedRuntimeFunction('doWritev', false); +unexportedRuntimeFunction('dlopenMissingError', false); +unexportedRuntimeFunction('setImmediateWrapped', false); +unexportedRuntimeFunction('clearImmediateWrapped', false); +unexportedRuntimeFunction('polyfillSetImmediate', false); +unexportedRuntimeFunction('uncaughtExceptionCount', false); +unexportedRuntimeFunction('exceptionLast', false); +unexportedRuntimeFunction('exceptionCaught', false); +unexportedRuntimeFunction('ExceptionInfo', false); +unexportedRuntimeFunction('exception_addRef', false); +unexportedRuntimeFunction('exception_decRef', false); +unexportedRuntimeFunction('getExceptionMessage', false); +unexportedRuntimeFunction('Browser', false); +unexportedRuntimeFunction('setMainLoop', false); +unexportedRuntimeFunction('wget', false); +unexportedRuntimeFunction('FS', false); +unexportedRuntimeFunction('MEMFS', false); +unexportedRuntimeFunction('TTY', false); +unexportedRuntimeFunction('PIPEFS', false); +unexportedRuntimeFunction('SOCKFS', false); +unexportedRuntimeFunction('_setNetworkCallback', false); +unexportedRuntimeFunction('tempFixedLengthArray', false); +unexportedRuntimeFunction('miniTempWebGLFloatBuffers', false); +unexportedRuntimeFunction('heapObjectForWebGLType', false); +unexportedRuntimeFunction('heapAccessShiftForWebGLHeap', false); +unexportedRuntimeFunction('GL', false); +unexportedRuntimeFunction('emscriptenWebGLGet', false); +unexportedRuntimeFunction('computeUnpackAlignedImageSize', false); +unexportedRuntimeFunction('emscriptenWebGLGetTexPixelData', false); +unexportedRuntimeFunction('emscriptenWebGLGetUniform', false); +unexportedRuntimeFunction('webglGetUniformLocation', false); +unexportedRuntimeFunction('webglPrepareUniformLocationsBeforeFirstUse', false); +unexportedRuntimeFunction('webglGetLeftBracePos', false); +unexportedRuntimeFunction('emscriptenWebGLGetVertexAttrib', false); +unexportedRuntimeFunction('writeGLArray', false); +unexportedRuntimeFunction('AL', false); +unexportedRuntimeFunction('SDL_unicode', false); +unexportedRuntimeFunction('SDL_ttfContext', false); +unexportedRuntimeFunction('SDL_audio', false); +unexportedRuntimeFunction('SDL', false); +unexportedRuntimeFunction('SDL_gfx', false); +unexportedRuntimeFunction('GLUT', false); +unexportedRuntimeFunction('EGL', false); +unexportedRuntimeFunction('GLFW_Window', false); +unexportedRuntimeFunction('GLFW', false); +unexportedRuntimeFunction('GLEW', false); +unexportedRuntimeFunction('IDBStore', false); +unexportedRuntimeFunction('runAndAbortIfError', false); +unexportedRuntimeFunction('InternalError', false); +unexportedRuntimeFunction('BindingError', false); +unexportedRuntimeFunction('UnboundTypeError', false); +unexportedRuntimeFunction('PureVirtualError', false); +unexportedRuntimeFunction('init_embind', false); +unexportedRuntimeFunction('throwInternalError', false); +unexportedRuntimeFunction('throwBindingError', false); +unexportedRuntimeFunction('throwUnboundTypeError', false); +unexportedRuntimeFunction('ensureOverloadTable', false); +unexportedRuntimeFunction('exposePublicSymbol', false); +unexportedRuntimeFunction('replacePublicSymbol', false); +unexportedRuntimeFunction('extendError', false); +unexportedRuntimeFunction('createNamedFunction', false); +unexportedRuntimeFunction('registeredInstances', false); +unexportedRuntimeFunction('getBasestPointer', false); +unexportedRuntimeFunction('registerInheritedInstance', false); +unexportedRuntimeFunction('unregisterInheritedInstance', false); +unexportedRuntimeFunction('getInheritedInstance', false); +unexportedRuntimeFunction('getInheritedInstanceCount', false); +unexportedRuntimeFunction('getLiveInheritedInstances', false); +unexportedRuntimeFunction('registeredTypes', false); +unexportedRuntimeFunction('awaitingDependencies', false); +unexportedRuntimeFunction('typeDependencies', false); +unexportedRuntimeFunction('registeredPointers', false); +unexportedRuntimeFunction('registerType', false); +unexportedRuntimeFunction('whenDependentTypesAreResolved', false); +unexportedRuntimeFunction('embind_charCodes', false); +unexportedRuntimeFunction('embind_init_charCodes', false); +unexportedRuntimeFunction('readLatin1String', false); +unexportedRuntimeFunction('getTypeName', false); +unexportedRuntimeFunction('heap32VectorToArray', false); +unexportedRuntimeFunction('requireRegisteredType', false); +unexportedRuntimeFunction('getShiftFromSize', false); +unexportedRuntimeFunction('integerReadValueFromPointer', false); +unexportedRuntimeFunction('enumReadValueFromPointer', false); +unexportedRuntimeFunction('floatReadValueFromPointer', false); +unexportedRuntimeFunction('simpleReadValueFromPointer', false); +unexportedRuntimeFunction('runDestructors', false); +unexportedRuntimeFunction('new_', false); +unexportedRuntimeFunction('craftInvokerFunction', false); +unexportedRuntimeFunction('embind__requireFunction', false); +unexportedRuntimeFunction('tupleRegistrations', false); +unexportedRuntimeFunction('structRegistrations', false); +unexportedRuntimeFunction('genericPointerToWireType', false); +unexportedRuntimeFunction('constNoSmartPtrRawPointerToWireType', false); +unexportedRuntimeFunction('nonConstNoSmartPtrRawPointerToWireType', false); +unexportedRuntimeFunction('init_RegisteredPointer', false); +unexportedRuntimeFunction('RegisteredPointer', false); +unexportedRuntimeFunction('RegisteredPointer_getPointee', false); +unexportedRuntimeFunction('RegisteredPointer_destructor', false); +unexportedRuntimeFunction('RegisteredPointer_deleteObject', false); +unexportedRuntimeFunction('RegisteredPointer_fromWireType', false); +unexportedRuntimeFunction('runDestructor', false); +unexportedRuntimeFunction('releaseClassHandle', false); +unexportedRuntimeFunction('finalizationRegistry', false); +unexportedRuntimeFunction('detachFinalizer_deps', false); +unexportedRuntimeFunction('detachFinalizer', false); +unexportedRuntimeFunction('attachFinalizer', false); +unexportedRuntimeFunction('makeClassHandle', false); +unexportedRuntimeFunction('init_ClassHandle', false); +unexportedRuntimeFunction('ClassHandle', false); +unexportedRuntimeFunction('ClassHandle_isAliasOf', false); +unexportedRuntimeFunction('throwInstanceAlreadyDeleted', false); +unexportedRuntimeFunction('ClassHandle_clone', false); +unexportedRuntimeFunction('ClassHandle_delete', false); +unexportedRuntimeFunction('deletionQueue', false); +unexportedRuntimeFunction('ClassHandle_isDeleted', false); +unexportedRuntimeFunction('ClassHandle_deleteLater', false); +unexportedRuntimeFunction('flushPendingDeletes', false); +unexportedRuntimeFunction('delayFunction', false); +unexportedRuntimeFunction('setDelayFunction', false); +unexportedRuntimeFunction('RegisteredClass', false); +unexportedRuntimeFunction('shallowCopyInternalPointer', false); +unexportedRuntimeFunction('downcastPointer', false); +unexportedRuntimeFunction('upcastPointer', false); +unexportedRuntimeFunction('validateThis', false); +unexportedRuntimeFunction('char_0', false); +unexportedRuntimeFunction('char_9', false); +unexportedRuntimeFunction('makeLegalFunctionName', false); +unexportedRuntimeFunction('emval_handle_array', false); +unexportedRuntimeFunction('emval_free_list', false); +unexportedRuntimeFunction('emval_symbols', false); +unexportedRuntimeFunction('init_emval', false); +unexportedRuntimeFunction('count_emval_handles', false); +unexportedRuntimeFunction('get_first_emval', false); +unexportedRuntimeFunction('getStringOrSymbol', false); +unexportedRuntimeFunction('Emval', false); +unexportedRuntimeFunction('emval_newers', false); +unexportedRuntimeFunction('craftEmvalAllocator', false); +unexportedRuntimeFunction('emval_get_global', false); +unexportedRuntimeFunction('emval_methodCallers', false); +unexportedRuntimeFunction('emval_registeredMethods', false); +unexportedRuntimeFunction('NODEFS', false); +Module["ALLOC_NORMAL"] = ALLOC_NORMAL; +Module["ALLOC_STACK"] = ALLOC_STACK; + +var calledRun; + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function callMain(args) { + assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])'); + assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called'); + + var entryFunction = Module['_main']; + + args = args || []; + args.unshift(thisProgram); + + var argc = args.length; + var argv = stackAlloc((argc + 1) * 4); + var argv_ptr = argv >> 2; + args.forEach((arg) => { + HEAP32[argv_ptr++] = allocateUTF8OnStack(arg); + }); + HEAP32[argv_ptr] = 0; + + try { + + var ret = entryFunction(argc, argv); + + // In PROXY_TO_PTHREAD builds, we should never exit the runtime below, as + // execution is asynchronously handed off to a pthread. + // if we're not running an evented main loop, it's time to exit + exit(ret, /* implicit = */ true); + return ret; + } + catch (e) { + return handleException(e); + } finally { + calledMain = true; + + } +} + +function stackCheckInit() { + // This is normally called automatically during __wasm_call_ctors but need to + // get these values before even running any of the ctors so we call it redundantly + // here. + // TODO(sbc): Move writeStackCookie to native to to avoid this. + _emscripten_stack_init(); + writeStackCookie(); +} + +/** @type {function(Array=)} */ +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + stackCheckInit(); + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + if (shouldRunNow) callMain(args); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} +Module['run'] = run; + +function checkUnflushedContent() { + // Compiler settings do not allow exiting the runtime, so flushing + // the streams is not possible. but in ASSERTIONS mode we check + // if there was something to flush, and if so tell the user they + // should request that the runtime be exitable. + // Normally we would not even include flush() at all, but in ASSERTIONS + // builds we do so just for this check, and here we see if there is any + // content to flush, that is, we check if there would have been + // something a non-ASSERTIONS build would have not seen. + // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 + // mode (which has its own special function for this; otherwise, all + // the code is inside libc) + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + } + try { // it doesn't matter if it fails + _fflush(0); + // also flush in the JS FS layer + ['stdout', 'stderr'].forEach(function(name) { + var info = FS.analyzePath('/dev/' + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty && tty.output && tty.output.length) { + has = true; + } + }); + } catch(e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.'); + } +} + +/** @param {boolean|number=} implicit */ +function exit(status, implicit) { + EXITSTATUS = status; + + checkUnflushedContent(); + + // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down + if (keepRuntimeAlive() && !implicit) { + var msg = 'program exited (with status: ' + status + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)'; + err(msg); + } + + procExit(status); +} + +function procExit(code) { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + if (Module['onExit']) Module['onExit'](code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +// shouldRunNow refers to calling main(), not run(). +var shouldRunNow = true; + +if (Module['noInitialRun']) shouldRunNow = false; + +run(); + + + + + + } + else { + console.error("Invalid action : " + action); + outgoingMessagePort.postMessage("invalid action"); + } +},false); + diff --git a/www/libzim-wasm.electron.dev.wasm.REMOVED.git-id b/www/libzim-wasm.electron.dev.wasm.REMOVED.git-id new file mode 100644 index 00000000..3684c7d4 --- /dev/null +++ b/www/libzim-wasm.electron.dev.wasm.REMOVED.git-id @@ -0,0 +1 @@ +1277c10d1092ef012f15d750bd6109c86a22c24d \ No newline at end of file