Skip to content

Instantly share code, notes, and snippets.

@kungfooman

kungfooman/libwebgame.js

Created December 20, 2018 16:57
Show Gist options
  • Save kungfooman/38bb42dbbcb69904c8592195aac7cdd3 to your computer and use it in GitHub Desktop.
Save kungfooman/38bb42dbbcb69904c8592195aac7cdd3 to your computer and use it in GitHub Desktop.
Download ZIP
emscripten generated glue code to libwebgame.wasm
Raw
libwebgame.js
// Copyright 2010 The Emscripten Authors. All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License. Both these licenses can be
// found in the LICENSE file.
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(Module) { ..generated code.. }
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module !== 'undefined' ? Module : {};
// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// {{PRE_JSES}}
// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = {};
var key;
for (key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key];
}
}
Module['arguments'] = [];
Module['thisProgram'] = './this.program';
Module['quit'] = function(status, toThrow) {
throw toThrow;
};
Module['preRun'] = [];
Module['postRun'] = [];
// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).
var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
ENVIRONMENT_IS_WEB = typeof window === 'object';
ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
// Three configurations we can be running in:
// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)
// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)
// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)
// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = '';
function locateFile(path) {
if (Module['locateFile']) {
return Module['locateFile'](path, scriptDirectory);
} else {
return scriptDirectory + path;
}
}
if (ENVIRONMENT_IS_NODE) {
scriptDirectory = __dirname + '/';
// Expose functionality in the same simple way that the shells work
// Note that we pollute the global namespace here, otherwise we break in node
var nodeFS;
var nodePath;
Module['read'] = function shell_read(filename, binary) {
var ret;
if (!nodeFS) nodeFS = require('fs');
if (!nodePath) nodePath = require('path');
filename = nodePath['normalize'](filename);
ret = nodeFS['readFileSync'](filename);
return binary ? ret : ret.toString();
};
Module['readBinary'] = function readBinary(filename) {
var ret = Module['read'](filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
assert(ret.buffer);
return ret;
};
if (process['argv'].length > 1) {
Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/');
}
Module['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;
}
});
// Currently node will swallow unhandled rejections, but this behavior is
// deprecated, and in the future it will exit with error status.
process['on']('unhandledRejection', abort);
Module['quit'] = function(status) {
process['exit'](status);
};
Module['inspect'] = function () { return '[Emscripten Module object]'; };
} else
if (ENVIRONMENT_IS_SHELL) {
if (typeof read != 'undefined') {
Module['read'] = function shell_read(f) {
return read(f);
};
}
Module['readBinary'] = function readBinary(f) {
var data;
if (typeof readbuffer === 'function') {
return new Uint8Array(readbuffer(f));
}
data = read(f, 'binary');
assert(typeof data === 'object');
return data;
};
if (typeof scriptArgs != 'undefined') {
Module['arguments'] = scriptArgs;
} else if (typeof arguments != 'undefined') {
Module['arguments'] = arguments;
}
if (typeof quit === 'function') {
Module['quit'] = function(status) {
quit(status);
}
}
} else
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
scriptDirectory = self.location.href;
} else if (document.currentScript) { // web
scriptDirectory = document.currentScript.src;
}
// blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
// otherwise, slice off the final part of the url to find the script directory.
// if scriptDirectory does not contain a slash, lastIndexOf will return -1,
// and scriptDirectory will correctly be replaced with an empty string.
if (scriptDirectory.indexOf('blob:') !== 0) {
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1);
} else {
scriptDirectory = '';
}
Module['read'] = function shell_read(url) {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
Module['readBinary'] = function readBinary(url) {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.responseType = 'arraybuffer';
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
Module['readAsync'] = function readAsync(url, onload, onerror) {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.responseType = 'arraybuffer';
xhr.onload = function xhr_onload() {
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
Module['setWindowTitle'] = function(title) { document.title = title };
} else
{
}
// Set up the out() and err() hooks, which are how we can print to stdout or
// stderr, respectively.
// If the user provided Module.print or printErr, use that. Otherwise,
// console.log is checked first, as 'print' on the web will open a print dialogue
// printErr is preferable to console.warn (works better in shells)
// bind(console) is necessary to fix IE/Edge closed dev tools panel behavior.
var out = Module['print'] || (typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null));
var err = Module['printErr'] || (typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || out));
// Merge back in the overrides
for (key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key];
}
}
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
moduleOverrides = undefined;
// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Copyright 2017 The Emscripten Authors. All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License. Both these licenses can be
// found in the LICENSE file.
// {{PREAMBLE_ADDITIONS}}
var STACK_ALIGN = 16;
function staticAlloc(size) {
var ret = STATICTOP;
STATICTOP = (STATICTOP + size + 15) & -16;
return ret;
}
function dynamicAlloc(size) {
var ret = HEAP32[DYNAMICTOP_PTR>>2];
var end = (ret + size + 15) & -16;
HEAP32[DYNAMICTOP_PTR>>2] = end;
if (end >= TOTAL_MEMORY) {
var success = enlargeMemory();
if (!success) {
HEAP32[DYNAMICTOP_PTR>>2] = ret;
return 0;
}
}
return ret;
}
function alignMemory(size, factor) {
if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default
var ret = size = Math.ceil(size / factor) * factor;
return ret;
}
function getNativeTypeSize(type) {
switch (type) {
case 'i1': case 'i8': return 1;
case 'i16': return 2;
case 'i32': return 4;
case 'i64': return 8;
case 'float': return 4;
case 'double': return 8;
default: {
if (type[type.length-1] === '*') {
return 4; // A pointer
} else if (type[0] === 'i') {
var bits = parseInt(type.substr(1));
assert(bits % 8 === 0);
return bits / 8;
} else {
return 0;
}
}
}
}
function warnOnce(text) {
if (!warnOnce.shown) warnOnce.shown = {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
err(text);
}
}
var asm2wasmImports = { // special asm2wasm imports
"f64-rem": function(x, y) {
return x % y;
},
"debugger": function() {
debugger;
}
};
var jsCallStartIndex = 1;
var functionPointers = new Array(0);
// 'sig' parameter is only used on LLVM wasm backend
function addFunction(func, sig) {
var base = 0;
for (var i = base; i < base + 0; i++) {
if (!functionPointers[i]) {
functionPointers[i] = func;
return jsCallStartIndex + i;
}
}
throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
}
function removeFunction(index) {
functionPointers[index-jsCallStartIndex] = null;
}
var funcWrappers = {};
function getFuncWrapper(func, sig) {
if (!func) return; // on null pointer, return undefined
assert(sig);
if (!funcWrappers[sig]) {
funcWrappers[sig] = {};
}
var sigCache = funcWrappers[sig];
if (!sigCache[func]) {
// optimize away arguments usage in common cases
if (sig.length === 1) {
sigCache[func] = function dynCall_wrapper() {
return dynCall(sig, func);
};
} else if (sig.length === 2) {
sigCache[func] = function dynCall_wrapper(arg) {
return dynCall(sig, func, [arg]);
};
} else {
// general case
sigCache[func] = function dynCall_wrapper() {
return dynCall(sig, func, Array.prototype.slice.call(arguments));
};
}
}
return sigCache[func];
}
function makeBigInt(low, high, unsigned) {
return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));
}
function dynCall(sig, ptr, args) {
if (args && args.length) {
return Module['dynCall_' + sig].apply(null, [ptr].concat(args));
} else {
return Module['dynCall_' + sig].call(null, ptr);
}
}
var tempRet0 = 0;
var setTempRet0 = function(value) {
tempRet0 = value;
}
var getTempRet0 = function() {
return tempRet0;
}
var Runtime = {
// FIXME backwards compatibility layer for ports. Support some Runtime.*
// for now, fix it there, then remove it from here. That way we
// can minimize any period of breakage.
dynCall: dynCall, // for SDL2 port
};
// The address globals begin at. Very low in memory, for code size and optimization opportunities.
// Above 0 is static memory, starting with globals.
// Then the stack.
// Then 'dynamic' memory for sbrk.
var GLOBAL_BASE = 1024;
// === 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
//========================================
// Runtime essentials
//========================================
// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;
// set by exit() and abort(). Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS = 0;
/** @type {function(*, string=)} */
function assert(condition, text) {
if (!condition) {
abort('Assertion failed: ' + text);
}
}
var globalScope = this;
// 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;
}
var JSfuncs = {
// Helpers for cwrap -- it can't refer to Runtime directly because it might
// be renamed by closure, instead it calls JSfuncs['stackSave'].body to find
// out what the minified function name is.
'stackSave': function() {
stackSave()
},
'stackRestore': function() {
stackRestore()
},
// type conversion from js to c
'arrayToC' : function(arr) {
var ret = stackAlloc(arr.length);
writeArrayToMemory(arr, ret);
return ret;
},
'stringToC' : 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;
}
};
// For fast lookup of conversion functions
var toC = {
'string': JSfuncs['stringToC'], 'array': JSfuncs['arrayToC']
};
// C calling interface.
function ccall(ident, returnType, argTypes, args, opts) {
function convertReturnValue(ret) {
if (returnType === 'string') return Pointer_stringify(ret);
if (returnType === 'boolean') return Boolean(ret);
return ret;
}
var func = getCFunc(ident);
var cArgs = [];
var stack = 0;
if (args) {
for (var i = 0; i < args.length; i++) {
var converter = toC[argTypes[i]];
if (converter) {
if (stack === 0) stack = stackSave();
cArgs[i] = converter(args[i]);
} else {
cArgs[i] = args[i];
}
}
}
var ret = func.apply(null, cArgs);
ret = convertReturnValue(ret);
if (stack !== 0) stackRestore(stack);
return ret;
}
function cwrap(ident, returnType, argTypes, opts) {
argTypes = argTypes || [];
// When the function takes numbers and returns a number, we can just return
// the original function
var numericArgs = argTypes.every(function(type){ return type === 'number'});
var numericRet = returnType !== 'string';
if (numericRet && numericArgs && !opts) {
return getCFunc(ident);
}
return function() {
return ccall(ident, returnType, argTypes, arguments, opts);
}
}
/** @type {function(number, number, string, boolean=)} */
function setValue(ptr, value, type, noSafe) {
type = type || 'i8';
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
switch(type) {
case 'i1': HEAP8[((ptr)>>0)]=value; break;
case 'i8': HEAP8[((ptr)>>0)]=value; break;
case 'i16': HEAP16[((ptr)>>1)]=value; break;
case 'i32': HEAP32[((ptr)>>2)]=value; break;
case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
case 'float': HEAPF32[((ptr)>>2)]=value; break;
case 'double': HEAPF64[((ptr)>>3)]=value; break;
default: abort('invalid type for setValue: ' + type);
}
}
/** @type {function(number, string, boolean=)} */
function getValue(ptr, type, noSafe) {
type = type || 'i8';
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
switch(type) {
case 'i1': return HEAP8[((ptr)>>0)];
case 'i8': return HEAP8[((ptr)>>0)];
case 'i16': return HEAP16[((ptr)>>1)];
case 'i32': return HEAP32[((ptr)>>2)];
case 'i64': return HEAP32[((ptr)>>2)];
case 'float': return HEAPF32[((ptr)>>2)];
case 'double': return HEAPF64[((ptr)>>3)];
default: abort('invalid type for getValue: ' + type);
}
return null;
}
var ALLOC_NORMAL = 0; // Tries to use _malloc()
var ALLOC_STACK = 1; // Lives for the duration of the current function call
var ALLOC_STATIC = 2; // Cannot be freed
var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
var ALLOC_NONE = 4; // Do not allocate
// allocate(): This is for internal use. You can use it yourself as well, but the interface
// is a little tricky (see docs right below). The reason is that it is optimized
// for multiple syntaxes to save space in generated code. So you should
// normally not use allocate(), and instead allocate memory using _malloc(),
// initialize it with setValue(), and so forth.
// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
// in *bytes* (note that this is sometimes confusing: the next parameter does not
// affect this!)
// @types: Either an array of types, one for each byte (or 0 if no type at that position),
// or a single type which is used for the entire block. This only matters if there
// is initial data - if @slab is a number, then this does not matter at all and is
// ignored.
// @allocator: How to allocate memory, see ALLOC_*
/** @type {function((TypedArray|Array<number>|number), string, number, number=)} */
function allocate(slab, types, allocator, ptr) {
var zeroinit, size;
if (typeof slab === 'number') {
zeroinit = true;
size = slab;
} else {
zeroinit = false;
size = slab.length;
}
var singleType = typeof types === 'string' ? types : null;
var ret;
if (allocator == ALLOC_NONE) {
ret = ptr;
} else {
ret = [typeof _malloc === 'function' ? _malloc : staticAlloc, stackAlloc, staticAlloc, dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
}
if (zeroinit) {
var stop;
ptr = ret;
assert((ret & 3) == 0);
stop = ret + (size & ~3);
for (; ptr < stop; ptr += 4) {
HEAP32[((ptr)>>2)]=0;
}
stop = ret + size;
while (ptr < stop) {
HEAP8[((ptr++)>>0)]=0;
}
return ret;
}
if (singleType === 'i8') {
if (slab.subarray || slab.slice) {
HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret);
} else {
HEAPU8.set(new Uint8Array(slab), ret);
}
return ret;
}
var i = 0, type, typeSize, previousType;
while (i < size) {
var curr = slab[i];
type = singleType || types[i];
if (type === 0) {
i++;
continue;
}
if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
setValue(ret+i, curr, type);
// no need to look up size unless type changes, so cache it
if (previousType !== type) {
typeSize = getNativeTypeSize(type);
previousType = type;
}
i += typeSize;
}
return ret;
}
// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready
function getMemory(size) {
if (!staticSealed) return staticAlloc(size);
if (!runtimeInitialized) return dynamicAlloc(size);
return _malloc(size);
}
/** @type {function(number, number=)} */
function Pointer_stringify(ptr, length) {
if (length === 0 || !ptr) return '';
// Find the length, and check for UTF while doing so
var hasUtf = 0;
var t;
var i = 0;
while (1) {
t = HEAPU8[(((ptr)+(i))>>0)];
hasUtf |= t;
if (t == 0 && !length) break;
i++;
if (length && i == length) break;
}
if (!length) length = i;
var ret = '';
if (hasUtf < 128) {
var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
var curr;
while (length > 0) {
curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
ret = ret ? ret + curr : curr;
ptr += MAX_CHUNK;
length -= MAX_CHUNK;
}
return ret;
}
return UTF8ToString(ptr);
}
// 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 = HEAP8[((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 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;
function UTF8ArrayToString(u8Array, idx) {
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.
while (u8Array[endPtr]) ++endPtr;
if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
} else {
var u0, u1, u2, u3, u4, u5;
var str = '';
while (1) {
// 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
u0 = u8Array[idx++];
if (!u0) return str;
if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
u1 = u8Array[idx++] & 63;
if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
u2 = u8Array[idx++] & 63;
if ((u0 & 0xF0) == 0xE0) {
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
} else {
u3 = u8Array[idx++] & 63;
if ((u0 & 0xF8) == 0xF0) {
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3;
} else {
u4 = u8Array[idx++] & 63;
if ((u0 & 0xFC) == 0xF8) {
u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4;
} else {
u5 = u8Array[idx++] & 63;
u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5;
}
}
}
if (u0 < 0x10000) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 0x10000;
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
}
}
}
}
// 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.
function UTF8ToString(ptr) {
return UTF8ArrayToString(HEAPU8,ptr);
}
// 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.
// outU8Array: 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, outU8Array, 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;
outU8Array[outIdx++] = u;
} else if (u <= 0x7FF) {
if (outIdx + 1 >= endIdx) break;
outU8Array[outIdx++] = 0xC0 | (u >> 6);
outU8Array[outIdx++] = 0x80 | (u & 63);
} else if (u <= 0xFFFF) {
if (outIdx + 2 >= endIdx) break;
outU8Array[outIdx++] = 0xE0 | (u >> 12);
outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
outU8Array[outIdx++] = 0x80 | (u & 63);
} else if (u <= 0x1FFFFF) {
if (outIdx + 3 >= endIdx) break;
outU8Array[outIdx++] = 0xF0 | (u >> 18);
outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
outU8Array[outIdx++] = 0x80 | (u & 63);
} else if (u <= 0x3FFFFFF) {
if (outIdx + 4 >= endIdx) break;
outU8Array[outIdx++] = 0xF8 | (u >> 24);
outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63);
outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
outU8Array[outIdx++] = 0x80 | (u & 63);
} else {
if (outIdx + 5 >= endIdx) break;
outU8Array[outIdx++] = 0xFC | (u >> 30);
outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63);
outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63);
outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
outU8Array[outIdx++] = 0x80 | (u & 63);
}
}
// Null-terminate the pointer to the buffer.
outU8Array[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) {
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 if (u <= 0x1FFFFF) {
len += 4;
} else if (u <= 0x3FFFFFF) {
len += 5;
} else {
len += 6;
}
}
return len;
}
// 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) {
var endPtr = ptr;
// TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
// Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
var idx = endPtr >> 1;
while (HEAP16[idx]) ++idx;
endPtr = idx << 1;
if (endPtr - ptr > 32 && UTF16Decoder) {
return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
} else {
var i = 0;
var str = '';
while (1) {
var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
if (codeUnit == 0) return str;
++i;
// fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
str += String.fromCharCode(codeUnit);
}
}
}
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
// str: the Javascript string to copy.
// outPtr: Byte address in Emscripten HEAP where to write the string to.
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function stringToUTF16(str, outPtr, maxBytesToWrite) {
// 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) {
var i = 0;
var str = '';
while (1) {
var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
if (utf32 == 0)
return str;
++i;
// Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
// See http://unicode.org/faq/utf_bom.html#utf16-3
if (utf32 >= 0x10000) {
var ch = utf32 - 0x10000;
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
} else {
str += String.fromCharCode(utf32);
}
}
}
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
// str: the Javascript string to copy.
// outPtr: Byte address in Emscripten HEAP where to write the string to.
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function stringToUTF32(str, outPtr, maxBytesToWrite) {
// 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;
}
function demangle(func) {
return func;
}
function demangleAll(text) {
var regex =
/__Z[\w\d_]+/g;
return text.replace(regex,
function(x) {
var y = demangle(x);
return x === y ? x : (y + ' [' + x + ']');
});
}
function jsStackTrace() {
var err = new Error();
if (!err.stack) {
// IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
// so try that as a special-case.
try {
throw new Error(0);
} catch(e) {
err = e;
}
if (!err.stack) {
return '(no stack trace available)';
}
}
return err.stack.toString();
}
function stackTrace() {
var js = jsStackTrace();
if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']();
return demangleAll(js);
}
// Memory management
var PAGE_SIZE = 16384;
var WASM_PAGE_SIZE = 65536;
var ASMJS_PAGE_SIZE = 16777216;
var MIN_TOTAL_MEMORY = 16777216;
function alignUp(x, multiple) {
if (x % multiple > 0) {
x += multiple - (x % multiple);
}
return x;
}
var HEAP,
/** @type {ArrayBuffer} */
buffer,
/** @type {Int8Array} */
HEAP8,
/** @type {Uint8Array} */
HEAPU8,
/** @type {Int16Array} */
HEAP16,
/** @type {Uint16Array} */
HEAPU16,
/** @type {Int32Array} */
HEAP32,
/** @type {Uint32Array} */
HEAPU32,
/** @type {Float32Array} */
HEAPF32,
/** @type {Float64Array} */
HEAPF64;
function updateGlobalBuffer(buf) {
Module['buffer'] = buffer = buf;
}
function updateGlobalBufferViews() {
Module['HEAP8'] = HEAP8 = new Int8Array(buffer);
Module['HEAP16'] = HEAP16 = new Int16Array(buffer);
Module['HEAP32'] = HEAP32 = new Int32Array(buffer);
Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer);
Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer);
Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer);
Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer);
Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer);
}
var STATIC_BASE, STATICTOP, staticSealed; // static area
var STACK_BASE, STACKTOP, STACK_MAX; // stack area
var DYNAMIC_BASE, DYNAMICTOP_PTR; // dynamic area handled by sbrk
STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
staticSealed = false;
function abortOnCannotGrowMemory() {
abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (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 enlargeMemory() {
abortOnCannotGrowMemory();
}
var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 268435456;
if (TOTAL_MEMORY < TOTAL_STACK) err('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')');
// Initialize the runtime's memory
// Use a provided buffer, if there is one, or else allocate a new one
if (Module['buffer']) {
buffer = Module['buffer'];
} else {
// Use a WebAssembly memory where available
if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') {
Module['wasmMemory'] = new WebAssembly.Memory({ 'initial': TOTAL_MEMORY / WASM_PAGE_SIZE, 'maximum': TOTAL_MEMORY / WASM_PAGE_SIZE });
buffer = Module['wasmMemory'].buffer;
} else
{
buffer = new ArrayBuffer(TOTAL_MEMORY);
}
Module['buffer'] = buffer;
}
updateGlobalBufferViews();
function getTotalMemory() {
return TOTAL_MEMORY;
}
// Endianness check (note: assumes compiler arch was little-endian)
function callRuntimeCallbacks(callbacks) {
while(callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == 'function') {
callback();
continue;
}
var func = callback.func;
if (typeof func === 'number') {
if (callback.arg === undefined) {
Module['dynCall_v'](func);
} else {
Module['dynCall_vi'](func, callback.arg);
}
} else {
func(callback.arg === undefined ? null : callback.arg);
}
}
}
var __ATPRERUN__ = []; // functions called before the runtime is initialized
var __ATINIT__ = []; // functions called during startup
var __ATMAIN__ = []; // functions called when main() is to be run
var __ATEXIT__ = []; // functions called during shutdown
var __ATPOSTRUN__ = []; // functions called after the main() is called
var runtimeInitialized = false;
var runtimeExited = false;
function preRun() {
// compatibility - merge in anything from Module['preRun'] at this time
if (Module['preRun']) {
if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
while (Module['preRun'].length) {
addOnPreRun(Module['preRun'].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function ensureInitRuntime() {
if (runtimeInitialized) return;
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
callRuntimeCallbacks(__ATEXIT__);
runtimeExited = true;
}
function postRun() {
// compatibility - merge in anything from Module['postRun'] at this time
if (Module['postRun']) {
if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
while (Module['postRun'].length) {
addOnPostRun(Module['postRun'].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnPreMain(cb) {
__ATMAIN__.unshift(cb);
}
function addOnExit(cb) {
__ATEXIT__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
// 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 */
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) {
HEAP8.set(array, buffer);
}
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; ++i) {
HEAP8[((buffer++)>>0)]=str.charCodeAt(i);
}
// Null-terminate the pointer to the HEAP.
if (!dontAddNull) HEAP8[((buffer)>>0)]=0;
}
function unSign(value, bits, ignore) {
if (value >= 0) {
return value;
}
return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
: Math.pow(2, bits) + value;
}
function reSign(value, bits, ignore) {
if (value <= 0) {
return value;
}
var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
: Math.pow(2, bits-1);
if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
// but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
// TODO: In i64 mode 1, resign the two parts separately and safely
value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
}
return value;
}
var Math_abs = Math.abs;
var Math_cos = Math.cos;
var Math_sin = Math.sin;
var Math_tan = Math.tan;
var Math_acos = Math.acos;
var Math_asin = Math.asin;
var Math_atan = Math.atan;
var Math_atan2 = Math.atan2;
var Math_exp = Math.exp;
var Math_log = Math.log;
var Math_sqrt = Math.sqrt;
var Math_ceil = Math.ceil;
var Math_floor = Math.floor;
var Math_pow = Math.pow;
var Math_imul = Math.imul;
var Math_fround = Math.fround;
var Math_round = Math.round;
var Math_min = Math.min;
var Math_max = Math.max;
var Math_clz32 = Math.clz32;
var Math_trunc = Math.trunc;
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
function getUniqueRunDependency(id) {
return id;
}
function addRunDependency(id) {
runDependencies++;
if (Module['monitorRunDependencies']) {
Module['monitorRunDependencies'](runDependencies);
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module['monitorRunDependencies']) {
Module['monitorRunDependencies'](runDependencies);
}
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
var memoryInitializer = null;
// Copyright 2017 The Emscripten Authors. All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License. Both these licenses can be
// found in the LICENSE file.
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = 'data:application/octet-stream;base64,';
// Indicates whether filename is a base64 data URI.
function isDataURI(filename) {
return String.prototype.startsWith ?
filename.startsWith(dataURIPrefix) :
filename.indexOf(dataURIPrefix) === 0;
}
function integrateWasmJS() {
// wasm.js has several methods for creating the compiled code module here:
// * 'native-wasm' : use native WebAssembly support in the browser
// * 'interpret-s-expr': load s-expression code from a .wast and interpret
// * 'interpret-binary': load binary wasm and interpret
// * 'interpret-asm2wasm': load asm.js code, translate to wasm, and interpret
// * 'asmjs': no wasm, just load the asm.js code and use that (good for testing)
// The method is set at compile time (BINARYEN_METHOD)
// The method can be a comma-separated list, in which case, we will try the
// options one by one. Some of them can fail gracefully, and then we can try
// the next.
// inputs
var method = 'native-wasm';
var wasmTextFile = 'libwebgame.wast';
var wasmBinaryFile = 'libwebgame.wasm';
var asmjsCodeFile = 'libwebgame.temp.asm.js';
if (!isDataURI(wasmTextFile)) {
wasmTextFile = locateFile(wasmTextFile);
}
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
if (!isDataURI(asmjsCodeFile)) {
asmjsCodeFile = locateFile(asmjsCodeFile);
}
// utilities
var wasmPageSize = 64*1024;
var info = {
'global': null,
'env': null,
'asm2wasm': asm2wasmImports,
'parent': Module // Module inside wasm-js.cpp refers to wasm-js.cpp; this allows access to the outside program.
};
var exports = null;
function mergeMemory(newBuffer) {
// The wasm instance creates its memory. But static init code might have written to
// buffer already, including the mem init file, and we must copy it over in a proper merge.
// TODO: avoid this copy, by avoiding such static init writes
// TODO: in shorter term, just copy up to the last static init write
var oldBuffer = Module['buffer'];
if (newBuffer.byteLength < oldBuffer.byteLength) {
err('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here');
}
var oldView = new Int8Array(oldBuffer);
var newView = new Int8Array(newBuffer);
newView.set(oldView);
updateGlobalBuffer(newBuffer);
updateGlobalBufferViews();
}
function getBinary() {
try {
if (Module['wasmBinary']) {
return new Uint8Array(Module['wasmBinary']);
}
if (Module['readBinary']) {
return Module['readBinary'](wasmBinaryFile);
} else {
throw "both async and sync fetching of the wasm failed";
}
}
catch (err) {
abort(err);
}
}
function getBinaryPromise() {
// if we don't have the binary yet, and have the Fetch api, use that
// in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web
if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') {
return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {
if (!response['ok']) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
}
return response['arrayBuffer']();
}).catch(function () {
return getBinary();
});
}
// Otherwise, getBinary should be able to get it synchronously
return new Promise(function(resolve, reject) {
resolve(getBinary());
});
}
// do-method functions
function doNativeWasm(global, env, providedBuffer) {
if (typeof WebAssembly !== 'object') {
err('no native wasm support detected');
return false;
}
// prepare memory import
if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) {
err('no native wasm Memory in use');
return false;
}
env['memory'] = Module['wasmMemory'];
// Load the wasm module and create an instance of using native support in the JS engine.
info['global'] = {
'NaN': NaN,
'Infinity': Infinity
};
info['global.Math'] = Math;
info['env'] = env;
// handle a generated wasm instance, receiving its exports and
// performing other necessary setup
function receiveInstance(instance, module) {
exports = instance.exports;
if (exports.memory) mergeMemory(exports.memory);
Module['asm'] = exports;
Module["usingWasm"] = true;
removeRunDependency('wasm-instantiate');
}
addRunDependency('wasm-instantiate');
// 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 {
return Module['instantiateWasm'](info, receiveInstance);
} catch(e) {
err('Module.instantiateWasm callback failed with error: ' + e);
return false;
}
}
function receiveInstantiatedSource(output) {
// 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.
// receiveInstance() will swap in the exports (to Module.asm) so they can be called
receiveInstance(output['instance'], output['module']);
}
function instantiateArrayBuffer(receiver) {
getBinaryPromise().then(function(binary) {
return WebAssembly.instantiate(binary, info);
}).then(receiver, function(reason) {
err('failed to asynchronously prepare wasm: ' + reason);
abort(reason);
});
}
// Prefer streaming instantiation if available.
if (!Module['wasmBinary'] &&
typeof WebAssembly.instantiateStreaming === 'function' &&
!isDataURI(wasmBinaryFile) &&
typeof fetch === 'function') {
WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, { credentials: 'same-origin' }), info)
.then(receiveInstantiatedSource, function(reason) {
// We expect the most common failure cause to be a bad MIME type for the binary,
// in which case falling back to ArrayBuffer instantiation should work.
err('wasm streaming compile failed: ' + reason);
err('falling back to ArrayBuffer instantiation');
instantiateArrayBuffer(receiveInstantiatedSource);
});
} else {
instantiateArrayBuffer(receiveInstantiatedSource);
}
return {}; // no exports yet; we'll fill them in later
}
// We may have a preloaded value in Module.asm, save it
Module['asmPreload'] = Module['asm'];
// Memory growth integration code
var asmjsReallocBuffer = Module['reallocBuffer'];
var wasmReallocBuffer = function(size) {
var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB.
size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size
var old = Module['buffer'];
var oldSize = old.byteLength;
if (Module["usingWasm"]) {
// native wasm support
try {
var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize); // .grow() takes a delta compared to the previous size
if (result !== (-1 | 0)) {
// success in native wasm memory growth, get the buffer from the memory
return Module['buffer'] = Module['wasmMemory'].buffer;
} else {
return null;
}
} catch(e) {
return null;
}
}
};
Module['reallocBuffer'] = function(size) {
if (finalMethod === 'asmjs') {
return asmjsReallocBuffer(size);
} else {
return wasmReallocBuffer(size);
}
};
// we may try more than one; this is the final one, that worked and we are using
var finalMethod = '';
// Provide an "asm.js function" for the application, called to "link" the asm.js module. We instantiate
// the wasm module at that time, and it receives imports and provides exports and so forth, the app
// doesn't need to care that it is wasm or polyfilled wasm or asm.js.
Module['asm'] = function(global, env, providedBuffer) {
// import table
if (!env['table']) {
var TABLE_SIZE = Module['wasmTableSize'];
if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; // works in binaryen interpreter at least
var MAX_TABLE_SIZE = Module['wasmMaxTableSize'];
if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') {
if (MAX_TABLE_SIZE !== undefined) {
env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, 'maximum': MAX_TABLE_SIZE, 'element': 'anyfunc' });
} else {
env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, element: 'anyfunc' });
}
} else {
env['table'] = new Array(TABLE_SIZE); // works in binaryen interpreter at least
}
Module['wasmTable'] = env['table'];
}
if (!env['__memory_base']) {
env['__memory_base'] = Module['STATIC_BASE']; // tell the memory segments where to place themselves
}
if (!env['__table_base']) {
env['__table_base'] = 0; // table starts at 0 by default, in dynamic linking this will change
}
// try the methods. each should return the exports if it succeeded
var exports;
exports = doNativeWasm(global, env, providedBuffer);
assert(exports, 'no binaryen method succeeded.');
return exports;
};
var methodHandler = Module['asm']; // note our method handler, as we may modify Module['asm'] later
}
integrateWasmJS();
// === Body ===
var ASM_CONSTS = [function($0, $1, $2, $3, $4, $5, $6) { CG_Bullet($0, $1, $2, $3, $4, $5, $6); },
function($0) { cg_servercommand_centerprint($0); },
function($0) { cg_servercommand_print($0); },
function($0) { cg_servercommand_chat($0); },
function($0) { cg_servercommand_teamchat($0); },
function($0) { return _SDL_GetTicks(); },
function($0) { callback_main(); },
function($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) { RE_AddRefEntityToScene($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15); },
function($0, $1) { RE_RegisterModel_callback($0, $1); },
function($0, $1, $2) { RE_BeginFrame_callback($0, $1, $2); },
function($0) { RE_EndFrame_callback($0); },
function($0, $1, $2, $3) { callback_AL_StartSound($0, $1, $2, $3); },
function($0) { return callback_AL_RegisterSound($0); },
function($0, $1, $2) { CM_LoadMap_callback($0, $1, $2); },
function($0) { callback_printf($0); },
function($0, $1, $2, $3, $4, $5, $6, $7) { callback_sendpacket($0, $1, $2, $3, $4, $5, $6, $7); },
function($0, $1, $2, $3, $4, $5, $6) { NET_send_packet($0, $1, $2, $3, $4, $5, $6); },
function($0, $1, $2) { callback_save_file($0, $1, $2); }];
function _emscripten_asm_const_idddiddd(code, a0, a1, a2, a3, a4, a5, a6) {
return ASM_CONSTS[code](a0, a1, a2, a3, a4, a5, a6);
}
function _emscripten_asm_const_iiii(code, a0, a1, a2) {
return ASM_CONSTS[code](a0, a1, a2);
}
function _emscripten_asm_const_iiiiiiii(code, a0, a1, a2, a3, a4, a5, a6) {
return ASM_CONSTS[code](a0, a1, a2, a3, a4, a5, a6);
}
function _emscripten_asm_const_iiiddddddddddddii(code, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {
return ASM_CONSTS[code](a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
}
function _emscripten_asm_const_iddd(code, a0, a1, a2) {
return ASM_CONSTS[code](a0, a1, a2);
}
function _emscripten_asm_const_ii(code, a0) {
return ASM_CONSTS[code](a0);
}
function _emscripten_asm_const_iii(code, a0, a1) {
return ASM_CONSTS[code](a0, a1);
}
function _emscripten_asm_const_iiiii(code, a0, a1, a2, a3) {
return ASM_CONSTS[code](a0, a1, a2, a3);
}
function _emscripten_asm_const_iiiiiiiii(code, a0, a1, a2, a3, a4, a5, a6, a7) {
return ASM_CONSTS[code](a0, a1, a2, a3, a4, a5, a6, a7);
}
STATIC_BASE = GLOBAL_BASE;
STATICTOP = STATIC_BASE + 6900944;
/* global initializers */ __ATINIT__.push({ func: function() { __GLOBAL__I_000101() } }, { func: function() { __GLOBAL__I_000101_4978() } }, { func: function() { __GLOBAL__sub_I_ramfile_cpp() } }, { func: function() { __GLOBAL__sub_I_iostream_cpp() } }, { func: function() { __GLOBAL__sub_I_memory_resource_cpp() } });
var STATIC_BUMP = 6900944;
Module["STATIC_BASE"] = STATIC_BASE;
Module["STATIC_BUMP"] = STATIC_BUMP;
/* no memory initializer */
var tempDoublePtr = STATICTOP; STATICTOP += 16;
function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
HEAP8[tempDoublePtr] = HEAP8[ptr];
HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
}
function copyTempDouble(ptr) {
HEAP8[tempDoublePtr] = HEAP8[ptr];
HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
}
// {{PRE_LIBRARY}}
function ___assert_fail(condition, filename, line, func) {
abort('Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function']);
}
function ___cxa_pure_virtual() {
ABORT = true;
throw 'Pure virtual function called!';
}
function __ZSt18uncaught_exceptionv() { // std::uncaught_exception()
return !!__ZSt18uncaught_exceptionv.uncaught_exception;
}
var EXCEPTIONS={last:0,caught:[],infos:{},deAdjust:function (adjusted) {
if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted;
for (var key in EXCEPTIONS.infos) {
var ptr = +key; // the iteration key is a string, and if we throw this, it must be an integer as that is what we look for
var adj = EXCEPTIONS.infos[ptr].adjusted;
var len = adj.length;
for (var i = 0; i < len; i++) {
if (adj[i] === adjusted) {
return ptr;
}
}
}
return adjusted;
},addRef:function (ptr) {
if (!ptr) return;
var info = EXCEPTIONS.infos[ptr];
info.refcount++;
},decRef:function (ptr) {
if (!ptr) return;
var info = EXCEPTIONS.infos[ptr];
assert(info.refcount > 0);
info.refcount--;
// A rethrown exception can reach refcount 0; it must not be discarded
// Its next handler will clear the rethrown flag and addRef it, prior to
// final decRef and destruction here
if (info.refcount === 0 && !info.rethrown) {
if (info.destructor) {
Module['dynCall_vi'](info.destructor, ptr);
}
delete EXCEPTIONS.infos[ptr];
___cxa_free_exception(ptr);
}
},clearRef:function (ptr) {
if (!ptr) return;
var info = EXCEPTIONS.infos[ptr];
info.refcount = 0;
}};
function ___resumeException(ptr) {
if (!EXCEPTIONS.last) { EXCEPTIONS.last = ptr; }
throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
}function ___cxa_find_matching_catch() {
var thrown = EXCEPTIONS.last;
if (!thrown) {
// just pass through the null ptr
return ((setTempRet0(0),0)|0);
}
var info = EXCEPTIONS.infos[thrown];
var throwntype = info.type;
if (!throwntype) {
// just pass through the thrown ptr
return ((setTempRet0(0),thrown)|0);
}
var typeArray = Array.prototype.slice.call(arguments);
var pointer = Module['___cxa_is_pointer_type'](throwntype);
// can_catch receives a **, add indirection
if (!___cxa_find_matching_catch.buffer) ___cxa_find_matching_catch.buffer = _malloc(4);
HEAP32[((___cxa_find_matching_catch.buffer)>>2)]=thrown;
thrown = ___cxa_find_matching_catch.buffer;
// The different catch blocks are denoted by different types.
// Due to inheritance, those types may not precisely match the
// type of the thrown object. Find one which matches, and
// return the type of the catch block which should be called.
for (var i = 0; i < typeArray.length; i++) {
if (typeArray[i] && Module['___cxa_can_catch'](typeArray[i], throwntype, thrown)) {
thrown = HEAP32[((thrown)>>2)]; // undo indirection
info.adjusted.push(thrown);
return ((setTempRet0(typeArray[i]),thrown)|0);
}
}
// Shouldn't happen unless we have bogus data in typeArray
// or encounter a type for which emscripten doesn't have suitable
// typeinfo defined. Best-efforts match just in case.
thrown = HEAP32[((thrown)>>2)]; // undo indirection
return ((setTempRet0(throwntype),thrown)|0);
}function ___gxx_personality_v0() {
}
function ___lock() {}
var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
function ___setErrNo(value) {
if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value;
return value;
}function ___map_file(pathname, size) {
___setErrNo(ERRNO_CODES.EPERM);
return -1;
}
var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
var PATH={splitPath:function (filename) {
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
return splitPathRe.exec(filename).slice(1);
},normalizeArray:function (parts, allowAboveRoot) {
// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = parts.length - 1; i >= 0; i--) {
var last = parts[i];
if (last === '.') {
parts.splice(i, 1);
} else if (last === '..') {
parts.splice(i, 1);
up++;
} else if (up) {
parts.splice(i, 1);
up--;
}
}
// if the path is allowed to go above the root, restore leading ..s
if (allowAboveRoot) {
for (; up; up--) {
parts.unshift('..');
}
}
return parts;
},normalize:function (path) {
var isAbsolute = path.charAt(0) === '/',
trailingSlash = path.substr(-1) === '/';
// Normalize the path
path = PATH.normalizeArray(path.split('/').filter(function(p) {
return !!p;
}), !isAbsolute).join('/');
if (!path && !isAbsolute) {
path = '.';
}
if (path && trailingSlash) {
path += '/';
}
return (isAbsolute ? '/' : '') + path;
},dirname:function (path) {
var result = PATH.splitPath(path),
root = result[0],
dir = result[1];
if (!root && !dir) {
// No dirname whatsoever
return '.';
}
if (dir) {
// It has a dirname, strip trailing slash
dir = dir.substr(0, dir.length - 1);
}
return root + dir;
},basename:function (path) {
// EMSCRIPTEN return '/'' for '/', not an empty string
if (path === '/') return '/';
var lastSlash = path.lastIndexOf('/');
if (lastSlash === -1) return path;
return path.substr(lastSlash+1);
},extname:function (path) {
return PATH.splitPath(path)[3];
},join:function () {
var paths = Array.prototype.slice.call(arguments, 0);
return PATH.normalize(paths.join('/'));
},join2:function (l, r) {
return PATH.normalize(l + '/' + r);
},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.resolve(from).substr(1);
to = PATH.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/kripken/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/kripken/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(ERRNO_CODES.ENODEV);
}
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(ERRNO_CODES.ENXIO);
}
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(ERRNO_CODES.EIO);
}
if (result === undefined && bytesRead === 0) {
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
}
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(ERRNO_CODES.ENXIO);
}
try {
for (var i = 0; i < length; i++) {
stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
}
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES.EIO);
}
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 = new Buffer(BUFSIZE);
var bytesRead = 0;
var isPosixPlatform = (process.platform != 'win32'); // Node doesn't offer a direct check, so test by exclusion
var fd = process.stdin.fd;
if (isPosixPlatform) {
// Linux and Mac cannot use process.stdin.fd (which isn't set up as sync)
var usingDevice = false;
try {
fd = fs.openSync('/dev/stdin', 'r');
usingDevice = true;
} catch (e) {}
}
try {
bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, null);
} catch(e) {
// Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
// reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.
if (e.toString().indexOf('EOF') != -1) bytesRead = 0;
else throw e;
}
if (usingDevice) { fs.closeSync(fd); }
if (bytesRead > 0) {
result = buf.slice(0, bytesRead).toString('utf-8');
} else {
result = null;
}
} else if (typeof window != 'undefined' &&
typeof window.prompt == 'function') {
// Browser.
result = window.prompt('Input: '); // returns null on cancel
if (result !== null) {
result += '\n';
}
} else if (typeof readline == 'function') {
// Command line.
result = readline();
if (result !== null) {
result += '\n';
}
}
if (!result) {
return null;
}
tty.input = intArrayFromString(result, true);
}
return tty.input.shift();
},put_char:function (tty, val) {
if (val === null || val === 10) {
out(UTF8ArrayToString(tty.output, 0));
tty.output = [];
} else {
if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle.
}
},flush:function (tty) {
if (tty.output && tty.output.length > 0) {
out(UTF8ArrayToString(tty.output, 0));
tty.output = [];
}
}},default_tty1_ops:{put_char:function (tty, val) {
if (val === null || val === 10) {
err(UTF8ArrayToString(tty.output, 0));
tty.output = [];
} else {
if (val != 0) tty.output.push(val);
}
},flush:function (tty) {
if (tty.output && tty.output.length > 0) {
err(UTF8ArrayToString(tty.output, 0));
tty.output = [];
}
}}};
var MEMFS={ops_table:null,mount:function (mount) {
return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
},createNode:function (parent, name, mode, dev) {
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
// no supported
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
if (!MEMFS.ops_table) {
MEMFS.ops_table = {
dir: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr,
lookup: MEMFS.node_ops.lookup,
mknod: MEMFS.node_ops.mknod,
rename: MEMFS.node_ops.rename,
unlink: MEMFS.node_ops.unlink,
rmdir: MEMFS.node_ops.rmdir,
readdir: MEMFS.node_ops.readdir,
symlink: MEMFS.node_ops.symlink
},
stream: {
llseek: MEMFS.stream_ops.llseek
}
},
file: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr
},
stream: {
llseek: MEMFS.stream_ops.llseek,
read: MEMFS.stream_ops.read,
write: MEMFS.stream_ops.write,
allocate: MEMFS.stream_ops.allocate,
mmap: MEMFS.stream_ops.mmap,
msync: MEMFS.stream_ops.msync
}
},
link: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr,
readlink: MEMFS.node_ops.readlink
},
stream: {}
},
chrdev: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr
},
stream: FS.chrdev_stream_ops
}
};
}
var node = FS.createNode(parent, name, mode, dev);
if (FS.isDir(node.mode)) {
node.node_ops = MEMFS.ops_table.dir.node;
node.stream_ops = MEMFS.ops_table.dir.stream;
node.contents = {};
} else if (FS.isFile(node.mode)) {
node.node_ops = MEMFS.ops_table.file.node;
node.stream_ops = MEMFS.ops_table.file.stream;
node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity.
// When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred
// for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size
// penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme.
node.contents = null;
} else if (FS.isLink(node.mode)) {
node.node_ops = MEMFS.ops_table.link.node;
node.stream_ops = MEMFS.ops_table.link.stream;
} else if (FS.isChrdev(node.mode)) {
node.node_ops = MEMFS.ops_table.chrdev.node;
node.stream_ops = MEMFS.ops_table.chrdev.stream;
}
node.timestamp = Date.now();
// add the new node to the parent
if (parent) {
parent.contents[name] = node;
}
return node;
},getFileDataAsRegularArray:function (node) {
if (node.contents && node.contents.subarray) {
var arr = [];
for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
return arr; // Returns a copy of the original data.
}
return node.contents; // No-op, the file contents are already in a JS array. Return as-is.
},getFileDataAsTypedArray:function (node) {
if (!node.contents) return new Uint8Array;
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) {
// If we are asked to expand the size of a file that already exists, revert to using a standard JS array to store the file
// instead of a typed array. This makes resizing the array more flexible because we can just .push() elements at the back to
// increase the size.
if (node.contents && node.contents.subarray && newCapacity > node.contents.length) {
node.contents = MEMFS.getFileDataAsRegularArray(node);
node.usedBytes = node.contents.length; // We might be writing to a lazy-loaded file which had overridden this property, so force-reset it.
}
if (!node.contents || node.contents.subarray) { // Keep using a typed array if creating a new storage, or if old one was a typed array as well.
var prevCapacity = node.contents ? node.contents.length : 0;
if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough.
// Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity.
// For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to
// avoid overshooting the allocation cap by a very large margin.
var CAPACITY_DOUBLING_MAX = 1024 * 1024;
newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) | 0);
if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding.
var oldContents = node.contents;
node.contents = new Uint8Array(newCapacity); // Allocate new storage.
if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage.
return;
}
// Not using a typed array to back the file storage. Use a standard JS array instead.
if (!node.contents && newCapacity > 0) node.contents = [];
while (node.contents.length < newCapacity) node.contents.push(0);
},resizeFileStorage:function (node, newSize) {
if (node.usedBytes == newSize) return;
if (newSize == 0) {
node.contents = null; // Fully decommit when requesting a resize to zero.
node.usedBytes = 0;
return;
}
if (!node.contents || node.contents.subarray) { // Resize a typed array if that is being used as the backing store.
var oldContents = node.contents;
node.contents = new Uint8Array(new ArrayBuffer(newSize)); // Allocate new storage.
if (oldContents) {
node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage.
}
node.usedBytes = newSize;
return;
}
// Backing with a JS array.
if (!node.contents) node.contents = [];
if (node.contents.length > newSize) node.contents.length = newSize;
else while (node.contents.length < newSize) node.contents.push(0);
node.usedBytes = newSize;
},node_ops:{getattr:function (node) {
var attr = {};
// device numbers reuse inode numbers.
attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
attr.ino = node.id;
attr.mode = node.mode;
attr.nlink = 1;
attr.uid = 0;
attr.gid = 0;
attr.rdev = node.rdev;
if (FS.isDir(node.mode)) {
attr.size = 4096;
} else if (FS.isFile(node.mode)) {
attr.size = node.usedBytes;
} else if (FS.isLink(node.mode)) {
attr.size = node.link.length;
} else {
attr.size = 0;
}
attr.atime = new Date(node.timestamp);
attr.mtime = new Date(node.timestamp);
attr.ctime = new Date(node.timestamp);
// NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
// but this is not required by the standard.
attr.blksize = 4096;
attr.blocks = Math.ceil(attr.size / attr.blksize);
return attr;
},setattr:function (node, attr) {
if (attr.mode !== undefined) {
node.mode = attr.mode;
}
if (attr.timestamp !== undefined) {
node.timestamp = attr.timestamp;
}
if (attr.size !== undefined) {
MEMFS.resizeFileStorage(node, attr.size);
}
},lookup:function (parent, name) {
throw FS.genericErrors[ERRNO_CODES.ENOENT];
},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(ERRNO_CODES.ENOTEMPTY);
}
}
}
// do the internal rewiring
delete old_node.parent.contents[old_node.name];
old_node.name = new_name;
new_dir.contents[new_name] = old_node;
old_node.parent = new_dir;
},unlink:function (parent, name) {
delete parent.contents[name];
},rmdir:function (parent, name) {
var node = FS.lookupNode(parent, name);
for (var i in node.contents) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
}
delete parent.contents[name];
},readdir:function (node) {
var entries = ['.', '..']
for (var key in node.contents) {
if (!node.contents.hasOwnProperty(key)) {
continue;
}
entries.push(key);
}
return entries;
},symlink:function (parent, newname, oldpath) {
var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
node.link = oldpath;
return node;
},readlink:function (node) {
if (!FS.isLink(node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
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) {
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) {
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 = new Uint8Array(buffer.subarray(offset, offset + length));
node.usedBytes = length;
return length;
} else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file?
node.contents.set(buffer.subarray(offset, offset + length), position);
return length;
}
}
// Appending to an existing file and we need to reallocate, or source data did not come as a typed array.
MEMFS.expandFileStorage(node, position+length);
if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position); // Use typed array write if available.
else {
for (var i = 0; i < length; i++) {
node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not.
}
}
node.usedBytes = Math.max(node.usedBytes, position+length);
return length;
},llseek:function (stream, offset, whence) {
var position = offset;
if (whence === 1) { // SEEK_CUR.
position += stream.position;
} else if (whence === 2) { // SEEK_END.
if (FS.isFile(stream.node.mode)) {
position += stream.node.usedBytes;
}
}
if (position < 0) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
return position;
},allocate:function (stream, offset, length) {
MEMFS.expandFileStorage(stream.node, offset + length);
stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
},mmap:function (stream, buffer, offset, length, position, prot, flags) {
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
}
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 || contents.buffer === buffer.buffer) ) {
// We can't emulate MAP_SHARED when the file is not backed by the buffer
// we're mapping to (e.g. the HEAP buffer).
allocated = false;
ptr = contents.byteOffset;
} else {
// Try to avoid unnecessary slices.
if (position > 0 || position + length < stream.node.usedBytes) {
if (contents.subarray) {
contents = contents.subarray(position, position + length);
} else {
contents = Array.prototype.slice.call(contents, position, position + length);
}
}
allocated = true;
ptr = _malloc(length);
if (!ptr) {
throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
}
buffer.set(contents, ptr);
}
return { ptr: ptr, allocated: allocated };
},msync:function (stream, buffer, offset, length, mmapFlags) {
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
}
if (mmapFlags & 2) {
// MAP_PRIVATE calls need not to be synced back to underlying fs
return 0;
}
var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
// should we check if bytesWritten and length are the same?
return 0;
}}};
var IDBFS={dbs:{},indexedDB:function () {
if (typeof indexedDB !== 'undefined') return indexedDB;
var ret = null;
if (typeof window === 'object') ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
assert(ret, 'IDBFS used, but indexedDB not supported');
return ret;
},DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
// reuse all of the core MEMFS functionality
return MEMFS.mount.apply(null, arguments);
},syncfs:function (mount, populate, callback) {
IDBFS.getLocalSet(mount, function(err, local) {
if (err) return callback(err);
IDBFS.getRemoteSet(mount, function(err, remote) {
if (err) return callback(err);
var src = populate ? remote : local;
var dst = populate ? local : remote;
IDBFS.reconcile(src, dst, callback);
});
});
},getDB:function (name, callback) {
// check the cache first
var db = IDBFS.dbs[name];
if (db) {
return callback(null, db);
}
var req;
try {
req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
} catch (e) {
return callback(e);
}
if (!req) {
return callback("Unable to connect to IndexedDB");
}
req.onupgradeneeded = function(e) {
var db = e.target.result;
var transaction = e.target.transaction;
var fileStore;
if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
} else {
fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
}
if (!fileStore.indexNames.contains('timestamp')) {
fileStore.createIndex('timestamp', 'timestamp', { unique: false });
}
};
req.onsuccess = function() {
db = req.result;
// add to the cache
IDBFS.dbs[name] = db;
callback(null, db);
};
req.onerror = function(e) {
callback(this.error);
e.preventDefault();
};
},getLocalSet:function (mount, callback) {
var entries = {};
function isRealDir(p) {
return p !== '.' && p !== '..';
};
function toAbsolute(root) {
return function(p) {
return PATH.join2(root, p);
}
};
var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
while (check.length) {
var path = check.pop();
var stat;
try {
stat = FS.stat(path);
} catch (e) {
return callback(e);
}
if (FS.isDir(stat.mode)) {
check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
}
entries[path] = { timestamp: stat.mtime };
}
return callback(null, { type: 'local', entries: entries });
},getRemoteSet:function (mount, callback) {
var entries = {};
IDBFS.getDB(mount.mountpoint, function(err, db) {
if (err) return callback(err);
try {
var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
transaction.onerror = function(e) {
callback(this.error);
e.preventDefault();
};
var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
var index = store.index('timestamp');
index.openKeyCursor().onsuccess = function(event) {
var cursor = event.target.result;
if (!cursor) {
return callback(null, { type: 'remote', db: db, entries: entries });
}
entries[cursor.primaryKey] = { timestamp: cursor.key };
cursor.continue();
};
} catch (e) {
return callback(e);
}
});
},loadLocalEntry:function (path, callback) {
var stat, node;
try {
var lookup = FS.lookupPath(path);
node = lookup.node;
stat = FS.stat(path);
} catch (e) {
return callback(e);
}
if (FS.isDir(stat.mode)) {
return callback(null, { timestamp: stat.mtime, mode: stat.mode });
} else if (FS.isFile(stat.mode)) {
// Performance consideration: storing a normal JavaScript array to a IndexedDB is much slower than storing a typed array.
// Therefore always convert the file contents to a typed array first before writing the data to IndexedDB.
node.contents = MEMFS.getFileDataAsTypedArray(node);
return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
} else {
return callback(new Error('node type not supported'));
}
},storeLocalEntry:function (path, entry, callback) {
try {
if (FS.isDir(entry.mode)) {
FS.mkdir(path, entry.mode);
} else if (FS.isFile(entry.mode)) {
FS.writeFile(path, entry.contents, { canOwn: true });
} else {
return callback(new Error('node type not supported'));
}
FS.chmod(path, entry.mode);
FS.utime(path, entry.timestamp, entry.timestamp);
} catch (e) {
return callback(e);
}
callback(null);
},removeLocalEntry:function (path, callback) {
try {
var lookup = FS.lookupPath(path);
var stat = FS.stat(path);
if (FS.isDir(stat.mode)) {
FS.rmdir(path);
} else if (FS.isFile(stat.mode)) {
FS.unlink(path);
}
} catch (e) {
return callback(e);
}
callback(null);
},loadRemoteEntry:function (store, path, callback) {
var req = store.get(path);
req.onsuccess = function(event) { callback(null, event.target.result); };
req.onerror = function(e) {
callback(this.error);
e.preventDefault();
};
},storeRemoteEntry:function (store, path, entry, callback) {
var req = store.put(entry, path);
req.onsuccess = function() { callback(null); };
req.onerror = function(e) {
callback(this.error);
e.preventDefault();
};
},removeRemoteEntry:function (store, path, callback) {
var req = store.delete(path);
req.onsuccess = function() { callback(null); };
req.onerror = function(e) {
callback(this.error);
e.preventDefault();
};
},reconcile:function (src, dst, callback) {
var total = 0;
var create = [];
Object.keys(src.entries).forEach(function (key) {
var e = src.entries[key];
var e2 = dst.entries[key];
if (!e2 || e.timestamp > e2.timestamp) {
create.push(key);
total++;
}
});
var remove = [];
Object.keys(dst.entries).forEach(function (key) {
var e = dst.entries[key];
var e2 = src.entries[key];
if (!e2) {
remove.push(key);
total++;
}
});
if (!total) {
return callback(null);
}
var errored = false;
var completed = 0;
var db = src.type === 'remote' ? src.db : dst.db;
var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
function done(err) {
if (err) {
if (!done.errored) {
done.errored = true;
return callback(err);
}
return;
}
if (++completed >= total) {
return callback(null);
}
};
transaction.onerror = function(e) {
done(this.error);
e.preventDefault();
};
// sort paths in ascending order so directory entries are created
// before the files inside them
create.sort().forEach(function (path) {
if (dst.type === 'local') {
IDBFS.loadRemoteEntry(store, path, function (err, entry) {
if (err) return done(err);
IDBFS.storeLocalEntry(path, entry, done);
});
} else {
IDBFS.loadLocalEntry(path, function (err, entry) {
if (err) return done(err);
IDBFS.storeRemoteEntry(store, path, entry, done);
});
}
});
// sort paths in descending order so files are deleted before their
// parent directories
remove.sort().reverse().forEach(function(path) {
if (dst.type === 'local') {
IDBFS.removeLocalEntry(path, done);
} else {
IDBFS.removeRemoteEntry(store, path, done);
}
});
}};
var NODEFS={isWindows:false,staticInit:function () {
NODEFS.isWindows = !!process.platform.match(/^win/);
var flags = process["binding"]("constants");
// Node.js 4 compatibility: it has no namespaces for constants
if (flags["fs"]) {
flags = flags["fs"];
}
NODEFS.flagsForNodeMap = {
"1024": flags["O_APPEND"],
"64": flags["O_CREAT"],
"128": flags["O_EXCL"],
"0": flags["O_RDONLY"],
"2": flags["O_RDWR"],
"4096": flags["O_SYNC"],
"512": flags["O_TRUNC"],
"1": flags["O_WRONLY"]
};
},bufferFrom:function (arrayBuffer) {
// Node.js < 4.5 compatibility: Buffer.from does not support ArrayBuffer
// Buffer.from before 4.5 was just a method inherited from Uint8Array
// Buffer.alloc has been added with Buffer.from together, so check it instead
return Buffer.alloc ? Buffer.from(arrayBuffer) : new Buffer(arrayBuffer);
},mount:function (mount) {
assert(ENVIRONMENT_IS_NODE);
return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
},createNode:function (parent, name, mode, dev) {
if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
var node = FS.createNode(parent, name, mode);
node.node_ops = NODEFS.node_ops;
node.stream_ops = NODEFS.stream_ops;
return node;
},getMode:function (path) {
var stat;
try {
stat = fs.lstatSync(path);
if (NODEFS.isWindows) {
// Node.js on Windows never represents permission bit 'x', so
// propagate read bits to execute bits
stat.mode = stat.mode | ((stat.mode & 292) >> 2);
}
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
return stat.mode;
},realPath:function (node) {
var parts = [];
while (node.parent !== node) {
parts.push(node.name);
node = node.parent;
}
parts.push(node.mount.opts.root);
parts.reverse();
return PATH.join.apply(null, parts);
},flagsForNode:function (flags) {
flags &= ~0x200000 /*O_PATH*/; // Ignore this flag from musl, otherwise node.js fails to open the file.
flags &= ~0x800 /*O_NONBLOCK*/; // Ignore this flag from musl, otherwise node.js fails to open the file.
flags &= ~0x8000 /*O_LARGEFILE*/; // Ignore this flag from musl, otherwise node.js fails to open the file.
flags &= ~0x80000 /*O_CLOEXEC*/; // Some applications may pass it; it makes no sense for a single process.
var newFlags = 0;
for (var k in NODEFS.flagsForNodeMap) {
if (flags & k) {
newFlags |= NODEFS.flagsForNodeMap[k];
flags ^= k;
}
}
if (!flags) {
return newFlags;
} else {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
},node_ops:{getattr:function (node) {
var path = NODEFS.realPath(node);
var stat;
try {
stat = fs.lstatSync(path);
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
// node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
// See http://support.microsoft.com/kb/140365
if (NODEFS.isWindows && !stat.blksize) {
stat.blksize = 4096;
}
if (NODEFS.isWindows && !stat.blocks) {
stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
}
return {
dev: stat.dev,
ino: stat.ino,
mode: stat.mode,
nlink: stat.nlink,
uid: stat.uid,
gid: stat.gid,
rdev: stat.rdev,
size: stat.size,
atime: stat.atime,
mtime: stat.mtime,
ctime: stat.ctime,
blksize: stat.blksize,
blocks: stat.blocks
};
},setattr:function (node, attr) {
var path = NODEFS.realPath(node);
try {
if (attr.mode !== undefined) {
fs.chmodSync(path, attr.mode);
// update the common node structure mode as well
node.mode = attr.mode;
}
if (attr.timestamp !== undefined) {
var date = new Date(attr.timestamp);
fs.utimesSync(path, date, date);
}
if (attr.size !== undefined) {
fs.truncateSync(path, attr.size);
}
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},lookup:function (parent, name) {
var path = PATH.join2(NODEFS.realPath(parent), name);
var mode = NODEFS.getMode(path);
return NODEFS.createNode(parent, name, mode);
},mknod:function (parent, name, mode, dev) {
var node = NODEFS.createNode(parent, name, mode, dev);
// create the backing node for this in the fs root as well
var path = NODEFS.realPath(node);
try {
if (FS.isDir(node.mode)) {
fs.mkdirSync(path, node.mode);
} else {
fs.writeFileSync(path, '', { mode: node.mode });
}
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
return node;
},rename:function (oldNode, newDir, newName) {
var oldPath = NODEFS.realPath(oldNode);
var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
try {
fs.renameSync(oldPath, newPath);
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},unlink:function (parent, name) {
var path = PATH.join2(NODEFS.realPath(parent), name);
try {
fs.unlinkSync(path);
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},rmdir:function (parent, name) {
var path = PATH.join2(NODEFS.realPath(parent), name);
try {
fs.rmdirSync(path);
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},readdir:function (node) {
var path = NODEFS.realPath(node);
try {
return fs.readdirSync(path);
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},symlink:function (parent, newName, oldPath) {
var newPath = PATH.join2(NODEFS.realPath(parent), newName);
try {
fs.symlinkSync(oldPath, newPath);
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},readlink:function (node) {
var path = NODEFS.realPath(node);
try {
path = fs.readlinkSync(path);
path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path);
return path;
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
}},stream_ops:{open:function (stream) {
var path = NODEFS.realPath(stream.node);
try {
if (FS.isFile(stream.node.mode)) {
stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags));
}
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},close:function (stream) {
try {
if (FS.isFile(stream.node.mode) && stream.nfd) {
fs.closeSync(stream.nfd);
}
} catch (e) {
if (!e.code) throw e;
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},read:function (stream, buffer, offset, length, position) {
// Node.js < 6 compatibility: node errors on 0 length reads
if (length === 0) return 0;
try {
return fs.readSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position);
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},write:function (stream, buffer, offset, length, position) {
try {
return fs.writeSync(stream.nfd, NODEFS.bufferFrom(buffer.buffer), offset, length, position);
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
},llseek:function (stream, offset, whence) {
var position = offset;
if (whence === 1) { // SEEK_CUR.
position += stream.position;
} else if (whence === 2) { // SEEK_END.
if (FS.isFile(stream.node.mode)) {
try {
var stat = fs.fstatSync(stream.nfd);
position += stat.size;
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES[e.code]);
}
}
}
if (position < 0) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
return position;
}}};
var WORKERFS={DIR_MODE:16895,FILE_MODE:33279,reader:null,mount:function (mount) {
assert(ENVIRONMENT_IS_WORKER);
if (!WORKERFS.reader) WORKERFS.reader = new FileReaderSync();
var root = WORKERFS.createNode(null, '/', WORKERFS.DIR_MODE, 0);
var createdParents = {};
function ensureParent(path) {
// return the parent node, creating subdirs as necessary
var parts = path.split('/');
var parent = root;
for (var i = 0; i < parts.length-1; i++) {
var curr = parts.slice(0, i+1).join('/');
// Issue 4254: Using curr as a node name will prevent the node
// from being found in FS.nameTable when FS.open is called on
// a path which holds a child of this node,
// given that all FS functions assume node names
// are just their corresponding parts within their given path,
// rather than incremental aggregates which include their parent's
// directories.
if (!createdParents[curr]) {
createdParents[curr] = WORKERFS.createNode(parent, parts[i], WORKERFS.DIR_MODE, 0);
}
parent = createdParents[curr];
}
return parent;
}
function base(path) {
var parts = path.split('/');
return parts[parts.length-1];
}
// We also accept FileList here, by using Array.prototype
Array.prototype.forEach.call(mount.opts["files"] || [], function(file) {
WORKERFS.createNode(ensureParent(file.name), base(file.name), WORKERFS.FILE_MODE, 0, file, file.lastModifiedDate);
});
(mount.opts["blobs"] || []).forEach(function(obj) {
WORKERFS.createNode(ensureParent(obj["name"]), base(obj["name"]), WORKERFS.FILE_MODE, 0, obj["data"]);
});
(mount.opts["packages"] || []).forEach(function(pack) {
pack['metadata'].files.forEach(function(file) {
var name = file.filename.substr(1); // remove initial slash
WORKERFS.createNode(ensureParent(name), base(name), WORKERFS.FILE_MODE, 0, pack['blob'].slice(file.start, file.end));
});
});
return root;
},createNode:function (parent, name, mode, dev, contents, mtime) {
var node = FS.createNode(parent, name, mode);
node.mode = mode;
node.node_ops = WORKERFS.node_ops;
node.stream_ops = WORKERFS.stream_ops;
node.timestamp = (mtime || new Date).getTime();
assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE);
if (mode === WORKERFS.FILE_MODE) {
node.size = contents.size;
node.contents = contents;
} else {
node.size = 4096;
node.contents = {};
}
if (parent) {
parent.contents[name] = node;
}
return node;
},node_ops:{getattr:function (node) {
return {
dev: 1,
ino: undefined,
mode: node.mode,
nlink: 1,
uid: 0,
gid: 0,
rdev: undefined,
size: node.size,
atime: new Date(node.timestamp),
mtime: new Date(node.timestamp),
ctime: new Date(node.timestamp),
blksize: 4096,
blocks: Math.ceil(node.size / 4096),
};
},setattr:function (node, attr) {
if (attr.mode !== undefined) {
node.mode = attr.mode;
}
if (attr.timestamp !== undefined) {
node.timestamp = attr.timestamp;
}
},lookup:function (parent, name) {
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
},mknod:function (parent, name, mode, dev) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
},rename:function (oldNode, newDir, newName) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
},unlink:function (parent, name) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
},rmdir:function (parent, name) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
},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) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
},readlink:function (node) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}},stream_ops:{read:function (stream, buffer, offset, length, position) {
if (position >= stream.node.size) return 0;
var chunk = stream.node.contents.slice(position, position + length);
var ab = WORKERFS.reader.readAsArrayBuffer(chunk);
buffer.set(new Uint8Array(ab), offset);
return chunk.size;
},write:function (stream, buffer, offset, length, position) {
throw new FS.ErrnoError(ERRNO_CODES.EIO);
},llseek:function (stream, offset, whence) {
var position = offset;
if (whence === 1) { // SEEK_CUR.
position += stream.position;
} else if (whence === 2) { // SEEK_END.
if (FS.isFile(stream.node.mode)) {
position += stream.node.size;
}
}
if (position < 0) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
return position;
}}};
var _stdin=STATICTOP; STATICTOP += 16;;
var _stdout=STATICTOP; STATICTOP += 16;;
var _stderr=STATICTOP; STATICTOP += 16;;var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,trackingDelegate:{},tracking:{openFlags:{READ:1,WRITE:2}},ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,handleFSError:function (e) {
if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
return ___setErrNo(e.errno);
},lookupPath:function (path, opts) {
path = PATH.resolve(FS.cwd(), path);
opts = opts || {};
if (!path) return { path: '', node: null };
var defaults = {
follow_mount: true,
recurse_count: 0
};
for (var key in defaults) {
if (opts[key] === undefined) {
opts[key] = defaults[key];
}
}
if (opts.recurse_count > 8) { // max recursive lookup of 8
throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
}
// 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.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(ERRNO_CODES.ELOOP);
}
}
}
}
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 err = FS.mayLookup(parent);
if (err) {
throw new FS.ErrnoError(err, 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) {
if (!FS.FSNode) {
FS.FSNode = 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;
};
FS.FSNode.prototype = {};
// compatibility
var readMode = 292 | 73;
var writeMode = 146;
// NOTE we must use Object.defineProperties instead of individual calls to
// Object.defineProperty in order to make closure compiler happy
Object.defineProperties(FS.FSNode.prototype, {
read: {
get: function() { return (this.mode & readMode) === readMode; },
set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
},
write: {
get: function() { return (this.mode & writeMode) === writeMode; },
set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
},
isFolder: {
get: function() { return FS.isDir(this.mode); }
},
isDevice: {
get: function() { return FS.isChrdev(this.mode); }
}
});
}
var node = new FS.FSNode(parent, name, mode, rdev);
FS.hashAddNode(node);
return node;
},destroyNode:function (node) {
FS.hashRemoveNode(node);
},isRoot:function (node) {
return node === node.parent;
},isMountpoint:function (node) {
return !!node.mounted;
},isFile:function (mode) {
return (mode & 61440) === 32768;
},isDir:function (mode) {
return (mode & 61440) === 16384;
},isLink:function (mode) {
return (mode & 61440) === 40960;
},isChrdev:function (mode) {
return (mode & 61440) === 8192;
},isBlkdev:function (mode) {
return (mode & 61440) === 24576;
},isFIFO:function (mode) {
return (mode & 61440) === 4096;
},isSocket:function (mode) {
return (mode & 49152) === 49152;
},flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
var flags = FS.flagModes[str];
if (typeof flags === 'undefined') {
throw new Error('Unknown file open mode: ' + str);
}
return flags;
},flagsToPermissionString:function (flag) {
var perms = ['r', 'w', 'rw'][flag & 3];
if ((flag & 512)) {
perms += 'w';
}
return perms;
},nodePermissions:function (node, perms) {
if (FS.ignorePermissions) {
return 0;
}
// return 0 if any user, group or owner bits are set.
if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
return ERRNO_CODES.EACCES;
} else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
return ERRNO_CODES.EACCES;
} else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
return ERRNO_CODES.EACCES;
}
return 0;
},mayLookup:function (dir) {
var err = FS.nodePermissions(dir, 'x');
if (err) return err;
if (!dir.node_ops.lookup) return ERRNO_CODES.EACCES;
return 0;
},mayCreate:function (dir, name) {
try {
var node = FS.lookupNode(dir, name);
return ERRNO_CODES.EEXIST;
} 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 err = FS.nodePermissions(dir, 'wx');
if (err) {
return err;
}
if (isdir) {
if (!FS.isDir(node.mode)) {
return ERRNO_CODES.ENOTDIR;
}
if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
return ERRNO_CODES.EBUSY;
}
} else {
if (FS.isDir(node.mode)) {
return ERRNO_CODES.EISDIR;
}
}
return 0;
},mayOpen:function (node, flags) {
if (!node) {
return ERRNO_CODES.ENOENT;
}
if (FS.isLink(node.mode)) {
return ERRNO_CODES.ELOOP;
} 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 ERRNO_CODES.EISDIR;
}
}
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
},MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
fd_start = fd_start || 0;
fd_end = fd_end || FS.MAX_OPEN_FDS;
for (var fd = fd_start; fd <= fd_end; fd++) {
if (!FS.streams[fd]) {
return fd;
}
}
throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
},getStream:function (fd) {
return FS.streams[fd];
},createStream:function (stream, fd_start, fd_end) {
if (!FS.FSStream) {
FS.FSStream = function(){};
FS.FSStream.prototype = {};
// compatibility
Object.defineProperties(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(ERRNO_CODES.ESPIPE);
}},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) {
console.log('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(err) {
assert(FS.syncFSRequests > 0);
FS.syncFSRequests--;
return callback(err);
}
function done(err) {
if (err) {
if (!done.errored) {
done.errored = true;
return doCallback(err);
}
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) {
var root = mountpoint === '/';
var pseudo = !mountpoint;
var node;
if (root && FS.root) {
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
} 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(ERRNO_CODES.EBUSY);
}
if (!FS.isDir(node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
}
}
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(ERRNO_CODES.EINVAL);
}
// destroy the nodes for this mount, and all its child mounts
var node = lookup.node;
var mount = node.mounted;
var mounts = FS.getMounts(mount);
Object.keys(FS.nameTable).forEach(function (hash) {
var current = FS.nameTable[hash];
while (current) {
var next = current.name_next;
if (mounts.indexOf(current.mount) !== -1) {
FS.destroyNode(current);
}
current = next;
}
});
// no longer a mountpoint
node.mounted = null;
// remove this mount from the child mounts
var idx = node.mount.mounts.indexOf(mount);
assert(idx !== -1);
node.mount.mounts.splice(idx, 1);
},lookup:function (parent, name) {
return parent.node_ops.lookup(parent, name);
},mknod:function (path, mode, dev) {
var lookup = FS.lookupPath(path, { parent: true });
var parent = lookup.node;
var name = PATH.basename(path);
if (!name || name === '.' || name === '..') {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
var err = FS.mayCreate(parent, name);
if (err) {
throw new FS.ErrnoError(err);
}
if (!parent.node_ops.mknod) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
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 != ERRNO_CODES.EEXIST) 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.resolve(oldpath)) {
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
}
var lookup = FS.lookupPath(newpath, { parent: true });
var parent = lookup.node;
if (!parent) {
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
}
var newname = PATH.basename(newpath);
var err = FS.mayCreate(parent, newname);
if (err) {
throw new FS.ErrnoError(err);
}
if (!parent.node_ops.symlink) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
return parent.node_ops.symlink(parent, newname, oldpath);
},rename:function (old_path, new_path) {
var old_dirname = PATH.dirname(old_path);
var new_dirname = PATH.dirname(new_path);
var old_name = PATH.basename(old_path);
var new_name = PATH.basename(new_path);
// parents must exist
var lookup, old_dir, new_dir;
try {
lookup = FS.lookupPath(old_path, { parent: true });
old_dir = lookup.node;
lookup = FS.lookupPath(new_path, { parent: true });
new_dir = lookup.node;
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
}
if (!old_dir || !new_dir) throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
// need to be part of the same mount
if (old_dir.mount !== new_dir.mount) {
throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
}
// 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.relative(old_path, new_dirname);
if (relative.charAt(0) !== '.') {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
// new path should not be an ancestor of the old path
relative = PATH.relative(new_path, old_dirname);
if (relative.charAt(0) !== '.') {
throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
}
// 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 err = FS.mayDelete(old_dir, old_name, isdir);
if (err) {
throw new FS.ErrnoError(err);
}
// need delete permissions if we'll be overwriting.
// need create permissions if new doesn't already exist.
err = new_node ?
FS.mayDelete(new_dir, new_name, isdir) :
FS.mayCreate(new_dir, new_name);
if (err) {
throw new FS.ErrnoError(err);
}
if (!old_dir.node_ops.rename) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
}
// if we are going to change the parent, check write permissions
if (new_dir !== old_dir) {
err = FS.nodePermissions(old_dir, 'w');
if (err) {
throw new FS.ErrnoError(err);
}
}
try {
if (FS.trackingDelegate['willMovePath']) {
FS.trackingDelegate['willMovePath'](old_path, new_path);
}
} catch(e) {
console.log("FS.trackingDelegate['willMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message);
}
// remove the node from the lookup hash
FS.hashRemoveNode(old_node);
// do the underlying fs rename
try {
old_dir.node_ops.rename(old_node, new_dir, new_name);
} catch (e) {
throw e;
} finally {
// add the node back to the hash (in case node_ops.rename
// changed its name)
FS.hashAddNode(old_node);
}
try {
if (FS.trackingDelegate['onMovePath']) FS.trackingDelegate['onMovePath'](old_path, new_path);
} catch(e) {
console.log("FS.trackingDelegate['onMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message);
}
},rmdir:function (path) {
var lookup = FS.lookupPath(path, { parent: true });
var parent = lookup.node;
var name = PATH.basename(path);
var node = FS.lookupNode(parent, name);
var err = FS.mayDelete(parent, name, true);
if (err) {
throw new FS.ErrnoError(err);
}
if (!parent.node_ops.rmdir) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
if (FS.isMountpoint(node)) {
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
}
try {
if (FS.trackingDelegate['willDeletePath']) {
FS.trackingDelegate['willDeletePath'](path);
}
} catch(e) {
console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message);
}
parent.node_ops.rmdir(parent, name);
FS.destroyNode(node);
try {
if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path);
} catch(e) {
console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message);
}
},readdir:function (path) {
var lookup = FS.lookupPath(path, { follow: true });
var node = lookup.node;
if (!node.node_ops.readdir) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
}
return node.node_ops.readdir(node);
},unlink:function (path) {
var lookup = FS.lookupPath(path, { parent: true });
var parent = lookup.node;
var name = PATH.basename(path);
var node = FS.lookupNode(parent, name);
var err = FS.mayDelete(parent, name, false);
if (err) {
// 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(err);
}
if (!parent.node_ops.unlink) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
if (FS.isMountpoint(node)) {
throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
}
try {
if (FS.trackingDelegate['willDeletePath']) {
FS.trackingDelegate['willDeletePath'](path);
}
} catch(e) {
console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message);
}
parent.node_ops.unlink(parent, name);
FS.destroyNode(node);
try {
if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path);
} catch(e) {
console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message);
}
},readlink:function (path) {
var lookup = FS.lookupPath(path);
var link = lookup.node;
if (!link) {
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
}
if (!link.node_ops.readlink) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
return PATH.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(ERRNO_CODES.ENOENT);
}
if (!node.node_ops.getattr) {
throw new FS.ErrnoError(ERRNO_CODES.EPERM);
}
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(ERRNO_CODES.EPERM);
}
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(ERRNO_CODES.EBADF);
}
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(ERRNO_CODES.EPERM);
}
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(ERRNO_CODES.EBADF);
}
FS.chown(stream.node, uid, gid);
},truncate:function (path, len) {
if (len < 0) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
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(ERRNO_CODES.EPERM);
}
if (FS.isDir(node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
}
if (!FS.isFile(node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
var err = FS.nodePermissions(node, 'w');
if (err) {
throw new FS.ErrnoError(err);
}
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(ERRNO_CODES.EBADF);
}
if ((stream.flags & 2097155) === 0) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
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(ERRNO_CODES.ENOENT);
}
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(ERRNO_CODES.EEXIST);
}
} else {
// node doesn't exist, try to create it
node = FS.mknod(path, mode, 0);
created = true;
}
}
if (!node) {
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
}
// 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(ERRNO_CODES.ENOTDIR);
}
// 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 err = FS.mayOpen(node, flags);
if (err) {
throw new FS.ErrnoError(err);
}
}
// 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);
// register the stream with the filesystem
var stream = FS.createStream({
node: node,
path: FS.getPath(node), // we want the absolute path to the node
flags: flags,
seekable: true,
position: 0,
stream_ops: node.stream_ops,
// used by the file family libc calls (fopen, fwrite, ferror, etc.)
ungotten: [],
error: false
}, fd_start, fd_end);
// call the new stream's open function
if (stream.stream_ops.open) {
stream.stream_ops.open(stream);
}
if (Module['logReadFiles'] && !(flags & 1)) {
if (!FS.readFiles) FS.readFiles = {};
if (!(path in FS.readFiles)) {
FS.readFiles[path] = 1;
console.log("FS.trackingDelegate error on read file: " + path);
}
}
try {
if (FS.trackingDelegate['onOpenFile']) {
var trackingFlags = 0;
if ((flags & 2097155) !== 1) {
trackingFlags |= FS.tracking.openFlags.READ;
}
if ((flags & 2097155) !== 0) {
trackingFlags |= FS.tracking.openFlags.WRITE;
}
FS.trackingDelegate['onOpenFile'](path, trackingFlags);
}
} catch(e) {
console.log("FS.trackingDelegate['onOpenFile']('"+path+"', flags) threw an exception: " + e.message);
}
return stream;
},close:function (stream) {
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
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(ERRNO_CODES.EBADF);
}
if (!stream.seekable || !stream.stream_ops.llseek) {
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
}
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(ERRNO_CODES.EINVAL);
}
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
if ((stream.flags & 2097155) === 1) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
if (FS.isDir(stream.node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
}
if (!stream.stream_ops.read) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
var seeking = typeof position !== 'undefined';
if (!seeking) {
position = stream.position;
} else if (!stream.seekable) {
throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
}
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(ERRNO_CODES.EINVAL);
}
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
if ((stream.flags & 2097155) === 0) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
if (FS.isDir(stream.node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
}
if (!stream.stream_ops.write) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
if (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(ERRNO_CODES.ESPIPE);
}
var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
if (!seeking) stream.position += bytesWritten;
try {
if (stream.path && FS.trackingDelegate['onWriteToFile']) FS.trackingDelegate['onWriteToFile'](stream.path);
} catch(e) {
console.log("FS.trackingDelegate['onWriteToFile']('"+path+"') threw an exception: " + e.message);
}
return bytesWritten;
},allocate:function (stream, offset, length) {
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
if (offset < 0 || length <= 0) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
if ((stream.flags & 2097155) === 0) {
throw new FS.ErrnoError(ERRNO_CODES.EBADF);
}
if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
}
if (!stream.stream_ops.allocate) {
throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
}
stream.stream_ops.allocate(stream, offset, length);
},mmap:function (stream, buffer, offset, length, position, prot, flags) {
// TODO if PROT is PROT_WRITE, make sure we have write access
if ((stream.flags & 2097155) === 1) {
throw new FS.ErrnoError(ERRNO_CODES.EACCES);
}
if (!stream.stream_ops.mmap) {
throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
}
return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
},msync:function (stream, buffer, offset, length, mmapFlags) {
if (!stream || !stream.stream_ops.msync) {
return 0;
}
return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
},munmap:function (stream) {
return 0;
},ioctl:function (stream, cmd, arg) {
if (!stream.stream_ops.ioctl) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
}
return stream.stream_ops.ioctl(stream, cmd, arg);
},readFile:function (path, opts) {
opts = opts || {};
opts.flags = opts.flags || 'r';
opts.encoding = opts.encoding || 'binary';
if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
throw new Error('Invalid encoding type "' + opts.encoding + '"');
}
var ret;
var stream = FS.open(path, opts.flags);
var stat = FS.stat(path);
var length = stat.size;
var buf = new Uint8Array(length);
FS.read(stream, buf, 0, length, 0);
if (opts.encoding === 'utf8') {
ret = UTF8ArrayToString(buf, 0);
} else if (opts.encoding === 'binary') {
ret = buf;
}
FS.close(stream);
return ret;
},writeFile:function (path, data, opts) {
opts = opts || {};
opts.flags = opts.flags || 'w';
var stream = FS.open(path, opts.flags, opts.mode);
if (typeof data === 'string') {
var buf = new Uint8Array(lengthBytesUTF8(data)+1);
var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
} else if (ArrayBuffer.isView(data)) {
FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
} else {
throw new Error('Unsupported data type');
}
FS.close(stream);
},cwd:function () {
return FS.currentPath;
},chdir:function (path) {
var lookup = FS.lookupPath(path, { follow: true });
if (lookup.node === null) {
throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
}
if (!FS.isDir(lookup.node.mode)) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
}
var err = FS.nodePermissions(lookup.node, 'x');
if (err) {
throw new FS.ErrnoError(err);
}
FS.currentPath = lookup.path;
},createDefaultDirectories:function () {
FS.mkdir('/tmp');
FS.mkdir('/home');
FS.mkdir('/home/web_user');
},createDefaultDevices:function () {
// create /dev
FS.mkdir('/dev');
// setup /dev/null
FS.registerDevice(FS.makedev(1, 3), {
read: function() { return 0; },
write: function(stream, buffer, offset, length, pos) { return length; }
});
FS.mkdev('/dev/null', FS.makedev(1, 3));
// setup /dev/tty and /dev/tty1
// stderr needs to print output using Module['printErr']
// so we register a second tty just for it.
TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
FS.mkdev('/dev/tty', FS.makedev(5, 0));
FS.mkdev('/dev/tty1', FS.makedev(6, 0));
// setup /dev/[u]random
var random_device;
if (typeof crypto !== 'undefined') {
// for modern web browsers
var randomBuffer = new Uint8Array(1);
random_device = function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; };
} else if (ENVIRONMENT_IS_NODE) {
// for nodejs
random_device = function() { return require('crypto')['randomBytes'](1)[0]; };
} else {
// default for ES5 platforms
random_device = function() { abort("random_device"); /*Math.random() is not safe for random number generation, so this fallback random_device implementation aborts... see kripken/emscripten/pull/7096 */ };
}
FS.createDevice('/dev', 'random', random_device);
FS.createDevice('/dev', 'urandom', random_device);
// we're not going to emulate the actual shm device,
// just create the tmp dirs that reside in it commonly
FS.mkdir('/dev/shm');
FS.mkdir('/dev/shm/tmp');
},createSpecialDirectories:function () {
// create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the name of the stream for fd 6 (see test_unistd_ttyname)
FS.mkdir('/proc');
FS.mkdir('/proc/self');
FS.mkdir('/proc/self/fd');
FS.mount({
mount: function() {
var node = FS.createNode('/proc/self', 'fd', 16384 | 511 /* 0777 */, 73);
node.node_ops = {
lookup: function(parent, name) {
var fd = +name;
var stream = FS.getStream(fd);
if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
var ret = {
parent: null,
mount: { mountpoint: 'fake' },
node_ops: { readlink: function() { return stream.path } }
};
ret.parent = ret; // make it look like a simple root node
return ret;
}
};
return node;
}
}, {}, '/proc/self/fd');
},createStandardStreams:function () {
// TODO deprecate the old functionality of a single
// input / output callback and that utilizes FS.createDevice
// and instead require a unique set of stream ops
// by default, we symlink the standard streams to the
// default tty devices. however, if the standard streams
// have been overwritten we create a unique device for
// them instead.
if (Module['stdin']) {
FS.createDevice('/dev', 'stdin', Module['stdin']);
} else {
FS.symlink('/dev/tty', '/dev/stdin');
}
if (Module['stdout']) {
FS.createDevice('/dev', 'stdout', null, Module['stdout']);
} else {
FS.symlink('/dev/tty', '/dev/stdout');
}
if (Module['stderr']) {
FS.createDevice('/dev', 'stderr', null, Module['stderr']);
} else {
FS.symlink('/dev/tty1', '/dev/stderr');
}
// open default streams for the stdin, stdout and stderr devices
var stdin = FS.open('/dev/stdin', 'r');
assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
var stdout = FS.open('/dev/stdout', 'w');
assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
var stderr = FS.open('/dev/stderr', 'w');
assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
},ensureErrnoError:function () {
if (FS.ErrnoError) return;
FS.ErrnoError = function ErrnoError(errno, node) {
this.node = node;
this.setErrno = function(errno) {
this.errno = errno;
for (var key in ERRNO_CODES) {
if (ERRNO_CODES[key] === errno) {
this.code = key;
break;
}
}
};
this.setErrno(errno);
this.message = ERRNO_MESSAGES[errno];
// Node.js compatibility: assigning on this.stack fails on Node 4 (but fixed on Node 8)
if (this.stack) Object.defineProperty(this, "stack", { value: (new Error).stack, writable: true });
};
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)
[ERRNO_CODES.ENOENT].forEach(function(code) {
FS.genericErrors[code] = new FS.ErrnoError(code);
FS.genericErrors[code].stack = '<generic error, no stack>';
});
},staticInit:function () {
FS.ensureErrnoError();
FS.nameTable = new Array(4096);
FS.mount(MEMFS, {}, '/');
FS.createDefaultDirectories();
FS.createDefaultDevices();
FS.createSpecialDirectories();
FS.filesystems = {
'MEMFS': MEMFS,
'IDBFS': IDBFS,
'NODEFS': NODEFS,
'WORKERFS': WORKERFS,
};
},init:function (input, output, error) {
assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
FS.init.initialized = true;
FS.ensureErrnoError();
// Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
Module['stdin'] = input || Module['stdin'];
Module['stdout'] = output || Module['stdout'];
Module['stderr'] = error || Module['stderr'];
FS.createStandardStreams();
},quit:function () {
FS.init.initialized = false;
// force-flush all streams, so we get musl std streams printed out
var fflush = Module['_fflush'];
if (fflush) fflush(0);
// close all of our streams
for (var i = 0; i < FS.streams.length; i++) {
var stream = FS.streams[i];
if (!stream) {
continue;
}
FS.close(stream);
}
},getMode:function (canRead, canWrite) {
var mode = 0;
if (canRead) mode |= 292 | 73;
if (canWrite) mode |= 146;
return mode;
},joinPath:function (parts, forceRelative) {
var path = PATH.join.apply(null, parts);
if (forceRelative && path[0] == '/') path = path.substr(1);
return path;
},absolutePath:function (relative, base) {
return PATH.resolve(base, relative);
},standardizePath:function (path) {
return PATH.normalize(path);
},findObject:function (path, dontResolveLastLink) {
var ret = FS.analyzePath(path, dontResolveLastLink);
if (ret.exists) {
return ret.object;
} else {
___setErrNo(ret.error);
return null;
}
},analyzePath:function (path, dontResolveLastLink) {
// operate from within the context of the symlink's target
try {
var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
path = lookup.path;
} catch (e) {
}
var ret = {
isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
parentExists: false, parentPath: null, parentObject: null
};
try {
var lookup = FS.lookupPath(path, { parent: true });
ret.parentExists = true;
ret.parentPath = lookup.path;
ret.parentObject = lookup.node;
ret.name = PATH.basename(path);
lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
ret.exists = true;
ret.path = lookup.path;
ret.object = lookup.node;
ret.name = lookup.node.name;
ret.isRoot = lookup.path === '/';
} catch (e) {
ret.error = e.errno;
};
return ret;
},createFolder:function (parent, name, canRead, canWrite) {
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
var mode = FS.getMode(canRead, canWrite);
return FS.mkdir(path, mode);
},createPath:function (parent, path, canRead, canWrite) {
parent = typeof parent === 'string' ? parent : FS.getPath(parent);
var parts = path.split('/').reverse();
while (parts.length) {
var part = parts.pop();
if (!part) continue;
var current = PATH.join2(parent, part);
try {
FS.mkdir(current);
} catch (e) {
// ignore EEXIST
}
parent = current;
}
return current;
},createFile:function (parent, name, properties, canRead, canWrite) {
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
var mode = FS.getMode(canRead, canWrite);
return FS.create(path, mode);
},createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
var mode = FS.getMode(canRead, canWrite);
var node = FS.create(path, mode);
if (data) {
if (typeof data === 'string') {
var arr = new Array(data.length);
for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
data = arr;
}
// make sure we can write to the file
FS.chmod(node, mode | 146);
var stream = FS.open(node, 'w');
FS.write(stream, data, 0, data.length, 0, canOwn);
FS.close(stream);
FS.chmod(node, mode);
}
return node;
},createDevice:function (parent, name, input, output) {
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
var mode = FS.getMode(!!input, !!output);
if (!FS.createDevice.major) FS.createDevice.major = 64;
var dev = FS.makedev(FS.createDevice.major++, 0);
// Create a fake device that a set of stream ops to emulate
// the old behavior.
FS.registerDevice(dev, {
open: function(stream) {
stream.seekable = false;
},
close: function(stream) {
// flush any pending line data
if (output && output.buffer && output.buffer.length) {
output(10);
}
},
read: function(stream, buffer, offset, length, pos /* ignored */) {
var bytesRead = 0;
for (var i = 0; i < length; i++) {
var result;
try {
result = input();
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES.EIO);
}
if (result === undefined && bytesRead === 0) {
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
}
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(ERRNO_CODES.EIO);
}
}
if (length) {
stream.node.timestamp = Date.now();
}
return i;
}
});
return FS.mkdev(path, mode, dev);
},createLink:function (parent, name, target, canRead, canWrite) {
var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
return FS.symlink(target, path);
},forceLoadFile:function (obj) {
if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
var success = true;
if (typeof XMLHttpRequest !== 'undefined') {
throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
} else if (Module['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(Module['read'](obj.url), true);
obj.usedBytes = obj.contents.length;
} catch (e) {
success = false;
}
} else {
throw new Error('Cannot load without read() or XMLHttpRequest.');
}
if (!success) ___setErrNo(ERRNO_CODES.EIO);
return success;
},createLazyFile:function (parent, name, url, canRead, canWrite) {
// Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
function LazyUint8Array() {
this.lengthKnown = false;
this.chunks = []; // Loaded chunks. Index is the chunk number
}
LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
if (idx > this.length-1 || idx < 0) {
return undefined;
}
var chunkOffset = idx % this.chunkSize;
var chunkNum = (idx / this.chunkSize)|0;
return this.getter(chunkNum)[chunkOffset];
}
LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
this.getter = getter;
}
LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
// 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(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;
console.log("LazyFiles on gzip forces download of the whole file when length is accessed");
}
this._length = datalength;
this._chunkSize = chunkSize;
this.lengthKnown = true;
}
if (typeof XMLHttpRequest !== 'undefined') {
if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
var lazyArray = new LazyUint8Array();
Object.defineProperties(lazyArray, {
length: {
get: function() {
if(!this.lengthKnown) {
this.cacheLength();
}
return this._length;
}
},
chunkSize: {
get: function() {
if(!this.lengthKnown) {
this.cacheLength();
}
return this._chunkSize;
}
}
});
var properties = { isDevice: false, contents: lazyArray };
} else {
var properties = { isDevice: false, url: url };
}
var node = FS.createFile(parent, name, properties, canRead, canWrite);
// 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: function() { return this.contents.length; }
}
});
// override each stream op with one that tries to force load the lazy file first
var stream_ops = {};
var keys = Object.keys(node.stream_ops);
keys.forEach(function(key) {
var fn = node.stream_ops[key];
stream_ops[key] = function forceLoadLazyFile() {
if (!FS.forceLoadFile(node)) {
throw new FS.ErrnoError(ERRNO_CODES.EIO);
}
return fn.apply(null, arguments);
};
});
// use a custom read function
stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
if (!FS.forceLoadFile(node)) {
throw new FS.ErrnoError(ERRNO_CODES.EIO);
}
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.resolve(PATH.join2(parent, name)) : parent;
var dep = getUniqueRunDependency('cp ' + fullname); // might have several active requests for the same fullname
function processData(byteArray) {
function finish(byteArray) {
if (preFinish) preFinish();
if (!dontCreateFile) {
FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
}
if (onload) onload();
removeRunDependency(dep);
}
var handled = false;
Module['preloadPlugins'].forEach(function(plugin) {
if (handled) return;
if (plugin['canHandle'](fullname)) {
plugin['handle'](byteArray, fullname, finish, function() {
if (onerror) onerror();
removeRunDependency(dep);
});
handled = true;
}
});
if (!handled) finish(byteArray);
}
addRunDependency(dep);
if (typeof url == 'string') {
Browser.asyncLoad(url, function(byteArray) {
processData(byteArray);
}, onerror);
} else {
processData(url);
}
},indexedDB:function () {
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
},DB_NAME:function () {
return 'EM_FS_' + window.location.pathname;
},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
onload = onload || function(){};
onerror = onerror || function(){};
var indexedDB = FS.indexedDB();
try {
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
} catch (e) {
return onerror(e);
}
openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
console.log('creating db');
var db = openRequest.result;
db.createObjectStore(FS.DB_STORE_NAME);
};
openRequest.onsuccess = function openRequest_onsuccess() {
var db = openRequest.result;
var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
var files = transaction.objectStore(FS.DB_STORE_NAME);
var ok = 0, fail = 0, total = paths.length;
function finish() {
if (fail == 0) onload(); else onerror();
}
paths.forEach(function(path) {
var putRequest = files.put(FS.analyzePath(path).object.contents, path);
putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
});
transaction.onerror = onerror;
};
openRequest.onerror = onerror;
},loadFilesFromDB:function (paths, onload, onerror) {
onload = onload || function(){};
onerror = onerror || function(){};
var indexedDB = FS.indexedDB();
try {
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
} catch (e) {
return onerror(e);
}
openRequest.onupgradeneeded = onerror; // no database to load from
openRequest.onsuccess = function openRequest_onsuccess() {
var db = openRequest.result;
try {
var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
} catch(e) {
onerror(e);
return;
}
var files = transaction.objectStore(FS.DB_STORE_NAME);
var ok = 0, fail = 0, total = paths.length;
function finish() {
if (fail == 0) onload(); else onerror();
}
paths.forEach(function(path) {
var getRequest = files.get(path);
getRequest.onsuccess = function getRequest_onsuccess() {
if (FS.analyzePath(path).exists) {
FS.unlink(path);
}
FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
ok++;
if (ok + fail == total) finish();
};
getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
});
transaction.onerror = onerror;
};
openRequest.onerror = onerror;
}};var SOCKFS={mount:function (mount) {
// If Module['websocket'] has already been defined (e.g. for configuring
// the subprotocol/url) use that, if not initialise it to a new object.
Module['websocket'] = (Module['websocket'] &&
('object' === typeof Module['websocket'])) ? Module['websocket'] : {};
// Add the Event registration mechanism to the exported websocket configuration
// object so we can register network callbacks from native JavaScript too.
// For more documentation see system/include/emscripten/emscripten.h
Module['websocket']._callbacks = {};
Module['websocket']['on'] = function(event, callback) {
if ('function' === typeof callback) {
this._callbacks[event] = callback;
}
return this;
};
Module['websocket'].emit = function(event, param) {
if ('function' === typeof this._callbacks[event]) {
this._callbacks[event].call(this, param);
}
};
// If debug is enabled register simple default logging callbacks for each Event.
return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
},createSocket:function (family, type, protocol) {
var streaming = type == 1;
if (protocol) {
assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
}
// create our internal socket structure
var sock = {
family: family,
type: type,
protocol: protocol,
server: null,
error: null, // Used in getsockopt for SOL_SOCKET/SO_ERROR test
peers: {},
pending: [],
recv_queue: [],
sock_ops: SOCKFS.websocket_sock_ops
};
// create the filesystem node to store the socket structure
var name = SOCKFS.nextname();
var node = FS.createNode(SOCKFS.root, name, 49152, 0);
node.sock = sock;
// and the wrapping stream that enables library functions such
// as read and write to indirectly interact with the socket
var stream = FS.createStream({
path: name,
node: node,
flags: FS.modeStringToFlags('r+'),
seekable: false,
stream_ops: SOCKFS.stream_ops
});
// map the new stream to the socket structure (sockets have a 1:1
// relationship with a stream)
sock.stream = stream;
return sock;
},getSocket:function (fd) {
var stream = FS.getStream(fd);
if (!stream || !FS.isSocket(stream.node.mode)) {
return null;
}
return stream.node.sock;
},stream_ops:{poll:function (stream) {
var sock = stream.node.sock;
return sock.sock_ops.poll(sock);
},ioctl:function (stream, request, varargs) {
var sock = stream.node.sock;
return sock.sock_ops.ioctl(sock, request, varargs);
},read:function (stream, buffer, offset, length, position /* ignored */) {
var sock = stream.node.sock;
var msg = sock.sock_ops.recvmsg(sock, length);
if (!msg) {
// socket is closed
return 0;
}
buffer.set(msg.buffer, offset);
return msg.buffer.length;
},write:function (stream, buffer, offset, length, position /* ignored */) {
var sock = stream.node.sock;
return sock.sock_ops.sendmsg(sock, buffer, offset, length);
},close:function (stream) {
var sock = stream.node.sock;
sock.sock_ops.close(sock);
}},nextname:function () {
if (!SOCKFS.nextname.current) {
SOCKFS.nextname.current = 0;
}
return 'socket[' + (SOCKFS.nextname.current++) + ']';
},websocket_sock_ops:{createPeer:function (sock, addr, port) {
var ws;
if (typeof addr === 'object') {
ws = addr;
addr = null;
port = null;
}
if (ws) {
// for sockets that've already connected (e.g. we're the server)
// we can inspect the _socket property for the address
if (ws._socket) {
addr = ws._socket.remoteAddress;
port = ws._socket.remotePort;
}
// if we're just now initializing a connection to the remote,
// inspect the url property
else {
var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
if (!result) {
throw new Error('WebSocket URL must be in the format ws(s)://address:port');
}
addr = result[1];
port = parseInt(result[2], 10);
}
} else {
// create the actual websocket object and connect
try {
// runtimeConfig gets set to true if WebSocket runtime configuration is available.
var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
// The default value is 'ws://' the replace is needed because the compiler replaces '//' comments with '#'
// comments without checking context, so we'd end up with ws:#, the replace swaps the '#' for '//' again.
var url = 'ws:#'.replace('#', '//');
if (runtimeConfig) {
if ('string' === typeof Module['websocket']['url']) {
url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
}
}
if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
var parts = addr.split('/');
url = url + parts[0] + ":" + port + "/" + parts.slice(1).join('/');
}
// Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
var subProtocols = 'binary'; // The default value is 'binary'
if (runtimeConfig) {
if ('string' === typeof Module['websocket']['subprotocol']) {
subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
}
}
// The regex trims the string (removes spaces at the beginning and end, then splits the string by
// <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
// The node ws library API for specifying optional subprotocol is slightly different than the browser's.
var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
// some webservers (azure) does not support subprotocol header
if (runtimeConfig && null === Module['websocket']['subprotocol']) {
subProtocols = 'null';
opts = undefined;
}
// If node we use the ws library.
var WebSocketConstructor;
if (ENVIRONMENT_IS_NODE) {
WebSocketConstructor = require('ws');
} else if (ENVIRONMENT_IS_WEB) {
WebSocketConstructor = window['WebSocket'];
} else {
WebSocketConstructor = WebSocket;
}
ws = new WebSocketConstructor(url, opts);
ws.binaryType = 'arraybuffer';
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
}
}
var peer = {
addr: addr,
port: port,
socket: ws,
dgram_send_queue: []
};
SOCKFS.websocket_sock_ops.addPeer(sock, peer);
SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
// if this is a bound dgram socket, send the port number first to allow
// us to override the ephemeral port reported to us by remotePort on the
// remote end.
if (sock.type === 2 && typeof sock.sport !== 'undefined') {
peer.dgram_send_queue.push(new Uint8Array([
255, 255, 255, 255,
'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
]));
}
return peer;
},getPeer:function (sock, addr, port) {
return sock.peers[addr + ':' + port];
},addPeer:function (sock, peer) {
sock.peers[peer.addr + ':' + peer.port] = peer;
},removePeer:function (sock, peer) {
delete sock.peers[peer.addr + ':' + peer.port];
},handlePeerEvents:function (sock, peer) {
var first = true;
var handleOpen = function () {
Module['websocket'].emit('open', sock.stream.fd);
try {
var queued = peer.dgram_send_queue.shift();
while (queued) {
peer.socket.send(queued);
queued = peer.dgram_send_queue.shift();
}
} catch (e) {
// not much we can do here in the way of proper error handling as we've already
// lied and said this data was sent. shut it down.
peer.socket.close();
}
};
function handleMessage(data) {
assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
// An empty ArrayBuffer will emit a pseudo disconnect event
// as recv/recvmsg will return zero which indicates that a socket
// has performed a shutdown although the connection has not been disconnected yet.
if (data.byteLength == 0) {
return;
}
data = new Uint8Array(data); // make a typed array view on the array buffer
// if this is the port message, override the peer's port with it
var wasfirst = first;
first = false;
if (wasfirst &&
data.length === 10 &&
data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
// update the peer's port and it's key in the peer map
var newport = ((data[8] << 8) | data[9]);
SOCKFS.websocket_sock_ops.removePeer(sock, peer);
peer.port = newport;
SOCKFS.websocket_sock_ops.addPeer(sock, peer);
return;
}
sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
Module['websocket'].emit('message', sock.stream.fd);
};
if (ENVIRONMENT_IS_NODE) {
peer.socket.on('open', handleOpen);
peer.socket.on('message', function(data, flags) {
if (!flags.binary) {
return;
}
handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
});
peer.socket.on('close', function() {
Module['websocket'].emit('close', sock.stream.fd);
});
peer.socket.on('error', function(error) {
// Although the ws library may pass errors that may be more descriptive than
// ECONNREFUSED they are not necessarily the expected error code e.g.
// ENOTFOUND on getaddrinfo seems to be node.js specific, so using ECONNREFUSED
// is still probably the most useful thing to do.
sock.error = ERRNO_CODES.ECONNREFUSED; // Used in getsockopt for SOL_SOCKET/SO_ERROR test.
Module['websocket'].emit('error', [sock.stream.fd, sock.error, 'ECONNREFUSED: Connection refused']);
// don't throw
});
} else {
peer.socket.onopen = handleOpen;
peer.socket.onclose = function() {
Module['websocket'].emit('close', sock.stream.fd);
};
peer.socket.onmessage = function peer_socket_onmessage(event) {
handleMessage(event.data);
};
peer.socket.onerror = function(error) {
// The WebSocket spec only allows a 'simple event' to be thrown on error,
// so we only really know as much as ECONNREFUSED.
sock.error = ERRNO_CODES.ECONNREFUSED; // Used in getsockopt for SOL_SOCKET/SO_ERROR test.
Module['websocket'].emit('error', [sock.stream.fd, sock.error, 'ECONNREFUSED: Connection refused']);
};
}
},poll:function (sock) {
if (sock.type === 1 && sock.server) {
// listen sockets should only say they're available for reading
// if there are pending clients.
return sock.pending.length ? (64 | 1) : 0;
}
var mask = 0;
var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
null;
if (sock.recv_queue.length ||
!dest || // connection-less sockets are always ready to read
(dest && dest.socket.readyState === dest.socket.CLOSING) ||
(dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
mask |= (64 | 1);
}
if (!dest || // connection-less sockets are always ready to write
(dest && dest.socket.readyState === dest.socket.OPEN)) {
mask |= 4;
}
if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
(dest && dest.socket.readyState === dest.socket.CLOSED)) {
mask |= 16;
}
return mask;
},ioctl:function (sock, request, arg) {
switch (request) {
case 21531:
var bytes = 0;
if (sock.recv_queue.length) {
bytes = sock.recv_queue[0].data.length;
}
HEAP32[((arg)>>2)]=bytes;
return 0;
default:
return ERRNO_CODES.EINVAL;
}
},close:function (sock) {
// if we've spawned a listen server, close it
if (sock.server) {
try {
sock.server.close();
} catch (e) {
}
sock.server = null;
}
// close any peer connections
var peers = Object.keys(sock.peers);
for (var i = 0; i < peers.length; i++) {
var peer = sock.peers[peers[i]];
try {
peer.socket.close();
} catch (e) {
}
SOCKFS.websocket_sock_ops.removePeer(sock, peer);
}
return 0;
},bind:function (sock, addr, port) {
if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
}
sock.saddr = addr;
sock.sport = port;
// in order to emulate dgram sockets, we need to launch a listen server when
// binding on a connection-less socket
// note: this is only required on the server side
if (sock.type === 2) {
// close the existing server if it exists
if (sock.server) {
sock.server.close();
sock.server = null;
}
// swallow error operation not supported error that occurs when binding in the
// browser where this isn't supported
try {
sock.sock_ops.listen(sock, 0);
} catch (e) {
if (!(e instanceof FS.ErrnoError)) throw e;
if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
}
}
},connect:function (sock, addr, port) {
if (sock.server) {
throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
}
// TODO autobind
// if (!sock.addr && sock.type == 2) {
// }
// early out if we're already connected / in the middle of connecting
if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
if (dest) {
if (dest.socket.readyState === dest.socket.CONNECTING) {
throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
} else {
throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
}
}
}
// add the socket to our peer list and set our
// destination address / port to match
var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
sock.daddr = peer.addr;
sock.dport = peer.port;
// always "fail" in non-blocking mode
throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
},listen:function (sock, backlog) {
if (!ENVIRONMENT_IS_NODE) {
throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
}
if (sock.server) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
}
var WebSocketServer = require('ws').Server;
var host = sock.saddr;
sock.server = new WebSocketServer({
host: host,
port: sock.sport
// TODO support backlog
});
Module['websocket'].emit('listen', sock.stream.fd); // Send Event with listen fd.
sock.server.on('connection', function(ws) {
if (sock.type === 1) {
var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
// create a peer on the new socket
var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
newsock.daddr = peer.addr;
newsock.dport = peer.port;
// push to queue for accept to pick up
sock.pending.push(newsock);
Module['websocket'].emit('connection', newsock.stream.fd);
} else {
// create a peer on the listen socket so calling sendto
// with the listen socket and an address will resolve
// to the correct client
SOCKFS.websocket_sock_ops.createPeer(sock, ws);
Module['websocket'].emit('connection', sock.stream.fd);
}
});
sock.server.on('closed', function() {
Module['websocket'].emit('close', sock.stream.fd);
sock.server = null;
});
sock.server.on('error', function(error) {
// Although the ws library may pass errors that may be more descriptive than
// ECONNREFUSED they are not necessarily the expected error code e.g.
// ENOTFOUND on getaddrinfo seems to be node.js specific, so using EHOSTUNREACH
// is still probably the most useful thing to do. This error shouldn't
// occur in a well written app as errors should get trapped in the compiled
// app's own getaddrinfo call.
sock.error = ERRNO_CODES.EHOSTUNREACH; // Used in getsockopt for SOL_SOCKET/SO_ERROR test.
Module['websocket'].emit('error', [sock.stream.fd, sock.error, 'EHOSTUNREACH: Host is unreachable']);
// don't throw
});
},accept:function (listensock) {
if (!listensock.server) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
var newsock = listensock.pending.shift();
newsock.stream.flags = listensock.stream.flags;
return newsock;
},getname:function (sock, peer) {
var addr, port;
if (peer) {
if (sock.daddr === undefined || sock.dport === undefined) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
}
addr = sock.daddr;
port = sock.dport;
} else {
// TODO saddr and sport will be set for bind()'d UDP sockets, but what
// should we be returning for TCP sockets that've been connect()'d?
addr = sock.saddr || 0;
port = sock.sport || 0;
}
return { addr: addr, port: port };
},sendmsg:function (sock, buffer, offset, length, addr, port) {
if (sock.type === 2) {
// connection-less sockets will honor the message address,
// and otherwise fall back to the bound destination address
if (addr === undefined || port === undefined) {
addr = sock.daddr;
port = sock.dport;
}
// if there was no address to fall back to, error out
if (addr === undefined || port === undefined) {
throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
}
} else {
// connection-based sockets will only use the bound
addr = sock.daddr;
port = sock.dport;
}
// find the peer for the destination address
var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
// early out if not connected with a connection-based socket
if (sock.type === 1) {
if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
} else if (dest.socket.readyState === dest.socket.CONNECTING) {
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
}
}
// create a copy of the incoming data to send, as the WebSocket API
// doesn't work entirely with an ArrayBufferView, it'll just send
// the entire underlying buffer
if (ArrayBuffer.isView(buffer)) {
offset += buffer.byteOffset;
buffer = buffer.buffer;
}
var data;
data = buffer.slice(offset, offset + length);
// if we're emulating a connection-less dgram socket and don't have
// a cached connection, queue the buffer to send upon connect and
// lie, saying the data was sent now.
if (sock.type === 2) {
if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
// if we're not connected, open a new connection
if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
}
dest.dgram_send_queue.push(data);
return length;
}
}
try {
// send the actual data
dest.socket.send(data);
return length;
} catch (e) {
throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
}
},recvmsg:function (sock, length) {
// http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
if (sock.type === 1 && sock.server) {
// tcp servers should not be recv()'ing on the listen socket
throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
}
var queued = sock.recv_queue.shift();
if (!queued) {
if (sock.type === 1) {
var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
if (!dest) {
// if we have a destination address but are not connected, error out
throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
}
else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
// return null if the socket has closed
return null;
}
else {
// else, our socket is in a valid state but truly has nothing available
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
}
} else {
throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
}
}
// queued.data will be an ArrayBuffer if it's unadulterated, but if it's
// requeued TCP data it'll be an ArrayBufferView
var queuedLength = queued.data.byteLength || queued.data.length;
var queuedOffset = queued.data.byteOffset || 0;
var queuedBuffer = queued.data.buffer || queued.data;
var bytesRead = Math.min(length, queuedLength);
var res = {
buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
addr: queued.addr,
port: queued.port
};
// push back any unread data for TCP connections
if (sock.type === 1 && bytesRead < queuedLength) {
var bytesRemaining = queuedLength - bytesRead;
queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
sock.recv_queue.unshift(queued);
}
return res;
}}};
function __inet_pton4_raw(str) {
var b = str.split('.');
for (var i = 0; i < 4; i++) {
var tmp = Number(b[i]);
if (isNaN(tmp)) return null;
b[i] = tmp;
}
return (b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0;
}
function __inet_pton6_raw(str) {
var words;
var w, offset, z, i;
/* http://home.deds.nl/~aeron/regex/ */
var valid6regx = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i
var parts = [];
if (!valid6regx.test(str)) {
return null;
}
if (str === "::") {
return [0, 0, 0, 0, 0, 0, 0, 0];
}
// Z placeholder to keep track of zeros when splitting the string on ":"
if (str.indexOf("::") === 0) {
str = str.replace("::", "Z:"); // leading zeros case
} else {
str = str.replace("::", ":Z:");
}
if (str.indexOf(".") > 0) {
// parse IPv4 embedded stress
str = str.replace(new RegExp('[.]', 'g'), ":");
words = str.split(":");
words[words.length-4] = parseInt(words[words.length-4]) + parseInt(words[words.length-3])*256;
words[words.length-3] = parseInt(words[words.length-2]) + parseInt(words[words.length-1])*256;
words = words.slice(0, words.length-2);
} else {
words = str.split(":");
}
offset = 0; z = 0;
for (w=0; w < words.length; w++) {
if (typeof words[w] === 'string') {
if (words[w] === 'Z') {
// compressed zeros - write appropriate number of zero words
for (z = 0; z < (8 - words.length+1); z++) {
parts[w+z] = 0;
}
offset = z-1;
} else {
// parse hex to field to 16-bit value and write it in network byte-order
parts[w+offset] = _htons(parseInt(words[w],16));
}
} else {
// parsed IPv4 words
parts[w+offset] = words[w];
}
}
return [
(parts[1] << 16) | parts[0],
(parts[3] << 16) | parts[2],
(parts[5] << 16) | parts[4],
(parts[7] << 16) | parts[6]
];
}var DNS={address_map:{id:1,addrs:{},names:{}},lookup_name:function (name) {
// If the name is already a valid ipv4 / ipv6 address, don't generate a fake one.
var res = __inet_pton4_raw(name);
if (res !== null) {
return name;
}
res = __inet_pton6_raw(name);
if (res !== null) {
return name;
}
// See if this name is already mapped.
var addr;
if (DNS.address_map.addrs[name]) {
addr = DNS.address_map.addrs[name];
} else {
var id = DNS.address_map.id++;
assert(id < 65535, 'exceeded max address mappings of 65535');
addr = '172.29.' + (id & 0xff) + '.' + (id & 0xff00);
DNS.address_map.names[addr] = name;
DNS.address_map.addrs[name] = addr;
}
return addr;
},lookup_addr:function (addr) {
if (DNS.address_map.names[addr]) {
return DNS.address_map.names[addr];
}
return null;
}};
var Sockets={BUFFER_SIZE:10240,MAX_BUFFER_SIZE:10485760,nextFd:1,fds:{},nextport:1,maxport:65535,peer:null,connections:{},portmap:{},localAddr:4261412874,addrPool:[33554442,50331658,67108874,83886090,100663306,117440522,134217738,150994954,167772170,184549386,201326602,218103818,234881034]};
function __inet_ntop4_raw(addr) {
return (addr & 0xff) + '.' + ((addr >> 8) & 0xff) + '.' + ((addr >> 16) & 0xff) + '.' + ((addr >> 24) & 0xff)
}
function __inet_ntop6_raw(ints) {
// ref: http://www.ietf.org/rfc/rfc2373.txt - section 2.5.4
// Format for IPv4 compatible and mapped 128-bit IPv6 Addresses
// 128-bits are split into eight 16-bit words
// stored in network byte order (big-endian)
// | 80 bits | 16 | 32 bits |
// +-----------------------------------------------------------------+
// | 10 bytes | 2 | 4 bytes |
// +--------------------------------------+--------------------------+
// + 5 words | 1 | 2 words |
// +--------------------------------------+--------------------------+
// |0000..............................0000|0000| IPv4 ADDRESS | (compatible)
// +--------------------------------------+----+---------------------+
// |0000..............................0000|FFFF| IPv4 ADDRESS | (mapped)
// +--------------------------------------+----+---------------------+
var str = "";
var word = 0;
var longest = 0;
var lastzero = 0;
var zstart = 0;
var len = 0;
var i = 0;
var parts = [
ints[0] & 0xffff,
(ints[0] >> 16),
ints[1] & 0xffff,
(ints[1] >> 16),
ints[2] & 0xffff,
(ints[2] >> 16),
ints[3] & 0xffff,
(ints[3] >> 16)
];
// Handle IPv4-compatible, IPv4-mapped, loopback and any/unspecified addresses
var hasipv4 = true;
var v4part = "";
// check if the 10 high-order bytes are all zeros (first 5 words)
for (i = 0; i < 5; i++) {
if (parts[i] !== 0) { hasipv4 = false; break; }
}
if (hasipv4) {
// low-order 32-bits store an IPv4 address (bytes 13 to 16) (last 2 words)
v4part = __inet_ntop4_raw(parts[6] | (parts[7] << 16));
// IPv4-mapped IPv6 address if 16-bit value (bytes 11 and 12) == 0xFFFF (6th word)
if (parts[5] === -1) {
str = "::ffff:";
str += v4part;
return str;
}
// IPv4-compatible IPv6 address if 16-bit value (bytes 11 and 12) == 0x0000 (6th word)
if (parts[5] === 0) {
str = "::";
//special case IPv6 addresses
if(v4part === "0.0.0.0") v4part = ""; // any/unspecified address
if(v4part === "0.0.0.1") v4part = "1";// loopback address
str += v4part;
return str;
}
}
// Handle all other IPv6 addresses
// first run to find the longest contiguous zero words
for (word = 0; word < 8; word++) {
if (parts[word] === 0) {
if (word - lastzero > 1) {
len = 0;
}
lastzero = word;
len++;
}
if (len > longest) {
longest = len;
zstart = word - longest + 1;
}
}
for (word = 0; word < 8; word++) {
if (longest > 1) {
// compress contiguous zeros - to produce "::"
if (parts[word] === 0 && word >= zstart && word < (zstart + longest) ) {
if (word === zstart) {
str += ":";
if (zstart === 0) str += ":"; //leading zeros case
}
continue;
}
}
// converts 16-bit words from big-endian to little-endian before converting to hex string
str += Number(_ntohs(parts[word] & 0xffff)).toString(16);
str += word < 7 ? ":" : "";
}
return str;
}function __read_sockaddr(sa, salen) {
// family / port offsets are common to both sockaddr_in and sockaddr_in6
var family = HEAP16[((sa)>>1)];
var port = _ntohs(HEAP16[(((sa)+(2))>>1)]);
var addr;
switch (family) {
case 2:
if (salen !== 16) {
return { errno: ERRNO_CODES.EINVAL };
}
addr = HEAP32[(((sa)+(4))>>2)];
addr = __inet_ntop4_raw(addr);
break;
case 10:
if (salen !== 28) {
return { errno: ERRNO_CODES.EINVAL };
}
addr = [
HEAP32[(((sa)+(8))>>2)],
HEAP32[(((sa)+(12))>>2)],
HEAP32[(((sa)+(16))>>2)],
HEAP32[(((sa)+(20))>>2)]
];
addr = __inet_ntop6_raw(addr);
break;
default:
return { errno: ERRNO_CODES.EAFNOSUPPORT };
}
return { family: family, addr: addr, port: port };
}
function __write_sockaddr(sa, family, addr, port) {
switch (family) {
case 2:
addr = __inet_pton4_raw(addr);
HEAP16[((sa)>>1)]=family;
HEAP32[(((sa)+(4))>>2)]=addr;
HEAP16[(((sa)+(2))>>1)]=_htons(port);
break;
case 10:
addr = __inet_pton6_raw(addr);
HEAP32[((sa)>>2)]=family;
HEAP32[(((sa)+(8))>>2)]=addr[0];
HEAP32[(((sa)+(12))>>2)]=addr[1];
HEAP32[(((sa)+(16))>>2)]=addr[2];
HEAP32[(((sa)+(20))>>2)]=addr[3];
HEAP16[(((sa)+(2))>>1)]=_htons(port);
HEAP32[(((sa)+(4))>>2)]=0;
HEAP32[(((sa)+(24))>>2)]=0;
break;
default:
return { errno: ERRNO_CODES.EAFNOSUPPORT };
}
// kind of lame, but let's match _read_sockaddr's interface
return {};
}
var SYSCALLS={DEFAULT_POLLMASK:5,mappings:{},umask:511,calculateAt:function (dirfd, path) {
if (path[0] !== '/') {
// relative path
var dir;
if (dirfd === -100) {
dir = FS.cwd();
} else {
var dirstream = FS.getStream(dirfd);
if (!dirstream) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
dir = dirstream.path;
}
path = PATH.join2(dir, path);
}
return path;
},doStat:function (func, path, buf) {
try {
var stat = func(path);
} catch (e) {
if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
// an error occurred while trying to look up the path; we should just report ENOTDIR
return -ERRNO_CODES.ENOTDIR;
}
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;
HEAP32[(((buf)+(36))>>2)]=stat.size;
HEAP32[(((buf)+(40))>>2)]=4096;
HEAP32[(((buf)+(44))>>2)]=stat.blocks;
HEAP32[(((buf)+(48))>>2)]=(stat.atime.getTime() / 1000)|0;
HEAP32[(((buf)+(52))>>2)]=0;
HEAP32[(((buf)+(56))>>2)]=(stat.mtime.getTime() / 1000)|0;
HEAP32[(((buf)+(60))>>2)]=0;
HEAP32[(((buf)+(64))>>2)]=(stat.ctime.getTime() / 1000)|0;
HEAP32[(((buf)+(68))>>2)]=0;
HEAP32[(((buf)+(72))>>2)]=stat.ino;
return 0;
},doMsync:function (addr, stream, len, flags) {
var buffer = new Uint8Array(HEAPU8.subarray(addr, addr + len));
FS.msync(stream, buffer, 0, 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 -ERRNO_CODES.EINVAL;
}
FS.mknod(path, mode, dev);
return 0;
},doReadlink:function (path, buf, bufsize) {
if (bufsize <= 0) return -ERRNO_CODES.EINVAL;
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 -ERRNO_CODES.EINVAL;
}
var node;
var lookup = FS.lookupPath(path, { follow: true });
node = lookup.node;
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 -ERRNO_CODES.EACCES;
}
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:0,get:function (varargs) {
SYSCALLS.varargs += 4;
var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
return ret;
},getStr:function () {
var ret = Pointer_stringify(SYSCALLS.get());
return ret;
},getStreamFromFD:function () {
var stream = FS.getStream(SYSCALLS.get());
if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
return stream;
},getSocketFromFD:function () {
var socket = SOCKFS.getSocket(SYSCALLS.get());
if (!socket) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
return socket;
},getSocketAddress:function (allowNull) {
var addrp = SYSCALLS.get(), addrlen = SYSCALLS.get();
if (allowNull && addrp === 0) return null;
var info = __read_sockaddr(addrp, addrlen);
if (info.errno) throw new FS.ErrnoError(info.errno);
info.addr = DNS.lookup_addr(info.addr) || info.addr;
return info;
},get64:function () {
var low = SYSCALLS.get(), high = SYSCALLS.get();
if (low >= 0) assert(high === 0);
else assert(high === -1);
return low;
},getZero:function () {
assert(SYSCALLS.get() === 0);
}};function ___syscall102(which, varargs) {SYSCALLS.varargs = varargs;
try {
// socketcall
var call = SYSCALLS.get(), socketvararg = SYSCALLS.get();
// socketcalls pass the rest of the arguments in a struct
SYSCALLS.varargs = socketvararg;
switch (call) {
case 1: { // socket
var domain = SYSCALLS.get(), type = SYSCALLS.get(), protocol = SYSCALLS.get();
var sock = SOCKFS.createSocket(domain, type, protocol);
assert(sock.stream.fd < 64); // XXX ? select() assumes socket fd values are in 0..63
return sock.stream.fd;
}
case 2: { // bind
var sock = SYSCALLS.getSocketFromFD(), info = SYSCALLS.getSocketAddress();
sock.sock_ops.bind(sock, info.addr, info.port);
return 0;
}
case 3: { // connect
var sock = SYSCALLS.getSocketFromFD(), info = SYSCALLS.getSocketAddress();
sock.sock_ops.connect(sock, info.addr, info.port);
return 0;
}
case 4: { // listen
var sock = SYSCALLS.getSocketFromFD(), backlog = SYSCALLS.get();
sock.sock_ops.listen(sock, backlog);
return 0;
}
case 5: { // accept
var sock = SYSCALLS.getSocketFromFD(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get();
var newsock = sock.sock_ops.accept(sock);
if (addr) {
var res = __write_sockaddr(addr, newsock.family, DNS.lookup_name(newsock.daddr), newsock.dport);
assert(!res.errno);
}
return newsock.stream.fd;
}
case 6: { // getsockname
var sock = SYSCALLS.getSocketFromFD(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get();
// TODO: sock.saddr should never be undefined, see TODO in websocket_sock_ops.getname
var res = __write_sockaddr(addr, sock.family, DNS.lookup_name(sock.saddr || '0.0.0.0'), sock.sport);
assert(!res.errno);
return 0;
}
case 7: { // getpeername
var sock = SYSCALLS.getSocketFromFD(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get();
if (!sock.daddr) {
return -ERRNO_CODES.ENOTCONN; // The socket is not connected.
}
var res = __write_sockaddr(addr, sock.family, DNS.lookup_name(sock.daddr), sock.dport);
assert(!res.errno);
return 0;
}
case 11: { // sendto
var sock = SYSCALLS.getSocketFromFD(), message = SYSCALLS.get(), length = SYSCALLS.get(), flags = SYSCALLS.get(), dest = SYSCALLS.getSocketAddress(true);
if (!dest) {
// send, no address provided
return FS.write(sock.stream, HEAP8,message, length);
} else {
// sendto an address
return sock.sock_ops.sendmsg(sock, HEAP8,message, length, dest.addr, dest.port);
}
}
case 12: { // recvfrom
var sock = SYSCALLS.getSocketFromFD(), buf = SYSCALLS.get(), len = SYSCALLS.get(), flags = SYSCALLS.get(), addr = SYSCALLS.get(), addrlen = SYSCALLS.get();
var msg = sock.sock_ops.recvmsg(sock, len);
if (!msg) return 0; // socket is closed
if (addr) {
var res = __write_sockaddr(addr, sock.family, DNS.lookup_name(msg.addr), msg.port);
assert(!res.errno);
}
HEAPU8.set(msg.buffer, buf);
return msg.buffer.byteLength;
}
case 14: { // setsockopt
return -ERRNO_CODES.ENOPROTOOPT; // The option is unknown at the level indicated.
}
case 15: { // getsockopt
var sock = SYSCALLS.getSocketFromFD(), level = SYSCALLS.get(), optname = SYSCALLS.get(), optval = SYSCALLS.get(), optlen = SYSCALLS.get();
// Minimal getsockopt aimed at resolving https://github.com/kripken/emscripten/issues/2211
// so only supports SOL_SOCKET with SO_ERROR.
if (level === 1) {
if (optname === 4) {
HEAP32[((optval)>>2)]=sock.error;
HEAP32[((optlen)>>2)]=4;
sock.error = null; // Clear the error (The SO_ERROR option obtains and then clears this field).
return 0;
}
}
return -ERRNO_CODES.ENOPROTOOPT; // The option is unknown at the level indicated.
}
case 16: { // sendmsg
var sock = SYSCALLS.getSocketFromFD(), message = SYSCALLS.get(), flags = SYSCALLS.get();
var iov = HEAP32[(((message)+(8))>>2)];
var num = HEAP32[(((message)+(12))>>2)];
// read the address and port to send to
var addr, port;
var name = HEAP32[((message)>>2)];
var namelen = HEAP32[(((message)+(4))>>2)];
if (name) {
var info = __read_sockaddr(name, namelen);
if (info.errno) return -info.errno;
port = info.port;
addr = DNS.lookup_addr(info.addr) || info.addr;
}
// concatenate scatter-gather arrays into one message buffer
var total = 0;
for (var i = 0; i < num; i++) {
total += HEAP32[(((iov)+((8 * i) + 4))>>2)];
}
var view = new Uint8Array(total);
var offset = 0;
for (var i = 0; i < num; i++) {
var iovbase = HEAP32[(((iov)+((8 * i) + 0))>>2)];
var iovlen = HEAP32[(((iov)+((8 * i) + 4))>>2)];
for (var j = 0; j < iovlen; j++) {
view[offset++] = HEAP8[(((iovbase)+(j))>>0)];
}
}
// write the buffer
return sock.sock_ops.sendmsg(sock, view, 0, total, addr, port);
}
case 17: { // recvmsg
var sock = SYSCALLS.getSocketFromFD(), message = SYSCALLS.get(), flags = SYSCALLS.get();
var iov = HEAP32[(((message)+(8))>>2)];
var num = HEAP32[(((message)+(12))>>2)];
// get the total amount of data we can read across all arrays
var total = 0;
for (var i = 0; i < num; i++) {
total += HEAP32[(((iov)+((8 * i) + 4))>>2)];
}
// try to read total data
var msg = sock.sock_ops.recvmsg(sock, total);
if (!msg) return 0; // socket is closed
// TODO honor flags:
// MSG_OOB
// Requests out-of-band data. The significance and semantics of out-of-band data are protocol-specific.
// MSG_PEEK
// Peeks at the incoming message.
// MSG_WAITALL
// Requests that the function block until the full amount of data requested can be returned. The function may return a smaller amount of data if a signal is caught, if the connection is terminated, if MSG_PEEK was specified, or if an error is pending for the socket.
// write the source address out
var name = HEAP32[((message)>>2)];
if (name) {
var res = __write_sockaddr(name, sock.family, DNS.lookup_name(msg.addr), msg.port);
assert(!res.errno);
}
// write the buffer out to the scatter-gather arrays
var bytesRead = 0;
var bytesRemaining = msg.buffer.byteLength;
for (var i = 0; bytesRemaining > 0 && i < num; i++) {
var iovbase = HEAP32[(((iov)+((8 * i) + 0))>>2)];
var iovlen = HEAP32[(((iov)+((8 * i) + 4))>>2)];
if (!iovlen) {
continue;
}
var length = Math.min(iovlen, bytesRemaining);
var buf = msg.buffer.subarray(bytesRead, bytesRead + length);
HEAPU8.set(buf, iovbase + bytesRead);
bytesRead += length;
bytesRemaining -= length;
}
// TODO set msghdr.msg_flags
// MSG_EOR
// End of record was received (if supported by the protocol).
// MSG_OOB
// Out-of-band data was received.
// MSG_TRUNC
// Normal data was truncated.
// MSG_CTRUNC
return bytesRead;
}
default: abort('unsupported socketcall syscall ' + call);
}
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall140(which, varargs) {SYSCALLS.varargs = varargs;
try {
// llseek
var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get();
// NOTE: offset_high is unused - Emscripten's off_t is 32-bit
var offset = offset_low;
FS.llseek(stream, offset, whence);
HEAP32[((result)>>2)]=stream.position;
if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state
return 0;
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall142(which, varargs) {SYSCALLS.varargs = varargs;
try {
// newselect
// readfds are supported,
// writefds checks socket open status
// exceptfds not supported
// timeout is always 0 - fully async
var nfds = SYSCALLS.get(), readfds = SYSCALLS.get(), writefds = SYSCALLS.get(), exceptfds = SYSCALLS.get(), timeout = SYSCALLS.get();
assert(nfds <= 64, 'nfds must be less than or equal to 64'); // fd sets have 64 bits // TODO: this could be 1024 based on current musl headers
assert(!exceptfds, 'exceptfds not supported');
var total = 0;
var srcReadLow = (readfds ? HEAP32[((readfds)>>2)] : 0),
srcReadHigh = (readfds ? HEAP32[(((readfds)+(4))>>2)] : 0);
var srcWriteLow = (writefds ? HEAP32[((writefds)>>2)] : 0),
srcWriteHigh = (writefds ? HEAP32[(((writefds)+(4))>>2)] : 0);
var srcExceptLow = (exceptfds ? HEAP32[((exceptfds)>>2)] : 0),
srcExceptHigh = (exceptfds ? HEAP32[(((exceptfds)+(4))>>2)] : 0);
var dstReadLow = 0,
dstReadHigh = 0;
var dstWriteLow = 0,
dstWriteHigh = 0;
var dstExceptLow = 0,
dstExceptHigh = 0;
var allLow = (readfds ? HEAP32[((readfds)>>2)] : 0) |
(writefds ? HEAP32[((writefds)>>2)] : 0) |
(exceptfds ? HEAP32[((exceptfds)>>2)] : 0);
var allHigh = (readfds ? HEAP32[(((readfds)+(4))>>2)] : 0) |
(writefds ? HEAP32[(((writefds)+(4))>>2)] : 0) |
(exceptfds ? HEAP32[(((exceptfds)+(4))>>2)] : 0);
function check(fd, low, high, val) {
return (fd < 32 ? (low & val) : (high & val));
}
for (var fd = 0; fd < nfds; fd++) {
var mask = 1 << (fd % 32);
if (!(check(fd, allLow, allHigh, mask))) {
continue; // index isn't in the set
}
var stream = FS.getStream(fd);
if (!stream) throw new FS.ErrnoError(ERRNO_CODES.EBADF);
var flags = SYSCALLS.DEFAULT_POLLMASK;
if (stream.stream_ops.poll) {
flags = stream.stream_ops.poll(stream);
}
if ((flags & 1) && check(fd, srcReadLow, srcReadHigh, mask)) {
fd < 32 ? (dstReadLow = dstReadLow | mask) : (dstReadHigh = dstReadHigh | mask);
total++;
}
if ((flags & 4) && check(fd, srcWriteLow, srcWriteHigh, mask)) {
fd < 32 ? (dstWriteLow = dstWriteLow | mask) : (dstWriteHigh = dstWriteHigh | mask);
total++;
}
if ((flags & 2) && check(fd, srcExceptLow, srcExceptHigh, mask)) {
fd < 32 ? (dstExceptLow = dstExceptLow | mask) : (dstExceptHigh = dstExceptHigh | mask);
total++;
}
}
if (readfds) {
HEAP32[((readfds)>>2)]=dstReadLow;
HEAP32[(((readfds)+(4))>>2)]=dstReadHigh;
}
if (writefds) {
HEAP32[((writefds)>>2)]=dstWriteLow;
HEAP32[(((writefds)+(4))>>2)]=dstWriteHigh;
}
if (exceptfds) {
HEAP32[((exceptfds)>>2)]=dstExceptLow;
HEAP32[(((exceptfds)+(4))>>2)]=dstExceptHigh;
}
return total;
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall145(which, varargs) {SYSCALLS.varargs = varargs;
try {
// readv
var stream = SYSCALLS.getStreamFromFD(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
return SYSCALLS.doReadv(stream, iov, iovcnt);
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall146(which, varargs) {SYSCALLS.varargs = varargs;
try {
// writev
var stream = SYSCALLS.getStreamFromFD(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
return SYSCALLS.doWritev(stream, iov, iovcnt);
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall221(which, varargs) {SYSCALLS.varargs = varargs;
try {
// fcntl64
var stream = SYSCALLS.getStreamFromFD(), cmd = SYSCALLS.get();
switch (cmd) {
case 0: {
var arg = SYSCALLS.get();
if (arg < 0) {
return -ERRNO_CODES.EINVAL;
}
var newStream;
newStream = FS.open(stream.path, stream.flags, 0, arg);
return newStream.fd;
}
case 1:
case 2:
return 0; // FD_CLOEXEC makes no sense for a single process.
case 3:
return stream.flags;
case 4: {
var arg = SYSCALLS.get();
stream.flags |= arg;
return 0;
}
case 12:
case 12: {
var arg = SYSCALLS.get();
var offset = 0;
// We're always unlocked.
HEAP16[(((arg)+(offset))>>1)]=2;
return 0;
}
case 13:
case 14:
case 13:
case 14:
return 0; // Pretend that the locking is successful.
case 16:
case 8:
return -ERRNO_CODES.EINVAL; // These are for sockets. We don't have them fully implemented yet.
case 9:
// musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fnctl() returns that, and we set errno ourselves.
___setErrNo(ERRNO_CODES.EINVAL);
return -1;
default: {
return -ERRNO_CODES.EINVAL;
}
}
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall5(which, varargs) {SYSCALLS.varargs = varargs;
try {
// open
var pathname = SYSCALLS.getStr(), flags = SYSCALLS.get(), mode = SYSCALLS.get() // optional TODO
var stream = FS.open(pathname, flags, mode);
return stream.fd;
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall54(which, varargs) {SYSCALLS.varargs = varargs;
try {
// ioctl
var stream = SYSCALLS.getStreamFromFD(), op = SYSCALLS.get();
switch (op) {
case 21509:
case 21505: {
if (!stream.tty) return -ERRNO_CODES.ENOTTY;
return 0;
}
case 21510:
case 21511:
case 21512:
case 21506:
case 21507:
case 21508: {
if (!stream.tty) return -ERRNO_CODES.ENOTTY;
return 0; // no-op, not actually adjusting terminal settings
}
case 21519: {
if (!stream.tty) return -ERRNO_CODES.ENOTTY;
var argp = SYSCALLS.get();
HEAP32[((argp)>>2)]=0;
return 0;
}
case 21520: {
if (!stream.tty) return -ERRNO_CODES.ENOTTY;
return -ERRNO_CODES.EINVAL; // not supported
}
case 21531: {
var argp = SYSCALLS.get();
return FS.ioctl(stream, op, argp);
}
case 21523: {
// TODO: in theory we should write to the winsize struct that gets
// passed in, but for now musl doesn't read anything on it
if (!stream.tty) return -ERRNO_CODES.ENOTTY;
return 0;
}
case 21524: {
// TODO: technically, this ioctl call should change the window size.
// but, since emscripten doesn't have any concept of a terminal window
// yet, we'll just silently throw it away as we do TIOCGWINSZ
if (!stream.tty) return -ERRNO_CODES.ENOTTY;
return 0;
}
default: abort('bad ioctl syscall ' + op);
}
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall6(which, varargs) {SYSCALLS.varargs = varargs;
try {
// close
var stream = SYSCALLS.getStreamFromFD();
FS.close(stream);
return 0;
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___syscall91(which, varargs) {SYSCALLS.varargs = varargs;
try {
// munmap
var addr = SYSCALLS.get(), len = SYSCALLS.get();
// TODO: support unmmap'ing parts of allocations
var info = SYSCALLS.mappings[addr];
if (!info) return 0;
if (len === info.len) {
var stream = FS.getStream(info.fd);
SYSCALLS.doMsync(addr, stream, len, info.flags)
FS.munmap(stream);
SYSCALLS.mappings[addr] = null;
if (info.allocated) {
_free(info.malloc);
}
}
return 0;
} catch (e) {
if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___unlock() {}
function _abort() {
Module['abort']();
}
function _clock() {
if (_clock.start === undefined) _clock.start = Date.now();
return ((Date.now() - _clock.start) * (1000000 / 1000))|0;
}
var _emscripten_asm_const_int=true;
var GAI_ERRNO_MESSAGES={};function _gai_strerror(val) {
var buflen = 256;
// On first call to gai_strerror we initialise the buffer and populate the error messages.
if (!_gai_strerror.buffer) {
_gai_strerror.buffer = _malloc(buflen);
GAI_ERRNO_MESSAGES['0'] = 'Success';
GAI_ERRNO_MESSAGES['' + -1] = 'Invalid value for \'ai_flags\' field';
GAI_ERRNO_MESSAGES['' + -2] = 'NAME or SERVICE is unknown';
GAI_ERRNO_MESSAGES['' + -3] = 'Temporary failure in name resolution';
GAI_ERRNO_MESSAGES['' + -4] = 'Non-recoverable failure in name res';
GAI_ERRNO_MESSAGES['' + -6] = '\'ai_family\' not supported';
GAI_ERRNO_MESSAGES['' + -7] = '\'ai_socktype\' not supported';
GAI_ERRNO_MESSAGES['' + -8] = 'SERVICE not supported for \'ai_socktype\'';
GAI_ERRNO_MESSAGES['' + -10] = 'Memory allocation failure';
GAI_ERRNO_MESSAGES['' + -11] = 'System error returned in \'errno\'';
GAI_ERRNO_MESSAGES['' + -12] = 'Argument buffer overflow';
}
var msg = 'Unknown error';
if (val in GAI_ERRNO_MESSAGES) {
if (GAI_ERRNO_MESSAGES[val].length > buflen - 1) {
msg = 'Message too long'; // EMSGSIZE message. This should never occur given the GAI_ERRNO_MESSAGES above.
} else {
msg = GAI_ERRNO_MESSAGES[val];
}
}
writeAsciiToMemory(msg, _gai_strerror.buffer);
return _gai_strerror.buffer;
}
function _getaddrinfo(node, service, hint, out) {
// Note getaddrinfo currently only returns a single addrinfo with ai_next defaulting to NULL. When NULL
// hints are specified or ai_family set to AF_UNSPEC or ai_socktype or ai_protocol set to 0 then we
// really should provide a linked list of suitable addrinfo values.
var addrs = [];
var canon = null;
var addr = 0;
var port = 0;
var flags = 0;
var family = 0;
var type = 0;
var proto = 0;
var ai, last;
function allocaddrinfo(family, type, proto, canon, addr, port) {
var sa, salen, ai;
var res;
salen = family === 10 ?
28 :
16;
addr = family === 10 ?
__inet_ntop6_raw(addr) :
__inet_ntop4_raw(addr);
sa = _malloc(salen);
res = __write_sockaddr(sa, family, addr, port);
assert(!res.errno);
ai = _malloc(32);
HEAP32[(((ai)+(4))>>2)]=family;
HEAP32[(((ai)+(8))>>2)]=type;
HEAP32[(((ai)+(12))>>2)]=proto;
HEAP32[(((ai)+(24))>>2)]=canon;
HEAP32[(((ai)+(20))>>2)]=sa;
if (family === 10) {
HEAP32[(((ai)+(16))>>2)]=28;
} else {
HEAP32[(((ai)+(16))>>2)]=16;
}
HEAP32[(((ai)+(28))>>2)]=0;
return ai;
}
if (hint) {
flags = HEAP32[((hint)>>2)];
family = HEAP32[(((hint)+(4))>>2)];
type = HEAP32[(((hint)+(8))>>2)];
proto = HEAP32[(((hint)+(12))>>2)];
}
if (type && !proto) {
proto = type === 2 ? 17 : 6;
}
if (!type && proto) {
type = proto === 17 ? 2 : 1;
}
// If type or proto are set to zero in hints we should really be returning multiple addrinfo values, but for
// now default to a TCP STREAM socket so we can at least return a sensible addrinfo given NULL hints.
if (proto === 0) {
proto = 6;
}
if (type === 0) {
type = 1;
}
if (!node && !service) {
return -2;
}
if (flags & ~(1|2|4|
1024|8|16|32)) {
return -1;
}
if (hint !== 0 && (HEAP32[((hint)>>2)] & 2) && !node) {
return -1;
}
if (flags & 32) {
// TODO
return -2;
}
if (type !== 0 && type !== 1 && type !== 2) {
return -7;
}
if (family !== 0 && family !== 2 && family !== 10) {
return -6;
}
if (service) {
service = Pointer_stringify(service);
port = parseInt(service, 10);
if (isNaN(port)) {
if (flags & 1024) {
return -2;
}
// TODO support resolving well-known service names from:
// http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt
return -8;
}
}
if (!node) {
if (family === 0) {
family = 2;
}
if ((flags & 1) === 0) {
if (family === 2) {
addr = _htonl(2130706433);
} else {
addr = [0, 0, 0, 1];
}
}
ai = allocaddrinfo(family, type, proto, null, addr, port);
HEAP32[((out)>>2)]=ai;
return 0;
}
//
// try as a numeric address
//
node = Pointer_stringify(node);
addr = __inet_pton4_raw(node);
if (addr !== null) {
// incoming node is a valid ipv4 address
if (family === 0 || family === 2) {
family = 2;
}
else if (family === 10 && (flags & 8)) {
addr = [0, 0, _htonl(0xffff), addr];
family = 10;
} else {
return -2;
}
} else {
addr = __inet_pton6_raw(node);
if (addr !== null) {
// incoming node is a valid ipv6 address
if (family === 0 || family === 10) {
family = 10;
} else {
return -2;
}
}
}
if (addr != null) {
ai = allocaddrinfo(family, type, proto, node, addr, port);
HEAP32[((out)>>2)]=ai;
return 0;
}
if (flags & 4) {
return -2;
}
//
// try as a hostname
//
// resolve the hostname to a temporary fake address
node = DNS.lookup_name(node);
addr = __inet_pton4_raw(node);
if (family === 0) {
family = 2;
} else if (family === 10) {
addr = [0, 0, _htonl(0xffff), addr];
}
ai = allocaddrinfo(family, type, proto, null, addr, port);
HEAP32[((out)>>2)]=ai;
return 0;
}
var ENV={};function _getenv(name) {
// char *getenv(const char *name);
// http://pubs.opengroup.org/onlinepubs/009695399/functions/getenv.html
if (name === 0) return 0;
name = Pointer_stringify(name);
if (!ENV.hasOwnProperty(name)) return 0;
if (_getenv.ret) _free(_getenv.ret);
_getenv.ret = allocateUTF8(ENV[name]);
return _getenv.ret;
}
function _getnameinfo(sa, salen, node, nodelen, serv, servlen, flags) {
var info = __read_sockaddr(sa, salen);
if (info.errno) {
return -6;
}
var port = info.port;
var addr = info.addr;
var overflowed = false;
if (node && nodelen) {
var lookup;
if ((flags & 1) || !(lookup = DNS.lookup_addr(addr))) {
if (flags & 8) {
return -2;
}
} else {
addr = lookup;
}
var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen);
if (numBytesWrittenExclNull+1 >= nodelen) {
overflowed = true;
}
}
if (serv && servlen) {
port = '' + port;
var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
if (numBytesWrittenExclNull+1 >= servlen) {
overflowed = true;
}
}
if (overflowed) {
// Note: even when we overflow, getnameinfo() is specced to write out the truncated results.
return -12;
}
return 0;
}
function _llvm_stackrestore(p) {
var self = _llvm_stacksave;
var ret = self.LLVM_SAVEDSTACKS[p];
self.LLVM_SAVEDSTACKS.splice(p, 1);
stackRestore(ret);
}
function _llvm_stacksave() {
var self = _llvm_stacksave;
if (!self.LLVM_SAVEDSTACKS) {
self.LLVM_SAVEDSTACKS = [];
}
self.LLVM_SAVEDSTACKS.push(stackSave());
return self.LLVM_SAVEDSTACKS.length-1;
}
function _llvm_trap() {
abort('trap!');
}
function _longjmp(env, value) {
Module['setThrew'](env, value || 1);
throw 'longjmp';
}
function _emscripten_memcpy_big(dest, src, num) {
HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
return dest;
}
function _pthread_cond_wait() { return 0; }
function __isLeapYear(year) {
return year%4 === 0 && (year%100 !== 0 || year%400 === 0);
}
function __arraySum(array, index) {
var sum = 0;
for (var i = 0; i <= index; sum += array[i++]);
return sum;
}
var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];
var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];function __addDays(date, days) {
var newDate = new Date(date.getTime());
while(days > 0) {
var leap = __isLeapYear(newDate.getFullYear());
var currentMonth = newDate.getMonth();
var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
if (days > daysInCurrentMonth-newDate.getDate()) {
// 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 ? Pointer_stringify(tm_zone) : ''
};
var pattern = Pointer_stringify(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 date representation
};
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) {
var day = new Date(date.tm_year+1900, date.tm_mon+1, date.tm_mday, 0, 0, 0, 0);
return day.getDay() || 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) {
var day = new Date(date.tm_year+1900, date.tm_mon+1, date.tm_mday, 0, 0, 0, 0);
return day.getDay();
},
'%W': function(date) {
// Replaced by the week number of the year as a decimal number [00,53].
// The first Monday of January is the first day of week 1;
// days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
var janFirst = new Date(date.tm_year, 0, 1);
var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1);
var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
// is target date after the first Monday?
if (compareByDay(firstMonday, endDate) < 0) {
var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
var firstMondayUntilEndJanuary = 31-firstMonday.getDate();
var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
return leadingNulls(Math.ceil(days/7), 2);
}
return compareByDay(firstMonday, janFirst) === 0 ? '01': '00';
},
'%y': function(date) {
// Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
return (date.tm_year+1900).toString().substring(2);
},
'%Y': function(date) {
// Replaced by the year as a decimal number (for example, 1997). [ tm_year]
return date.tm_year+1900;
},
'%z': function(date) {
// Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ).
// For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
var off = date.tm_gmtoff;
var ahead = off >= 0;
off = Math.abs(off) / 60;
// convert from minutes into hhmm format (which means 60 minutes = 100 units)
off = (off / 60)*100 + (off % 60);
return (ahead ? '+' : '-') + String("0000" + off).slice(-4);
},
'%Z': function(date) {
return date.tm_zone;
},
'%%': function() {
return '%';
}
};
for (var rule in EXPANSION_RULES_2) {
if (pattern.indexOf(rule) >= 0) {
pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
}
}
var bytes = intArrayFromString(pattern, false);
if (bytes.length > maxsize) {
return 0;
}
writeArrayToMemory(bytes, s);
return bytes.length-1;
}function _strftime_l(s, maxsize, format, tm) {
return _strftime(s, maxsize, format, tm); // no locale support yet
}
__ATINIT__.push(function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); });;
FS.staticInit();__ATINIT__.unshift(function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() });__ATMAIN__.push(function() { FS.ignorePermissions = false });__ATEXIT__.push(function() { FS.quit() });;
__ATINIT__.unshift(function() { TTY.init() });__ATEXIT__.push(function() { TTY.shutdown() });;
if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); var NODEJS_PATH = require("path"); NODEFS.staticInit(); };
DYNAMICTOP_PTR = staticAlloc(4);
STACK_BASE = STACKTOP = alignMemory(STATICTOP);
STACK_MAX = STACK_BASE + TOTAL_STACK;
DYNAMIC_BASE = alignMemory(STACK_MAX);
HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE;
staticSealed = true; // seal the static portion of memory
var ASSERTIONS = false;
// Copyright 2017 The Emscripten Authors. All rights reserved.
// Emscripten is available under two separate licenses, the MIT license and the
// University of Illinois/NCSA Open Source License. Both these licenses can be
// found in the LICENSE file.
/** @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('');
}
Module['wasmTableSize'] = 932;
Module['wasmMaxTableSize'] = 932;
function invoke_i(index) {
var sp = stackSave();
try {
return Module["dynCall_i"](index);
} catch(e) {
stackRestore(sp);
if (typeof e !== 'number' && e !== 'longjmp') throw e;
Module["setThrew"](1, 0);
}
}
function invoke_iiii(index,a1,a2,a3) {
var sp = stackSave();
try {
return Module["dynCall_iiii"](index,a1,a2,a3);
} catch(e) {
stackRestore(sp);
if (typeof e !== 'number' && e !== 'longjmp') throw e;
Module["setThrew"](1, 0);
}
}
function invoke_v(index) {
var sp = stackSave();
try {
Module["dynCall_v"](index);
} catch(e) {
stackRestore(sp);
if (typeof e !== 'number' && e !== 'longjmp') throw e;
Module["setThrew"](1, 0);
}
}
function invoke_vi(index,a1) {
var sp = stackSave();
try {
Module["dynCall_vi"](index,a1);
} catch(e) {
stackRestore(sp);
if (typeof e !== 'number' && e !== 'longjmp') throw e;
Module["setThrew"](1, 0);
}
}
function invoke_vii(index,a1,a2) {
var sp = stackSave();
try {
Module["dynCall_vii"](index,a1,a2);
} catch(e) {
stackRestore(sp);
if (typeof e !== 'number' && e !== 'longjmp') throw e;
Module["setThrew"](1, 0);
}
}
Module.asmGlobalArg = {};
Module.asmLibraryArg = { "abort": abort, "assert": assert, "enlargeMemory": enlargeMemory, "getTotalMemory": getTotalMemory, "setTempRet0": setTempRet0, "getTempRet0": getTempRet0, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "invoke_i": invoke_i, "invoke_iiii": invoke_iiii, "invoke_v": invoke_v, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv, "___assert_fail": ___assert_fail, "___cxa_find_matching_catch": ___cxa_find_matching_catch, "___cxa_pure_virtual": ___cxa_pure_virtual, "___gxx_personality_v0": ___gxx_personality_v0, "___lock": ___lock, "___map_file": ___map_file, "___resumeException": ___resumeException, "___setErrNo": ___setErrNo, "___syscall102": ___syscall102, "___syscall140": ___syscall140, "___syscall142": ___syscall142, "___syscall145": ___syscall145, "___syscall146": ___syscall146, "___syscall221": ___syscall221, "___syscall5": ___syscall5, "___syscall54": ___syscall54, "___syscall6": ___syscall6, "___syscall91": ___syscall91, "___unlock": ___unlock, "__addDays": __addDays, "__arraySum": __arraySum, "__inet_ntop4_raw": __inet_ntop4_raw, "__inet_ntop6_raw": __inet_ntop6_raw, "__inet_pton4_raw": __inet_pton4_raw, "__inet_pton6_raw": __inet_pton6_raw, "__isLeapYear": __isLeapYear, "__read_sockaddr": __read_sockaddr, "__write_sockaddr": __write_sockaddr, "_abort": _abort, "_clock": _clock, "_emscripten_asm_const_iddd": _emscripten_asm_const_iddd, "_emscripten_asm_const_idddiddd": _emscripten_asm_const_idddiddd, "_emscripten_asm_const_ii": _emscripten_asm_const_ii, "_emscripten_asm_const_iii": _emscripten_asm_const_iii, "_emscripten_asm_const_iiiddddddddddddii": _emscripten_asm_const_iiiddddddddddddii, "_emscripten_asm_const_iiii": _emscripten_asm_const_iiii, "_emscripten_asm_const_iiiii": _emscripten_asm_const_iiiii, "_emscripten_asm_const_iiiiiiii": _emscripten_asm_const_iiiiiiii, "_emscripten_asm_const_iiiiiiiii": _emscripten_asm_const_iiiiiiiii, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_gai_strerror": _gai_strerror, "_getaddrinfo": _getaddrinfo, "_getenv": _getenv, "_getnameinfo": _getnameinfo, "_llvm_stackrestore": _llvm_stackrestore, "_llvm_stacksave": _llvm_stacksave, "_llvm_trap": _llvm_trap, "_longjmp": _longjmp, "_pthread_cond_wait": _pthread_cond_wait, "_strftime": _strftime, "_strftime_l": _strftime_l, "DYNAMICTOP_PTR": DYNAMICTOP_PTR, "tempDoublePtr": tempDoublePtr, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX };
// EMSCRIPTEN_START_ASM
var asm =Module["asm"]// EMSCRIPTEN_END_ASM
(Module.asmGlobalArg, Module.asmLibraryArg, buffer);
Module["asm"] = asm;
var _AddRemap = Module["_AddRemap"] = function() { return Module["asm"]["_AddRemap"].apply(null, arguments) };
var _AddScore = Module["_AddScore"] = function() { return Module["asm"]["_AddScore"].apply(null, arguments) };
var _AddTournamentQueue = Module["_AddTournamentQueue"] = function() { return Module["asm"]["_AddTournamentQueue"].apply(null, arguments) };
var _Add_Ammo = Module["_Add_Ammo"] = function() { return Module["asm"]["_Add_Ammo"].apply(null, arguments) };
var _AngleDelta = Module["_AngleDelta"] = function() { return Module["asm"]["_AngleDelta"].apply(null, arguments) };
var _AngleMod = Module["_AngleMod"] = function() { return Module["asm"]["_AngleMod"].apply(null, arguments) };
var _AngleNormalize180 = Module["_AngleNormalize180"] = function() { return Module["asm"]["_AngleNormalize180"].apply(null, arguments) };
var _AngleNormalize360 = Module["_AngleNormalize360"] = function() { return Module["asm"]["_AngleNormalize360"].apply(null, arguments) };
var _AngleSubtract = Module["_AngleSubtract"] = function() { return Module["asm"]["_AngleSubtract"].apply(null, arguments) };
var _AngleVectors = Module["_AngleVectors"] = function() { return Module["asm"]["_AngleVectors"].apply(null, arguments) };
var _AnglesSubtract = Module["_AnglesSubtract"] = function() { return Module["asm"]["_AnglesSubtract"].apply(null, arguments) };
var _AnglesToAxis = Module["_AnglesToAxis"] = function() { return Module["asm"]["_AnglesToAxis"].apply(null, arguments) };
var _AxisClear = Module["_AxisClear"] = function() { return Module["asm"]["_AxisClear"].apply(null, arguments) };
var _AxisCopy = Module["_AxisCopy"] = function() { return Module["asm"]["_AxisCopy"].apply(null, arguments) };
var _BG_AddPredictableEventToPlayerstate = Module["_BG_AddPredictableEventToPlayerstate"] = function() { return Module["asm"]["_BG_AddPredictableEventToPlayerstate"].apply(null, arguments) };
var _BG_CanItemBeGrabbed = Module["_BG_CanItemBeGrabbed"] = function() { return Module["asm"]["_BG_CanItemBeGrabbed"].apply(null, arguments) };
var _BG_EvaluateTrajectory = Module["_BG_EvaluateTrajectory"] = function() { return Module["asm"]["_BG_EvaluateTrajectory"].apply(null, arguments) };
var _BG_EvaluateTrajectoryDelta = Module["_BG_EvaluateTrajectoryDelta"] = function() { return Module["asm"]["_BG_EvaluateTrajectoryDelta"].apply(null, arguments) };
var _BG_FindItem = Module["_BG_FindItem"] = function() { return Module["asm"]["_BG_FindItem"].apply(null, arguments) };
var _BG_FindItemForHoldable = Module["_BG_FindItemForHoldable"] = function() { return Module["asm"]["_BG_FindItemForHoldable"].apply(null, arguments) };
var _BG_FindItemForPowerup = Module["_BG_FindItemForPowerup"] = function() { return Module["asm"]["_BG_FindItemForPowerup"].apply(null, arguments) };
var _BG_FindItemForWeapon = Module["_BG_FindItemForWeapon"] = function() { return Module["asm"]["_BG_FindItemForWeapon"].apply(null, arguments) };
var _BG_PlayerStateToEntityState = Module["_BG_PlayerStateToEntityState"] = function() { return Module["asm"]["_BG_PlayerStateToEntityState"].apply(null, arguments) };
var _BG_PlayerStateToEntityStateExtraPolate = Module["_BG_PlayerStateToEntityStateExtraPolate"] = function() { return Module["asm"]["_BG_PlayerStateToEntityStateExtraPolate"].apply(null, arguments) };
var _BG_TouchJumpPad = Module["_BG_TouchJumpPad"] = function() { return Module["asm"]["_BG_TouchJumpPad"].apply(null, arguments) };
var _BeginIntermission = Module["_BeginIntermission"] = function() { return Module["asm"]["_BeginIntermission"].apply(null, arguments) };
var _BotImport_DebugPolygonCreate = Module["_BotImport_DebugPolygonCreate"] = function() { return Module["asm"]["_BotImport_DebugPolygonCreate"].apply(null, arguments) };
var _BotImport_DebugPolygonDelete = Module["_BotImport_DebugPolygonDelete"] = function() { return Module["asm"]["_BotImport_DebugPolygonDelete"].apply(null, arguments) };
var _BoundsIntersect = Module["_BoundsIntersect"] = function() { return Module["asm"]["_BoundsIntersect"].apply(null, arguments) };
var _BoundsIntersectPoint = Module["_BoundsIntersectPoint"] = function() { return Module["asm"]["_BoundsIntersectPoint"].apply(null, arguments) };
var _BoundsIntersectSphere = Module["_BoundsIntersectSphere"] = function() { return Module["asm"]["_BoundsIntersectSphere"].apply(null, arguments) };
var _BoxOnPlaneSide = Module["_BoxOnPlaneSide"] = function() { return Module["asm"]["_BoxOnPlaneSide"].apply(null, arguments) };
var _BroadcastTeamChange = Module["_BroadcastTeamChange"] = function() { return Module["asm"]["_BroadcastTeamChange"].apply(null, arguments) };
var _BuildShaderStateConfig = Module["_BuildShaderStateConfig"] = function() { return Module["asm"]["_BuildShaderStateConfig"].apply(null, arguments) };
var _CG_AddBufferedSound = Module["_CG_AddBufferedSound"] = function() { return Module["asm"]["_CG_AddBufferedSound"].apply(null, arguments) };
var _CG_AddLagometerFrameInfo = Module["_CG_AddLagometerFrameInfo"] = function() { return Module["asm"]["_CG_AddLagometerFrameInfo"].apply(null, arguments) };
var _CG_AddLagometerSnapshotInfo = Module["_CG_AddLagometerSnapshotInfo"] = function() { return Module["asm"]["_CG_AddLagometerSnapshotInfo"].apply(null, arguments) };
var _CG_AddLocalEntities = Module["_CG_AddLocalEntities"] = function() { return Module["asm"]["_CG_AddLocalEntities"].apply(null, arguments) };
var _CG_AddPacketEntities = Module["_CG_AddPacketEntities"] = function() { return Module["asm"]["_CG_AddPacketEntities"].apply(null, arguments) };
var _CG_AddParticleShrapnel = Module["_CG_AddParticleShrapnel"] = function() { return Module["asm"]["_CG_AddParticleShrapnel"].apply(null, arguments) };
var _CG_AddParticles = Module["_CG_AddParticles"] = function() { return Module["asm"]["_CG_AddParticles"].apply(null, arguments) };
var _CG_AddPlayerWeapon = Module["_CG_AddPlayerWeapon"] = function() { return Module["asm"]["_CG_AddPlayerWeapon"].apply(null, arguments) };
var _CG_AddRefEntityWithPowerups = Module["_CG_AddRefEntityWithPowerups"] = function() { return Module["asm"]["_CG_AddRefEntityWithPowerups"].apply(null, arguments) };
var _CG_AddViewWeapon = Module["_CG_AddViewWeapon"] = function() { return Module["asm"]["_CG_AddViewWeapon"].apply(null, arguments) };
var _CG_AdjustFrom640 = Module["_CG_AdjustFrom640"] = function() { return Module["asm"]["_CG_AdjustFrom640"].apply(null, arguments) };
var _CG_AdjustPositionForMover = Module["_CG_AdjustPositionForMover"] = function() { return Module["asm"]["_CG_AdjustPositionForMover"].apply(null, arguments) };
var _CG_AllocLocalEntity = Module["_CG_AllocLocalEntity"] = function() { return Module["asm"]["_CG_AllocLocalEntity"].apply(null, arguments) };
var _CG_Argv = Module["_CG_Argv"] = function() { return Module["asm"]["_CG_Argv"].apply(null, arguments) };
var _CG_Beam = Module["_CG_Beam"] = function() { return Module["asm"]["_CG_Beam"].apply(null, arguments) };
var _CG_BigExplode = Module["_CG_BigExplode"] = function() { return Module["asm"]["_CG_BigExplode"].apply(null, arguments) };
var _CG_Bleed = Module["_CG_Bleed"] = function() { return Module["asm"]["_CG_Bleed"].apply(null, arguments) };
var _CG_BubbleTrail = Module["_CG_BubbleTrail"] = function() { return Module["asm"]["_CG_BubbleTrail"].apply(null, arguments) };
var _CG_BuildSolidList = Module["_CG_BuildSolidList"] = function() { return Module["asm"]["_CG_BuildSolidList"].apply(null, arguments) };
var _CG_BuildSpectatorString = Module["_CG_BuildSpectatorString"] = function() { return Module["asm"]["_CG_BuildSpectatorString"].apply(null, arguments) };
var _CG_Bullet = Module["_CG_Bullet"] = function() { return Module["asm"]["_CG_Bullet"].apply(null, arguments) };
var _CG_CenterPrint = Module["_CG_CenterPrint"] = function() { return Module["asm"]["_CG_CenterPrint"].apply(null, arguments) };
var _CG_CheckChangedPredictableEvents = Module["_CG_CheckChangedPredictableEvents"] = function() { return Module["asm"]["_CG_CheckChangedPredictableEvents"].apply(null, arguments) };
var _CG_CheckEvents = Module["_CG_CheckEvents"] = function() { return Module["asm"]["_CG_CheckEvents"].apply(null, arguments) };
var _CG_ClearParticles = Module["_CG_ClearParticles"] = function() { return Module["asm"]["_CG_ClearParticles"].apply(null, arguments) };
var _CG_ColorForHealth = Module["_CG_ColorForHealth"] = function() { return Module["asm"]["_CG_ColorForHealth"].apply(null, arguments) };
var _CG_ConfigString = Module["_CG_ConfigString"] = function() { return Module["asm"]["_CG_ConfigString"].apply(null, arguments) };
var _CG_ConsoleCommand = Module["_CG_ConsoleCommand"] = function() { return Module["asm"]["_CG_ConsoleCommand"].apply(null, arguments) };
var _CG_CrosshairPlayer = Module["_CG_CrosshairPlayer"] = function() { return Module["asm"]["_CG_CrosshairPlayer"].apply(null, arguments) };
var _CG_CustomSound = Module["_CG_CustomSound"] = function() { return Module["asm"]["_CG_CustomSound"].apply(null, arguments) };
var _CG_Draw3DModel = Module["_CG_Draw3DModel"] = function() { return Module["asm"]["_CG_Draw3DModel"].apply(null, arguments) };
var _CG_DrawActiveFrame = Module["_CG_DrawActiveFrame"] = function() { return Module["asm"]["_CG_DrawActiveFrame"].apply(null, arguments) };
var _CG_DrawBigString = Module["_CG_DrawBigString"] = function() { return Module["asm"]["_CG_DrawBigString"].apply(null, arguments) };
var _CG_DrawBigStringColor = Module["_CG_DrawBigStringColor"] = function() { return Module["asm"]["_CG_DrawBigStringColor"].apply(null, arguments) };
var _CG_DrawFlagModel = Module["_CG_DrawFlagModel"] = function() { return Module["asm"]["_CG_DrawFlagModel"].apply(null, arguments) };
var _CG_DrawHead = Module["_CG_DrawHead"] = function() { return Module["asm"]["_CG_DrawHead"].apply(null, arguments) };
var _CG_DrawInformation = Module["_CG_DrawInformation"] = function() { return Module["asm"]["_CG_DrawInformation"].apply(null, arguments) };
var _CG_DrawOldScoreboard = Module["_CG_DrawOldScoreboard"] = function() { return Module["asm"]["_CG_DrawOldScoreboard"].apply(null, arguments) };
var _CG_DrawOldTourneyScoreboard = Module["_CG_DrawOldTourneyScoreboard"] = function() { return Module["asm"]["_CG_DrawOldTourneyScoreboard"].apply(null, arguments) };
var _CG_DrawPic = Module["_CG_DrawPic"] = function() { return Module["asm"]["_CG_DrawPic"].apply(null, arguments) };
var _CG_DrawRect = Module["_CG_DrawRect"] = function() { return Module["asm"]["_CG_DrawRect"].apply(null, arguments) };
var _CG_DrawSides = Module["_CG_DrawSides"] = function() { return Module["asm"]["_CG_DrawSides"].apply(null, arguments) };
var _CG_DrawSmallString = Module["_CG_DrawSmallString"] = function() { return Module["asm"]["_CG_DrawSmallString"].apply(null, arguments) };
var _CG_DrawSmallStringColor = Module["_CG_DrawSmallStringColor"] = function() { return Module["asm"]["_CG_DrawSmallStringColor"].apply(null, arguments) };
var _CG_DrawStringExt = Module["_CG_DrawStringExt"] = function() { return Module["asm"]["_CG_DrawStringExt"].apply(null, arguments) };
var _CG_DrawStrlen = Module["_CG_DrawStrlen"] = function() { return Module["asm"]["_CG_DrawStrlen"].apply(null, arguments) };
var _CG_DrawTeamBackground = Module["_CG_DrawTeamBackground"] = function() { return Module["asm"]["_CG_DrawTeamBackground"].apply(null, arguments) };
var _CG_DrawTopBottom = Module["_CG_DrawTopBottom"] = function() { return Module["asm"]["_CG_DrawTopBottom"].apply(null, arguments) };
var _CG_DrawWeaponSelect = Module["_CG_DrawWeaponSelect"] = function() { return Module["asm"]["_CG_DrawWeaponSelect"].apply(null, arguments) };
var _CG_EntityEvent = Module["_CG_EntityEvent"] = function() { return Module["asm"]["_CG_EntityEvent"].apply(null, arguments) };
var _CG_Error = Module["_CG_Error"] = function() { return Module["asm"]["_CG_Error"].apply(null, arguments) };
var _CG_ExecuteNewServerCommands = Module["_CG_ExecuteNewServerCommands"] = function() { return Module["asm"]["_CG_ExecuteNewServerCommands"].apply(null, arguments) };
var _CG_FadeColor = Module["_CG_FadeColor"] = function() { return Module["asm"]["_CG_FadeColor"].apply(null, arguments) };
var _CG_FillRect = Module["_CG_FillRect"] = function() { return Module["asm"]["_CG_FillRect"].apply(null, arguments) };
var _CG_FireWeapon = Module["_CG_FireWeapon"] = function() { return Module["asm"]["_CG_FireWeapon"].apply(null, arguments) };
var _CG_FreeHUD = Module["_CG_FreeHUD"] = function() { return Module["asm"]["_CG_FreeHUD"].apply(null, arguments) };
var _CG_GetColorForHealth = Module["_CG_GetColorForHealth"] = function() { return Module["asm"]["_CG_GetColorForHealth"].apply(null, arguments) };
var _CG_GibPlayer = Module["_CG_GibPlayer"] = function() { return Module["asm"]["_CG_GibPlayer"].apply(null, arguments) };
var _CG_GrappleTrail = Module["_CG_GrappleTrail"] = function() { return Module["asm"]["_CG_GrappleTrail"].apply(null, arguments) };
var _CG_Init = Module["_CG_Init"] = function() { return Module["asm"]["_CG_Init"].apply(null, arguments) };
var _CG_InitConsoleCommands = Module["_CG_InitConsoleCommands"] = function() { return Module["asm"]["_CG_InitConsoleCommands"].apply(null, arguments) };
var _CG_InitLocalEntities = Module["_CG_InitLocalEntities"] = function() { return Module["asm"]["_CG_InitLocalEntities"].apply(null, arguments) };
var _CG_Init_Resume = Module["_CG_Init_Resume"] = function() { return Module["asm"]["_CG_Init_Resume"].apply(null, arguments) };
var _CG_LastAttacker = Module["_CG_LastAttacker"] = function() { return Module["asm"]["_CG_LastAttacker"].apply(null, arguments) };
var _CG_LoadDeferredPlayers = Module["_CG_LoadDeferredPlayers"] = function() { return Module["asm"]["_CG_LoadDeferredPlayers"].apply(null, arguments) };
var _CG_LoadingClient = Module["_CG_LoadingClient"] = function() { return Module["asm"]["_CG_LoadingClient"].apply(null, arguments) };
var _CG_LoadingItem = Module["_CG_LoadingItem"] = function() { return Module["asm"]["_CG_LoadingItem"].apply(null, arguments) };
var _CG_LoadingString = Module["_CG_LoadingString"] = function() { return Module["asm"]["_CG_LoadingString"].apply(null, arguments) };
var _CG_MakeExplosion = Module["_CG_MakeExplosion"] = function() { return Module["asm"]["_CG_MakeExplosion"].apply(null, arguments) };
var _CG_MissileHitPlayer = Module["_CG_MissileHitPlayer"] = function() { return Module["asm"]["_CG_MissileHitPlayer"].apply(null, arguments) };
var _CG_MissileHitWall = Module["_CG_MissileHitWall"] = function() { return Module["asm"]["_CG_MissileHitWall"].apply(null, arguments) };
var _CG_MouseEvent = Module["_CG_MouseEvent"] = function() { return Module["asm"]["_CG_MouseEvent"].apply(null, arguments) };
var _CG_NewClientInfo = Module["_CG_NewClientInfo"] = function() { return Module["asm"]["_CG_NewClientInfo"].apply(null, arguments) };
var _CG_NewParticleArea = Module["_CG_NewParticleArea"] = function() { return Module["asm"]["_CG_NewParticleArea"].apply(null, arguments) };
var _CG_NextWeapon_f = Module["_CG_NextWeapon_f"] = function() { return Module["asm"]["_CG_NextWeapon_f"].apply(null, arguments) };
var _CG_OutOfAmmoChange = Module["_CG_OutOfAmmoChange"] = function() { return Module["asm"]["_CG_OutOfAmmoChange"].apply(null, arguments) };
var _CG_PainEvent = Module["_CG_PainEvent"] = function() { return Module["asm"]["_CG_PainEvent"].apply(null, arguments) };
var _CG_ParseHUD = Module["_CG_ParseHUD"] = function() { return Module["asm"]["_CG_ParseHUD"].apply(null, arguments) };
var _CG_ParseServerinfo = Module["_CG_ParseServerinfo"] = function() { return Module["asm"]["_CG_ParseServerinfo"].apply(null, arguments) };
var _CG_ParticleBulletDebris = Module["_CG_ParticleBulletDebris"] = function() { return Module["asm"]["_CG_ParticleBulletDebris"].apply(null, arguments) };
var _CG_ParticleDust = Module["_CG_ParticleDust"] = function() { return Module["asm"]["_CG_ParticleDust"].apply(null, arguments) };
var _CG_ParticleExplosion = Module["_CG_ParticleExplosion"] = function() { return Module["asm"]["_CG_ParticleExplosion"].apply(null, arguments) };
var _CG_ParticleMisc = Module["_CG_ParticleMisc"] = function() { return Module["asm"]["_CG_ParticleMisc"].apply(null, arguments) };
var _CG_ParticleSmoke = Module["_CG_ParticleSmoke"] = function() { return Module["asm"]["_CG_ParticleSmoke"].apply(null, arguments) };
var _CG_ParticleSnow = Module["_CG_ParticleSnow"] = function() { return Module["asm"]["_CG_ParticleSnow"].apply(null, arguments) };
var _CG_ParticleSnowFlurry = Module["_CG_ParticleSnowFlurry"] = function() { return Module["asm"]["_CG_ParticleSnowFlurry"].apply(null, arguments) };
var _CG_ParticleSparks = Module["_CG_ParticleSparks"] = function() { return Module["asm"]["_CG_ParticleSparks"].apply(null, arguments) };
var _CG_PlaceString = Module["_CG_PlaceString"] = function() { return Module["asm"]["_CG_PlaceString"].apply(null, arguments) };
var _CG_Player = Module["_CG_Player"] = function() { return Module["asm"]["_CG_Player"].apply(null, arguments) };
var _CG_PointContents = Module["_CG_PointContents"] = function() { return Module["asm"]["_CG_PointContents"].apply(null, arguments) };
var _CG_PositionEntityOnTag = Module["_CG_PositionEntityOnTag"] = function() { return Module["asm"]["_CG_PositionEntityOnTag"].apply(null, arguments) };
var _CG_PositionRotatedEntityOnTag = Module["_CG_PositionRotatedEntityOnTag"] = function() { return Module["asm"]["_CG_PositionRotatedEntityOnTag"].apply(null, arguments) };
var _CG_PredictPlayerState = Module["_CG_PredictPlayerState"] = function() { return Module["asm"]["_CG_PredictPlayerState"].apply(null, arguments) };
var _CG_PrevWeapon_f = Module["_CG_PrevWeapon_f"] = function() { return Module["asm"]["_CG_PrevWeapon_f"].apply(null, arguments) };
var _CG_Printf = Module["_CG_Printf"] = function() { return Module["asm"]["_CG_Printf"].apply(null, arguments) };
var _CG_ProcessSnapshots = Module["_CG_ProcessSnapshots"] = function() { return Module["asm"]["_CG_ProcessSnapshots"].apply(null, arguments) };
var _CG_RailTrail = Module["_CG_RailTrail"] = function() { return Module["asm"]["_CG_RailTrail"].apply(null, arguments) };
var _CG_RegisterItemVisuals = Module["_CG_RegisterItemVisuals"] = function() { return Module["asm"]["_CG_RegisterItemVisuals"].apply(null, arguments) };
var _CG_RegisterWeapon = Module["_CG_RegisterWeapon"] = function() { return Module["asm"]["_CG_RegisterWeapon"].apply(null, arguments) };
var _CG_RenderHUDS = Module["_CG_RenderHUDS"] = function() { return Module["asm"]["_CG_RenderHUDS"].apply(null, arguments) };
var _CG_ResetPlayerEntity = Module["_CG_ResetPlayerEntity"] = function() { return Module["asm"]["_CG_ResetPlayerEntity"].apply(null, arguments) };
var _CG_Respawn = Module["_CG_Respawn"] = function() { return Module["asm"]["_CG_Respawn"].apply(null, arguments) };
var _CG_ScorePlum = Module["_CG_ScorePlum"] = function() { return Module["asm"]["_CG_ScorePlum"].apply(null, arguments) };
var _CG_SetConfigValues = Module["_CG_SetConfigValues"] = function() { return Module["asm"]["_CG_SetConfigValues"].apply(null, arguments) };
var _CG_SetEntitySoundPosition = Module["_CG_SetEntitySoundPosition"] = function() { return Module["asm"]["_CG_SetEntitySoundPosition"].apply(null, arguments) };
var _CG_ShaderStateChanged = Module["_CG_ShaderStateChanged"] = function() { return Module["asm"]["_CG_ShaderStateChanged"].apply(null, arguments) };
var _CG_ShotgunFire = Module["_CG_ShotgunFire"] = function() { return Module["asm"]["_CG_ShotgunFire"].apply(null, arguments) };
var _CG_SmokePuff = Module["_CG_SmokePuff"] = function() { return Module["asm"]["_CG_SmokePuff"].apply(null, arguments) };
var _CG_SpawnEffect = Module["_CG_SpawnEffect"] = function() { return Module["asm"]["_CG_SpawnEffect"].apply(null, arguments) };
var _CG_StartMusic = Module["_CG_StartMusic"] = function() { return Module["asm"]["_CG_StartMusic"].apply(null, arguments) };
var _CG_TeamColor = Module["_CG_TeamColor"] = function() { return Module["asm"]["_CG_TeamColor"].apply(null, arguments) };
var _CG_TestGun_f = Module["_CG_TestGun_f"] = function() { return Module["asm"]["_CG_TestGun_f"].apply(null, arguments) };
var _CG_TestModelNextFrame_f = Module["_CG_TestModelNextFrame_f"] = function() { return Module["asm"]["_CG_TestModelNextFrame_f"].apply(null, arguments) };
var _CG_TestModelNextSkin_f = Module["_CG_TestModelNextSkin_f"] = function() { return Module["asm"]["_CG_TestModelNextSkin_f"].apply(null, arguments) };
var _CG_TestModelPrevFrame_f = Module["_CG_TestModelPrevFrame_f"] = function() { return Module["asm"]["_CG_TestModelPrevFrame_f"].apply(null, arguments) };
var _CG_TestModelPrevSkin_f = Module["_CG_TestModelPrevSkin_f"] = function() { return Module["asm"]["_CG_TestModelPrevSkin_f"].apply(null, arguments) };
var _CG_TestModel_f = Module["_CG_TestModel_f"] = function() { return Module["asm"]["_CG_TestModel_f"].apply(null, arguments) };
var _CG_TileClear = Module["_CG_TileClear"] = function() { return Module["asm"]["_CG_TileClear"].apply(null, arguments) };
var _CG_Trace = Module["_CG_Trace"] = function() { return Module["asm"]["_CG_Trace"].apply(null, arguments) };
var _CG_TransitionPlayerState = Module["_CG_TransitionPlayerState"] = function() { return Module["asm"]["_CG_TransitionPlayerState"].apply(null, arguments) };
var _CG_UpdateCvars = Module["_CG_UpdateCvars"] = function() { return Module["asm"]["_CG_UpdateCvars"].apply(null, arguments) };
var _CG_Weapon_f = Module["_CG_Weapon_f"] = function() { return Module["asm"]["_CG_Weapon_f"].apply(null, arguments) };
var _CG_ZoomDown_f = Module["_CG_ZoomDown_f"] = function() { return Module["asm"]["_CG_ZoomDown_f"].apply(null, arguments) };
var _CG_ZoomUp_f = Module["_CG_ZoomUp_f"] = function() { return Module["asm"]["_CG_ZoomUp_f"].apply(null, arguments) };
var _CL_AddCgameCommand = Module["_CL_AddCgameCommand"] = function() { return Module["asm"]["_CL_AddCgameCommand"].apply(null, arguments) };
var _CL_AddReliableCommand = Module["_CL_AddReliableCommand"] = function() { return Module["asm"]["_CL_AddReliableCommand"].apply(null, arguments) };
var _CL_AdjustTimeDelta = Module["_CL_AdjustTimeDelta"] = function() { return Module["asm"]["_CL_AdjustTimeDelta"].apply(null, arguments) };
var _CL_CGameRendering = Module["_CL_CGameRendering"] = function() { return Module["asm"]["_CL_CGameRendering"].apply(null, arguments) };
var _CL_CM_LoadMap = Module["_CL_CM_LoadMap"] = function() { return Module["asm"]["_CL_CM_LoadMap"].apply(null, arguments) };
var _CL_CharEvent = Module["_CL_CharEvent"] = function() { return Module["asm"]["_CL_CharEvent"].apply(null, arguments) };
var _CL_CheckPaused = Module["_CL_CheckPaused"] = function() { return Module["asm"]["_CL_CheckPaused"].apply(null, arguments) };
var _CL_ClearState = Module["_CL_ClearState"] = function() { return Module["asm"]["_CL_ClearState"].apply(null, arguments) };
var _CL_ConfigstringModified = Module["_CL_ConfigstringModified"] = function() { return Module["asm"]["_CL_ConfigstringModified"].apply(null, arguments) };
var _CL_Disconnect = Module["_CL_Disconnect"] = function() { return Module["asm"]["_CL_Disconnect"].apply(null, arguments) };
var _CL_Disconnect_f = Module["_CL_Disconnect_f"] = function() { return Module["asm"]["_CL_Disconnect_f"].apply(null, arguments) };
var _CL_FirstSnapshot = Module["_CL_FirstSnapshot"] = function() { return Module["asm"]["_CL_FirstSnapshot"].apply(null, arguments) };
var _CL_FlushMemory = Module["_CL_FlushMemory"] = function() { return Module["asm"]["_CL_FlushMemory"].apply(null, arguments) };
var _CL_ForwardCommandToServer = Module["_CL_ForwardCommandToServer"] = function() { return Module["asm"]["_CL_ForwardCommandToServer"].apply(null, arguments) };
var _CL_Frame = Module["_CL_Frame"] = function() { return Module["asm"]["_CL_Frame"].apply(null, arguments) };
var _CL_GameCommand = Module["_CL_GameCommand"] = function() { return Module["asm"]["_CL_GameCommand"].apply(null, arguments) };
var _CL_GetCurrentCmdNumber = Module["_CL_GetCurrentCmdNumber"] = function() { return Module["asm"]["_CL_GetCurrentCmdNumber"].apply(null, arguments) };
var _CL_GetCurrentSnapshotNumber = Module["_CL_GetCurrentSnapshotNumber"] = function() { return Module["asm"]["_CL_GetCurrentSnapshotNumber"].apply(null, arguments) };
var _CL_GetGameState = Module["_CL_GetGameState"] = function() { return Module["asm"]["_CL_GetGameState"].apply(null, arguments) };
var _CL_GetParseEntityState = Module["_CL_GetParseEntityState"] = function() { return Module["asm"]["_CL_GetParseEntityState"].apply(null, arguments) };
var _CL_GetServerCommand = Module["_CL_GetServerCommand"] = function() { return Module["asm"]["_CL_GetServerCommand"].apply(null, arguments) };
var _CL_GetSnapshot = Module["_CL_GetSnapshot"] = function() { return Module["asm"]["_CL_GetSnapshot"].apply(null, arguments) };
var _CL_GetUserCmd = Module["_CL_GetUserCmd"] = function() { return Module["asm"]["_CL_GetUserCmd"].apply(null, arguments) };
var _CL_Init = Module["_CL_Init"] = function() { return Module["asm"]["_CL_Init"].apply(null, arguments) };
var _CL_InitCGame = Module["_CL_InitCGame"] = function() { return Module["asm"]["_CL_InitCGame"].apply(null, arguments) };
var _CL_InitDownloads = Module["_CL_InitDownloads"] = function() { return Module["asm"]["_CL_InitDownloads"].apply(null, arguments) };
var _CL_InitInput = Module["_CL_InitInput"] = function() { return Module["asm"]["_CL_InitInput"].apply(null, arguments) };
var _CL_InitKeyCommands = Module["_CL_InitKeyCommands"] = function() { return Module["asm"]["_CL_InitKeyCommands"].apply(null, arguments) };
var _CL_InitRef = Module["_CL_InitRef"] = function() { return Module["asm"]["_CL_InitRef"].apply(null, arguments) };
var _CL_InitRenderer = Module["_CL_InitRenderer"] = function() { return Module["asm"]["_CL_InitRenderer"].apply(null, arguments) };
var _CL_JoystickEvent = Module["_CL_JoystickEvent"] = function() { return Module["asm"]["_CL_JoystickEvent"].apply(null, arguments) };
var _CL_KeyEvent = Module["_CL_KeyEvent"] = function() { return Module["asm"]["_CL_KeyEvent"].apply(null, arguments) };
var _CL_KeyState = Module["_CL_KeyState"] = function() { return Module["asm"]["_CL_KeyState"].apply(null, arguments) };
var _CL_MapLoading = Module["_CL_MapLoading"] = function() { return Module["asm"]["_CL_MapLoading"].apply(null, arguments) };
var _CL_MouseEvent = Module["_CL_MouseEvent"] = function() { return Module["asm"]["_CL_MouseEvent"].apply(null, arguments) };
var _CL_NextDownload = Module["_CL_NextDownload"] = function() { return Module["asm"]["_CL_NextDownload"].apply(null, arguments) };
var _CL_PacketEvent = Module["_CL_PacketEvent"] = function() { return Module["asm"]["_CL_PacketEvent"].apply(null, arguments) };
var _CL_ParseServerMessage = Module["_CL_ParseServerMessage"] = function() { return Module["asm"]["_CL_ParseServerMessage"].apply(null, arguments) };
var _CL_ReadDemoMessage = Module["_CL_ReadDemoMessage"] = function() { return Module["asm"]["_CL_ReadDemoMessage"].apply(null, arguments) };
var _CL_RefMalloc = Module["_CL_RefMalloc"] = function() { return Module["asm"]["_CL_RefMalloc"].apply(null, arguments) };
var _CL_ScaledMilliseconds = Module["_CL_ScaledMilliseconds"] = function() { return Module["asm"]["_CL_ScaledMilliseconds"].apply(null, arguments) };
var _CL_SendCmd = Module["_CL_SendCmd"] = function() { return Module["asm"]["_CL_SendCmd"].apply(null, arguments) };
var _CL_SetCGameTime = Module["_CL_SetCGameTime"] = function() { return Module["asm"]["_CL_SetCGameTime"].apply(null, arguments) };
var _CL_SetUserCmdValue = Module["_CL_SetUserCmdValue"] = function() { return Module["asm"]["_CL_SetUserCmdValue"].apply(null, arguments) };
var _CL_Shutdown = Module["_CL_Shutdown"] = function() { return Module["asm"]["_CL_Shutdown"].apply(null, arguments) };
var _CL_ShutdownAll = Module["_CL_ShutdownAll"] = function() { return Module["asm"]["_CL_ShutdownAll"].apply(null, arguments) };
var _CL_Snd_Restart_f = Module["_CL_Snd_Restart_f"] = function() { return Module["asm"]["_CL_Snd_Restart_f"].apply(null, arguments) };
var _CL_Snd_Shutdown = Module["_CL_Snd_Shutdown"] = function() { return Module["asm"]["_CL_Snd_Shutdown"].apply(null, arguments) };
var _CL_StartHunkUsers = Module["_CL_StartHunkUsers"] = function() { return Module["asm"]["_CL_StartHunkUsers"].apply(null, arguments) };
var _CL_SystemInfoChanged = Module["_CL_SystemInfoChanged"] = function() { return Module["asm"]["_CL_SystemInfoChanged"].apply(null, arguments) };
var _CL_WritePacket = Module["_CL_WritePacket"] = function() { return Module["asm"]["_CL_WritePacket"].apply(null, arguments) };
var _CM_LoadMap_real = Module["_CM_LoadMap_real"] = function() { return Module["asm"]["_CM_LoadMap_real"].apply(null, arguments) };
var _CM_Trace = Module["_CM_Trace"] = function() { return Module["asm"]["_CM_Trace"].apply(null, arguments) };
var _CM_TraceBoundingBoxThroughCapsule = Module["_CM_TraceBoundingBoxThroughCapsule"] = function() { return Module["asm"]["_CM_TraceBoundingBoxThroughCapsule"].apply(null, arguments) };
var _CM_TraceCapsuleThroughCapsule = Module["_CM_TraceCapsuleThroughCapsule"] = function() { return Module["asm"]["_CM_TraceCapsuleThroughCapsule"].apply(null, arguments) };
var _CM_TraceThroughTree = Module["_CM_TraceThroughTree"] = function() { return Module["asm"]["_CM_TraceThroughTree"].apply(null, arguments) };
var _COM_BeginParseSession = Module["_COM_BeginParseSession"] = function() { return Module["asm"]["_COM_BeginParseSession"].apply(null, arguments) };
var _COM_CompareExtension = Module["_COM_CompareExtension"] = function() { return Module["asm"]["_COM_CompareExtension"].apply(null, arguments) };
var _COM_Compress = Module["_COM_Compress"] = function() { return Module["asm"]["_COM_Compress"].apply(null, arguments) };
var _COM_DefaultExtension = Module["_COM_DefaultExtension"] = function() { return Module["asm"]["_COM_DefaultExtension"].apply(null, arguments) };
var _COM_GetCurrentParseLine = Module["_COM_GetCurrentParseLine"] = function() { return Module["asm"]["_COM_GetCurrentParseLine"].apply(null, arguments) };
var _COM_GetExtension = Module["_COM_GetExtension"] = function() { return Module["asm"]["_COM_GetExtension"].apply(null, arguments) };
var _COM_Parse = Module["_COM_Parse"] = function() { return Module["asm"]["_COM_Parse"].apply(null, arguments) };
var _COM_ParseError = Module["_COM_ParseError"] = function() { return Module["asm"]["_COM_ParseError"].apply(null, arguments) };
var _COM_ParseExt = Module["_COM_ParseExt"] = function() { return Module["asm"]["_COM_ParseExt"].apply(null, arguments) };
var _COM_ParseWarning = Module["_COM_ParseWarning"] = function() { return Module["asm"]["_COM_ParseWarning"].apply(null, arguments) };
var _COM_SkipPath = Module["_COM_SkipPath"] = function() { return Module["asm"]["_COM_SkipPath"].apply(null, arguments) };
var _COM_StripExtension = Module["_COM_StripExtension"] = function() { return Module["asm"]["_COM_StripExtension"].apply(null, arguments) };
var _CalcMuzzlePoint = Module["_CalcMuzzlePoint"] = function() { return Module["asm"]["_CalcMuzzlePoint"].apply(null, arguments) };
var _CalculateRanks = Module["_CalculateRanks"] = function() { return Module["asm"]["_CalculateRanks"].apply(null, arguments) };
var _CanDamage = Module["_CanDamage"] = function() { return Module["asm"]["_CanDamage"].apply(null, arguments) };
var _Cbuf_AddText = Module["_Cbuf_AddText"] = function() { return Module["asm"]["_Cbuf_AddText"].apply(null, arguments) };
var _Cbuf_Execute = Module["_Cbuf_Execute"] = function() { return Module["asm"]["_Cbuf_Execute"].apply(null, arguments) };
var _Cbuf_ExecuteText = Module["_Cbuf_ExecuteText"] = function() { return Module["asm"]["_Cbuf_ExecuteText"].apply(null, arguments) };
var _Cbuf_Init = Module["_Cbuf_Init"] = function() { return Module["asm"]["_Cbuf_Init"].apply(null, arguments) };
var _CheckGauntletAttack = Module["_CheckGauntletAttack"] = function() { return Module["asm"]["_CheckGauntletAttack"].apply(null, arguments) };
var _CheckTeamLeader = Module["_CheckTeamLeader"] = function() { return Module["asm"]["_CheckTeamLeader"].apply(null, arguments) };
var _ClearRegisteredItems = Module["_ClearRegisteredItems"] = function() { return Module["asm"]["_ClearRegisteredItems"].apply(null, arguments) };
var _ClientBegin = Module["_ClientBegin"] = function() { return Module["asm"]["_ClientBegin"].apply(null, arguments) };
var _ClientCommand = Module["_ClientCommand"] = function() { return Module["asm"]["_ClientCommand"].apply(null, arguments) };
var _ClientConnect = Module["_ClientConnect"] = function() { return Module["asm"]["_ClientConnect"].apply(null, arguments) };
var _ClientDisconnect = Module["_ClientDisconnect"] = function() { return Module["asm"]["_ClientDisconnect"].apply(null, arguments) };
var _ClientEndFrame = Module["_ClientEndFrame"] = function() { return Module["asm"]["_ClientEndFrame"].apply(null, arguments) };
var _ClientRespawn = Module["_ClientRespawn"] = function() { return Module["asm"]["_ClientRespawn"].apply(null, arguments) };
var _ClientSpawn = Module["_ClientSpawn"] = function() { return Module["asm"]["_ClientSpawn"].apply(null, arguments) };
var _ClientThink = Module["_ClientThink"] = function() { return Module["asm"]["_ClientThink"].apply(null, arguments) };
var _ClientUserinfoChanged = Module["_ClientUserinfoChanged"] = function() { return Module["asm"]["_ClientUserinfoChanged"].apply(null, arguments) };
var _Cmd_AddCommand = Module["_Cmd_AddCommand"] = function() { return Module["asm"]["_Cmd_AddCommand"].apply(null, arguments) };
var _Cmd_Argc = Module["_Cmd_Argc"] = function() { return Module["asm"]["_Cmd_Argc"].apply(null, arguments) };
var _Cmd_Args = Module["_Cmd_Args"] = function() { return Module["asm"]["_Cmd_Args"].apply(null, arguments) };
var _Cmd_ArgsBuffer = Module["_Cmd_ArgsBuffer"] = function() { return Module["asm"]["_Cmd_ArgsBuffer"].apply(null, arguments) };
var _Cmd_ArgsFrom = Module["_Cmd_ArgsFrom"] = function() { return Module["asm"]["_Cmd_ArgsFrom"].apply(null, arguments) };
var _Cmd_Args_Sanitize = Module["_Cmd_Args_Sanitize"] = function() { return Module["asm"]["_Cmd_Args_Sanitize"].apply(null, arguments) };
var _Cmd_Argv = Module["_Cmd_Argv"] = function() { return Module["asm"]["_Cmd_Argv"].apply(null, arguments) };
var _Cmd_ArgvBuffer = Module["_Cmd_ArgvBuffer"] = function() { return Module["asm"]["_Cmd_ArgvBuffer"].apply(null, arguments) };
var _Cmd_Cmd = Module["_Cmd_Cmd"] = function() { return Module["asm"]["_Cmd_Cmd"].apply(null, arguments) };
var _Cmd_CommandCompletion = Module["_Cmd_CommandCompletion"] = function() { return Module["asm"]["_Cmd_CommandCompletion"].apply(null, arguments) };
var _Cmd_CompleteArgument = Module["_Cmd_CompleteArgument"] = function() { return Module["asm"]["_Cmd_CompleteArgument"].apply(null, arguments) };
var _Cmd_ExecuteString = Module["_Cmd_ExecuteString"] = function() { return Module["asm"]["_Cmd_ExecuteString"].apply(null, arguments) };
var _Cmd_FollowCycle_f = Module["_Cmd_FollowCycle_f"] = function() { return Module["asm"]["_Cmd_FollowCycle_f"].apply(null, arguments) };
var _Cmd_Init = Module["_Cmd_Init"] = function() { return Module["asm"]["_Cmd_Init"].apply(null, arguments) };
var _Cmd_RemoveCommand = Module["_Cmd_RemoveCommand"] = function() { return Module["asm"]["_Cmd_RemoveCommand"].apply(null, arguments) };
var _Cmd_RemoveCommandSafe = Module["_Cmd_RemoveCommandSafe"] = function() { return Module["asm"]["_Cmd_RemoveCommandSafe"].apply(null, arguments) };
var _Cmd_Score_f = Module["_Cmd_Score_f"] = function() { return Module["asm"]["_Cmd_Score_f"].apply(null, arguments) };
var _Cmd_SetCommandCompletionFunc = Module["_Cmd_SetCommandCompletionFunc"] = function() { return Module["asm"]["_Cmd_SetCommandCompletionFunc"].apply(null, arguments) };
var _Cmd_TokenizeString = Module["_Cmd_TokenizeString"] = function() { return Module["asm"]["_Cmd_TokenizeString"].apply(null, arguments) };
var _Cmd_TokenizeStringIgnoreQuotes = Module["_Cmd_TokenizeStringIgnoreQuotes"] = function() { return Module["asm"]["_Cmd_TokenizeStringIgnoreQuotes"].apply(null, arguments) };
var _Com_BeginRedirect = Module["_Com_BeginRedirect"] = function() { return Module["asm"]["_Com_BeginRedirect"].apply(null, arguments) };
var _Com_Clamp = Module["_Com_Clamp"] = function() { return Module["asm"]["_Com_Clamp"].apply(null, arguments) };
var _Com_DPrintf = Module["_Com_DPrintf"] = function() { return Module["asm"]["_Com_DPrintf"].apply(null, arguments) };
var _Com_EndRedirect = Module["_Com_EndRedirect"] = function() { return Module["asm"]["_Com_EndRedirect"].apply(null, arguments) };
var _Com_Error = Module["_Com_Error"] = function() { return Module["asm"]["_Com_Error"].apply(null, arguments) };
var _Com_EventLoop = Module["_Com_EventLoop"] = function() { return Module["asm"]["_Com_EventLoop"].apply(null, arguments) };
var _Com_Filter = Module["_Com_Filter"] = function() { return Module["asm"]["_Com_Filter"].apply(null, arguments) };
var _Com_Frame = Module["_Com_Frame"] = function() { return Module["asm"]["_Com_Frame"].apply(null, arguments) };
var _Com_GameRestart = Module["_Com_GameRestart"] = function() { return Module["asm"]["_Com_GameRestart"].apply(null, arguments) };
var _Com_GetSystemEvent = Module["_Com_GetSystemEvent"] = function() { return Module["asm"]["_Com_GetSystemEvent"].apply(null, arguments) };
var _Com_Init = Module["_Com_Init"] = function() { return Module["asm"]["_Com_Init"].apply(null, arguments) };
var _Com_IsVoipTarget = Module["_Com_IsVoipTarget"] = function() { return Module["asm"]["_Com_IsVoipTarget"].apply(null, arguments) };
var _Com_Milliseconds = Module["_Com_Milliseconds"] = function() { return Module["asm"]["_Com_Milliseconds"].apply(null, arguments) };
var _Com_PlayerNameToFieldString = Module["_Com_PlayerNameToFieldString"] = function() { return Module["asm"]["_Com_PlayerNameToFieldString"].apply(null, arguments) };
var _Com_Printf = Module["_Com_Printf"] = function() { return Module["asm"]["_Com_Printf"].apply(null, arguments) };
var _Com_QueueEvent = Module["_Com_QueueEvent"] = function() { return Module["asm"]["_Com_QueueEvent"].apply(null, arguments) };
var _Com_RunAndTimeServerPacket = Module["_Com_RunAndTimeServerPacket"] = function() { return Module["asm"]["_Com_RunAndTimeServerPacket"].apply(null, arguments) };
var _Com_SafeMode = Module["_Com_SafeMode"] = function() { return Module["asm"]["_Com_SafeMode"].apply(null, arguments) };
var _Com_StartupVariable = Module["_Com_StartupVariable"] = function() { return Module["asm"]["_Com_StartupVariable"].apply(null, arguments) };
var _Com_TouchMemory = Module["_Com_TouchMemory"] = function() { return Module["asm"]["_Com_TouchMemory"].apply(null, arguments) };
var _Com_TruncateLongString = Module["_Com_TruncateLongString"] = function() { return Module["asm"]["_Com_TruncateLongString"].apply(null, arguments) };
var _Com_strCompare = Module["_Com_strCompare"] = function() { return Module["asm"]["_Com_strCompare"].apply(null, arguments) };
var _ConsoleCommand = Module["_ConsoleCommand"] = function() { return Module["asm"]["_ConsoleCommand"].apply(null, arguments) };
var _CopyString = Module["_CopyString"] = function() { return Module["asm"]["_CopyString"].apply(null, arguments) };
var _CopyToBodyQue = Module["_CopyToBodyQue"] = function() { return Module["asm"]["_CopyToBodyQue"].apply(null, arguments) };
var _Cvar_CheckRange = Module["_Cvar_CheckRange"] = function() { return Module["asm"]["_Cvar_CheckRange"].apply(null, arguments) };
var _Cvar_Command = Module["_Cvar_Command"] = function() { return Module["asm"]["_Cvar_Command"].apply(null, arguments) };
var _Cvar_Flags = Module["_Cvar_Flags"] = function() { return Module["asm"]["_Cvar_Flags"].apply(null, arguments) };
var _Cvar_ForceReset = Module["_Cvar_ForceReset"] = function() { return Module["asm"]["_Cvar_ForceReset"].apply(null, arguments) };
var _Cvar_Get = Module["_Cvar_Get"] = function() { return Module["asm"]["_Cvar_Get"].apply(null, arguments) };
var _Cvar_InfoString = Module["_Cvar_InfoString"] = function() { return Module["asm"]["_Cvar_InfoString"].apply(null, arguments) };
var _Cvar_InfoStringBuffer = Module["_Cvar_InfoStringBuffer"] = function() { return Module["asm"]["_Cvar_InfoStringBuffer"].apply(null, arguments) };
var _Cvar_InfoString_Big = Module["_Cvar_InfoString_Big"] = function() { return Module["asm"]["_Cvar_InfoString_Big"].apply(null, arguments) };
var _Cvar_Init = Module["_Cvar_Init"] = function() { return Module["asm"]["_Cvar_Init"].apply(null, arguments) };
var _Cvar_Register = Module["_Cvar_Register"] = function() { return Module["asm"]["_Cvar_Register"].apply(null, arguments) };
var _Cvar_Reset = Module["_Cvar_Reset"] = function() { return Module["asm"]["_Cvar_Reset"].apply(null, arguments) };
var _Cvar_Restart = Module["_Cvar_Restart"] = function() { return Module["asm"]["_Cvar_Restart"].apply(null, arguments) };
var _Cvar_Restart_f = Module["_Cvar_Restart_f"] = function() { return Module["asm"]["_Cvar_Restart_f"].apply(null, arguments) };
var _Cvar_Set = Module["_Cvar_Set"] = function() { return Module["asm"]["_Cvar_Set"].apply(null, arguments) };
var _Cvar_Set2 = Module["_Cvar_Set2"] = function() { return Module["asm"]["_Cvar_Set2"].apply(null, arguments) };
var _Cvar_SetCheatState = Module["_Cvar_SetCheatState"] = function() { return Module["asm"]["_Cvar_SetCheatState"].apply(null, arguments) };
var _Cvar_SetDescription = Module["_Cvar_SetDescription"] = function() { return Module["asm"]["_Cvar_SetDescription"].apply(null, arguments) };
var _Cvar_SetLatched = Module["_Cvar_SetLatched"] = function() { return Module["asm"]["_Cvar_SetLatched"].apply(null, arguments) };
var _Cvar_SetSafe = Module["_Cvar_SetSafe"] = function() { return Module["asm"]["_Cvar_SetSafe"].apply(null, arguments) };
var _Cvar_SetValue = Module["_Cvar_SetValue"] = function() { return Module["asm"]["_Cvar_SetValue"].apply(null, arguments) };
var _Cvar_SetValueSafe = Module["_Cvar_SetValueSafe"] = function() { return Module["asm"]["_Cvar_SetValueSafe"].apply(null, arguments) };
var _Cvar_Update = Module["_Cvar_Update"] = function() { return Module["asm"]["_Cvar_Update"].apply(null, arguments) };
var _Cvar_VariableIntegerValue = Module["_Cvar_VariableIntegerValue"] = function() { return Module["asm"]["_Cvar_VariableIntegerValue"].apply(null, arguments) };
var _Cvar_VariableString = Module["_Cvar_VariableString"] = function() { return Module["asm"]["_Cvar_VariableString"].apply(null, arguments) };
var _Cvar_VariableStringBuffer = Module["_Cvar_VariableStringBuffer"] = function() { return Module["asm"]["_Cvar_VariableStringBuffer"].apply(null, arguments) };
var _Cvar_VariableValue = Module["_Cvar_VariableValue"] = function() { return Module["asm"]["_Cvar_VariableValue"].apply(null, arguments) };
var _Cvar_WriteVariables = Module["_Cvar_WriteVariables"] = function() { return Module["asm"]["_Cvar_WriteVariables"].apply(null, arguments) };
var _DeathmatchScoreboardMessage = Module["_DeathmatchScoreboardMessage"] = function() { return Module["asm"]["_DeathmatchScoreboardMessage"].apply(null, arguments) };
var _Drop_Item = Module["_Drop_Item"] = function() { return Module["asm"]["_Drop_Item"].apply(null, arguments) };
var _FS_ReadFile = Module["_FS_ReadFile"] = function() { return Module["asm"]["_FS_ReadFile"].apply(null, arguments) };
var _FS_fplength = Module["_FS_fplength"] = function() { return Module["asm"]["_FS_fplength"].apply(null, arguments) };
var _FindIntermissionPoint = Module["_FindIntermissionPoint"] = function() { return Module["asm"]["_FindIntermissionPoint"].apply(null, arguments) };
var _FinishSpawningItem = Module["_FinishSpawningItem"] = function() { return Module["asm"]["_FinishSpawningItem"].apply(null, arguments) };
var _FireWeapon = Module["_FireWeapon"] = function() { return Module["asm"]["_FireWeapon"].apply(null, arguments) };
var _FxHandleAddSound = Module["_FxHandleAddSound"] = function() { return Module["asm"]["_FxHandleAddSound"].apply(null, arguments) };
var _FxHandleGetID = Module["_FxHandleGetID"] = function() { return Module["asm"]["_FxHandleGetID"].apply(null, arguments) };
var _FxHandleInit = Module["_FxHandleInit"] = function() { return Module["asm"]["_FxHandleInit"].apply(null, arguments) };
var _G_AddBot = Module["_G_AddBot"] = function() { return Module["asm"]["_G_AddBot"].apply(null, arguments) };
var _G_AddEvent = Module["_G_AddEvent"] = function() { return Module["asm"]["_G_AddEvent"].apply(null, arguments) };
var _G_AddPredictableEvent = Module["_G_AddPredictableEvent"] = function() { return Module["asm"]["_G_AddPredictableEvent"].apply(null, arguments) };
var _G_Alloc = Module["_G_Alloc"] = function() { return Module["asm"]["_G_Alloc"].apply(null, arguments) };
var _G_BotConnect = Module["_G_BotConnect"] = function() { return Module["asm"]["_G_BotConnect"].apply(null, arguments) };
var _G_CheckBotSpawn = Module["_G_CheckBotSpawn"] = function() { return Module["asm"]["_G_CheckBotSpawn"].apply(null, arguments) };
var _G_Damage = Module["_G_Damage"] = function() { return Module["asm"]["_G_Damage"].apply(null, arguments) };
var _G_EntitiesFree = Module["_G_EntitiesFree"] = function() { return Module["asm"]["_G_EntitiesFree"].apply(null, arguments) };
var _G_Error = Module["_G_Error"] = function() { return Module["asm"]["_G_Error"].apply(null, arguments) };
var _G_FilterPacket = Module["_G_FilterPacket"] = function() { return Module["asm"]["_G_FilterPacket"].apply(null, arguments) };
var _G_Find = Module["_G_Find"] = function() { return Module["asm"]["_G_Find"].apply(null, arguments) };
var _G_FreeEntity = Module["_G_FreeEntity"] = function() { return Module["asm"]["_G_FreeEntity"].apply(null, arguments) };
var _G_GetBotInfoByName = Module["_G_GetBotInfoByName"] = function() { return Module["asm"]["_G_GetBotInfoByName"].apply(null, arguments) };
var _G_GetBotInfoByNumber = Module["_G_GetBotInfoByNumber"] = function() { return Module["asm"]["_G_GetBotInfoByNumber"].apply(null, arguments) };
var _G_InitBots = Module["_G_InitBots"] = function() { return Module["asm"]["_G_InitBots"].apply(null, arguments) };
var _G_InitGame = Module["_G_InitGame"] = function() { return Module["asm"]["_G_InitGame"].apply(null, arguments) };
var _G_InitGentity = Module["_G_InitGentity"] = function() { return Module["asm"]["_G_InitGentity"].apply(null, arguments) };
var _G_InitMemory = Module["_G_InitMemory"] = function() { return Module["asm"]["_G_InitMemory"].apply(null, arguments) };
var _G_KillBox = Module["_G_KillBox"] = function() { return Module["asm"]["_G_KillBox"].apply(null, arguments) };
var _G_LogPrintf = Module["_G_LogPrintf"] = function() { return Module["asm"]["_G_LogPrintf"].apply(null, arguments) };
var _G_ModelIndex = Module["_G_ModelIndex"] = function() { return Module["asm"]["_G_ModelIndex"].apply(null, arguments) };
var _G_NewString = Module["_G_NewString"] = function() { return Module["asm"]["_G_NewString"].apply(null, arguments) };
var _G_PickTarget = Module["_G_PickTarget"] = function() { return Module["asm"]["_G_PickTarget"].apply(null, arguments) };
var _G_Printf = Module["_G_Printf"] = function() { return Module["asm"]["_G_Printf"].apply(null, arguments) };
var _G_ProcessIPBans = Module["_G_ProcessIPBans"] = function() { return Module["asm"]["_G_ProcessIPBans"].apply(null, arguments) };
var _G_RadiusDamage = Module["_G_RadiusDamage"] = function() { return Module["asm"]["_G_RadiusDamage"].apply(null, arguments) };
var _G_RemoveQueuedBotBegin = Module["_G_RemoveQueuedBotBegin"] = function() { return Module["asm"]["_G_RemoveQueuedBotBegin"].apply(null, arguments) };
var _G_RunClient = Module["_G_RunClient"] = function() { return Module["asm"]["_G_RunClient"].apply(null, arguments) };
var _G_RunFrame = Module["_G_RunFrame"] = function() { return Module["asm"]["_G_RunFrame"].apply(null, arguments) };
var _G_RunItem = Module["_G_RunItem"] = function() { return Module["asm"]["_G_RunItem"].apply(null, arguments) };
var _G_RunMissile = Module["_G_RunMissile"] = function() { return Module["asm"]["_G_RunMissile"].apply(null, arguments) };
var _G_RunMover = Module["_G_RunMover"] = function() { return Module["asm"]["_G_RunMover"].apply(null, arguments) };
var _G_RunThink = Module["_G_RunThink"] = function() { return Module["asm"]["_G_RunThink"].apply(null, arguments) };
var _G_SetMovedir = Module["_G_SetMovedir"] = function() { return Module["asm"]["_G_SetMovedir"].apply(null, arguments) };
var _G_SetOrigin = Module["_G_SetOrigin"] = function() { return Module["asm"]["_G_SetOrigin"].apply(null, arguments) };
var _G_ShutdownGame = Module["_G_ShutdownGame"] = function() { return Module["asm"]["_G_ShutdownGame"].apply(null, arguments) };
var _G_Sound = Module["_G_Sound"] = function() { return Module["asm"]["_G_Sound"].apply(null, arguments) };
var _G_SoundIndex = Module["_G_SoundIndex"] = function() { return Module["asm"]["_G_SoundIndex"].apply(null, arguments) };
var _G_Spawn = Module["_G_Spawn"] = function() { return Module["asm"]["_G_Spawn"].apply(null, arguments) };
var _G_SpawnEntitiesFromString = Module["_G_SpawnEntitiesFromString"] = function() { return Module["asm"]["_G_SpawnEntitiesFromString"].apply(null, arguments) };
var _G_SpawnFloat = Module["_G_SpawnFloat"] = function() { return Module["asm"]["_G_SpawnFloat"].apply(null, arguments) };
var _G_SpawnInt = Module["_G_SpawnInt"] = function() { return Module["asm"]["_G_SpawnInt"].apply(null, arguments) };
var _G_SpawnItem = Module["_G_SpawnItem"] = function() { return Module["asm"]["_G_SpawnItem"].apply(null, arguments) };
var _G_SpawnString = Module["_G_SpawnString"] = function() { return Module["asm"]["_G_SpawnString"].apply(null, arguments) };
var _G_SpawnVector = Module["_G_SpawnVector"] = function() { return Module["asm"]["_G_SpawnVector"].apply(null, arguments) };
var _G_TeamCommand = Module["_G_TeamCommand"] = function() { return Module["asm"]["_G_TeamCommand"].apply(null, arguments) };
var _G_TempEntity = Module["_G_TempEntity"] = function() { return Module["asm"]["_G_TempEntity"].apply(null, arguments) };
var _G_TouchTriggers = Module["_G_TouchTriggers"] = function() { return Module["asm"]["_G_TouchTriggers"].apply(null, arguments) };
var _G_UseTargets = Module["_G_UseTargets"] = function() { return Module["asm"]["_G_UseTargets"].apply(null, arguments) };
var _HTML_debug = Module["_HTML_debug"] = function() { return Module["asm"]["_HTML_debug"].apply(null, arguments) };
var _HTML_fclose = Module["_HTML_fclose"] = function() { return Module["asm"]["_HTML_fclose"].apply(null, arguments) };
var _HTML_ferror = Module["_HTML_ferror"] = function() { return Module["asm"]["_HTML_ferror"].apply(null, arguments) };
var _HTML_fopen = Module["_HTML_fopen"] = function() { return Module["asm"]["_HTML_fopen"].apply(null, arguments) };
var _HTML_fplength = Module["_HTML_fplength"] = function() { return Module["asm"]["_HTML_fplength"].apply(null, arguments) };
var _HTML_fprintf = Module["_HTML_fprintf"] = function() { return Module["asm"]["_HTML_fprintf"].apply(null, arguments) };
var _HTML_fread = Module["_HTML_fread"] = function() { return Module["asm"]["_HTML_fread"].apply(null, arguments) };
var _HTML_fscanf = Module["_HTML_fscanf"] = function() { return Module["asm"]["_HTML_fscanf"].apply(null, arguments) };
var _HTML_fseek = Module["_HTML_fseek"] = function() { return Module["asm"]["_HTML_fseek"].apply(null, arguments) };
var _HTML_ftell = Module["_HTML_ftell"] = function() { return Module["asm"]["_HTML_ftell"].apply(null, arguments) };
var _HTML_fwrite = Module["_HTML_fwrite"] = function() { return Module["asm"]["_HTML_fwrite"].apply(null, arguments) };
var _HTML_unlink = Module["_HTML_unlink"] = function() { return Module["asm"]["_HTML_unlink"].apply(null, arguments) };
var _Huff_Compress = Module["_Huff_Compress"] = function() { return Module["asm"]["_Huff_Compress"].apply(null, arguments) };
var _Huff_Decompress = Module["_Huff_Decompress"] = function() { return Module["asm"]["_Huff_Decompress"].apply(null, arguments) };
var _Huff_Init = Module["_Huff_Init"] = function() { return Module["asm"]["_Huff_Init"].apply(null, arguments) };
var _Huff_Receive = Module["_Huff_Receive"] = function() { return Module["asm"]["_Huff_Receive"].apply(null, arguments) };
var _Huff_addRef = Module["_Huff_addRef"] = function() { return Module["asm"]["_Huff_addRef"].apply(null, arguments) };
var _Huff_getBit = Module["_Huff_getBit"] = function() { return Module["asm"]["_Huff_getBit"].apply(null, arguments) };
var _Huff_getBloc = Module["_Huff_getBloc"] = function() { return Module["asm"]["_Huff_getBloc"].apply(null, arguments) };
var _Huff_offsetReceive = Module["_Huff_offsetReceive"] = function() { return Module["asm"]["_Huff_offsetReceive"].apply(null, arguments) };
var _Huff_offsetTransmit = Module["_Huff_offsetTransmit"] = function() { return Module["asm"]["_Huff_offsetTransmit"].apply(null, arguments) };
var _Huff_putBit = Module["_Huff_putBit"] = function() { return Module["asm"]["_Huff_putBit"].apply(null, arguments) };
var _Huff_setBloc = Module["_Huff_setBloc"] = function() { return Module["asm"]["_Huff_setBloc"].apply(null, arguments) };
var _Huff_transmit = Module["_Huff_transmit"] = function() { return Module["asm"]["_Huff_transmit"].apply(null, arguments) };
var _Hunk_AllocDebug = Module["_Hunk_AllocDebug"] = function() { return Module["asm"]["_Hunk_AllocDebug"].apply(null, arguments) };
var _Hunk_AllocateTempMemory = Module["_Hunk_AllocateTempMemory"] = function() { return Module["asm"]["_Hunk_AllocateTempMemory"].apply(null, arguments) };
var _Hunk_CheckMark = Module["_Hunk_CheckMark"] = function() { return Module["asm"]["_Hunk_CheckMark"].apply(null, arguments) };
var _Hunk_Clear = Module["_Hunk_Clear"] = function() { return Module["asm"]["_Hunk_Clear"].apply(null, arguments) };
var _Hunk_ClearTempMemory = Module["_Hunk_ClearTempMemory"] = function() { return Module["asm"]["_Hunk_ClearTempMemory"].apply(null, arguments) };
var _Hunk_ClearToMark = Module["_Hunk_ClearToMark"] = function() { return Module["asm"]["_Hunk_ClearToMark"].apply(null, arguments) };
var _Hunk_FreeTempMemory = Module["_Hunk_FreeTempMemory"] = function() { return Module["asm"]["_Hunk_FreeTempMemory"].apply(null, arguments) };
var _Hunk_Log = Module["_Hunk_Log"] = function() { return Module["asm"]["_Hunk_Log"].apply(null, arguments) };
var _Hunk_MemoryRemaining = Module["_Hunk_MemoryRemaining"] = function() { return Module["asm"]["_Hunk_MemoryRemaining"].apply(null, arguments) };
var _Hunk_SetMark = Module["_Hunk_SetMark"] = function() { return Module["asm"]["_Hunk_SetMark"].apply(null, arguments) };
var _IN_CenterView = Module["_IN_CenterView"] = function() { return Module["asm"]["_IN_CenterView"].apply(null, arguments) };
var _Info_NextPair = Module["_Info_NextPair"] = function() { return Module["asm"]["_Info_NextPair"].apply(null, arguments) };
var _Info_Print = Module["_Info_Print"] = function() { return Module["asm"]["_Info_Print"].apply(null, arguments) };
var _Info_RemoveKey = Module["_Info_RemoveKey"] = function() { return Module["asm"]["_Info_RemoveKey"].apply(null, arguments) };
var _Info_RemoveKey_Big = Module["_Info_RemoveKey_Big"] = function() { return Module["asm"]["_Info_RemoveKey_Big"].apply(null, arguments) };
var _Info_SetValueForKey = Module["_Info_SetValueForKey"] = function() { return Module["asm"]["_Info_SetValueForKey"].apply(null, arguments) };
var _Info_SetValueForKey_Big = Module["_Info_SetValueForKey_Big"] = function() { return Module["asm"]["_Info_SetValueForKey_Big"].apply(null, arguments) };
var _Info_Validate = Module["_Info_Validate"] = function() { return Module["asm"]["_Info_Validate"].apply(null, arguments) };
var _Info_ValueForKey = Module["_Info_ValueForKey"] = function() { return Module["asm"]["_Info_ValueForKey"].apply(null, arguments) };
var _InitBodyQue = Module["_InitBodyQue"] = function() { return Module["asm"]["_InitBodyQue"].apply(null, arguments) };
var _Key_GetCatcher = Module["_Key_GetCatcher"] = function() { return Module["asm"]["_Key_GetCatcher"].apply(null, arguments) };
var _Key_KeynameCompletion = Module["_Key_KeynameCompletion"] = function() { return Module["asm"]["_Key_KeynameCompletion"].apply(null, arguments) };
var _Key_KeynumToString = Module["_Key_KeynumToString"] = function() { return Module["asm"]["_Key_KeynumToString"].apply(null, arguments) };
var _Key_SetCatcher = Module["_Key_SetCatcher"] = function() { return Module["asm"]["_Key_SetCatcher"].apply(null, arguments) };
var _Key_StringToKeynum = Module["_Key_StringToKeynum"] = function() { return Module["asm"]["_Key_StringToKeynum"].apply(null, arguments) };
var _Key_WriteBindings = Module["_Key_WriteBindings"] = function() { return Module["asm"]["_Key_WriteBindings"].apply(null, arguments) };
var _LaunchItem = Module["_LaunchItem"] = function() { return Module["asm"]["_LaunchItem"].apply(null, arguments) };
var _LerpAngle = Module["_LerpAngle"] = function() { return Module["asm"]["_LerpAngle"].apply(null, arguments) };
var _LogAccuracyHit = Module["_LogAccuracyHit"] = function() { return Module["asm"]["_LogAccuracyHit"].apply(null, arguments) };
var _MSG_BeginReading = Module["_MSG_BeginReading"] = function() { return Module["asm"]["_MSG_BeginReading"].apply(null, arguments) };
var _MSG_BeginReadingOOB = Module["_MSG_BeginReadingOOB"] = function() { return Module["asm"]["_MSG_BeginReadingOOB"].apply(null, arguments) };
var _MSG_Bitstream = Module["_MSG_Bitstream"] = function() { return Module["asm"]["_MSG_Bitstream"].apply(null, arguments) };
var _MSG_Clear = Module["_MSG_Clear"] = function() { return Module["asm"]["_MSG_Clear"].apply(null, arguments) };
var _MSG_Copy = Module["_MSG_Copy"] = function() { return Module["asm"]["_MSG_Copy"].apply(null, arguments) };
var _MSG_HashKey = Module["_MSG_HashKey"] = function() { return Module["asm"]["_MSG_HashKey"].apply(null, arguments) };
var _MSG_Init = Module["_MSG_Init"] = function() { return Module["asm"]["_MSG_Init"].apply(null, arguments) };
var _MSG_InitOOB = Module["_MSG_InitOOB"] = function() { return Module["asm"]["_MSG_InitOOB"].apply(null, arguments) };
var _MSG_LookaheadByte = Module["_MSG_LookaheadByte"] = function() { return Module["asm"]["_MSG_LookaheadByte"].apply(null, arguments) };
var _MSG_ReadAngle16 = Module["_MSG_ReadAngle16"] = function() { return Module["asm"]["_MSG_ReadAngle16"].apply(null, arguments) };
var _MSG_ReadBigString = Module["_MSG_ReadBigString"] = function() { return Module["asm"]["_MSG_ReadBigString"].apply(null, arguments) };
var _MSG_ReadBits = Module["_MSG_ReadBits"] = function() { return Module["asm"]["_MSG_ReadBits"].apply(null, arguments) };
var _MSG_ReadByte = Module["_MSG_ReadByte"] = function() { return Module["asm"]["_MSG_ReadByte"].apply(null, arguments) };
var _MSG_ReadChar = Module["_MSG_ReadChar"] = function() { return Module["asm"]["_MSG_ReadChar"].apply(null, arguments) };
var _MSG_ReadData = Module["_MSG_ReadData"] = function() { return Module["asm"]["_MSG_ReadData"].apply(null, arguments) };
var _MSG_ReadDeltaEntity = Module["_MSG_ReadDeltaEntity"] = function() { return Module["asm"]["_MSG_ReadDeltaEntity"].apply(null, arguments) };
var _MSG_ReadDeltaPlayerstate = Module["_MSG_ReadDeltaPlayerstate"] = function() { return Module["asm"]["_MSG_ReadDeltaPlayerstate"].apply(null, arguments) };
var _MSG_ReadDeltaUsercmdKey = Module["_MSG_ReadDeltaUsercmdKey"] = function() { return Module["asm"]["_MSG_ReadDeltaUsercmdKey"].apply(null, arguments) };
var _MSG_ReadFloat = Module["_MSG_ReadFloat"] = function() { return Module["asm"]["_MSG_ReadFloat"].apply(null, arguments) };
var _MSG_ReadLong = Module["_MSG_ReadLong"] = function() { return Module["asm"]["_MSG_ReadLong"].apply(null, arguments) };
var _MSG_ReadShort = Module["_MSG_ReadShort"] = function() { return Module["asm"]["_MSG_ReadShort"].apply(null, arguments) };
var _MSG_ReadString = Module["_MSG_ReadString"] = function() { return Module["asm"]["_MSG_ReadString"].apply(null, arguments) };
var _MSG_ReadStringLine = Module["_MSG_ReadStringLine"] = function() { return Module["asm"]["_MSG_ReadStringLine"].apply(null, arguments) };
var _MSG_ReportChangeVectors_f = Module["_MSG_ReportChangeVectors_f"] = function() { return Module["asm"]["_MSG_ReportChangeVectors_f"].apply(null, arguments) };
var _MSG_WriteAngle16 = Module["_MSG_WriteAngle16"] = function() { return Module["asm"]["_MSG_WriteAngle16"].apply(null, arguments) };
var _MSG_WriteBigString = Module["_MSG_WriteBigString"] = function() { return Module["asm"]["_MSG_WriteBigString"].apply(null, arguments) };
var _MSG_WriteBits = Module["_MSG_WriteBits"] = function() { return Module["asm"]["_MSG_WriteBits"].apply(null, arguments) };
var _MSG_WriteByte = Module["_MSG_WriteByte"] = function() { return Module["asm"]["_MSG_WriteByte"].apply(null, arguments) };
var _MSG_WriteChar = Module["_MSG_WriteChar"] = function() { return Module["asm"]["_MSG_WriteChar"].apply(null, arguments) };
var _MSG_WriteData = Module["_MSG_WriteData"] = function() { return Module["asm"]["_MSG_WriteData"].apply(null, arguments) };
var _MSG_WriteDeltaEntity = Module["_MSG_WriteDeltaEntity"] = function() { return Module["asm"]["_MSG_WriteDeltaEntity"].apply(null, arguments) };
var _MSG_WriteDeltaPlayerstate = Module["_MSG_WriteDeltaPlayerstate"] = function() { return Module["asm"]["_MSG_WriteDeltaPlayerstate"].apply(null, arguments) };
var _MSG_WriteDeltaUsercmdKey = Module["_MSG_WriteDeltaUsercmdKey"] = function() { return Module["asm"]["_MSG_WriteDeltaUsercmdKey"].apply(null, arguments) };
var _MSG_WriteFloat = Module["_MSG_WriteFloat"] = function() { return Module["asm"]["_MSG_WriteFloat"].apply(null, arguments) };
var _MSG_WriteLong = Module["_MSG_WriteLong"] = function() { return Module["asm"]["_MSG_WriteLong"].apply(null, arguments) };
var _MSG_WriteShort = Module["_MSG_WriteShort"] = function() { return Module["asm"]["_MSG_WriteShort"].apply(null, arguments) };
var _MSG_WriteString = Module["_MSG_WriteString"] = function() { return Module["asm"]["_MSG_WriteString"].apply(null, arguments) };
var _MakeNormalVectors = Module["_MakeNormalVectors"] = function() { return Module["asm"]["_MakeNormalVectors"].apply(null, arguments) };
var _MatrixMultiply = Module["_MatrixMultiply"] = function() { return Module["asm"]["_MatrixMultiply"].apply(null, arguments) };
var _MoveClientToIntermission = Module["_MoveClientToIntermission"] = function() { return Module["asm"]["_MoveClientToIntermission"].apply(null, arguments) };
var _NET_AdrToString = Module["_NET_AdrToString"] = function() { return Module["asm"]["_NET_AdrToString"].apply(null, arguments) };
var _NET_AdrToStringwPort = Module["_NET_AdrToStringwPort"] = function() { return Module["asm"]["_NET_AdrToStringwPort"].apply(null, arguments) };
var _NET_CompareAdr = Module["_NET_CompareAdr"] = function() { return Module["asm"]["_NET_CompareAdr"].apply(null, arguments) };
var _NET_CompareBaseAdr = Module["_NET_CompareBaseAdr"] = function() { return Module["asm"]["_NET_CompareBaseAdr"].apply(null, arguments) };
var _NET_CompareBaseAdrMask = Module["_NET_CompareBaseAdrMask"] = function() { return Module["asm"]["_NET_CompareBaseAdrMask"].apply(null, arguments) };
var _NET_Config = Module["_NET_Config"] = function() { return Module["asm"]["_NET_Config"].apply(null, arguments) };
var _NET_FlushPacketQueue = Module["_NET_FlushPacketQueue"] = function() { return Module["asm"]["_NET_FlushPacketQueue"].apply(null, arguments) };
var _NET_GetLoopPacket = Module["_NET_GetLoopPacket"] = function() { return Module["asm"]["_NET_GetLoopPacket"].apply(null, arguments) };
var _NET_Init = Module["_NET_Init"] = function() { return Module["asm"]["_NET_Init"].apply(null, arguments) };
var _NET_IsLocalAddress = Module["_NET_IsLocalAddress"] = function() { return Module["asm"]["_NET_IsLocalAddress"].apply(null, arguments) };
var _NET_OutOfBandData = Module["_NET_OutOfBandData"] = function() { return Module["asm"]["_NET_OutOfBandData"].apply(null, arguments) };
var _NET_OutOfBandPrint = Module["_NET_OutOfBandPrint"] = function() { return Module["asm"]["_NET_OutOfBandPrint"].apply(null, arguments) };
var _NET_Restart_f = Module["_NET_Restart_f"] = function() { return Module["asm"]["_NET_Restart_f"].apply(null, arguments) };
var _NET_SendPacket = Module["_NET_SendPacket"] = function() { return Module["asm"]["_NET_SendPacket"].apply(null, arguments) };
var _NET_Shutdown = Module["_NET_Shutdown"] = function() { return Module["asm"]["_NET_Shutdown"].apply(null, arguments) };
var _NET_Sleep = Module["_NET_Sleep"] = function() { return Module["asm"]["_NET_Sleep"].apply(null, arguments) };
var _NET_StringToAdr = Module["_NET_StringToAdr"] = function() { return Module["asm"]["_NET_StringToAdr"].apply(null, arguments) };
var _NET_inject_packet = Module["_NET_inject_packet"] = function() { return Module["asm"]["_NET_inject_packet"].apply(null, arguments) };
var _NET_inject_packet_for_client = Module["_NET_inject_packet_for_client"] = function() { return Module["asm"]["_NET_inject_packet_for_client"].apply(null, arguments) };
var _Netchan_Init = Module["_Netchan_Init"] = function() { return Module["asm"]["_Netchan_Init"].apply(null, arguments) };
var _Netchan_Process = Module["_Netchan_Process"] = function() { return Module["asm"]["_Netchan_Process"].apply(null, arguments) };
var _Netchan_Setup = Module["_Netchan_Setup"] = function() { return Module["asm"]["_Netchan_Setup"].apply(null, arguments) };
var _Netchan_Transmit = Module["_Netchan_Transmit"] = function() { return Module["asm"]["_Netchan_Transmit"].apply(null, arguments) };
var _Netchan_TransmitNextFragment = Module["_Netchan_TransmitNextFragment"] = function() { return Module["asm"]["_Netchan_TransmitNextFragment"].apply(null, arguments) };
var _OnSameTeam = Module["_OnSameTeam"] = function() { return Module["asm"]["_OnSameTeam"].apply(null, arguments) };
var _PM_Accelerate = Module["_PM_Accelerate"] = function() { return Module["asm"]["_PM_Accelerate"].apply(null, arguments) };
var _PM_AddEvent = Module["_PM_AddEvent"] = function() { return Module["asm"]["_PM_AddEvent"].apply(null, arguments) };
var _PM_AddTouchEnt = Module["_PM_AddTouchEnt"] = function() { return Module["asm"]["_PM_AddTouchEnt"].apply(null, arguments) };
var _PM_AirMove = Module["_PM_AirMove"] = function() { return Module["asm"]["_PM_AirMove"].apply(null, arguments) };
var _PM_CheckLadderMove = Module["_PM_CheckLadderMove"] = function() { return Module["asm"]["_PM_CheckLadderMove"].apply(null, arguments) };
var _PM_ClipVelocity = Module["_PM_ClipVelocity"] = function() { return Module["asm"]["_PM_ClipVelocity"].apply(null, arguments) };
var _PM_CmdScale = Module["_PM_CmdScale"] = function() { return Module["asm"]["_PM_CmdScale"].apply(null, arguments) };
var _PM_Debug = Module["_PM_Debug"] = function() { return Module["asm"]["_PM_Debug"].apply(null, arguments) };
var _PM_Friction = Module["_PM_Friction"] = function() { return Module["asm"]["_PM_Friction"].apply(null, arguments) };
var _PM_LadderMove = Module["_PM_LadderMove"] = function() { return Module["asm"]["_PM_LadderMove"].apply(null, arguments) };
var _PM_SetMovementDir = Module["_PM_SetMovementDir"] = function() { return Module["asm"]["_PM_SetMovementDir"].apply(null, arguments) };
var _PM_UpdateViewAngles = Module["_PM_UpdateViewAngles"] = function() { return Module["asm"]["_PM_UpdateViewAngles"].apply(null, arguments) };
var _PerpendicularVector = Module["_PerpendicularVector"] = function() { return Module["asm"]["_PerpendicularVector"].apply(null, arguments) };
var _PickTeam = Module["_PickTeam"] = function() { return Module["asm"]["_PickTeam"].apply(null, arguments) };
var _PlaneFromPoints = Module["_PlaneFromPoints"] = function() { return Module["asm"]["_PlaneFromPoints"].apply(null, arguments) };
var _Pmove = Module["_Pmove"] = function() { return Module["asm"]["_Pmove"].apply(null, arguments) };
var _ProjectPointOnPlane = Module["_ProjectPointOnPlane"] = function() { return Module["asm"]["_ProjectPointOnPlane"].apply(null, arguments) };
var _Q_CleanStr = Module["_Q_CleanStr"] = function() { return Module["asm"]["_Q_CleanStr"].apply(null, arguments) };
var _Q_CountChar = Module["_Q_CountChar"] = function() { return Module["asm"]["_Q_CountChar"].apply(null, arguments) };
var _Q_PrintStrlen = Module["_Q_PrintStrlen"] = function() { return Module["asm"]["_Q_PrintStrlen"].apply(null, arguments) };
var _Q_SnapVector = Module["_Q_SnapVector"] = function() { return Module["asm"]["_Q_SnapVector"].apply(null, arguments) };
var _Q_acos = Module["_Q_acos"] = function() { return Module["asm"]["_Q_acos"].apply(null, arguments) };
var _Q_crandom = Module["_Q_crandom"] = function() { return Module["asm"]["_Q_crandom"].apply(null, arguments) };
var _Q_ftol = Module["_Q_ftol"] = function() { return Module["asm"]["_Q_ftol"].apply(null, arguments) };
var _Q_isalpha = Module["_Q_isalpha"] = function() { return Module["asm"]["_Q_isalpha"].apply(null, arguments) };
var _Q_isanumber = Module["_Q_isanumber"] = function() { return Module["asm"]["_Q_isanumber"].apply(null, arguments) };
var _Q_isintegral = Module["_Q_isintegral"] = function() { return Module["asm"]["_Q_isintegral"].apply(null, arguments) };
var _Q_islower = Module["_Q_islower"] = function() { return Module["asm"]["_Q_islower"].apply(null, arguments) };
var _Q_isprint = Module["_Q_isprint"] = function() { return Module["asm"]["_Q_isprint"].apply(null, arguments) };
var _Q_isupper = Module["_Q_isupper"] = function() { return Module["asm"]["_Q_isupper"].apply(null, arguments) };
var _Q_log2 = Module["_Q_log2"] = function() { return Module["asm"]["_Q_log2"].apply(null, arguments) };
var _Q_rand = Module["_Q_rand"] = function() { return Module["asm"]["_Q_rand"].apply(null, arguments) };
var _Q_random = Module["_Q_random"] = function() { return Module["asm"]["_Q_random"].apply(null, arguments) };
var _Q_strcat = Module["_Q_strcat"] = function() { return Module["asm"]["_Q_strcat"].apply(null, arguments) };
var _Q_stricmp = Module["_Q_stricmp"] = function() { return Module["asm"]["_Q_stricmp"].apply(null, arguments) };
var _Q_stricmpn = Module["_Q_stricmpn"] = function() { return Module["asm"]["_Q_stricmpn"].apply(null, arguments) };
var _Q_stristr = Module["_Q_stristr"] = function() { return Module["asm"]["_Q_stristr"].apply(null, arguments) };
var _Q_strlwr = Module["_Q_strlwr"] = function() { return Module["asm"]["_Q_strlwr"].apply(null, arguments) };
var _Q_strncmp = Module["_Q_strncmp"] = function() { return Module["asm"]["_Q_strncmp"].apply(null, arguments) };
var _Q_strncpyz = Module["_Q_strncpyz"] = function() { return Module["asm"]["_Q_strncpyz"].apply(null, arguments) };
var _Q_strupr = Module["_Q_strupr"] = function() { return Module["asm"]["_Q_strupr"].apply(null, arguments) };
var _RE_AddAdditiveLightToScene = Module["_RE_AddAdditiveLightToScene"] = function() { return Module["asm"]["_RE_AddAdditiveLightToScene"].apply(null, arguments) };
var _RE_AddLightToScene = Module["_RE_AddLightToScene"] = function() { return Module["asm"]["_RE_AddLightToScene"].apply(null, arguments) };
var _RE_AddRefEntityToScene = Module["_RE_AddRefEntityToScene"] = function() { return Module["asm"]["_RE_AddRefEntityToScene"].apply(null, arguments) };
var _RE_RenderScene = Module["_RE_RenderScene"] = function() { return Module["asm"]["_RE_RenderScene"].apply(null, arguments) };
var _R_AddWorldSurfaces = Module["_R_AddWorldSurfaces"] = function() { return Module["asm"]["_R_AddWorldSurfaces"].apply(null, arguments) };
var _R_inPVS = Module["_R_inPVS"] = function() { return Module["asm"]["_R_inPVS"].apply(null, arguments) };
var _RegisterItem = Module["_RegisterItem"] = function() { return Module["asm"]["_RegisterItem"].apply(null, arguments) };
var _RespawnItem = Module["_RespawnItem"] = function() { return Module["asm"]["_RespawnItem"].apply(null, arguments) };
var _RotateAroundDirection = Module["_RotateAroundDirection"] = function() { return Module["asm"]["_RotateAroundDirection"].apply(null, arguments) };
var _RotatePointAroundVector = Module["_RotatePointAroundVector"] = function() { return Module["asm"]["_RotatePointAroundVector"].apply(null, arguments) };
var _SCR_AdjustFrom640 = Module["_SCR_AdjustFrom640"] = function() { return Module["asm"]["_SCR_AdjustFrom640"].apply(null, arguments) };
var _SCR_DebugGraph = Module["_SCR_DebugGraph"] = function() { return Module["asm"]["_SCR_DebugGraph"].apply(null, arguments) };
var _SCR_DrawBigString = Module["_SCR_DrawBigString"] = function() { return Module["asm"]["_SCR_DrawBigString"].apply(null, arguments) };
var _SCR_DrawBigStringColor = Module["_SCR_DrawBigStringColor"] = function() { return Module["asm"]["_SCR_DrawBigStringColor"].apply(null, arguments) };
var _SCR_DrawNamedPic = Module["_SCR_DrawNamedPic"] = function() { return Module["asm"]["_SCR_DrawNamedPic"].apply(null, arguments) };
var _SCR_DrawPic = Module["_SCR_DrawPic"] = function() { return Module["asm"]["_SCR_DrawPic"].apply(null, arguments) };
var _SCR_DrawSmallChar = Module["_SCR_DrawSmallChar"] = function() { return Module["asm"]["_SCR_DrawSmallChar"].apply(null, arguments) };
var _SCR_DrawSmallStringExt = Module["_SCR_DrawSmallStringExt"] = function() { return Module["asm"]["_SCR_DrawSmallStringExt"].apply(null, arguments) };
var _SCR_FillRect = Module["_SCR_FillRect"] = function() { return Module["asm"]["_SCR_FillRect"].apply(null, arguments) };
var _SCR_GetBigStringWidth = Module["_SCR_GetBigStringWidth"] = function() { return Module["asm"]["_SCR_GetBigStringWidth"].apply(null, arguments) };
var _SCR_Init = Module["_SCR_Init"] = function() { return Module["asm"]["_SCR_Init"].apply(null, arguments) };
var _SCR_UpdateScreen = Module["_SCR_UpdateScreen"] = function() { return Module["asm"]["_SCR_UpdateScreen"].apply(null, arguments) };
var _SVC_RateLimit = Module["_SVC_RateLimit"] = function() { return Module["asm"]["_SVC_RateLimit"].apply(null, arguments) };
var _SVC_RateLimitAddress = Module["_SVC_RateLimitAddress"] = function() { return Module["asm"]["_SVC_RateLimitAddress"].apply(null, arguments) };
var _SV_AddOperatorCommands = Module["_SV_AddOperatorCommands"] = function() { return Module["asm"]["_SV_AddOperatorCommands"].apply(null, arguments) };
var _SV_AddServerCommand = Module["_SV_AddServerCommand"] = function() { return Module["asm"]["_SV_AddServerCommand"].apply(null, arguments) };
var _SV_AreaEntities = Module["_SV_AreaEntities"] = function() { return Module["asm"]["_SV_AreaEntities"].apply(null, arguments) };
var _SV_AuthorizeIpPacket = Module["_SV_AuthorizeIpPacket"] = function() { return Module["asm"]["_SV_AuthorizeIpPacket"].apply(null, arguments) };
var _SV_BotAllocateClient = Module["_SV_BotAllocateClient"] = function() { return Module["asm"]["_SV_BotAllocateClient"].apply(null, arguments) };
var _SV_BotFreeClient = Module["_SV_BotFreeClient"] = function() { return Module["asm"]["_SV_BotFreeClient"].apply(null, arguments) };
var _SV_BotGetConsoleMessage = Module["_SV_BotGetConsoleMessage"] = function() { return Module["asm"]["_SV_BotGetConsoleMessage"].apply(null, arguments) };
var _SV_BotGetSnapshotEntity = Module["_SV_BotGetSnapshotEntity"] = function() { return Module["asm"]["_SV_BotGetSnapshotEntity"].apply(null, arguments) };
var _SV_ChangeMaxClients = Module["_SV_ChangeMaxClients"] = function() { return Module["asm"]["_SV_ChangeMaxClients"].apply(null, arguments) };
var _SV_ClearWorld = Module["_SV_ClearWorld"] = function() { return Module["asm"]["_SV_ClearWorld"].apply(null, arguments) };
var _SV_ClientEnterWorld = Module["_SV_ClientEnterWorld"] = function() { return Module["asm"]["_SV_ClientEnterWorld"].apply(null, arguments) };
var _SV_ClientThink = Module["_SV_ClientThink"] = function() { return Module["asm"]["_SV_ClientThink"].apply(null, arguments) };
var _SV_ClipHandleForEntity = Module["_SV_ClipHandleForEntity"] = function() { return Module["asm"]["_SV_ClipHandleForEntity"].apply(null, arguments) };
var _SV_ClipToEntity = Module["_SV_ClipToEntity"] = function() { return Module["asm"]["_SV_ClipToEntity"].apply(null, arguments) };
var _SV_DirectConnect = Module["_SV_DirectConnect"] = function() { return Module["asm"]["_SV_DirectConnect"].apply(null, arguments) };
var _SV_DropClient = Module["_SV_DropClient"] = function() { return Module["asm"]["_SV_DropClient"].apply(null, arguments) };
var _SV_DropClientByID = Module["_SV_DropClientByID"] = function() { return Module["asm"]["_SV_DropClientByID"].apply(null, arguments) };
var _SV_ExecuteClientCommand = Module["_SV_ExecuteClientCommand"] = function() { return Module["asm"]["_SV_ExecuteClientCommand"].apply(null, arguments) };
var _SV_ExecuteClientMessage = Module["_SV_ExecuteClientMessage"] = function() { return Module["asm"]["_SV_ExecuteClientMessage"].apply(null, arguments) };
var _SV_FinalMessage = Module["_SV_FinalMessage"] = function() { return Module["asm"]["_SV_FinalMessage"].apply(null, arguments) };
var _SV_Frame = Module["_SV_Frame"] = function() { return Module["asm"]["_SV_Frame"].apply(null, arguments) };
var _SV_FrameMsec = Module["_SV_FrameMsec"] = function() { return Module["asm"]["_SV_FrameMsec"].apply(null, arguments) };
var _SV_FreeClient = Module["_SV_FreeClient"] = function() { return Module["asm"]["_SV_FreeClient"].apply(null, arguments) };
var _SV_GEntityForSvEntity = Module["_SV_GEntityForSvEntity"] = function() { return Module["asm"]["_SV_GEntityForSvEntity"].apply(null, arguments) };
var _SV_GameClientNum = Module["_SV_GameClientNum"] = function() { return Module["asm"]["_SV_GameClientNum"].apply(null, arguments) };
var _SV_GameCommand = Module["_SV_GameCommand"] = function() { return Module["asm"]["_SV_GameCommand"].apply(null, arguments) };
var _SV_GentityNum = Module["_SV_GentityNum"] = function() { return Module["asm"]["_SV_GentityNum"].apply(null, arguments) };
var _SV_GetChallenge = Module["_SV_GetChallenge"] = function() { return Module["asm"]["_SV_GetChallenge"].apply(null, arguments) };
var _SV_GetConfigstring = Module["_SV_GetConfigstring"] = function() { return Module["asm"]["_SV_GetConfigstring"].apply(null, arguments) };
var _SV_GetUserinfo = Module["_SV_GetUserinfo"] = function() { return Module["asm"]["_SV_GetUserinfo"].apply(null, arguments) };
var _SV_Heartbeat_f = Module["_SV_Heartbeat_f"] = function() { return Module["asm"]["_SV_Heartbeat_f"].apply(null, arguments) };
var _SV_Init = Module["_SV_Init"] = function() { return Module["asm"]["_SV_Init"].apply(null, arguments) };
var _SV_InitGameProgs = Module["_SV_InitGameProgs"] = function() { return Module["asm"]["_SV_InitGameProgs"].apply(null, arguments) };
var _SV_LinkEntity = Module["_SV_LinkEntity"] = function() { return Module["asm"]["_SV_LinkEntity"].apply(null, arguments) };
var _SV_MasterShutdown = Module["_SV_MasterShutdown"] = function() { return Module["asm"]["_SV_MasterShutdown"].apply(null, arguments) };
var _SV_Netchan_FreeQueue = Module["_SV_Netchan_FreeQueue"] = function() { return Module["asm"]["_SV_Netchan_FreeQueue"].apply(null, arguments) };
var _SV_Netchan_Process = Module["_SV_Netchan_Process"] = function() { return Module["asm"]["_SV_Netchan_Process"].apply(null, arguments) };
var _SV_Netchan_Transmit = Module["_SV_Netchan_Transmit"] = function() { return Module["asm"]["_SV_Netchan_Transmit"].apply(null, arguments) };
var _SV_Netchan_TransmitNextFragment = Module["_SV_Netchan_TransmitNextFragment"] = function() { return Module["asm"]["_SV_Netchan_TransmitNextFragment"].apply(null, arguments) };
var _SV_NumForGentity = Module["_SV_NumForGentity"] = function() { return Module["asm"]["_SV_NumForGentity"].apply(null, arguments) };
var _SV_PacketEvent = Module["_SV_PacketEvent"] = function() { return Module["asm"]["_SV_PacketEvent"].apply(null, arguments) };
var _SV_PointContents = Module["_SV_PointContents"] = function() { return Module["asm"]["_SV_PointContents"].apply(null, arguments) };
var _SV_QuakeIDByPort = Module["_SV_QuakeIDByPort"] = function() { return Module["asm"]["_SV_QuakeIDByPort"].apply(null, arguments) };
var _SV_RateMsec = Module["_SV_RateMsec"] = function() { return Module["asm"]["_SV_RateMsec"].apply(null, arguments) };
var _SV_RemoveOperatorCommands = Module["_SV_RemoveOperatorCommands"] = function() { return Module["asm"]["_SV_RemoveOperatorCommands"].apply(null, arguments) };
var _SV_RestartGameProgs = Module["_SV_RestartGameProgs"] = function() { return Module["asm"]["_SV_RestartGameProgs"].apply(null, arguments) };
var _SV_SectorList_f = Module["_SV_SectorList_f"] = function() { return Module["asm"]["_SV_SectorList_f"].apply(null, arguments) };
var _SV_SendClientMessages = Module["_SV_SendClientMessages"] = function() { return Module["asm"]["_SV_SendClientMessages"].apply(null, arguments) };
var _SV_SendClientSnapshot = Module["_SV_SendClientSnapshot"] = function() { return Module["asm"]["_SV_SendClientSnapshot"].apply(null, arguments) };
var _SV_SendDownloadMessages = Module["_SV_SendDownloadMessages"] = function() { return Module["asm"]["_SV_SendDownloadMessages"].apply(null, arguments) };
var _SV_SendMessageToClient = Module["_SV_SendMessageToClient"] = function() { return Module["asm"]["_SV_SendMessageToClient"].apply(null, arguments) };
var _SV_SendQueuedMessages = Module["_SV_SendQueuedMessages"] = function() { return Module["asm"]["_SV_SendQueuedMessages"].apply(null, arguments) };
var _SV_SendQueuedPackets = Module["_SV_SendQueuedPackets"] = function() { return Module["asm"]["_SV_SendQueuedPackets"].apply(null, arguments) };
var _SV_SendServerCommand = Module["_SV_SendServerCommand"] = function() { return Module["asm"]["_SV_SendServerCommand"].apply(null, arguments) };
var _SV_SetConfigstring = Module["_SV_SetConfigstring"] = function() { return Module["asm"]["_SV_SetConfigstring"].apply(null, arguments) };
var _SV_SetUserinfo = Module["_SV_SetUserinfo"] = function() { return Module["asm"]["_SV_SetUserinfo"].apply(null, arguments) };
var _SV_Shutdown = Module["_SV_Shutdown"] = function() { return Module["asm"]["_SV_Shutdown"].apply(null, arguments) };
var _SV_ShutdownGameProgs = Module["_SV_ShutdownGameProgs"] = function() { return Module["asm"]["_SV_ShutdownGameProgs"].apply(null, arguments) };
var _SV_SpawnServer = Module["_SV_SpawnServer"] = function() { return Module["asm"]["_SV_SpawnServer"].apply(null, arguments) };
var _SV_SpawnServer_Resume = Module["_SV_SpawnServer_Resume"] = function() { return Module["asm"]["_SV_SpawnServer_Resume"].apply(null, arguments) };
var _SV_SvEntityForGentity = Module["_SV_SvEntityForGentity"] = function() { return Module["asm"]["_SV_SvEntityForGentity"].apply(null, arguments) };
var _SV_Trace = Module["_SV_Trace"] = function() { return Module["asm"]["_SV_Trace"].apply(null, arguments) };
var _SV_UnlinkEntity = Module["_SV_UnlinkEntity"] = function() { return Module["asm"]["_SV_UnlinkEntity"].apply(null, arguments) };
var _SV_UpdateConfigstrings = Module["_SV_UpdateConfigstrings"] = function() { return Module["asm"]["_SV_UpdateConfigstrings"].apply(null, arguments) };
var _SV_UpdateServerCommandsToClient = Module["_SV_UpdateServerCommandsToClient"] = function() { return Module["asm"]["_SV_UpdateServerCommandsToClient"].apply(null, arguments) };
var _SV_UserinfoChanged = Module["_SV_UserinfoChanged"] = function() { return Module["asm"]["_SV_UserinfoChanged"].apply(null, arguments) };
var _SV_WriteDownloadToClient = Module["_SV_WriteDownloadToClient"] = function() { return Module["asm"]["_SV_WriteDownloadToClient"].apply(null, arguments) };
var _SV_WriteSnapshotHUDS = Module["_SV_WriteSnapshotHUDS"] = function() { return Module["asm"]["_SV_WriteSnapshotHUDS"].apply(null, arguments) };
var _SV_inPVS = Module["_SV_inPVS"] = function() { return Module["asm"]["_SV_inPVS"].apply(null, arguments) };
var _S_AL_SanitiseVectorLine = Module["_S_AL_SanitiseVectorLine"] = function() { return Module["asm"]["_S_AL_SanitiseVectorLine"].apply(null, arguments) };
var _S_ClearSoundBuffer = Module["_S_ClearSoundBuffer"] = function() { return Module["asm"]["_S_ClearSoundBuffer"].apply(null, arguments) };
var _S_MallocDebug = Module["_S_MallocDebug"] = function() { return Module["asm"]["_S_MallocDebug"].apply(null, arguments) };
var _SaveRegisteredItems = Module["_SaveRegisteredItems"] = function() { return Module["asm"]["_SaveRegisteredItems"].apply(null, arguments) };
var _SelectSpawnPoint = Module["_SelectSpawnPoint"] = function() { return Module["asm"]["_SelectSpawnPoint"].apply(null, arguments) };
var _SendScoreboardMessageToAllClients = Module["_SendScoreboardMessageToAllClients"] = function() { return Module["asm"]["_SendScoreboardMessageToAllClients"].apply(null, arguments) };
var _SetClientViewAngle = Module["_SetClientViewAngle"] = function() { return Module["asm"]["_SetClientViewAngle"].apply(null, arguments) };
var _SetLeader = Module["_SetLeader"] = function() { return Module["asm"]["_SetLeader"].apply(null, arguments) };
var _SetTeam = Module["_SetTeam"] = function() { return Module["asm"]["_SetTeam"].apply(null, arguments) };
var _SnapVectorTowards = Module["_SnapVectorTowards"] = function() { return Module["asm"]["_SnapVectorTowards"].apply(null, arguments) };
var _SpawnModelsOnVictoryPads = Module["_SpawnModelsOnVictoryPads"] = function() { return Module["asm"]["_SpawnModelsOnVictoryPads"].apply(null, arguments) };
var _SpotWouldTelefrag = Module["_SpotWouldTelefrag"] = function() { return Module["asm"]["_SpotWouldTelefrag"].apply(null, arguments) };
var _StopFollowing = Module["_StopFollowing"] = function() { return Module["asm"]["_StopFollowing"].apply(null, arguments) };
var _Svcmd_AbortPodium_f = Module["_Svcmd_AbortPodium_f"] = function() { return Module["asm"]["_Svcmd_AbortPodium_f"].apply(null, arguments) };
var _Svcmd_AddBot_f = Module["_Svcmd_AddBot_f"] = function() { return Module["asm"]["_Svcmd_AddBot_f"].apply(null, arguments) };
var _Svcmd_BotList_f = Module["_Svcmd_BotList_f"] = function() { return Module["asm"]["_Svcmd_BotList_f"].apply(null, arguments) };
var _Svcmd_GameMem_f = Module["_Svcmd_GameMem_f"] = function() { return Module["asm"]["_Svcmd_GameMem_f"].apply(null, arguments) };
var _Sys_IsLANAddress = Module["_Sys_IsLANAddress"] = function() { return Module["asm"]["_Sys_IsLANAddress"].apply(null, arguments) };
var _Sys_MilliSeconds = Module["_Sys_MilliSeconds"] = function() { return Module["asm"]["_Sys_MilliSeconds"].apply(null, arguments) };
var _Sys_Milliseconds = Module["_Sys_Milliseconds"] = function() { return Module["asm"]["_Sys_Milliseconds"].apply(null, arguments) };
var _Sys_SendPacket = Module["_Sys_SendPacket"] = function() { return Module["asm"]["_Sys_SendPacket"].apply(null, arguments) };
var _Sys_ShowIP = Module["_Sys_ShowIP"] = function() { return Module["asm"]["_Sys_ShowIP"].apply(null, arguments) };
var _Sys_StringToAdr = Module["_Sys_StringToAdr"] = function() { return Module["asm"]["_Sys_StringToAdr"].apply(null, arguments) };
var _TeamCount = Module["_TeamCount"] = function() { return Module["asm"]["_TeamCount"].apply(null, arguments) };
var _TeamLeader = Module["_TeamLeader"] = function() { return Module["asm"]["_TeamLeader"].apply(null, arguments) };
var _TeleportPlayer = Module["_TeleportPlayer"] = function() { return Module["asm"]["_TeleportPlayer"].apply(null, arguments) };
var _TossClientItems = Module["_TossClientItems"] = function() { return Module["asm"]["_TossClientItems"].apply(null, arguments) };
var _Touch_DoorTrigger = Module["_Touch_DoorTrigger"] = function() { return Module["asm"]["_Touch_DoorTrigger"].apply(null, arguments) };
var _Touch_Item = Module["_Touch_Item"] = function() { return Module["asm"]["_Touch_Item"].apply(null, arguments) };
var _UI_DrawProportionalString = Module["_UI_DrawProportionalString"] = function() { return Module["asm"]["_UI_DrawProportionalString"].apply(null, arguments) };
var _UpdateTournamentInfo = Module["_UpdateTournamentInfo"] = function() { return Module["asm"]["_UpdateTournamentInfo"].apply(null, arguments) };
var _Vector4Scale = Module["_Vector4Scale"] = function() { return Module["asm"]["_Vector4Scale"].apply(null, arguments) };
var _VectorNormalize = Module["_VectorNormalize"] = function() { return Module["asm"]["_VectorNormalize"].apply(null, arguments) };
var _VectorNormalize2 = Module["_VectorNormalize2"] = function() { return Module["asm"]["_VectorNormalize2"].apply(null, arguments) };
var _VectorRotate = Module["_VectorRotate"] = function() { return Module["asm"]["_VectorRotate"].apply(null, arguments) };
var _Weapon_HookFree = Module["_Weapon_HookFree"] = function() { return Module["asm"]["_Weapon_HookFree"].apply(null, arguments) };
var _Weapon_HookThink = Module["_Weapon_HookThink"] = function() { return Module["asm"]["_Weapon_HookThink"].apply(null, arguments) };
var _Z_AvailableMemory = Module["_Z_AvailableMemory"] = function() { return Module["asm"]["_Z_AvailableMemory"].apply(null, arguments) };
var _Z_Free = Module["_Z_Free"] = function() { return Module["asm"]["_Z_Free"].apply(null, arguments) };
var _Z_FreeTags = Module["_Z_FreeTags"] = function() { return Module["asm"]["_Z_FreeTags"].apply(null, arguments) };
var _Z_LogHeap = Module["_Z_LogHeap"] = function() { return Module["asm"]["_Z_LogHeap"].apply(null, arguments) };
var _Z_MallocDebug = Module["_Z_MallocDebug"] = function() { return Module["asm"]["_Z_MallocDebug"].apply(null, arguments) };
var _Z_TagMallocDebug = Module["_Z_TagMallocDebug"] = function() { return Module["asm"]["_Z_TagMallocDebug"].apply(null, arguments) };
var __GLOBAL__I_000101 = Module["__GLOBAL__I_000101"] = function() { return Module["asm"]["__GLOBAL__I_000101"].apply(null, arguments) };
var __GLOBAL__I_000101_4978 = Module["__GLOBAL__I_000101_4978"] = function() { return Module["asm"]["__GLOBAL__I_000101_4978"].apply(null, arguments) };
var __GLOBAL__sub_I_iostream_cpp = Module["__GLOBAL__sub_I_iostream_cpp"] = function() { return Module["asm"]["__GLOBAL__sub_I_iostream_cpp"].apply(null, arguments) };
var __GLOBAL__sub_I_memory_resource_cpp = Module["__GLOBAL__sub_I_memory_resource_cpp"] = function() { return Module["asm"]["__GLOBAL__sub_I_memory_resource_cpp"].apply(null, arguments) };
var __GLOBAL__sub_I_ramfile_cpp = Module["__GLOBAL__sub_I_ramfile_cpp"] = function() { return Module["asm"]["__GLOBAL__sub_I_ramfile_cpp"].apply(null, arguments) };
var ___errno_location = Module["___errno_location"] = function() { return Module["asm"]["___errno_location"].apply(null, arguments) };
var _beginRegistration = Module["_beginRegistration"] = function() { return Module["asm"]["_beginRegistration"].apply(null, arguments) };
var _body_die = Module["_body_die"] = function() { return Module["asm"]["_body_die"].apply(null, arguments) };
var _c_get_uint = Module["_c_get_uint"] = function() { return Module["asm"]["_c_get_uint"].apply(null, arguments) };
var _c_getchar = Module["_c_getchar"] = function() { return Module["asm"]["_c_getchar"].apply(null, arguments) };
var _c_malloc = Module["_c_malloc"] = function() { return Module["asm"]["_c_malloc"].apply(null, arguments) };
var _c_memcpy = Module["_c_memcpy"] = function() { return Module["asm"]["_c_memcpy"].apply(null, arguments) };
var _c_pointer = Module["_c_pointer"] = function() { return Module["asm"]["_c_pointer"].apply(null, arguments) };
var _c_set_uint = Module["_c_set_uint"] = function() { return Module["asm"]["_c_set_uint"].apply(null, arguments) };
var _callback_add = Module["_callback_add"] = function() { return Module["asm"]["_callback_add"].apply(null, arguments) };
var _cg_vars_init = Module["_cg_vars_init"] = function() { return Module["asm"]["_cg_vars_init"].apply(null, arguments) };
var _entity_get_position = Module["_entity_get_position"] = function() { return Module["asm"]["_entity_get_position"].apply(null, arguments) };
var _fgc_test = Module["_fgc_test"] = function() { return Module["asm"]["_fgc_test"].apply(null, arguments) };
var _file_dump_memory = Module["_file_dump_memory"] = function() { return Module["asm"]["_file_dump_memory"].apply(null, arguments) };
var _file_flush_disc = Module["_file_flush_disc"] = function() { return Module["asm"]["_file_flush_disc"].apply(null, arguments) };
var _file_get_buffer_by_name = Module["_file_get_buffer_by_name"] = function() { return Module["asm"]["_file_get_buffer_by_name"].apply(null, arguments) };
var _file_get_contents = Module["_file_get_contents"] = function() { return Module["asm"]["_file_get_contents"].apply(null, arguments) };
var _file_loaded = Module["_file_loaded"] = function() { return Module["asm"]["_file_loaded"].apply(null, arguments) };
var _file_put_contents = Module["_file_put_contents"] = function() { return Module["asm"]["_file_put_contents"].apply(null, arguments) };
var _fire_bfg = Module["_fire_bfg"] = function() { return Module["asm"]["_fire_bfg"].apply(null, arguments) };
var _fire_grapple = Module["_fire_grapple"] = function() { return Module["asm"]["_fire_grapple"].apply(null, arguments) };
var _fire_grenade = Module["_fire_grenade"] = function() { return Module["asm"]["_fire_grenade"].apply(null, arguments) };
var _fire_plasma = Module["_fire_plasma"] = function() { return Module["asm"]["_fire_plasma"].apply(null, arguments) };
var _fire_rocket = Module["_fire_rocket"] = function() { return Module["asm"]["_fire_rocket"].apply(null, arguments) };
var _free = Module["_free"] = function() { return Module["asm"]["_free"].apply(null, arguments) };
var _htonl = Module["_htonl"] = function() { return Module["asm"]["_htonl"].apply(null, arguments) };
var _htons = Module["_htons"] = function() { return Module["asm"]["_htons"].apply(null, arguments) };
var _jl_SV_SendServerCommand = Module["_jl_SV_SendServerCommand"] = function() { return Module["asm"]["_jl_SV_SendServerCommand"].apply(null, arguments) };
var _jl_clients = Module["_jl_clients"] = function() { return Module["asm"]["_jl_clients"].apply(null, arguments) };
var _jl_clients_sizeof = Module["_jl_clients_sizeof"] = function() { return Module["asm"]["_jl_clients_sizeof"].apply(null, arguments) };
var _jl_entity_get_angles = Module["_jl_entity_get_angles"] = function() { return Module["asm"]["_jl_entity_get_angles"].apply(null, arguments) };
var _jl_entity_get_pos = Module["_jl_entity_get_pos"] = function() { return Module["asm"]["_jl_entity_get_pos"].apply(null, arguments) };
var _jl_entity_inuse = Module["_jl_entity_inuse"] = function() { return Module["asm"]["_jl_entity_inuse"].apply(null, arguments) };
var _jl_entity_moveto = Module["_jl_entity_moveto"] = function() { return Module["asm"]["_jl_entity_moveto"].apply(null, arguments) };
var _jl_entity_send_hud = Module["_jl_entity_send_hud"] = function() { return Module["asm"]["_jl_entity_send_hud"].apply(null, arguments) };
var _jl_entity_set_angles = Module["_jl_entity_set_angles"] = function() { return Module["asm"]["_jl_entity_set_angles"].apply(null, arguments) };
var _jl_entity_set_model = Module["_jl_entity_set_model"] = function() { return Module["asm"]["_jl_entity_set_model"].apply(null, arguments) };
var _jl_entity_set_pos = Module["_jl_entity_set_pos"] = function() { return Module["asm"]["_jl_entity_set_pos"].apply(null, arguments) };
var _jl_entity_update_hud = Module["_jl_entity_update_hud"] = function() { return Module["asm"]["_jl_entity_update_hud"].apply(null, arguments) };
var _jl_g_entities = Module["_jl_g_entities"] = function() { return Module["asm"]["_jl_g_entities"].apply(null, arguments) };
var _jl_g_entities_sizeof = Module["_jl_g_entities_sizeof"] = function() { return Module["asm"]["_jl_g_entities_sizeof"].apply(null, arguments) };
var _jl_g_spawn = Module["_jl_g_spawn"] = function() { return Module["asm"]["_jl_g_spawn"].apply(null, arguments) };
var _jl_player_aimbuttonpressed = Module["_jl_player_aimbuttonpressed"] = function() { return Module["asm"]["_jl_player_aimbuttonpressed"].apply(null, arguments) };
var _jl_player_attackbuttonpressed = Module["_jl_player_attackbuttonpressed"] = function() { return Module["asm"]["_jl_player_attackbuttonpressed"].apply(null, arguments) };
var _jl_player_forward = Module["_jl_player_forward"] = function() { return Module["asm"]["_jl_player_forward"].apply(null, arguments) };
var _jl_player_get_velocity = Module["_jl_player_get_velocity"] = function() { return Module["asm"]["_jl_player_get_velocity"].apply(null, arguments) };
var _jl_player_get_viewangles = Module["_jl_player_get_viewangles"] = function() { return Module["asm"]["_jl_player_get_viewangles"].apply(null, arguments) };
var _jl_player_hudelem_free = Module["_jl_player_hudelem_free"] = function() { return Module["asm"]["_jl_player_hudelem_free"].apply(null, arguments) };
var _jl_player_hudelem_hide = Module["_jl_player_hudelem_hide"] = function() { return Module["asm"]["_jl_player_hudelem_hide"].apply(null, arguments) };
var _jl_player_hudelem_settext = Module["_jl_player_hudelem_settext"] = function() { return Module["asm"]["_jl_player_hudelem_settext"].apply(null, arguments) };
var _jl_player_hudelem_show = Module["_jl_player_hudelem_show"] = function() { return Module["asm"]["_jl_player_hudelem_show"].apply(null, arguments) };
var _jl_player_nadebuttonpressed = Module["_jl_player_nadebuttonpressed"] = function() { return Module["asm"]["_jl_player_nadebuttonpressed"].apply(null, arguments) };
var _jl_player_set_velocity = Module["_jl_player_set_velocity"] = function() { return Module["asm"]["_jl_player_set_velocity"].apply(null, arguments) };
var _jl_player_set_viewangles = Module["_jl_player_set_viewangles"] = function() { return Module["asm"]["_jl_player_set_viewangles"].apply(null, arguments) };
var _jl_player_usebuttonpressed = Module["_jl_player_usebuttonpressed"] = function() { return Module["asm"]["_jl_player_usebuttonpressed"].apply(null, arguments) };
var _jl_player_viewheight = Module["_jl_player_viewheight"] = function() { return Module["asm"]["_jl_player_viewheight"].apply(null, arguments) };
var _jl_player_walkbuttonpressed = Module["_jl_player_walkbuttonpressed"] = function() { return Module["asm"]["_jl_player_walkbuttonpressed"].apply(null, arguments) };
var _jl_trace = Module["_jl_trace"] = function() { return Module["asm"]["_jl_trace"].apply(null, arguments) };
var _js_player_forward = Module["_js_player_forward"] = function() { return Module["asm"]["_js_player_forward"].apply(null, arguments) };
var _llvm_bswap_i16 = Module["_llvm_bswap_i16"] = function() { return Module["asm"]["_llvm_bswap_i16"].apply(null, arguments) };
var _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = function() { return Module["asm"]["_llvm_bswap_i32"].apply(null, arguments) };
var _llvm_round_f32 = Module["_llvm_round_f32"] = function() { return Module["asm"]["_llvm_round_f32"].apply(null, arguments) };
var _main = Module["_main"] = function() { return Module["asm"]["_main"].apply(null, arguments) };
var _malloc = Module["_malloc"] = function() { return Module["asm"]["_malloc"].apply(null, arguments) };
var _memcpy = Module["_memcpy"] = function() { return Module["asm"]["_memcpy"].apply(null, arguments) };
var _memmove = Module["_memmove"] = function() { return Module["asm"]["_memmove"].apply(null, arguments) };
var _memset = Module["_memset"] = function() { return Module["asm"]["_memset"].apply(null, arguments) };
var _ntohs = Module["_ntohs"] = function() { return Module["asm"]["_ntohs"].apply(null, arguments) };
var _player_die = Module["_player_die"] = function() { return Module["asm"]["_player_die"].apply(null, arguments) };
var _player_forwardmove = Module["_player_forwardmove"] = function() { return Module["asm"]["_player_forwardmove"].apply(null, arguments) };
var _player_get_deaths = Module["_player_get_deaths"] = function() { return Module["asm"]["_player_get_deaths"].apply(null, arguments) };
var _player_get_health = Module["_player_get_health"] = function() { return Module["asm"]["_player_get_health"].apply(null, arguments) };
var _player_get_maxhealth = Module["_player_get_maxhealth"] = function() { return Module["asm"]["_player_get_maxhealth"].apply(null, arguments) };
var _player_get_score = Module["_player_get_score"] = function() { return Module["asm"]["_player_get_score"].apply(null, arguments) };
var _player_get_team = Module["_player_get_team"] = function() { return Module["asm"]["_player_get_team"].apply(null, arguments) };
var _player_isbot = Module["_player_isbot"] = function() { return Module["asm"]["_player_isbot"].apply(null, arguments) };
var _player_set_deaths = Module["_player_set_deaths"] = function() { return Module["asm"]["_player_set_deaths"].apply(null, arguments) };
var _player_set_health = Module["_player_set_health"] = function() { return Module["asm"]["_player_set_health"].apply(null, arguments) };
var _player_set_maxhealth = Module["_player_set_maxhealth"] = function() { return Module["asm"]["_player_set_maxhealth"].apply(null, arguments) };
var _player_set_score = Module["_player_set_score"] = function() { return Module["asm"]["_player_set_score"].apply(null, arguments) };
var _player_set_team = Module["_player_set_team"] = function() { return Module["asm"]["_player_set_team"].apply(null, arguments) };
var _pointer_ClientPlayerStateAmmo = Module["_pointer_ClientPlayerStateAmmo"] = function() { return Module["asm"]["_pointer_ClientPlayerStateAmmo"].apply(null, arguments) };
var _pointer_ClientPlayerStateStats = Module["_pointer_ClientPlayerStateStats"] = function() { return Module["asm"]["_pointer_ClientPlayerStateStats"].apply(null, arguments) };
var _pthread_cond_broadcast = Module["_pthread_cond_broadcast"] = function() { return Module["asm"]["_pthread_cond_broadcast"].apply(null, arguments) };
var _pthread_mutex_lock = Module["_pthread_mutex_lock"] = function() { return Module["asm"]["_pthread_mutex_lock"].apply(null, arguments) };
var _pthread_mutex_unlock = Module["_pthread_mutex_unlock"] = function() { return Module["asm"]["_pthread_mutex_unlock"].apply(null, arguments) };
var _q3_main = Module["_q3_main"] = function() { return Module["asm"]["_q3_main"].apply(null, arguments) };
var _q3_main_dedicated = Module["_q3_main_dedicated"] = function() { return Module["asm"]["_q3_main_dedicated"].apply(null, arguments) };
var _quake_set_widthheight = Module["_quake_set_widthheight"] = function() { return Module["asm"]["_quake_set_widthheight"].apply(null, arguments) };
var _realloc = Module["_realloc"] = function() { return Module["asm"]["_realloc"].apply(null, arguments) };
var _rintf = Module["_rintf"] = function() { return Module["asm"]["_rintf"].apply(null, arguments) };
var _saveSetjmp = Module["_saveSetjmp"] = function() { return Module["asm"]["_saveSetjmp"].apply(null, arguments) };
var _sbrk = Module["_sbrk"] = function() { return Module["asm"]["_sbrk"].apply(null, arguments) };
var _set_callback_CG_ServerCommand = Module["_set_callback_CG_ServerCommand"] = function() { return Module["asm"]["_set_callback_CG_ServerCommand"].apply(null, arguments) };
var _set_callback_SV_DropClient = Module["_set_callback_SV_DropClient"] = function() { return Module["asm"]["_set_callback_SV_DropClient"].apply(null, arguments) };
var _set_callback_clientspawn = Module["_set_callback_clientspawn"] = function() { return Module["asm"]["_set_callback_clientspawn"].apply(null, arguments) };
var _set_callback_getticks = Module["_set_callback_getticks"] = function() { return Module["asm"]["_set_callback_getticks"].apply(null, arguments) };
var _set_callback_player_damage = Module["_set_callback_player_damage"] = function() { return Module["asm"]["_set_callback_player_damage"].apply(null, arguments) };
var _set_callback_player_killed = Module["_set_callback_player_killed"] = function() { return Module["asm"]["_set_callback_player_killed"].apply(null, arguments) };
var _set_callback_rocket = Module["_set_callback_rocket"] = function() { return Module["asm"]["_set_callback_rocket"].apply(null, arguments) };
var _switchToWeapon = Module["_switchToWeapon"] = function() { return Module["asm"]["_switchToWeapon"].apply(null, arguments) };
var _testSetjmp = Module["_testSetjmp"] = function() { return Module["asm"]["_testSetjmp"].apply(null, arguments) };
var _test_fopen = Module["_test_fopen"] = function() { return Module["asm"]["_test_fopen"].apply(null, arguments) };
var _trap_AddCommand = Module["_trap_AddCommand"] = function() { return Module["asm"]["_trap_AddCommand"].apply(null, arguments) };
var _trap_AdjustAreaPortalState = Module["_trap_AdjustAreaPortalState"] = function() { return Module["asm"]["_trap_AdjustAreaPortalState"].apply(null, arguments) };
var _trap_AreasConnected = Module["_trap_AreasConnected"] = function() { return Module["asm"]["_trap_AreasConnected"].apply(null, arguments) };
var _trap_Argc = Module["_trap_Argc"] = function() { return Module["asm"]["_trap_Argc"].apply(null, arguments) };
var _trap_Args = Module["_trap_Args"] = function() { return Module["asm"]["_trap_Args"].apply(null, arguments) };
var _trap_Argv = Module["_trap_Argv"] = function() { return Module["asm"]["_trap_Argv"].apply(null, arguments) };
var _trap_BotAllocateClient = Module["_trap_BotAllocateClient"] = function() { return Module["asm"]["_trap_BotAllocateClient"].apply(null, arguments) };
var _trap_BotFreeClient = Module["_trap_BotFreeClient"] = function() { return Module["asm"]["_trap_BotFreeClient"].apply(null, arguments) };
var _trap_CM_BoxTrace = Module["_trap_CM_BoxTrace"] = function() { return Module["asm"]["_trap_CM_BoxTrace"].apply(null, arguments) };
var _trap_CM_CapsuleTrace = Module["_trap_CM_CapsuleTrace"] = function() { return Module["asm"]["_trap_CM_CapsuleTrace"].apply(null, arguments) };
var _trap_CM_InlineModel = Module["_trap_CM_InlineModel"] = function() { return Module["asm"]["_trap_CM_InlineModel"].apply(null, arguments) };
var _trap_CM_LoadMap = Module["_trap_CM_LoadMap"] = function() { return Module["asm"]["_trap_CM_LoadMap"].apply(null, arguments) };
var _trap_CM_MarkFragments = Module["_trap_CM_MarkFragments"] = function() { return Module["asm"]["_trap_CM_MarkFragments"].apply(null, arguments) };
var _trap_CM_NumInlineModels = Module["_trap_CM_NumInlineModels"] = function() { return Module["asm"]["_trap_CM_NumInlineModels"].apply(null, arguments) };
var _trap_CM_PointContents = Module["_trap_CM_PointContents"] = function() { return Module["asm"]["_trap_CM_PointContents"].apply(null, arguments) };
var _trap_CM_TempBoxModel = Module["_trap_CM_TempBoxModel"] = function() { return Module["asm"]["_trap_CM_TempBoxModel"].apply(null, arguments) };
var _trap_CM_TransformedBoxTrace = Module["_trap_CM_TransformedBoxTrace"] = function() { return Module["asm"]["_trap_CM_TransformedBoxTrace"].apply(null, arguments) };
var _trap_CM_TransformedCapsuleTrace = Module["_trap_CM_TransformedCapsuleTrace"] = function() { return Module["asm"]["_trap_CM_TransformedCapsuleTrace"].apply(null, arguments) };
var _trap_CM_TransformedPointContents = Module["_trap_CM_TransformedPointContents"] = function() { return Module["asm"]["_trap_CM_TransformedPointContents"].apply(null, arguments) };
var _trap_Cvar_VariableIntegerValue = Module["_trap_Cvar_VariableIntegerValue"] = function() { return Module["asm"]["_trap_Cvar_VariableIntegerValue"].apply(null, arguments) };
var _trap_Cvar_VariableValue = Module["_trap_Cvar_VariableValue"] = function() { return Module["asm"]["_trap_Cvar_VariableValue"].apply(null, arguments) };
var _trap_DebugPolygonCreate = Module["_trap_DebugPolygonCreate"] = function() { return Module["asm"]["_trap_DebugPolygonCreate"].apply(null, arguments) };
var _trap_DebugPolygonDelete = Module["_trap_DebugPolygonDelete"] = function() { return Module["asm"]["_trap_DebugPolygonDelete"].apply(null, arguments) };
var _trap_DropClient = Module["_trap_DropClient"] = function() { return Module["asm"]["_trap_DropClient"].apply(null, arguments) };
var _trap_EntitiesInBox = Module["_trap_EntitiesInBox"] = function() { return Module["asm"]["_trap_EntitiesInBox"].apply(null, arguments) };
var _trap_EntityContact = Module["_trap_EntityContact"] = function() { return Module["asm"]["_trap_EntityContact"].apply(null, arguments) };
var _trap_Error = Module["_trap_Error"] = function() { return Module["asm"]["_trap_Error"].apply(null, arguments) };
var _trap_FS_FOpenFile = Module["_trap_FS_FOpenFile"] = function() { return Module["asm"]["_trap_FS_FOpenFile"].apply(null, arguments) };
var _trap_Game_GetEntityToken = Module["_trap_Game_GetEntityToken"] = function() { return Module["asm"]["_trap_Game_GetEntityToken"].apply(null, arguments) };
var _trap_GetConfigstring = Module["_trap_GetConfigstring"] = function() { return Module["asm"]["_trap_GetConfigstring"].apply(null, arguments) };
var _trap_GetCurrentCmdNumber = Module["_trap_GetCurrentCmdNumber"] = function() { return Module["asm"]["_trap_GetCurrentCmdNumber"].apply(null, arguments) };
var _trap_GetCurrentSnapshotNumber = Module["_trap_GetCurrentSnapshotNumber"] = function() { return Module["asm"]["_trap_GetCurrentSnapshotNumber"].apply(null, arguments) };
var _trap_GetEntityToken = Module["_trap_GetEntityToken"] = function() { return Module["asm"]["_trap_GetEntityToken"].apply(null, arguments) };
var _trap_GetGameState = Module["_trap_GetGameState"] = function() { return Module["asm"]["_trap_GetGameState"].apply(null, arguments) };
var _trap_GetServerCommand = Module["_trap_GetServerCommand"] = function() { return Module["asm"]["_trap_GetServerCommand"].apply(null, arguments) };
var _trap_GetServerinfo = Module["_trap_GetServerinfo"] = function() { return Module["asm"]["_trap_GetServerinfo"].apply(null, arguments) };
var _trap_GetSnapshot = Module["_trap_GetSnapshot"] = function() { return Module["asm"]["_trap_GetSnapshot"].apply(null, arguments) };
var _trap_GetUserCmd = Module["_trap_GetUserCmd"] = function() { return Module["asm"]["_trap_GetUserCmd"].apply(null, arguments) };
var _trap_GetUsercmd = Module["_trap_GetUsercmd"] = function() { return Module["asm"]["_trap_GetUsercmd"].apply(null, arguments) };
var _trap_GetUserinfo = Module["_trap_GetUserinfo"] = function() { return Module["asm"]["_trap_GetUserinfo"].apply(null, arguments) };
var _trap_InPVS = Module["_trap_InPVS"] = function() { return Module["asm"]["_trap_InPVS"].apply(null, arguments) };
var _trap_InPVSIgnorePortals = Module["_trap_InPVSIgnorePortals"] = function() { return Module["asm"]["_trap_InPVSIgnorePortals"].apply(null, arguments) };
var _trap_Key_GetCatcher = Module["_trap_Key_GetCatcher"] = function() { return Module["asm"]["_trap_Key_GetCatcher"].apply(null, arguments) };
var _trap_Key_GetKey = Module["_trap_Key_GetKey"] = function() { return Module["asm"]["_trap_Key_GetKey"].apply(null, arguments) };
var _trap_Key_IsDown = Module["_trap_Key_IsDown"] = function() { return Module["asm"]["_trap_Key_IsDown"].apply(null, arguments) };
var _trap_Key_SetCatcher = Module["_trap_Key_SetCatcher"] = function() { return Module["asm"]["_trap_Key_SetCatcher"].apply(null, arguments) };
var _trap_LinkEntity = Module["_trap_LinkEntity"] = function() { return Module["asm"]["_trap_LinkEntity"].apply(null, arguments) };
var _trap_LocateGameData = Module["_trap_LocateGameData"] = function() { return Module["asm"]["_trap_LocateGameData"].apply(null, arguments) };
var _trap_MemoryRemaining = Module["_trap_MemoryRemaining"] = function() { return Module["asm"]["_trap_MemoryRemaining"].apply(null, arguments) };
var _trap_Milliseconds = Module["_trap_Milliseconds"] = function() { return Module["asm"]["_trap_Milliseconds"].apply(null, arguments) };
var _trap_PointContents = Module["_trap_PointContents"] = function() { return Module["asm"]["_trap_PointContents"].apply(null, arguments) };
var _trap_Print = Module["_trap_Print"] = function() { return Module["asm"]["_trap_Print"].apply(null, arguments) };
var _trap_R_AddAdditiveLightToScene = Module["_trap_R_AddAdditiveLightToScene"] = function() { return Module["asm"]["_trap_R_AddAdditiveLightToScene"].apply(null, arguments) };
var _trap_R_AddLightToScene = Module["_trap_R_AddLightToScene"] = function() { return Module["asm"]["_trap_R_AddLightToScene"].apply(null, arguments) };
var _trap_R_DrawStretchPic = Module["_trap_R_DrawStretchPic"] = function() { return Module["asm"]["_trap_R_DrawStretchPic"].apply(null, arguments) };
var _trap_R_LoadWorldMap = Module["_trap_R_LoadWorldMap"] = function() { return Module["asm"]["_trap_R_LoadWorldMap"].apply(null, arguments) };
var _trap_R_RegisterModel = Module["_trap_R_RegisterModel"] = function() { return Module["asm"]["_trap_R_RegisterModel"].apply(null, arguments) };
var _trap_R_RegisterShader = Module["_trap_R_RegisterShader"] = function() { return Module["asm"]["_trap_R_RegisterShader"].apply(null, arguments) };
var _trap_R_RegisterShaderNoMip = Module["_trap_R_RegisterShaderNoMip"] = function() { return Module["asm"]["_trap_R_RegisterShaderNoMip"].apply(null, arguments) };
var _trap_R_RegisterSkin = Module["_trap_R_RegisterSkin"] = function() { return Module["asm"]["_trap_R_RegisterSkin"].apply(null, arguments) };
var _trap_R_SetColor = Module["_trap_R_SetColor"] = function() { return Module["asm"]["_trap_R_SetColor"].apply(null, arguments) };
var _trap_R_inPVS = Module["_trap_R_inPVS"] = function() { return Module["asm"]["_trap_R_inPVS"].apply(null, arguments) };
var _trap_RemoveCommand = Module["_trap_RemoveCommand"] = function() { return Module["asm"]["_trap_RemoveCommand"].apply(null, arguments) };
var _trap_S_AddLoopingSound = Module["_trap_S_AddLoopingSound"] = function() { return Module["asm"]["_trap_S_AddLoopingSound"].apply(null, arguments) };
var _trap_S_AddRealLoopingSound = Module["_trap_S_AddRealLoopingSound"] = function() { return Module["asm"]["_trap_S_AddRealLoopingSound"].apply(null, arguments) };
var _trap_S_ClearLoopingSounds = Module["_trap_S_ClearLoopingSounds"] = function() { return Module["asm"]["_trap_S_ClearLoopingSounds"].apply(null, arguments) };
var _trap_S_RegisterSound = Module["_trap_S_RegisterSound"] = function() { return Module["asm"]["_trap_S_RegisterSound"].apply(null, arguments) };
var _trap_S_Respatialize = Module["_trap_S_Respatialize"] = function() { return Module["asm"]["_trap_S_Respatialize"].apply(null, arguments) };
var _trap_S_StartBackgroundTrack = Module["_trap_S_StartBackgroundTrack"] = function() { return Module["asm"]["_trap_S_StartBackgroundTrack"].apply(null, arguments) };
var _trap_S_StartLocalSound = Module["_trap_S_StartLocalSound"] = function() { return Module["asm"]["_trap_S_StartLocalSound"].apply(null, arguments) };
var _trap_S_StartSound = Module["_trap_S_StartSound"] = function() { return Module["asm"]["_trap_S_StartSound"].apply(null, arguments) };
var _trap_S_StopBackgroundTrack = Module["_trap_S_StopBackgroundTrack"] = function() { return Module["asm"]["_trap_S_StopBackgroundTrack"].apply(null, arguments) };
var _trap_S_StopLoopingSound = Module["_trap_S_StopLoopingSound"] = function() { return Module["asm"]["_trap_S_StopLoopingSound"].apply(null, arguments) };
var _trap_S_UpdateEntityPosition = Module["_trap_S_UpdateEntityPosition"] = function() { return Module["asm"]["_trap_S_UpdateEntityPosition"].apply(null, arguments) };
var _trap_SendClientCommand = Module["_trap_SendClientCommand"] = function() { return Module["asm"]["_trap_SendClientCommand"].apply(null, arguments) };
var _trap_SendConsoleCommand = Module["_trap_SendConsoleCommand"] = function() { return Module["asm"]["_trap_SendConsoleCommand"].apply(null, arguments) };
var _trap_SendServerCommand = Module["_trap_SendServerCommand"] = function() { return Module["asm"]["_trap_SendServerCommand"].apply(null, arguments) };
var _trap_SetBrushModel = Module["_trap_SetBrushModel"] = function() { return Module["asm"]["_trap_SetBrushModel"].apply(null, arguments) };
var _trap_SetConfigstring = Module["_trap_SetConfigstring"] = function() { return Module["asm"]["_trap_SetConfigstring"].apply(null, arguments) };
var _trap_SetUserCmdValue = Module["_trap_SetUserCmdValue"] = function() { return Module["asm"]["_trap_SetUserCmdValue"].apply(null, arguments) };
var _trap_SetUserinfo = Module["_trap_SetUserinfo"] = function() { return Module["asm"]["_trap_SetUserinfo"].apply(null, arguments) };
var _trap_SnapVector = Module["_trap_SnapVector"] = function() { return Module["asm"]["_trap_SnapVector"].apply(null, arguments) };
var _trap_Trace = Module["_trap_Trace"] = function() { return Module["asm"]["_trap_Trace"].apply(null, arguments) };
var _trap_UnlinkEntity = Module["_trap_UnlinkEntity"] = function() { return Module["asm"]["_trap_UnlinkEntity"].apply(null, arguments) };
var _trap_UpdateScreen = Module["_trap_UpdateScreen"] = function() { return Module["asm"]["_trap_UpdateScreen"].apply(null, arguments) };
var _trigger_teleporter_touch = Module["_trigger_teleporter_touch"] = function() { return Module["asm"]["_trigger_teleporter_touch"].apply(null, arguments) };
var _tv = Module["_tv"] = function() { return Module["asm"]["_tv"].apply(null, arguments) };
var _va = Module["_va"] = function() { return Module["asm"]["_va"].apply(null, arguments) };
var _vec3_a_is_b_minus_c = Module["_vec3_a_is_b_minus_c"] = function() { return Module["asm"]["_vec3_a_is_b_minus_c"].apply(null, arguments) };
var _vec3_a_is_b_plus_c = Module["_vec3_a_is_b_plus_c"] = function() { return Module["asm"]["_vec3_a_is_b_plus_c"].apply(null, arguments) };
var _vec3_a_is_b_plus_c_times_d = Module["_vec3_a_is_b_plus_c_times_d"] = function() { return Module["asm"]["_vec3_a_is_b_plus_c_times_d"].apply(null, arguments) };
var _vec3_a_is_b_times_c = Module["_vec3_a_is_b_times_c"] = function() { return Module["asm"]["_vec3_a_is_b_times_c"].apply(null, arguments) };
var _vectoangles = Module["_vectoangles"] = function() { return Module["asm"]["_vectoangles"].apply(null, arguments) };
var _vectoyaw = Module["_vectoyaw"] = function() { return Module["asm"]["_vectoyaw"].apply(null, arguments) };
var _viewpos_pitch = Module["_viewpos_pitch"] = function() { return Module["asm"]["_viewpos_pitch"].apply(null, arguments) };
var _viewpos_roll = Module["_viewpos_roll"] = function() { return Module["asm"]["_viewpos_roll"].apply(null, arguments) };
var _viewpos_x = Module["_viewpos_x"] = function() { return Module["asm"]["_viewpos_x"].apply(null, arguments) };
var _viewpos_y = Module["_viewpos_y"] = function() { return Module["asm"]["_viewpos_y"].apply(null, arguments) };
var _viewpos_yaw = Module["_viewpos_yaw"] = function() { return Module["asm"]["_viewpos_yaw"].apply(null, arguments) };
var _viewpos_z = Module["_viewpos_z"] = function() { return Module["asm"]["_viewpos_z"].apply(null, arguments) };
var _vtos = Module["_vtos"] = function() { return Module["asm"]["_vtos"].apply(null, arguments) };
var establishStackSpace = Module["establishStackSpace"] = function() { return Module["asm"]["establishStackSpace"].apply(null, arguments) };
var setThrew = Module["setThrew"] = function() { return Module["asm"]["setThrew"].apply(null, arguments) };
var stackAlloc = Module["stackAlloc"] = function() { return Module["asm"]["stackAlloc"].apply(null, arguments) };
var stackRestore = Module["stackRestore"] = function() { return Module["asm"]["stackRestore"].apply(null, arguments) };
var stackSave = Module["stackSave"] = function() { return Module["asm"]["stackSave"].apply(null, arguments) };
var dynCall_i = Module["dynCall_i"] = function() { return Module["asm"]["dynCall_i"].apply(null, arguments) };
var dynCall_ii = Module["dynCall_ii"] = function() { return Module["asm"]["dynCall_ii"].apply(null, arguments) };
var dynCall_iii = Module["dynCall_iii"] = function() { return Module["asm"]["dynCall_iii"].apply(null, arguments) };
var dynCall_iiii = Module["dynCall_iiii"] = function() { return Module["asm"]["dynCall_iiii"].apply(null, arguments) };
var dynCall_iiiii = Module["dynCall_iiiii"] = function() { return Module["asm"]["dynCall_iiiii"].apply(null, arguments) };
var dynCall_iiiiid = Module["dynCall_iiiiid"] = function() { return Module["asm"]["dynCall_iiiiid"].apply(null, arguments) };
var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() { return Module["asm"]["dynCall_iiiiii"].apply(null, arguments) };
var dynCall_iiiiiid = Module["dynCall_iiiiiid"] = function() { return Module["asm"]["dynCall_iiiiiid"].apply(null, arguments) };
var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() { return Module["asm"]["dynCall_iiiiiii"].apply(null, arguments) };
var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function() { return Module["asm"]["dynCall_iiiiiiii"].apply(null, arguments) };
var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = function() { return Module["asm"]["dynCall_iiiiiiiii"].apply(null, arguments) };
var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() { return Module["asm"]["dynCall_iiiiij"].apply(null, arguments) };
var dynCall_v = Module["dynCall_v"] = function() { return Module["asm"]["dynCall_v"].apply(null, arguments) };
var dynCall_vi = Module["dynCall_vi"] = function() { return Module["asm"]["dynCall_vi"].apply(null, arguments) };
var dynCall_vii = Module["dynCall_vii"] = function() { return Module["asm"]["dynCall_vii"].apply(null, arguments) };
var dynCall_viii = Module["dynCall_viii"] = function() { return Module["asm"]["dynCall_viii"].apply(null, arguments) };
var dynCall_viiii = Module["dynCall_viiii"] = function() { return Module["asm"]["dynCall_viiii"].apply(null, arguments) };
var dynCall_viiiii = Module["dynCall_viiiii"] = function() { return Module["asm"]["dynCall_viiiii"].apply(null, arguments) };
var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() { return Module["asm"]["dynCall_viiiiii"].apply(null, arguments) };
var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() { return Module["asm"]["dynCall_viiiiiii"].apply(null, arguments) };
var dynCall_viijii = Module["dynCall_viijii"] = function() { return Module["asm"]["dynCall_viijii"].apply(null, arguments) };
;
// === Auto-generated postamble setup entry stuff ===
Module['asm'] = asm;
/**
* @constructor
* @extends {Error}
* @this {ExitStatus}
*/
function ExitStatus(status) {
this.name = "ExitStatus";
this.message = "Program terminated with exit(" + status + ")";
this.status = status;
};
ExitStatus.prototype = new Error();
ExitStatus.prototype.constructor = ExitStatus;
var initialStackTop;
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 (!Module['calledRun']) run();
if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
}
Module['callMain'] = function callMain(args) {
args = args || [];
ensureInitRuntime();
var argc = args.length+1;
var argv = stackAlloc((argc + 1) * 4);
HEAP32[argv >> 2] = allocateUTF8OnStack(Module['thisProgram']);
for (var i = 1; i < argc; i++) {
HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]);
}
HEAP32[(argv >> 2) + argc] = 0;
try {
var ret = Module['_main'](argc, argv, 0);
// if we're not running an evented main loop, it's time to exit
// DO NOT QUIT
}
catch(e) {
if (e instanceof ExitStatus) {
// exit() throws this once it's done to make sure execution
// has been stopped completely
return;
} else if (e == 'SimulateInfiniteLoop') {
// running an evented main loop, don't immediately exit
Module['noExitRuntime'] = true;
return;
} else {
var toLog = e;
if (e && typeof e === 'object' && e.stack) {
toLog = [e, e.stack];
}
err('exception thrown: ' + toLog);
Module['quit'](1, e);
}
} finally {
calledMain = true;
}
}
/** @type {function(Array=)} */
function run(args) {
args = args || Module['arguments'];
if (runDependencies > 0) {
return;
}
preRun();
if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
function doRun() {
if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
Module['calledRun'] = true;
if (ABORT) return;
ensureInitRuntime();
preMain();
if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
if (Module['_main'] && shouldRunNow) Module['callMain'](args);
postRun();
}
if (Module['setStatus']) {
Module['setStatus']('Running...');
setTimeout(function() {
setTimeout(function() {
Module['setStatus']('');
}, 1);
doRun();
}, 1);
} else {
doRun();
}
}
Module['run'] = run;
function exit(status, implicit) {
// if this is just main exit-ing implicitly, and the status is 0, then we
// don't need to do anything here and can just leave. if the status is
// non-zero, though, then we need to report it.
// (we may have warned about this earlier, if a situation justifies doing so)
if (implicit && Module['noExitRuntime'] && status === 0) {
return;
}
if (Module['noExitRuntime']) {
} else {
ABORT = true;
EXITSTATUS = status;
STACKTOP = initialStackTop;
exitRuntime();
if (Module['onExit']) Module['onExit'](status);
}
Module['quit'](status, new ExitStatus(status));
}
var abortDecorators = [];
function abort(what) {
if (Module['onAbort']) {
Module['onAbort'](what);
}
if (what !== undefined) {
out(what);
err(what);
what = JSON.stringify(what)
} else {
what = '';
}
ABORT = true;
EXITSTATUS = 1;
throw 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';
}
Module['abort'] = abort;
if (Module['preInit']) {
if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
while (Module['preInit'].length > 0) {
Module['preInit'].pop()();
}
}
// shouldRunNow refers to calling main(), not run().
var shouldRunNow = true;
if (Module['noInitialRun']) {
shouldRunNow = false;
}
Module["noExitRuntime"] = true;
run();
// {{MODULE_ADDITIONS}}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment