From 38a468a5ccaecb72f7b5bb738b8294f245bbffee Mon Sep 17 00:00:00 2001 From: rustdesk Date: Sun, 6 Feb 2022 03:13:41 +0800 Subject: [PATCH] opus is slow --- favicon.svg | 16 +- index.html | 3 +- libopus.js | 5555 +++++++++++++++++++++++++++++++++++++++++++++ libopus.wasm | Bin 0 -> 489750 bytes src/codec.js | 14 - src/connection.ts | 21 +- src/globals.js | 24 +- 7 files changed, 5580 insertions(+), 53 deletions(-) create mode 100644 libopus.js create mode 100755 libopus.wasm diff --git a/favicon.svg b/favicon.svg index de4aeddc1..0234ca69e 100644 --- a/favicon.svg +++ b/favicon.svg @@ -1,15 +1 @@ - - - - - - - - - - - - - - - + diff --git a/index.html b/index.html index 93d956b74..2ee0f7fbf 100644 --- a/index.html +++ b/index.html @@ -2,9 +2,10 @@ - + + Vite App diff --git a/libopus.js b/libopus.js new file mode 100644 index 000000000..5b0ff4907 --- /dev/null +++ b/libopus.js @@ -0,0 +1,5555 @@ + + +// 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 +var objAssign = 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) +Module["onRuntimeInitialized"] = function(){ + if(Module.onload) + Module.onload(); + Module.loaded = true; +} + +Module["locateFile"] = function(url){ + if(url == "libopus.wasm" && typeof LIBOPUS_WASM_URL != "undefined") + return LIBOPUS_WASM_URL; + else + return url; +} + + +// 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 = objAssign({}, 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, -s ENVIRONMENT=web or -s ENVIRONMENT=node)'); +} + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +// 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 ? null : '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 +objAssign(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; + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments']; +if (!Object.getOwnPropertyDescriptor(Module, 'arguments')) { + Object.defineProperty(Module, 'arguments', { + configurable: true, + get: function() { + abort('Module.arguments has been replaced with plain arguments_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +if (Module['thisProgram']) thisProgram = Module['thisProgram']; +if (!Object.getOwnPropertyDescriptor(Module, 'thisProgram')) { + Object.defineProperty(Module, 'thisProgram', { + configurable: true, + get: function() { + abort('Module.thisProgram has been replaced with plain thisProgram (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +if (Module['quit']) quit_ = Module['quit']; +if (!Object.getOwnPropertyDescriptor(Module, 'quit')) { + Object.defineProperty(Module, 'quit', { + configurable: true, + get: function() { + abort('Module.quit has been replaced with plain quit_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +assert(typeof Module['memoryInitializerPrefixURL'] === 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['pthreadMainPrefixURL'] === 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['cdInitializerPrefixURL'] === 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['filePackagePrefixURL'] === 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['read'] === 'undefined', 'Module.read option was removed (modify read_ in JS)'); +assert(typeof Module['readAsync'] === 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] === 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] === 'undefined', 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)'); +assert(typeof Module['TOTAL_MEMORY'] === 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); + +if (!Object.getOwnPropertyDescriptor(Module, 'read')) { + Object.defineProperty(Module, 'read', { + configurable: true, + get: function() { + abort('Module.read has been replaced with plain read_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module, 'readAsync')) { + Object.defineProperty(Module, 'readAsync', { + configurable: true, + get: function() { + abort('Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module, 'readBinary')) { + Object.defineProperty(Module, 'readBinary', { + configurable: true, + get: function() { + abort('Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +if (!Object.getOwnPropertyDescriptor(Module, 'setWindowTitle')) { + Object.defineProperty(Module, 'setWindowTitle', { + configurable: true, + get: function() { + abort('Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; +var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; +var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js'; + + +assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add 'shell' to `-s ENVIRONMENT` to enable."); + + + + +var STACK_ALIGN = 16; +var POINTER_SIZE = 4; + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': return 1; + case 'i16': return 2; + case 'i32': return 4; + case 'i64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length - 1] === '*') { + return 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 + + +// Wraps a JS function as a wasm function with a given signature. +function convertJsFunctionToWasm(func, sig) { + + // If the type reflection proposal is available, use the new + // "WebAssembly.Function" constructor. + // Otherwise, construct a minimal wasm module importing the JS function and + // re-exporting it. + if (typeof WebAssembly.Function === "function") { + var typeNames = { + 'i': 'i32', + 'j': 'i64', + 'f': 'f32', + 'd': 'f64' + }; + var type = { + parameters: [], + results: sig[0] == 'v' ? [] : [typeNames[sig[0]]] + }; + for (var i = 1; i < sig.length; ++i) { + type.parameters.push(typeNames[sig[i]]); + } + return new WebAssembly.Function(type, func); + } + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // id: section, + 0x00, // length: 0 (placeholder) + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the overall length of the type section back into the section header + // (excepting the 2 bytes for the section id and length) + typeSection[1] = typeSection.length - 2; + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + 'e': { + 'f': func + } + }); + var wrappedFunc = instance.exports['f']; + return wrappedFunc; +} + +var freeTableIndexes = []; + +// Weak map of functions in the table to their indexes, created on first use. +var functionsInTableMap; + +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. +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 + + +// 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']; +if (!Object.getOwnPropertyDescriptor(Module, 'wasmBinary')) { + Object.defineProperty(Module, 'wasmBinary', { + configurable: true, + get: function() { + abort('Module.wasmBinary has been replaced with plain wasmBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} +var noExitRuntime = Module['noExitRuntime'] || true; +if (!Object.getOwnPropertyDescriptor(Module, 'noExitRuntime')) { + Object.defineProperty(Module, 'noExitRuntime', { + configurable: true, + get: function() { + abort('Module.noExitRuntime has been replaced with plain noExitRuntime (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +if (typeof WebAssembly !== 'object') { + abort('no native wasm support detected'); +} + +// include: runtime_safe_heap.js + + +// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking. +// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties) + +/** @param {number} ptr + @param {number} value + @param {string} type + @param {number|boolean=} noSafe */ +function setValue(ptr, value, type = 'i8', noSafe) { + if (type.charAt(type.length-1) === '*') type = 'i32'; + switch (type) { + case 'i1': HEAP8[((ptr)>>0)] = value; break; + case 'i8': HEAP8[((ptr)>>0)] = value; break; + case 'i16': HEAP16[((ptr)>>1)] = value; break; + case 'i32': HEAP32[((ptr)>>2)] = value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + default: abort('invalid type for setValue: ' + type); + } +} + +/** @param {number} ptr + @param {string} type + @param {number|boolean=} noSafe */ +function getValue(ptr, type = 'i8', noSafe) { + if (type.charAt(type.length-1) === '*') 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; +} + +// end include: runtime_safe_heap.js +// 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. + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((Uint8Array|Array), number)} */ +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) { + HEAPU8.set(/** @type {!Uint8Array} */(slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; +} + +// include: runtime_strings.js + + +// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime. + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns +// a copy of that string as a Javascript String object. + +var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + +/** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(heap, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { + return UTF8Decoder.decode(heap.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heap[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heap[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heap[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; +} + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a +// copy of that string as a Javascript String object. +// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit +// this parameter to scan the string until the first \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will +// not produce a string of exact length [ptr, ptr+maxBytesToRead[) +// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may +// throw JS JIT optimizations off, so it is worth to consider consistently using one +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ToString(ptr, maxBytesToRead) { + ; + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; +} + +// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', +// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. +// This count should include the null terminator, +// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. +// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 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 + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; +} + +var HEAP, +/** @type {ArrayBuffer} */ + buffer, +/** @type {Int8Array} */ + HEAP8, +/** @type {Uint8Array} */ + HEAPU8, +/** @type {Int16Array} */ + HEAP16, +/** @type {Uint16Array} */ + HEAPU16, +/** @type {Int32Array} */ + HEAP32, +/** @type {Uint32Array} */ + HEAPU32, +/** @type {Float32Array} */ + HEAPF32, +/** @type {Float64Array} */ + HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); +} + +var 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'] || 16777216; +if (!Object.getOwnPropertyDescriptor(Module, 'INITIAL_MEMORY')) { + Object.defineProperty(Module, 'INITIAL_MEMORY', { + configurable: true, + get: function() { + abort('Module.INITIAL_MEMORY has been replaced with plain INITIAL_MEMORY (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)') + } + }); +} + +assert(INITIAL_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 -s IMPORTED_MEMORY to define wasmMemory externally'); +assert(INITIAL_MEMORY == 16777216, 'Detected runtime INITIAL_MEMORY setting. Use -s IMPORTED_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 grows downwards + HEAP32[((max + 4)>>2)] = 0x2135467; + HEAP32[((max + 8)>>2)] = 0x89BACDFE; + // Also test the global address 0 for integrity. + HEAP32[0] = 0x63736d65; /* 'emsc' */ +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + var cookie1 = HEAPU32[((max + 4)>>2)]; + var cookie2 = HEAPU32[((max + 8)>>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 (HEAP32[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 -s SUPPORT_BIG_ENDIAN=1 to bypass)'; +})(); + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; +var runtimeExited = false; +var runtimeKeepaliveCounter = 0; + +function keepRuntimeAlive() { + return noExitRuntime || runtimeKeepaliveCounter > 0; +} + +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 exitRuntime() { + checkStackCookie(); + runtimeExited = true; +} + +function postRun() { + checkStackCookie(); + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function 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 + } + } +} + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + +/** @param {string|number=} what */ +function abort(what) { + { + if (Module['onAbort']) { + Module['onAbort'](what); + } + } + + what = '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. + 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 +function createExportWrapper(name, fixedasm) { + return function() { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module['asm']; + } + assert(runtimeInitialized, 'native function `' + displayName + '` called before runtime initialization'); + assert(!runtimeExited, 'native function `' + displayName + '` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)'); + if (!asm[name]) { + assert(asm[name], 'exported native function `' + displayName + '` not found'); + } + return asm[name].apply(null, arguments); + }; +} + +var wasmBinaryFile; + wasmBinaryFile = 'libopus.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 === 16777216); + updateGlobalBufferAndViews(wasmMemory.buffer); + + wasmTable = Module['asm']['__indirect_function_table']; + assert(wasmTable, "table not found in wasm exports"); + + addOnInit(Module['asm']['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(function (instance) { + return instance; + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + + // Warn on some common problems. + if (isFileURI(wasmBinaryFile)) { + err('warning: Loading from a file URI (' + wasmBinaryFile + ') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing'); + } + abort(reason); + }); + } + + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(wasmBinaryFile) && + typeof fetch === 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + 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. + 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) { + getWasmTableEntry(func)(); + } else { + 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) { + warnOnce('warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling'); + return func; + } + + function demangleAll(text) { + var regex = + /\b_Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); + } + + 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(); + } + + function setWasmTableEntry(idx, func) { + wasmTable.set(idx, func); + wasmTableMirror[idx] = func; + } + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + + function ___cxa_allocate_exception(size) { + // Thrown object is prepended by exception metadata block + return _malloc(size + 16) + 16; + } + + function ExceptionInfo(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 16; + + this.set_type = function(type) { + HEAP32[(((this.ptr)+(4))>>2)] = type; + }; + + this.get_type = function() { + return HEAP32[(((this.ptr)+(4))>>2)]; + }; + + this.set_destructor = function(destructor) { + HEAP32[(((this.ptr)+(8))>>2)] = destructor; + }; + + this.get_destructor = function() { + return HEAP32[(((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_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; + }; + } + + var exceptionLast = 0; + + var uncaughtExceptionCount = 0; + 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 + " - Exception catching is disabled, this exception cannot be caught. Compile with -s NO_DISABLE_EXCEPTION_CATCHING or -s EXCEPTION_CATCHING_ALLOWED=[..] to catch."; + } + + function _abort() { + abort('native code called abort()'); + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + + function abortOnCannotGrowMemory(requestedSize) { + abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with -s INITIAL_MEMORY=X with X higher than the current value ' + HEAP8.length + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 '); + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + abortOnCannotGrowMemory(requestedSize); + } + + 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; + } + + var PATH = {splitPath:function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function(path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:function(path) { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function(path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },extname:function(path) { + return PATH.splitPath(path)[3]; + },join:function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:function(l, r) { + return PATH.normalize(l + '/' + r); + }}; + + 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.charAt(0) === '/'; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; + },relative:function(from, to) { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join('/'); + }}; + + var TTY = {ttys:[],init:function () { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // currently, FS.init does not distinguish if process.stdin is a file or TTY + // // device, it always assumes it's a TTY device. because of this, we're forcing + // // process.stdin to UTF8 encoding to at least make stdin reading compatible + // // with text files until FS.init can be refactored. + // process['stdin']['setEncoding']('utf8'); + // } + },shutdown:function() { + // https://github.com/emscripten-core/emscripten/pull/1555 + // if (ENVIRONMENT_IS_NODE) { + // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? + // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation + // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? + // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle + // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call + // process['stdin']['pause'](); + // } + },register:function(dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + },stream_ops:{open:function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + },close:function(stream) { + // flush any pending line data + stream.tty.ops.flush(stream.tty); + },flush:function(stream) { + stream.tty.ops.flush(stream.tty); + },read:function(stream, buffer, offset, length, pos /* ignored */) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + },write:function(stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset+i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }},default_tty_ops:{get_char:function(tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + // we will read data by chunks of BUFSIZE + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, null); + } catch(e) { + // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes, + // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0. + if (e.toString().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) { + abort('internal error: mmapAlloc called but `memalign` native symbol not exported'); + } + 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 (!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, address, length, position, prot, flags) { + if (address !== 0) { + // We don't currently support location hints for the address of the mapping + throw new FS.ErrnoError(28); + } + 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; + }}}; + + 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_MESSAGES = {0:"Success",1:"Arg list too long",2:"Permission denied",3:"Address already in use",4:"Address not available",5:"Address family not supported by protocol family",6:"No more processes",7:"Socket already connected",8:"Bad file number",9:"Trying to read unreadable message",10:"Mount device busy",11:"Operation canceled",12:"No children",13:"Connection aborted",14:"Connection refused",15:"Connection reset by peer",16:"File locking deadlock error",17:"Destination address required",18:"Math arg out of domain of func",19:"Quota exceeded",20:"File exists",21:"Bad address",22:"File too large",23:"Host is unreachable",24:"Identifier removed",25:"Illegal byte sequence",26:"Connection already in progress",27:"Interrupted system call",28:"Invalid argument",29:"I/O error",30:"Socket is already connected",31:"Is a directory",32:"Too many symbolic links",33:"Too many open files",34:"Too many links",35:"Message too long",36:"Multihop attempted",37:"File or path name too long",38:"Network interface is not configured",39:"Connection reset by network",40:"Network is unreachable",41:"Too many open files in system",42:"No buffer space available",43:"No such device",44:"No such file or directory",45:"Exec format error",46:"No record locks available",47:"The link has been severed",48:"Not enough core",49:"No message of desired type",50:"Protocol not available",51:"No space left on device",52:"Function not implemented",53:"Socket is not connected",54:"Not a directory",55:"Directory not empty",56:"State not recoverable",57:"Socket operation on non-socket",59:"Not a typewriter",60:"No such device or address",61:"Value too large for defined data type",62:"Previous owner died",63:"Not super-user",64:"Broken pipe",65:"Protocol error",66:"Unknown protocol",67:"Protocol wrong type for socket",68:"Math result not representable",69:"Read only file system",70:"Illegal seek",71:"No such process",72:"Stale file handle",73:"Connection timed out",74:"Text file busy",75:"Cross-device link",100:"Device not a stream",101:"Bad font file fmt",102:"Invalid slot",103:"Invalid request code",104:"No anode",105:"Block device required",106:"Channel number out of range",107:"Level 3 halted",108:"Level 3 reset",109:"Link number out of range",110:"Protocol driver not attached",111:"No CSI structure available",112:"Level 2 halted",113:"Invalid exchange",114:"Invalid request descriptor",115:"Exchange full",116:"No data (for no delay io)",117:"Timer expired",118:"Out of streams resources",119:"Machine is not on the network",120:"Package not installed",121:"The object is remote",122:"Advertise error",123:"Srmount error",124:"Communication error on send",125:"Cross mount point (not really error)",126:"Given log. name not unique",127:"f.d. invalid for this operation",128:"Remote address changed",129:"Can access a needed shared lib",130:"Accessing a corrupted shared lib",131:".lib section in a.out corrupted",132:"Attempting to link in too many libs",133:"Attempting to exec a shared library",135:"Streams pipe error",136:"Too many users",137:"Socket type not supported",138:"Not supported",139:"Protocol family not supported",140:"Can't send after socket shutdown",141:"Too many references",142:"Host is down",148:"No medium (in tape drive)",156:"Level 2 not synchronized"}; + + var ERRNO_CODES = {}; + var FS = {root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,lookupPath:function(path, opts = {}) { + path = PATH_FS.resolve(FS.cwd(), path); + + if (!path) return { path: '', node: null }; + + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + for (var key in defaults) { + if (opts[key] === undefined) { + opts[key] = defaults[key]; + } + } + + if (opts.recurse_count > 8) { // max recursive lookup of 8 + throw new FS.ErrnoError(32); + } + + // split the path + var parts = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), false); + + // start at the root + var current = FS.root; + var current_path = '/'; + + for (var i = 0; i < parts.length; i++) { + var islast = (i === parts.length-1); + if (islast && opts.parent) { + // stop resolving + break; + } + + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + + // jump to the mount's root node if this is a mountpoint + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + + // by default, lookupPath will not follow a symlink if it is the final path component. + // setting opts.follow = true will override this behavior. + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count }); + current = lookup.node; + + if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). + throw new FS.ErrnoError(32); + } + } + } + } + + return { path: current_path, node: current }; + },getPath:function(node) { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path; + } + path = path ? node.name + '/' + path : node.name; + node = node.parent; + } + },hashName:function(parentid, name) { + var hash = 0; + + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + },hashAddNode:function(node) { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + },hashRemoveNode:function(node) { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + },lookupNode:function(parent, name) { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + // if we failed to find it in the cache, call into the VFS + return FS.lookup(parent, name); + },createNode:function(parent, name, mode, rdev) { + assert(typeof parent === 'object') + var node = new FS.FSNode(parent, name, mode, rdev); + + FS.hashAddNode(node); + + return node; + },destroyNode:function(node) { + FS.hashRemoveNode(node); + },isRoot:function(node) { + return node === node.parent; + },isMountpoint:function(node) { + return !!node.mounted; + },isFile:function(mode) { + return (mode & 61440) === 32768; + },isDir:function(mode) { + return (mode & 61440) === 16384; + },isLink:function(mode) { + return (mode & 61440) === 40960; + },isChrdev:function(mode) { + return (mode & 61440) === 8192; + },isBlkdev:function(mode) { + return (mode & 61440) === 24576; + },isFIFO:function(mode) { + return (mode & 61440) === 4096; + },isSocket:function(mode) { + return (mode & 49152) === 49152; + },flagModes:{"r":0,"r+":2,"w":577,"w+":578,"a":1089,"a+":1090},modeStringToFlags:function(str) { + var flags = FS.flagModes[str]; + if (typeof flags === 'undefined') { + throw new Error('Unknown file open mode: ' + str); + } + return flags; + },flagsToPermissionString:function(flag) { + var perms = ['r', 'w', 'rw'][flag & 3]; + if ((flag & 512)) { + perms += 'w'; + } + return perms; + },nodePermissions:function(node, perms) { + if (FS.ignorePermissions) { + return 0; + } + // return 0 if any user, group or owner bits are set. + if (perms.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:function(dir) { + var errCode = FS.nodePermissions(dir, 'x'); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + },mayCreate:function(dir, name) { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, 'wx'); + },mayDelete:function(dir, name, isdir) { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, 'wx'); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + },mayOpen:function(node, flags) { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write + (flags & 512)) { // TODO: check for O_SEARCH? (== search for dir only) + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + },MAX_OPEN_FDS:4096,nextfd:function(fd_start = 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:function(fd) { + return FS.streams[fd]; + },createStream:function(stream, fd_start, fd_end) { + if (!FS.FSStream) { + FS.FSStream = /** @constructor */ function(){}; + FS.FSStream.prototype = { + object: { + get: function() { return this.node; }, + set: function(val) { this.node = val; } + }, + isRead: { + get: function() { return (this.flags & 2097155) !== 1; } + }, + isWrite: { + get: function() { return (this.flags & 2097155) !== 0; } + }, + isAppend: { + get: function() { return (this.flags & 1024); } + } + }; + } + // clone it, so we can return an instance of FSStream + var newStream = new FS.FSStream(); + for (var p in stream) { + newStream[p] = stream[p]; + } + stream = newStream; + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + },closeStream:function(fd) { + FS.streams[fd] = null; + },chrdev_stream_ops:{open:function(stream) { + var device = FS.getDevice(stream.node.rdev); + // override node's stream ops with the device's + stream.stream_ops = device.stream_ops; + // forward the open call + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + },llseek:function() { + throw new FS.ErrnoError(70); + }},major:function(dev) { + return ((dev) >> 8); + },minor:function(dev) { + return ((dev) & 0xff); + },makedev:function(ma, mi) { + return ((ma) << 8 | (mi)); + },registerDevice:function(dev, ops) { + FS.devices[dev] = { stream_ops: ops }; + },getDevice:function(dev) { + return FS.devices[dev]; + },getMounts:function(mount) { + var mounts = []; + var check = [mount]; + + while (check.length) { + var m = check.pop(); + + mounts.push(m); + + check.push.apply(check, m.mounts); + } + + return mounts; + },syncfs:function(populate, callback) { + if (typeof(populate) === 'function') { + callback = populate; + populate = false; + } + + FS.syncFSRequests++; + + if (FS.syncFSRequests > 1) { + err('warning: ' + FS.syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work'); + } + + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + }; + + // sync all mounts + mounts.forEach(function (mount) { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + },mount:function(type, opts, mountpoint) { + if (typeof type === 'string') { + // The filesystem was not included, and instead we have an error + // message stored in the variable. + throw type; + } + var root = mountpoint === '/'; + var pseudo = !mountpoint; + var node; + + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + mountpoint = lookup.path; // use the absolute path + node = lookup.node; + + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + + // create a root node for the fs + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + + if (root) { + FS.root = mountRoot; + } else if (node) { + // set as a mountpoint + node.mounted = mount; + + // add the new mount to the current mount's children + if (node.mount) { + node.mount.mounts.push(mount); + } + } + + return mountRoot; + },unmount:function (mountpoint) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + + // destroy the nodes for this mount, and all its child mounts + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + + Object.keys(FS.nameTable).forEach(function (hash) { + var current = FS.nameTable[hash]; + + while (current) { + var next = current.name_next; + + if (mounts.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:function(parent, name) { + return parent.node_ops.lookup(parent, name); + },mknod:function(path, mode, dev) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === '.' || name === '..') { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + },create:function(path, mode) { + mode = mode !== undefined ? mode : 438 /* 0666 */; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + },mkdir:function(path, mode) { + mode = mode !== undefined ? mode : 511 /* 0777 */; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + },mkdirTree:function(path, mode) { + var dirs = path.split('/'); + var d = ''; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += '/' + dirs[i]; + try { + FS.mkdir(d, mode); + } catch(e) { + if (e.errno != 20) throw e; + } + } + },mkdev:function(path, mode, dev) { + if (typeof(dev) === 'undefined') { + dev = mode; + mode = 438 /* 0666 */; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + },symlink:function(oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + },rename:function(old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + // parents must exist + var lookup, old_dir, new_dir; + + // 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:function(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + },readdir:function(path) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + },unlink:function(path) { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + 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:function(path) { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + },stat:function(path, dontFollow) { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + },lstat:function(path) { + return FS.stat(path, true); + },chmod:function(path, mode, dontFollow) { + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now() + }); + },lchmod:function(path, mode) { + FS.chmod(path, mode, true); + },fchmod:function(fd, mode) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + },chown:function(path, uid, gid, dontFollow) { + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + timestamp: Date.now() + // we ignore the uid / gid for now + }); + },lchown:function(path, uid, gid) { + FS.chown(path, uid, gid, true); + },fchown:function(fd, uid, gid) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + },truncate:function(path, len) { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path === 'string') { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, 'w'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }); + },ftruncate:function(fd, len) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + },utime:function(path, atime, mtime) { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }); + },open:function(path, flags, mode, fd_start, fd_end) { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode; + if ((flags & 64)) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path === 'object') { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node; + } catch (e) { + // ignore + } + } + // perhaps we need to create the node + var created = false; + if ((flags & 64)) { + if (node) { + // if O_CREAT and O_EXCL are set, error out if the node already exists + if ((flags & 128)) { + throw new FS.ErrnoError(20); + } + } else { + // node doesn't exist, try to create it + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + // can't truncate a device + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + // if asked only for a directory, then this must be one + if ((flags & 65536) && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + // check permissions, if this is not a file we just created now (it is ok to + // create and write to a file with read-only permissions; it is read-only + // for later use) + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + // do truncation if necessary + if ((flags & 512)) { + FS.truncate(node, 0); + } + // we've already handled these, don't pass down to the underlying vfs + flags &= ~(128 | 512 | 131072); + + // register the stream with the filesystem + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), // we want the absolute path to the node + id: node.id, + flags: flags, + mode: node.mode, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + node_ops: node.node_ops, + // used by the file family libc calls (fopen, fwrite, ferror, etc.) + ungotten: [], + error: false + }, fd_start, fd_end); + // call the new stream's open function + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module['logReadFiles'] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + },close:function(stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; // free readdir state + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + },isClosed:function(stream) { + return stream.fd === null; + },llseek:function(stream, offset, whence) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + },read:function(stream, buffer, offset, length, position) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position !== 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + },write:function(stream, buffer, offset, length, position, canOwn) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + // seek to the end before writing in append mode + FS.llseek(stream, 0, 2); + } + var seeking = typeof position !== 'undefined'; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + },allocate:function(stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + },mmap:function(stream, address, length, position, prot, flags) { + // 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, address, length, position, prot, flags); + },msync:function(stream, buffer, offset, length, mmapFlags) { + if (!stream || !stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + },munmap:function(stream) { + return 0; + },ioctl:function(stream, cmd, arg) { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + },readFile:function(path, opts = {}) { + opts.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:function(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:function() { + return FS.currentPath; + },chdir:function(path) { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, 'x'); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + },createDefaultDirectories:function() { + FS.mkdir('/tmp'); + FS.mkdir('/home'); + FS.mkdir('/home/web_user'); + },createDefaultDevices:function() { + // create /dev + FS.mkdir('/dev'); + // setup /dev/null + FS.registerDevice(FS.makedev(1, 3), { + read: function() { return 0; }, + write: function(stream, buffer, offset, length, pos) { return length; } + }); + FS.mkdev('/dev/null', FS.makedev(1, 3)); + // setup /dev/tty and /dev/tty1 + // stderr needs to print output using 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:function() { + // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the + // name of the stream for fd 6 (see test_unistd_ttyname) + FS.mkdir('/proc'); + var proc_self = FS.mkdir('/proc/self'); + FS.mkdir('/proc/self/fd'); + FS.mount({ + mount: function() { + var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73); + node.node_ops = { + lookup: function(parent, name) { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { readlink: function() { return stream.path } } + }; + ret.parent = ret; // make it look like a simple root node + return ret; + } + }; + return node; + } + }, {}, '/proc/self/fd'); + },createStandardStreams:function() { + // TODO deprecate the old functionality of a single + // input / output callback and that utilizes FS.createDevice + // and instead require a unique set of stream ops + + // by default, we symlink the standard streams to the + // default tty devices. however, if the standard streams + // have been overwritten we create a unique device for + // them instead. + if (Module['stdin']) { + FS.createDevice('/dev', 'stdin', Module['stdin']); + } else { + FS.symlink('/dev/tty', '/dev/stdin'); + } + if (Module['stdout']) { + FS.createDevice('/dev', 'stdout', null, Module['stdout']); + } else { + FS.symlink('/dev/tty', '/dev/stdout'); + } + if (Module['stderr']) { + FS.createDevice('/dev', 'stderr', null, Module['stderr']); + } else { + FS.symlink('/dev/tty1', '/dev/stderr'); + } + + // open default streams for the stdin, stdout and stderr devices + var stdin = FS.open('/dev/stdin', 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:function() { + if (FS.ErrnoError) return; + FS.ErrnoError = /** @this{Object} */ function ErrnoError(errno, node) { + this.node = node; + this.setErrno = /** @this{Object} */ function(errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + + // Try to get a maximally helpful stack trace. On Node.js, getting Error.stack + // now ensures it shows what we want. + if (this.stack) { + // Define the stack property for Node.js 4, which otherwise errors on the next line. + Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) + [44].forEach(function(code) { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ''; + }); + },staticInit:function() { + FS.ensureErrnoError(); + + FS.nameTable = new Array(4096); + + FS.mount(MEMFS, {}, '/'); + + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + + FS.filesystems = { + 'MEMFS': MEMFS, + }; + },init:function(input, output, error) { + assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'); + FS.init.initialized = true; + + FS.ensureErrnoError(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + Module['stdin'] = input || Module['stdin']; + Module['stdout'] = output || Module['stdout']; + Module['stderr'] = error || Module['stderr']; + + FS.createStandardStreams(); + },quit:function() { + FS.init.initialized = false; + // force-flush all streams, so we get musl std streams printed out + _fflush(0); + // close all of our streams + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + },getMode:function(canRead, canWrite) { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + },findObject:function(path, dontResolveLastLink) { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + return null; + } + },analyzePath:function(path, dontResolveLastLink) { + // operate from within the context of the symlink's target + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) { + } + var ret = { + isRoot: false, exists: false, error: 0, name: null, path: null, object: null, + parentExists: false, parentPath: null, parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === '/'; + } catch (e) { + ret.error = e.errno; + }; + return ret; + },createPath:function(parent, path, canRead, canWrite) { + parent = typeof parent === 'string' ? parent : FS.getPath(parent); + var parts = path.split('/').reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + // ignore EEXIST + } + parent = current; + } + return current; + },createFile:function(parent, name, properties, canRead, canWrite) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + },createDataFile:function(parent, name, data, canRead, canWrite, canOwn) { + var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent; + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data === 'string') { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + // make sure we can write to the file + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + },createDevice:function(parent, name, input, output) { + var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + // Create a fake device that a set of stream ops to emulate + // the old behavior. + FS.registerDevice(dev, { + open: function(stream) { + stream.seekable = false; + }, + close: function(stream) { + // flush any pending line data + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: function(stream, buffer, offset, length, pos /* ignored */) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset+i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: function(stream, buffer, offset, length, pos) { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset+i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + } + }); + return FS.mkdev(path, mode, dev); + },forceLoadFile:function(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:function(parent, name, url, canRead, canWrite) { + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + /** @constructor */ + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = /** @this{Object} */ function LazyUint8Array_get(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize)|0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + + var chunkSize = 1024*1024; // Chunk size in bytes + + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (function(from, to) { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(/** @type{Array} */(xhr.response || [])); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }); + var lazyArray = this; + lazyArray.setDataGetter(function(chunkNum) { + var start = chunkNum * chunkSize; + var end = (chunkNum+1) * chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum]; + }); + + if (usesGzip || !datalength) { + // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length + chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest !== 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + } + }, + chunkSize: { + get: /** @this{Object} */ function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + } + } + }); + + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + var node = FS.createFile(parent, name, properties, canRead, canWrite); + // This is a total hack, but I want to get this lazy file code out of the + // core of MEMFS. If we want to keep this lazy file concept I feel it should + // be its own thin LAZYFS proxying calls to MEMFS. + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + // Add a function that defers querying the file size until it is asked the first time. + Object.defineProperties(node, { + usedBytes: { + get: /** @this {FSNode} */ function() { return this.contents.length; } + } + }); + // override each stream op with one that tries to force load the lazy file first + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(function(key) { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + // use a custom read function + stream_ops.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:function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + Browser.init(); // XXX perhaps this method should move onto Browser? + // TODO we should allow people to just pass in a complete filename instead + // of parent and name being that we just join them anyways + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + var handled = false; + Module['preloadPlugins'].forEach(function(plugin) { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, function() { + if (onerror) onerror(); + removeRunDependency(dep); + }); + handled = true; + } + }); + if (!handled) finish(byteArray); + } + addRunDependency(dep); + if (typeof url == 'string') { + asyncLoad(url, function(byteArray) { + processData(byteArray); + }, onerror); + } else { + processData(url); + } + },indexedDB:function() { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + },DB_NAME:function() { + return 'EM_FS_' + window.location.pathname; + },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function(paths, onload, onerror) { + onload = onload || function(){}; + onerror = onerror || function(){}; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = function openRequest_onupgradeneeded() { + out('creating db'); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite'); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach(function(path) { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() }; + putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },loadFilesFromDB:function(paths, onload, onerror) { + onload = onload || function(){}; + onerror = onerror || function(){}; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; // no database to load from + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly'); + } catch(e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) onload(); else onerror(); + } + paths.forEach(function(path) { + var getRequest = files.get(path); + getRequest.onsuccess = function getRequest_onsuccess() { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) finish(); + }; + getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + },absolutePath:function() { + abort('FS.absolutePath has been removed; use PATH_FS.resolve instead'); + },createFolder:function() { + abort('FS.createFolder has been removed; use FS.mkdir instead'); + },createLink:function() { + abort('FS.createLink has been removed; use FS.symlink instead'); + },joinPath:function() { + abort('FS.joinPath has been removed; use PATH.join instead'); + },mmapAlloc:function() { + abort('FS.mmapAlloc has been replaced by the top level function mmapAlloc'); + },standardizePath:function() { + abort('FS.standardizePath has been removed; use PATH.normalize instead'); + }}; + var SYSCALLS = {mappings:{},DEFAULT_POLLMASK:5,calculateAt:function(dirfd, path, allowEmpty) { + if (path[0] === '/') { + 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); + },doMkdir:function(path, mode) { + // remove a trailing slash, if one - /a/b/ has basename of '', but + // we want to create b in the context of this function + path = PATH.normalize(path); + if (path[path.length-1] === '/') path = path.substr(0, path.length-1); + FS.mkdir(path, mode, 0); + return 0; + },doMknod:function(path, mode, dev) { + // we don't want this in the JS API as it uses mknod to create all nodes. + switch (mode & 61440) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: return -28; + } + FS.mknod(path, mode, dev); + return 0; + },doReadlink:function(path, buf, bufsize) { + if (bufsize <= 0) return -28; + var ret = FS.readlink(path); + + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf+len]; + stringToUTF8(ret, buf, bufsize+1); + // readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!) + // stringToUTF8() always appends a null byte, so restore the character under the null byte after the write. + HEAP8[buf+len] = endChar; + + return len; + },doAccess:function(path, amode) { + if (amode & ~7) { + // need a valid mode + return -28; + } + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node) { + return -44; + } + var perms = ''; + if (amode & 4) perms += 'r'; + if (amode & 2) perms += 'w'; + if (amode & 1) perms += 'x'; + if (perms /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + },doDup:function(path, flags, suggestFD) { + var suggest = FS.getStream(suggestFD); + if (suggest) FS.close(suggest); + return FS.open(path, flags, 0, suggestFD, suggestFD).fd; + },doReadv:function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + var curr = FS.read(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; // nothing more to read + } + return ret; + },doWritev:function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + var curr = FS.write(stream, HEAP8,ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + },varargs:undefined,get:function() { + assert(SYSCALLS.varargs != undefined); + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + },getStreamFromFD:function(fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + },get64:function(low, high) { + if (low >= 0) assert(high === 0); + else assert(high === -1); + return low; + }}; + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAP32[(((__environ)+(i * 4))>>2)] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } + + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAP32[((penviron_count)>>2)] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAP32[((penviron_buf_size)>>2)] = bufSize; + return 0; + } + + function _fd_close(fd) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_read(fd, iov, iovcnt, pnum) {try { + + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doReadv(stream, iov, iovcnt); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {try { + + + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 0x100000000; // 2^32 + // use an unsigned operator on low and shift high by 32-bits + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + + var DOUBLE_LIMIT = 0x20000000000000; // 2^53 + // we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT + if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) { + return -61; + } + + FS.llseek(stream, offset, whence); + (tempI64 = [stream.position>>>0,(tempDouble=stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + + function _fd_write(fd, iov, iovcnt, pnum) {try { + + ; + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doWritev(stream, iov, iovcnt); + HEAP32[((pnum)>>2)] = num; + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) 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++]) { + // no-op + } + return sum; + } + + var __MONTH_DAYS_LEAP = [31,29,31,30,31,30,31,31,30,31,30,31]; + + var __MONTH_DAYS_REGULAR = [31,28,31,30,31,30,31,31,30,31,30,31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + + if (days > daysInCurrentMonth-newDate.getDate()) { + // we spill over to next month + days -= (daysInCurrentMonth-newDate.getDate()+1); + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth+1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear()+1); + } + } else { + // we stay in current month + newDate.setDate(newDate.getDate()+days); + return newDate; + } + } + + return newDate; + } + function _strftime(s, maxsize, format, tm) { + // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html + + var tm_zone = HEAP32[(((tm)+(40))>>2)]; + + var date = { + tm_sec: HEAP32[((tm)>>2)], + tm_min: HEAP32[(((tm)+(4))>>2)], + tm_hour: HEAP32[(((tm)+(8))>>2)], + tm_mday: HEAP32[(((tm)+(12))>>2)], + tm_mon: HEAP32[(((tm)+(16))>>2)], + tm_year: HEAP32[(((tm)+(20))>>2)], + tm_wday: HEAP32[(((tm)+(24))>>2)], + tm_yday: HEAP32[(((tm)+(28))>>2)], + tm_isdst: HEAP32[(((tm)+(32))>>2)], + tm_gmtoff: HEAP32[(((tm)+(36))>>2)], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : '' + }; + + var pattern = UTF8ToString(format); + + // expand format + var EXPANSION_RULES_1 = { + '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013 + '%D': '%m/%d/%y', // Equivalent to %m / %d / %y + '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d + '%h': '%b', // Equivalent to %b + '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation + '%R': '%H:%M', // Replaced by the time in 24-hour notation + '%T': '%H:%M:%S', // Replaced by the time + '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation + '%X': '%H:%M:%S', // Replaced by the locale's appropriate time representation + // Modified Conversion Specifiers + '%Ec': '%c', // Replaced by the locale's alternative appropriate date and time representation. + '%EC': '%C', // Replaced by the name of the base year (period) in the locale's alternative representation. + '%Ex': '%m/%d/%y', // Replaced by the locale's alternative date representation. + '%EX': '%H:%M:%S', // Replaced by the locale's alternative time representation. + '%Ey': '%y', // Replaced by the offset from %EC (year only) in the locale's alternative representation. + '%EY': '%Y', // Replaced by the full alternative year representation. + '%Od': '%d', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading characters. + '%Oe': '%e', // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading characters. + '%OH': '%H', // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols. + '%OI': '%I', // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols. + '%Om': '%m', // Replaced by the month using the locale's alternative numeric symbols. + '%OM': '%M', // Replaced by the minutes using the locale's alternative numeric symbols. + '%OS': '%S', // Replaced by the seconds using the locale's alternative numeric symbols. + '%Ou': '%u', // Replaced by the weekday as a number in the locale's alternative representation (Monday=1). + '%OU': '%U', // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols. + '%OV': '%V', // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols. + '%Ow': '%w', // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols. + '%OW': '%W', // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols. + '%Oy': '%y', // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols. + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]); + } + + var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']; + var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']; + + function leadingSomething(value, digits, character) { + var str = typeof value === 'number' ? value.toString() : (value || ''); + while (str.length < digits) { + str = character[0]+str; + } + return str; + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, '0'); + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : (value > 0 ? 1 : 0); + } + + var compare; + if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) { + compare = sgn(date1.getDate()-date2.getDate()); + } + } + return compare; + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: // Sunday + return new Date(janFourth.getFullYear()-1, 11, 29); + case 1: // Monday + return janFourth; + case 2: // Tuesday + return new Date(janFourth.getFullYear(), 0, 3); + case 3: // Wednesday + return new Date(janFourth.getFullYear(), 0, 2); + case 4: // Thursday + return new Date(janFourth.getFullYear(), 0, 1); + case 5: // Friday + return new Date(janFourth.getFullYear()-1, 11, 31); + case 6: // Saturday + return new Date(janFourth.getFullYear()-1, 11, 30); + } + } + + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + // this date is after the start of the first week of this year + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear()+1; + } else { + return thisDate.getFullYear(); + } + } else { + return thisDate.getFullYear()-1; + } + } + + var EXPANSION_RULES_2 = { + '%a': function(date) { + return WEEKDAYS[date.tm_wday].substring(0,3); + }, + '%A': function(date) { + return WEEKDAYS[date.tm_wday]; + }, + '%b': function(date) { + return MONTHS[date.tm_mon].substring(0,3); + }, + '%B': function(date) { + return MONTHS[date.tm_mon]; + }, + '%C': function(date) { + var year = date.tm_year+1900; + return leadingNulls((year/100)|0,2); + }, + '%d': function(date) { + return leadingNulls(date.tm_mday, 2); + }, + '%e': function(date) { + return leadingSomething(date.tm_mday, 2, ' '); + }, + '%g': function(date) { + // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year. + // In this system, weeks begin on a Monday and week 1 of the year is the week that includes + // January 4th, which is also the week that includes the first Thursday of the year, and + // is also the first week that contains at least four days in the year. + // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of + // the last week of the preceding year; thus, for Saturday 2nd January 1999, + // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th, + // or 31st is a Monday, it and any following days are part of week 1 of the following year. + // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01. + + return getWeekBasedYear(date).toString().substring(2); + }, + '%G': function(date) { + return getWeekBasedYear(date); + }, + '%H': function(date) { + return leadingNulls(date.tm_hour, 2); + }, + '%I': function(date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + '%j': function(date) { + // Day of the year (001-366) + return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3); + }, + '%m': function(date) { + return leadingNulls(date.tm_mon+1, 2); + }, + '%M': function(date) { + return leadingNulls(date.tm_min, 2); + }, + '%n': function() { + return '\n'; + }, + '%p': function(date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return 'AM'; + } else { + return 'PM'; + } + }, + '%S': function(date) { + return leadingNulls(date.tm_sec, 2); + }, + '%t': function() { + return '\t'; + }, + '%u': function(date) { + return date.tm_wday || 7; + }, + '%U': function(date) { + // Replaced by the week number of the year as a decimal number [00,53]. + // The first Sunday of January is the first day of week 1; + // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday] + var janFirst = new Date(date.tm_year+1900, 0, 1); + var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7-janFirst.getDay()); + var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday); + + // is target date after the first Sunday? + if (compareByDay(firstSunday, endDate) < 0) { + // calculate difference in days between first Sunday and endDate + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31; + var firstSundayUntilEndJanuary = 31-firstSunday.getDate(); + var days = firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate(); + return leadingNulls(Math.ceil(days/7), 2); + } + + return compareByDay(firstSunday, janFirst) === 0 ? '01': '00'; + }, + '%V': function(date) { + // Replaced by the week number of the year (Monday as the first day of the week) + // as a decimal number [01,53]. If the week containing 1 January has four + // or more days in the new year, then it is considered week 1. + // Otherwise, it is the last week of the previous year, and the next week is week 1. + // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday] + var janFourthThisYear = new Date(date.tm_year+1900, 0, 4); + var janFourthNextYear = new Date(date.tm_year+1901, 0, 4); + + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + + var endDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday); + + if (compareByDay(endDate, firstWeekStartThisYear) < 0) { + // if given date is before this years first week, then it belongs to the 53rd week of last year + return '53'; + } + + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + // if given date is after next years first week, then it belongs to the 01th week of next year + return '01'; + } + + // given date is in between CW 01..53 of this calendar year + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date.tm_year+1900) { + // first CW of this year starts last year + daysDifference = date.tm_yday+32-firstWeekStartThisYear.getDate() + } else { + // first CW of this year starts this year + daysDifference = date.tm_yday+1-firstWeekStartThisYear.getDate(); + } + return leadingNulls(Math.ceil(daysDifference/7), 2); + }, + '%w': function(date) { + return date.tm_wday; + }, + '%W': function(date) { + // Replaced by the week number of the year as a decimal number [00,53]. + // The first Monday of January is the first day of week 1; + // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday] + var janFirst = new Date(date.tm_year, 0, 1); + var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1); + var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday); + + // is target date after the first Monday? + if (compareByDay(firstMonday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31; + var firstMondayUntilEndJanuary = 31-firstMonday.getDate(); + var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate(); + return leadingNulls(Math.ceil(days/7), 2); + } + return compareByDay(firstMonday, janFirst) === 0 ? '01': '00'; + }, + '%y': function(date) { + // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year] + return (date.tm_year+1900).toString().substring(2); + }, + '%Y': function(date) { + // Replaced by the year as a decimal number (for example, 1997). [ tm_year] + return date.tm_year+1900; + }, + '%z': function(date) { + // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ). + // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich). + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + // convert from minutes into hhmm format (which means 60 minutes = 100 units) + off = (off / 60)*100 + (off % 60); + return (ahead ? '+' : '-') + String("0000" + off).slice(-4); + }, + '%Z': function(date) { + return date.tm_zone; + }, + '%%': function() { + return '%'; + } + }; + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date)); + } + } + + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + + writeArrayToMemory(bytes, s); + return bytes.length-1; + } + function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm); // no locale support yet + } + + 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();; +ERRNO_CODES = { + 'EPERM': 63, + 'ENOENT': 44, + 'ESRCH': 71, + 'EINTR': 27, + 'EIO': 29, + 'ENXIO': 60, + 'E2BIG': 1, + 'ENOEXEC': 45, + 'EBADF': 8, + 'ECHILD': 12, + 'EAGAIN': 6, + 'EWOULDBLOCK': 6, + 'ENOMEM': 48, + 'EACCES': 2, + 'EFAULT': 21, + 'ENOTBLK': 105, + 'EBUSY': 10, + 'EEXIST': 20, + 'EXDEV': 75, + 'ENODEV': 43, + 'ENOTDIR': 54, + 'EISDIR': 31, + 'EINVAL': 28, + 'ENFILE': 41, + 'EMFILE': 33, + 'ENOTTY': 59, + 'ETXTBSY': 74, + 'EFBIG': 22, + 'ENOSPC': 51, + 'ESPIPE': 70, + 'EROFS': 69, + 'EMLINK': 34, + 'EPIPE': 64, + 'EDOM': 18, + 'ERANGE': 68, + 'ENOMSG': 49, + 'EIDRM': 24, + 'ECHRNG': 106, + 'EL2NSYNC': 156, + 'EL3HLT': 107, + 'EL3RST': 108, + 'ELNRNG': 109, + 'EUNATCH': 110, + 'ENOCSI': 111, + 'EL2HLT': 112, + 'EDEADLK': 16, + 'ENOLCK': 46, + 'EBADE': 113, + 'EBADR': 114, + 'EXFULL': 115, + 'ENOANO': 104, + 'EBADRQC': 103, + 'EBADSLT': 102, + 'EDEADLOCK': 16, + 'EBFONT': 101, + 'ENOSTR': 100, + 'ENODATA': 116, + 'ETIME': 117, + 'ENOSR': 118, + 'ENONET': 119, + 'ENOPKG': 120, + 'EREMOTE': 121, + 'ENOLINK': 47, + 'EADV': 122, + 'ESRMNT': 123, + 'ECOMM': 124, + 'EPROTO': 65, + 'EMULTIHOP': 36, + 'EDOTDOT': 125, + 'EBADMSG': 9, + 'ENOTUNIQ': 126, + 'EBADFD': 127, + 'EREMCHG': 128, + 'ELIBACC': 129, + 'ELIBBAD': 130, + 'ELIBSCN': 131, + 'ELIBMAX': 132, + 'ELIBEXEC': 133, + 'ENOSYS': 52, + 'ENOTEMPTY': 55, + 'ENAMETOOLONG': 37, + 'ELOOP': 32, + 'EOPNOTSUPP': 138, + 'EPFNOSUPPORT': 139, + 'ECONNRESET': 15, + 'ENOBUFS': 42, + 'EAFNOSUPPORT': 5, + 'EPROTOTYPE': 67, + 'ENOTSOCK': 57, + 'ENOPROTOOPT': 50, + 'ESHUTDOWN': 140, + 'ECONNREFUSED': 14, + 'EADDRINUSE': 3, + 'ECONNABORTED': 13, + 'ENETUNREACH': 40, + 'ENETDOWN': 38, + 'ETIMEDOUT': 73, + 'EHOSTDOWN': 142, + 'EHOSTUNREACH': 23, + 'EINPROGRESS': 26, + 'EALREADY': 7, + 'EDESTADDRREQ': 17, + 'EMSGSIZE': 35, + 'EPROTONOSUPPORT': 66, + 'ESOCKTNOSUPPORT': 137, + 'EADDRNOTAVAIL': 4, + 'ENETRESET': 39, + 'EISCONN': 30, + 'ENOTCONN': 53, + 'ETOOMANYREFS': 141, + 'EUSERS': 136, + 'EDQUOT': 19, + 'ESTALE': 72, + 'ENOTSUP': 138, + 'ENOMEDIUM': 148, + 'EILSEQ': 25, + 'EOVERFLOW': 61, + 'ECANCELED': 11, + 'ENOTRECOVERABLE': 56, + 'EOWNERDEAD': 62, + 'ESTRPIPE': 135, + };; +var 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(''); +} + + +var asmLibraryArg = { + "__cxa_allocate_exception": ___cxa_allocate_exception, + "__cxa_throw": ___cxa_throw, + "abort": _abort, + "emscripten_memcpy_big": _emscripten_memcpy_big, + "emscripten_resize_heap": _emscripten_resize_heap, + "environ_get": _environ_get, + "environ_sizes_get": _environ_sizes_get, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_write": _fd_write, + "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 _Encoder_new = Module["_Encoder_new"] = createExportWrapper("Encoder_new"); + +/** @type {function(...*):?} */ +var _Encoder_delete = Module["_Encoder_delete"] = createExportWrapper("Encoder_delete"); + +/** @type {function(...*):?} */ +var _Encoder_input = Module["_Encoder_input"] = createExportWrapper("Encoder_input"); + +/** @type {function(...*):?} */ +var _Encoder_output = Module["_Encoder_output"] = createExportWrapper("Encoder_output"); + +/** @type {function(...*):?} */ +var _Decoder_new = Module["_Decoder_new"] = createExportWrapper("Decoder_new"); + +/** @type {function(...*):?} */ +var _Decoder_delete = Module["_Decoder_delete"] = createExportWrapper("Decoder_delete"); + +/** @type {function(...*):?} */ +var _Decoder_input = Module["_Decoder_input"] = createExportWrapper("Decoder_input"); + +/** @type {function(...*):?} */ +var _Decoder_output = Module["_Decoder_output"] = createExportWrapper("Decoder_output"); + +/** @type {function(...*):?} */ +var _String_size = Module["_String_size"] = createExportWrapper("String_size"); + +/** @type {function(...*):?} */ +var _String_new = Module["_String_new"] = createExportWrapper("String_new"); + +/** @type {function(...*):?} */ +var _String_data = Module["_String_data"] = createExportWrapper("String_data"); + +/** @type {function(...*):?} */ +var _String_delete = Module["_String_delete"] = createExportWrapper("String_delete"); + +/** @type {function(...*):?} */ +var _Int16Array_size = Module["_Int16Array_size"] = createExportWrapper("Int16Array_size"); + +/** @type {function(...*):?} */ +var _Int16Array_new = Module["_Int16Array_new"] = createExportWrapper("Int16Array_new"); + +/** @type {function(...*):?} */ +var _Int16Array_data = Module["_Int16Array_data"] = createExportWrapper("Int16Array_data"); + +/** @type {function(...*):?} */ +var _Int16Array_delete = Module["_Int16Array_delete"] = createExportWrapper("Int16Array_delete"); + +/** @type {function(...*):?} */ +var _malloc = Module["_malloc"] = createExportWrapper("malloc"); + +/** @type {function(...*):?} */ +var _free = Module["_free"] = createExportWrapper("free"); + +/** @type {function(...*):?} */ +var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location"); + +/** @type {function(...*):?} */ +var _fflush = Module["_fflush"] = createExportWrapper("fflush"); + +/** @type {function(...*):?} */ +var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() { + return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments); +}; + +/** @type {function(...*):?} */ +var _emscripten_stack_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_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 dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii"); + +/** @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_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj"); + +/** @type {function(...*):?} */ +var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj"); + + + + + +// === Auto-generated postamble setup entry stuff === + +if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString")) Module["intArrayFromString"] = () => abort("'intArrayFromString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString")) Module["intArrayToString"] = () => abort("'intArrayToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "ccall")) Module["ccall"] = () => abort("'ccall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "cwrap")) Module["cwrap"] = () => abort("'cwrap' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setValue")) Module["setValue"] = () => abort("'setValue' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getValue")) Module["getValue"] = () => abort("'getValue' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "allocate")) Module["allocate"] = () => abort("'allocate' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString")) Module["UTF8ArrayToString"] = () => abort("'UTF8ArrayToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString")) Module["UTF8ToString"] = () => abort("'UTF8ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = () => abort("'stringToUTF8Array' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = () => abort("'stringToUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8")) Module["lengthBytesUTF8"] = () => abort("'lengthBytesUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = () => abort("'stackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun")) Module["addOnPreRun"] = () => abort("'addOnPreRun' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addOnInit")) Module["addOnInit"] = () => abort("'addOnInit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain")) Module["addOnPreMain"] = () => abort("'addOnPreMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = () => abort("'addOnExit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun")) Module["addOnPostRun"] = () => abort("'addOnPostRun' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory")) Module["writeStringToMemory"] = () => abort("'writeStringToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory")) Module["writeArrayToMemory"] = () => abort("'writeArrayToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory")) Module["writeAsciiToMemory"] = () => abort("'writeAsciiToMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency")) Module["addRunDependency"] = () => abort("'addRunDependency' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "removeRunDependency")) Module["removeRunDependency"] = () => abort("'removeRunDependency' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createFolder")) Module["FS_createFolder"] = () => abort("'FS_createFolder' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath")) Module["FS_createPath"] = () => abort("'FS_createPath' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createDataFile")) Module["FS_createDataFile"] = () => abort("'FS_createDataFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createPreloadedFile")) Module["FS_createPreloadedFile"] = () => abort("'FS_createPreloadedFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createLazyFile")) Module["FS_createLazyFile"] = () => abort("'FS_createLazyFile' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createLink")) Module["FS_createLink"] = () => abort("'FS_createLink' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice")) Module["FS_createDevice"] = () => abort("'FS_createDevice' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "FS_unlink")) Module["FS_unlink"] = () => abort("'FS_unlink' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); +if (!Object.getOwnPropertyDescriptor(Module, "getLEB")) Module["getLEB"] = () => abort("'getLEB' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables")) Module["getFunctionTables"] = () => abort("'getFunctionTables' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables")) Module["alignFunctionTables"] = () => abort("'alignFunctionTables' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions")) Module["registerFunctions"] = () => abort("'registerFunctions' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "addFunction")) Module["addFunction"] = () => abort("'addFunction' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "removeFunction")) Module["removeFunction"] = () => abort("'removeFunction' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = () => abort("'getFuncWrapper' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint")) Module["prettyPrint"] = () => abort("'prettyPrint' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = () => abort("'dynCall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting")) Module["getCompilerSetting"] = () => abort("'getCompilerSetting' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "print")) Module["print"] = () => abort("'print' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "printErr")) Module["printErr"] = () => abort("'printErr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0")) Module["getTempRet0"] = () => abort("'getTempRet0' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0")) Module["setTempRet0"] = () => abort("'setTempRet0' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "callMain")) Module["callMain"] = () => abort("'callMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "abort")) Module["abort"] = () => abort("'abort' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "keepRuntimeAlive")) Module["keepRuntimeAlive"] = () => abort("'keepRuntimeAlive' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "zeroMemory")) Module["zeroMemory"] = () => abort("'zeroMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8")) Module["stringToNewUTF8"] = () => abort("'stringToNewUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setFileTime")) Module["setFileTime"] = () => abort("'setFileTime' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "abortOnCannotGrowMemory")) Module["abortOnCannotGrowMemory"] = () => abort("'abortOnCannotGrowMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer")) Module["emscripten_realloc_buffer"] = () => abort("'emscripten_realloc_buffer' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "ENV")) Module["ENV"] = () => abort("'ENV' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "withStackSave")) Module["withStackSave"] = () => abort("'withStackSave' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES")) Module["ERRNO_CODES"] = () => abort("'ERRNO_CODES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES")) Module["ERRNO_MESSAGES"] = () => abort("'ERRNO_MESSAGES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setErrNo")) Module["setErrNo"] = () => abort("'setErrNo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "inetPton4")) Module["inetPton4"] = () => abort("'inetPton4' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "inetNtop4")) Module["inetNtop4"] = () => abort("'inetNtop4' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "inetPton6")) Module["inetPton6"] = () => abort("'inetPton6' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "inetNtop6")) Module["inetNtop6"] = () => abort("'inetNtop6' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "readSockaddr")) Module["readSockaddr"] = () => abort("'readSockaddr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeSockaddr")) Module["writeSockaddr"] = () => abort("'writeSockaddr' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "DNS")) Module["DNS"] = () => abort("'DNS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getHostByName")) Module["getHostByName"] = () => abort("'getHostByName' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "GAI_ERRNO_MESSAGES")) Module["GAI_ERRNO_MESSAGES"] = () => abort("'GAI_ERRNO_MESSAGES' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "Protocols")) Module["Protocols"] = () => abort("'Protocols' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "Sockets")) Module["Sockets"] = () => abort("'Sockets' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getRandomDevice")) Module["getRandomDevice"] = () => abort("'getRandomDevice' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "traverseStack")) Module["traverseStack"] = () => abort("'traverseStack' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "convertFrameToPC")) Module["convertFrameToPC"] = () => abort("'convertFrameToPC' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE")) Module["UNWIND_CACHE"] = () => abort("'UNWIND_CACHE' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "saveInUnwindCache")) Module["saveInUnwindCache"] = () => abort("'saveInUnwindCache' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "convertPCtoSourceLocation")) Module["convertPCtoSourceLocation"] = () => abort("'convertPCtoSourceLocation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray")) Module["readAsmConstArgsArray"] = () => abort("'readAsmConstArgsArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs")) Module["readAsmConstArgs"] = () => abort("'readAsmConstArgs' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "mainThreadEM_ASM")) Module["mainThreadEM_ASM"] = () => abort("'mainThreadEM_ASM' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q")) Module["jstoi_q"] = () => abort("'jstoi_q' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s")) Module["jstoi_s"] = () => abort("'jstoi_s' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getExecutableName")) Module["getExecutableName"] = () => abort("'getExecutableName' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "listenOnce")) Module["listenOnce"] = () => abort("'listenOnce' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext")) Module["autoResumeAudioContext"] = () => abort("'autoResumeAudioContext' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "dynCallLegacy")) Module["dynCallLegacy"] = () => abort("'dynCallLegacy' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getDynCaller")) Module["getDynCaller"] = () => abort("'getDynCaller' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = () => abort("'dynCall' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "callRuntimeCallbacks")) Module["callRuntimeCallbacks"] = () => abort("'callRuntimeCallbacks' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "wasmTableMirror")) Module["wasmTableMirror"] = () => abort("'wasmTableMirror' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setWasmTableEntry")) Module["setWasmTableEntry"] = () => abort("'setWasmTableEntry' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getWasmTableEntry")) Module["getWasmTableEntry"] = () => abort("'getWasmTableEntry' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "handleException")) Module["handleException"] = () => abort("'handleException' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePush")) Module["runtimeKeepalivePush"] = () => abort("'runtimeKeepalivePush' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePop")) Module["runtimeKeepalivePop"] = () => abort("'runtimeKeepalivePop' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "callUserCallback")) Module["callUserCallback"] = () => abort("'callUserCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "maybeExit")) Module["maybeExit"] = () => abort("'maybeExit' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "safeSetTimeout")) Module["safeSetTimeout"] = () => abort("'safeSetTimeout' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "asmjsMangle")) Module["asmjsMangle"] = () => abort("'asmjsMangle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "asyncLoad")) Module["asyncLoad"] = () => abort("'asyncLoad' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "alignMemory")) Module["alignMemory"] = () => abort("'alignMemory' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "mmapAlloc")) Module["mmapAlloc"] = () => abort("'mmapAlloc' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "reallyNegative")) Module["reallyNegative"] = () => abort("'reallyNegative' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "unSign")) Module["unSign"] = () => abort("'unSign' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "reSign")) Module["reSign"] = () => abort("'reSign' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "formatString")) Module["formatString"] = () => abort("'formatString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "PATH")) Module["PATH"] = () => abort("'PATH' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS")) Module["PATH_FS"] = () => abort("'PATH_FS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS")) Module["SYSCALLS"] = () => abort("'SYSCALLS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "syscallMmap2")) Module["syscallMmap2"] = () => abort("'syscallMmap2' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "syscallMunmap")) Module["syscallMunmap"] = () => abort("'syscallMunmap' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getSocketFromFD")) Module["getSocketFromFD"] = () => abort("'getSocketFromFD' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getSocketAddress")) Module["getSocketAddress"] = () => abort("'getSocketAddress' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "JSEvents")) Module["JSEvents"] = () => abort("'JSEvents' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerKeyEventCallback")) Module["registerKeyEventCallback"] = () => abort("'registerKeyEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "specialHTMLTargets")) Module["specialHTMLTargets"] = () => abort("'specialHTMLTargets' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "maybeCStringToJsString")) Module["maybeCStringToJsString"] = () => abort("'maybeCStringToJsString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget")) Module["findEventTarget"] = () => abort("'findEventTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget")) Module["findCanvasEventTarget"] = () => abort("'findCanvasEventTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getBoundingClientRect")) Module["getBoundingClientRect"] = () => abort("'getBoundingClientRect' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillMouseEventData")) Module["fillMouseEventData"] = () => abort("'fillMouseEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerMouseEventCallback")) Module["registerMouseEventCallback"] = () => abort("'registerMouseEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerWheelEventCallback")) Module["registerWheelEventCallback"] = () => abort("'registerWheelEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerUiEventCallback")) Module["registerUiEventCallback"] = () => abort("'registerUiEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerFocusEventCallback")) Module["registerFocusEventCallback"] = () => abort("'registerFocusEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceOrientationEventData")) Module["fillDeviceOrientationEventData"] = () => abort("'fillDeviceOrientationEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceOrientationEventCallback")) Module["registerDeviceOrientationEventCallback"] = () => abort("'registerDeviceOrientationEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceMotionEventData")) Module["fillDeviceMotionEventData"] = () => abort("'fillDeviceMotionEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceMotionEventCallback")) Module["registerDeviceMotionEventCallback"] = () => abort("'registerDeviceMotionEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "screenOrientation")) Module["screenOrientation"] = () => abort("'screenOrientation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillOrientationChangeEventData")) Module["fillOrientationChangeEventData"] = () => abort("'fillOrientationChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerOrientationChangeEventCallback")) Module["registerOrientationChangeEventCallback"] = () => abort("'registerOrientationChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillFullscreenChangeEventData")) Module["fillFullscreenChangeEventData"] = () => abort("'fillFullscreenChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerFullscreenChangeEventCallback")) Module["registerFullscreenChangeEventCallback"] = () => abort("'registerFullscreenChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerRestoreOldStyle")) Module["registerRestoreOldStyle"] = () => abort("'registerRestoreOldStyle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "hideEverythingExceptGivenElement")) Module["hideEverythingExceptGivenElement"] = () => abort("'hideEverythingExceptGivenElement' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "restoreHiddenElements")) Module["restoreHiddenElements"] = () => abort("'restoreHiddenElements' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setLetterbox")) Module["setLetterbox"] = () => abort("'setLetterbox' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "currentFullscreenStrategy")) Module["currentFullscreenStrategy"] = () => abort("'currentFullscreenStrategy' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "restoreOldWindowedStyle")) Module["restoreOldWindowedStyle"] = () => abort("'restoreOldWindowedStyle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "softFullscreenResizeWebGLRenderTarget")) Module["softFullscreenResizeWebGLRenderTarget"] = () => abort("'softFullscreenResizeWebGLRenderTarget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "doRequestFullscreen")) Module["doRequestFullscreen"] = () => abort("'doRequestFullscreen' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillPointerlockChangeEventData")) Module["fillPointerlockChangeEventData"] = () => abort("'fillPointerlockChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockChangeEventCallback")) Module["registerPointerlockChangeEventCallback"] = () => abort("'registerPointerlockChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockErrorEventCallback")) Module["registerPointerlockErrorEventCallback"] = () => abort("'registerPointerlockErrorEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "requestPointerLock")) Module["requestPointerLock"] = () => abort("'requestPointerLock' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillVisibilityChangeEventData")) Module["fillVisibilityChangeEventData"] = () => abort("'fillVisibilityChangeEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerVisibilityChangeEventCallback")) Module["registerVisibilityChangeEventCallback"] = () => abort("'registerVisibilityChangeEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerTouchEventCallback")) Module["registerTouchEventCallback"] = () => abort("'registerTouchEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillGamepadEventData")) Module["fillGamepadEventData"] = () => abort("'fillGamepadEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerGamepadEventCallback")) Module["registerGamepadEventCallback"] = () => abort("'registerGamepadEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerBeforeUnloadEventCallback")) Module["registerBeforeUnloadEventCallback"] = () => abort("'registerBeforeUnloadEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "fillBatteryEventData")) Module["fillBatteryEventData"] = () => abort("'fillBatteryEventData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "battery")) Module["battery"] = () => abort("'battery' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "registerBatteryEventCallback")) Module["registerBatteryEventCallback"] = () => abort("'registerBatteryEventCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setCanvasElementSize")) Module["setCanvasElementSize"] = () => abort("'setCanvasElementSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getCanvasElementSize")) Module["getCanvasElementSize"] = () => abort("'getCanvasElementSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "demangle")) Module["demangle"] = () => abort("'demangle' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "demangleAll")) Module["demangleAll"] = () => abort("'demangleAll' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace")) Module["jsStackTrace"] = () => abort("'jsStackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = () => abort("'stackTrace' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getEnvStrings")) Module["getEnvStrings"] = () => abort("'getEnvStrings' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "checkWasiClock")) Module["checkWasiClock"] = () => abort("'checkWasiClock' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64")) Module["writeI53ToI64"] = () => abort("'writeI53ToI64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped")) Module["writeI53ToI64Clamped"] = () => abort("'writeI53ToI64Clamped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling")) Module["writeI53ToI64Signaling"] = () => abort("'writeI53ToI64Signaling' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped")) Module["writeI53ToU64Clamped"] = () => abort("'writeI53ToU64Clamped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling")) Module["writeI53ToU64Signaling"] = () => abort("'writeI53ToU64Signaling' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64")) Module["readI53FromI64"] = () => abort("'readI53FromI64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64")) Module["readI53FromU64"] = () => abort("'readI53FromU64' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53")) Module["convertI32PairToI53"] = () => abort("'convertI32PairToI53' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53")) Module["convertU32PairToI53"] = () => abort("'convertU32PairToI53' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setImmediateWrapped")) Module["setImmediateWrapped"] = () => abort("'setImmediateWrapped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "clearImmediateWrapped")) Module["clearImmediateWrapped"] = () => abort("'clearImmediateWrapped' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate")) Module["polyfillSetImmediate"] = () => abort("'polyfillSetImmediate' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "uncaughtExceptionCount")) Module["uncaughtExceptionCount"] = () => abort("'uncaughtExceptionCount' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "exceptionLast")) Module["exceptionLast"] = () => abort("'exceptionLast' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught")) Module["exceptionCaught"] = () => abort("'exceptionCaught' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfo")) Module["ExceptionInfo"] = () => abort("'ExceptionInfo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "CatchInfo")) Module["CatchInfo"] = () => abort("'CatchInfo' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef")) Module["exception_addRef"] = () => abort("'exception_addRef' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef")) Module["exception_decRef"] = () => abort("'exception_decRef' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "Browser")) Module["Browser"] = () => abort("'Browser' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "funcWrappers")) Module["funcWrappers"] = () => abort("'funcWrappers' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = () => abort("'getFuncWrapper' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "setMainLoop")) Module["setMainLoop"] = () => abort("'setMainLoop' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "wget")) Module["wget"] = () => abort("'wget' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "FS")) Module["FS"] = () => abort("'FS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "MEMFS")) Module["MEMFS"] = () => abort("'MEMFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "TTY")) Module["TTY"] = () => abort("'TTY' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS")) Module["PIPEFS"] = () => abort("'PIPEFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS")) Module["SOCKFS"] = () => abort("'SOCKFS' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "_setNetworkCallback")) Module["_setNetworkCallback"] = () => abort("'_setNetworkCallback' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "tempFixedLengthArray")) Module["tempFixedLengthArray"] = () => abort("'tempFixedLengthArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers")) Module["miniTempWebGLFloatBuffers"] = () => abort("'miniTempWebGLFloatBuffers' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType")) Module["heapObjectForWebGLType"] = () => abort("'heapObjectForWebGLType' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap")) Module["heapAccessShiftForWebGLHeap"] = () => abort("'heapAccessShiftForWebGLHeap' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "GL")) Module["GL"] = () => abort("'GL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet")) Module["emscriptenWebGLGet"] = () => abort("'emscriptenWebGLGet' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "computeUnpackAlignedImageSize")) Module["computeUnpackAlignedImageSize"] = () => abort("'computeUnpackAlignedImageSize' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData")) Module["emscriptenWebGLGetTexPixelData"] = () => abort("'emscriptenWebGLGetTexPixelData' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform")) Module["emscriptenWebGLGetUniform"] = () => abort("'emscriptenWebGLGetUniform' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "webglGetUniformLocation")) Module["webglGetUniformLocation"] = () => abort("'webglGetUniformLocation' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "webglPrepareUniformLocationsBeforeFirstUse")) Module["webglPrepareUniformLocationsBeforeFirstUse"] = () => abort("'webglPrepareUniformLocationsBeforeFirstUse' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "webglGetLeftBracePos")) Module["webglGetLeftBracePos"] = () => abort("'webglGetLeftBracePos' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib")) Module["emscriptenWebGLGetVertexAttrib"] = () => abort("'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "writeGLArray")) Module["writeGLArray"] = () => abort("'writeGLArray' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "AL")) Module["AL"] = () => abort("'AL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SDL_unicode")) Module["SDL_unicode"] = () => abort("'SDL_unicode' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SDL_ttfContext")) Module["SDL_ttfContext"] = () => abort("'SDL_ttfContext' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SDL_audio")) Module["SDL_audio"] = () => abort("'SDL_audio' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SDL")) Module["SDL"] = () => abort("'SDL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx")) Module["SDL_gfx"] = () => abort("'SDL_gfx' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "GLUT")) Module["GLUT"] = () => abort("'GLUT' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "EGL")) Module["EGL"] = () => abort("'EGL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window")) Module["GLFW_Window"] = () => abort("'GLFW_Window' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "GLFW")) Module["GLFW"] = () => abort("'GLFW' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "GLEW")) Module["GLEW"] = () => abort("'GLEW' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "IDBStore")) Module["IDBStore"] = () => abort("'IDBStore' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError")) Module["runAndAbortIfError"] = () => abort("'runAndAbortIfError' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "warnOnce")) Module["warnOnce"] = () => abort("'warnOnce' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stackSave")) Module["stackSave"] = () => abort("'stackSave' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stackRestore")) Module["stackRestore"] = () => abort("'stackRestore' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc")) Module["stackAlloc"] = () => abort("'stackAlloc' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString")) Module["AsciiToString"] = () => abort("'AsciiToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii")) Module["stringToAscii"] = () => abort("'stringToAscii' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString")) Module["UTF16ToString"] = () => abort("'UTF16ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16")) Module["stringToUTF16"] = () => abort("'stringToUTF16' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16")) Module["lengthBytesUTF16"] = () => abort("'lengthBytesUTF16' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString")) Module["UTF32ToString"] = () => abort("'UTF32ToString' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32")) Module["stringToUTF32"] = () => abort("'stringToUTF32' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32")) Module["lengthBytesUTF32"] = () => abort("'lengthBytesUTF32' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8")) Module["allocateUTF8"] = () => abort("'allocateUTF8' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack")) Module["allocateUTF8OnStack"] = () => abort("'allocateUTF8OnStack' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"); +Module["writeStackCookie"] = writeStackCookie; +Module["checkStackCookie"] = checkStackCookie; +if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL")) Object.defineProperty(Module, "ALLOC_NORMAL", { configurable: true, get: function() { abort("'ALLOC_NORMAL' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); +if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK")) Object.defineProperty(Module, "ALLOC_STACK", { configurable: true, get: function() { abort("'ALLOC_STACK' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)") } }); + +var calledRun; + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function 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(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} +Module['run'] = run; + +function checkUnflushedContent() { + // 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 (keepRuntimeAlive()) { + // if exit() was called, we may warn the user if the runtime isn't actually being shut down + if (!implicit) { + var msg = 'program exited (with status: ' + status + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)'; + err(msg); + } + } else { + exitRuntime(); + } + + 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()(); + } +} + +run(); + + + + + +// Encoder + +// create encoder +// channels: 1-2 +// samplerate: 8000,12000,16000,24000,48000 +// bitrate: see Opus recommended bitrates +// frame_size: frame size in milliseconds (2.5,5,10,20,40,60), 20 is recommended +// voice_optimization: true/false +function Encoder(channels, samplerate, bitrate, frame_size, voice_optimization) +{ + this.enc = Module._Encoder_new.apply(null, arguments); + this.out = Module._String_new(); +} + +// free encoder memory +Encoder.prototype.destroy = function() +{ + Module._Encoder_delete(this.enc); + Module._String_delete(this.out); +} + +// add samples to the encoder buffer +// samples: Int16Array of interleaved (if multiple channels) samples +Encoder.prototype.input = function(samples) +{ + var ptr = Module._malloc(samples.length*samples.BYTES_PER_ELEMENT); + var pdata = new Uint8Array(Module.HEAPU8.buffer, ptr, samples.length*samples.BYTES_PER_ELEMENT); + pdata.set(new Uint8Array(samples.buffer, samples.byteOffset, samples.length*samples.BYTES_PER_ELEMENT)); + + Module._Encoder_input(this.enc, ptr, samples.length); + Module._free(ptr); +} + +// output the next encoded packet +// return Uint8Array (valid until the next output call) or null if there is no packet to output +Encoder.prototype.output = function() +{ + var ok = Module._Encoder_output(this.enc, this.out); + if(ok) + return new Uint8Array(Module.HEAPU8.buffer, Module._String_data(this.out), Module._String_size(this.out)); +} + +// Decoder + +// create decoder +// channels and samplerate should match the encoder options +function Decoder(channels, samplerate) +{ + this.dec = Module._Decoder_new.apply(null, arguments); + this.out = Module._Int16Array_new(); +} + +// free decoder memory +Decoder.prototype.destroy = function() +{ + Module._Decoder_delete(this.dec); + Module._Int16Array_delete(this.out); +} + +// add packet to the decoder buffer +// packet: Uint8Array +Decoder.prototype.input = function(packet) +{ + var ptr = Module._malloc(packet.length*packet.BYTES_PER_ELEMENT); + var pdata = new Uint8Array(Module.HEAPU8.buffer, ptr, packet.length*packet.BYTES_PER_ELEMENT); + pdata.set(new Uint8Array(packet.buffer, packet.byteOffset, packet.length*packet.BYTES_PER_ELEMENT)); + + Module._Decoder_input(this.dec, ptr, packet.length); + Module._free(ptr); +} + +// output the next decoded samples +// return samples (interleaved if multiple channels) as Int16Array (valid until the next output call) or null if there is no output +Decoder.prototype.output = function() +{ + var ok = Module._Decoder_output(this.dec, this.out); + if(ok) + return new Int16Array(Module.HEAPU8.buffer, Module._Int16Array_data(this.out), Module._Int16Array_size(this.out)); +} + + +//export objects +Module.Encoder = Encoder; +Module.Decoder = Decoder; + +//make the module global if not using nodejs +if(Module["ENVIRONMENT"] != "NODE") + libopus = Module; + +var dec; +var i = 0; +self.addEventListener('message', (e) => { + if (e.data.channels > 0) { + if (dec) dec.destroy(); + dec = new Decoder(e.data.channels, e.data.sampleRate); + } else { + dec.input(e.data); + self.postMessage(dec.output().slice(0)); + } +}); \ No newline at end of file diff --git a/libopus.wasm b/libopus.wasm new file mode 100755 index 0000000000000000000000000000000000000000..36e42afb17f032fbd8a78c5800e1db56d0f75efc GIT binary patch literal 489750 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 jcM`Q-*6NAUkX=+yp>#s35^6WKkX { - audioCodecClass({ audioFormat: { channels, rate } }).then((decoder) => { - decoder.init(() => { - callback(decoder); - }) - }) - }, - { worker: true } - ); } \ No newline at end of file diff --git a/src/connection.ts b/src/connection.ts index 712c1ced4..deed1b5d5 100644 --- a/src/connection.ts +++ b/src/connection.ts @@ -1,7 +1,7 @@ import Websock from "./websock"; import * as message from "./message.js"; import * as rendezvous from "./rendezvous.js"; -import { loadVp9, loadOpus } from "./codec"; +import { loadVp9 } from "./codec"; import * as sha256 from "fast-sha256"; import * as globals from "./globals"; import { decompress, mapKey, sleep } from "./common"; @@ -24,8 +24,6 @@ export default class Connection { _peerInfo: message.PeerInfo | undefined; _firstFrame: Boolean | undefined; _videoDecoder: any; - _audioDecoder: any; - _audioPlayer: any; _password: Uint8Array | undefined; _options: any; _videoTestSpeed: number[]; @@ -242,13 +240,7 @@ export default class Connection { } else if (msg?.misc) { this.handleMisc(msg?.misc); } else if (msg?.audio_frame) { - const dec = this._audioDecoder; - dec.processAudio(msg?.audio_frame.data.slice(0).buffer, (res: any) => { - // ogv.js bug here, audioBuffer always empty - // and ogv.js vpx version is very old (2015), to-do: discard ogv - // let samples = dec.audioBuffer; - // console.log(res, dec); - }); + globals.playAudio(msg?.audio_frame.data); } } } @@ -428,9 +420,7 @@ export default class Connection { handleMisc(misc: message.Misc) { if (misc.audio_format) { - this._audioDecoder?.destroy(); - // this._audioPlayer = globals.newAudioPlayer(misc.audio_format.channels, misc.audio_format.sample_rate); - this.loadAudioDecoder(misc.audio_format.channels, misc.audio_format.sample_rate); + globals.initAudio(misc.audio_format.channels, misc.audio_format.sample_rate); } else if (misc.chat_message) { globals.pushEvent("chat", misc.chat_message.text); } else if (misc.permission_info) { @@ -656,11 +646,6 @@ export default class Connection { } loadAudioDecoder(channels: number, sample_rate: number) { - this._audioDecoder?.close(); - loadOpus((decoder: any) => { - this._audioDecoder = decoder; - console.log("opus loaded"); - }, channels, sample_rate); } } diff --git a/src/globals.js b/src/globals.js index a404cedf5..ecca1ee3a 100644 --- a/src/globals.js +++ b/src/globals.js @@ -1,7 +1,7 @@ import Connection from "./connection"; import _sodium from "libsodium-wrappers"; import { CursorData } from "./message"; -import { loadOpus, loadVp9 } from "./codec"; +import { loadVp9 } from "./codec"; import { checkIfRetry, version } from "./gen_js_from_hbb"; import { initZstd, translate } from "./common"; import PCMPlayer from "pcm-player"; @@ -285,12 +285,27 @@ function _getByName(name, arg) { return ''; } +let opusWorker; +let pcmPlayer; + +export function initAudio(channels, sampleRate) { + pcmPlayer = newAudioPlayer(channels, sampleRate); + opusWorker.postMessage({ channels, sampleRate }); +} + +export function playAudio(packet) { + opusWorker.postMessage(packet); +} + window.init = async () => { yuvWorker = new Worker("./yuv.js"); + opusWorker = new Worker("./libopus.js"); yuvWorker.onmessage = (e) => { currentFrame = e.data; } - loadOpus(() => { }); + opusWorker.onmessage = (e) => { + pcmPlayer.feed(e.data); + } loadVp9(() => { }); await initZstd(); } @@ -303,11 +318,10 @@ export function getPeers() { } } -export function newAudioPlayer(channels, sampleRate) { +function newAudioPlayer(channels, sampleRate) { return new PCMPlayer({ - encoding: '16bitInt', channels, sampleRate, flushingTime: 2000 }); -} \ No newline at end of file +} \ No newline at end of file