2023-02-08 23:23:42 -05:00
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(Module) { ..generated code.. }
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module != 'undefined' ? Module : { } ;
// See https://caniuse.com/mdn-javascript_builtins_object_assign
// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
if ( ! Module . expectedDataFileDownloads ) {
Module . expectedDataFileDownloads = 0 ;
}
Module . expectedDataFileDownloads ++ ;
( function ( ) {
// When running as a pthread, FS operations are proxied to the main thread, so we don't need to
// fetch the .data bundle on the worker
if ( Module [ 'ENVIRONMENT_IS_PTHREAD' ] ) return ;
var loadPackage = function ( metadata ) {
var PACKAGE _PATH = '' ;
if ( typeof window === 'object' ) {
PACKAGE _PATH = window [ 'encodeURIComponent' ] ( window . location . pathname . toString ( ) . substring ( 0 , window . location . pathname . toString ( ) . lastIndexOf ( '/' ) ) + '/' ) ;
} else if ( typeof process === 'undefined' && typeof location !== 'undefined' ) {
// web worker
PACKAGE _PATH = encodeURIComponent ( location . pathname . toString ( ) . substring ( 0 , location . pathname . toString ( ) . lastIndexOf ( '/' ) ) + '/' ) ;
}
var PACKAGE _NAME = 'FinalProject.data' ;
var REMOTE _PACKAGE _BASE = 'FinalProject.data' ;
if ( typeof Module [ 'locateFilePackage' ] === 'function' && ! Module [ 'locateFile' ] ) {
Module [ 'locateFile' ] = Module [ 'locateFilePackage' ] ;
err ( 'warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)' ) ;
}
var REMOTE _PACKAGE _NAME = Module [ 'locateFile' ] ? Module [ 'locateFile' ] ( REMOTE _PACKAGE _BASE , '' ) : REMOTE _PACKAGE _BASE ;
var REMOTE _PACKAGE _SIZE = metadata [ 'remote_package_size' ] ;
var PACKAGE _UUID = metadata [ 'package_uuid' ] ;
function fetchRemotePackage ( packageName , packageSize , callback , errback ) {
if ( typeof process === 'object' && typeof process . versions === 'object' && typeof process . versions . node === 'string' ) {
require ( 'fs' ) . readFile ( packageName , function ( err , contents ) {
if ( err ) {
errback ( err ) ;
} else {
callback ( contents . buffer ) ;
}
} ) ;
return ;
}
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , packageName , true ) ;
xhr . responseType = 'arraybuffer' ;
xhr . onprogress = function ( event ) {
var url = packageName ;
var size = packageSize ;
if ( event . total ) size = event . total ;
if ( event . loaded ) {
if ( ! xhr . addedTotal ) {
xhr . addedTotal = true ;
if ( ! Module . dataFileDownloads ) Module . dataFileDownloads = { } ;
Module . dataFileDownloads [ url ] = {
loaded : event . loaded ,
total : size
} ;
} else {
Module . dataFileDownloads [ url ] . loaded = event . loaded ;
}
var total = 0 ;
var loaded = 0 ;
var num = 0 ;
for ( var download in Module . dataFileDownloads ) {
var data = Module . dataFileDownloads [ download ] ;
total += data . total ;
loaded += data . loaded ;
num ++ ;
}
total = Math . ceil ( total * Module . expectedDataFileDownloads / num ) ;
if ( Module [ 'setStatus' ] ) Module [ 'setStatus' ] ( 'Downloading data... (' + loaded + '/' + total + ')' ) ;
} else if ( ! Module . dataFileDownloads ) {
if ( Module [ 'setStatus' ] ) Module [ 'setStatus' ] ( 'Downloading data...' ) ;
}
} ;
xhr . onerror = function ( event ) {
throw new Error ( "NetworkError for: " + packageName ) ;
}
xhr . onload = function ( event ) {
if ( xhr . status == 200 || xhr . status == 304 || xhr . status == 206 || ( xhr . status == 0 && xhr . response ) ) { // file URLs can return 0
var packageData = xhr . response ;
callback ( packageData ) ;
} else {
throw new Error ( xhr . statusText + " : " + xhr . responseURL ) ;
}
} ;
xhr . send ( null ) ;
} ;
function handleError ( error ) {
console . error ( 'package error:' , error ) ;
} ;
var fetchedCallback = null ;
var fetched = Module [ 'getPreloadedPackage' ] ? Module [ 'getPreloadedPackage' ] ( REMOTE _PACKAGE _NAME , REMOTE _PACKAGE _SIZE ) : null ;
if ( ! fetched ) fetchRemotePackage ( REMOTE _PACKAGE _NAME , REMOTE _PACKAGE _SIZE , function ( data ) {
if ( fetchedCallback ) {
fetchedCallback ( data ) ;
fetchedCallback = null ;
} else {
fetched = data ;
}
} , handleError ) ;
function runWithFS ( ) {
function assert ( check , msg ) {
if ( ! check ) throw msg + new Error ( ) . stack ;
}
Module [ 'FS_createPath' ] ( "/" , "assets" , true , true ) ;
/** @constructor */
function DataRequest ( start , end , audio ) {
this . start = start ;
this . end = end ;
this . audio = audio ;
}
DataRequest . prototype = {
requests : { } ,
open : function ( mode , name ) {
this . name = name ;
this . requests [ name ] = this ;
Module [ 'addRunDependency' ] ( 'fp ' + this . name ) ;
} ,
send : function ( ) { } ,
onload : function ( ) {
var byteArray = this . byteArray . subarray ( this . start , this . end ) ;
this . finish ( byteArray ) ;
} ,
finish : function ( byteArray ) {
var that = this ;
// canOwn this data in the filesystem, it is a slide into the heap that will never change
Module [ 'FS_createDataFile' ] ( this . name , null , byteArray , true , true , true ) ;
Module [ 'removeRunDependency' ] ( 'fp ' + that . name ) ;
this . requests [ this . name ] = null ;
}
} ;
var files = metadata [ 'files' ] ;
for ( var i = 0 ; i < files . length ; ++ i ) {
new DataRequest ( files [ i ] [ 'start' ] , files [ i ] [ 'end' ] , files [ i ] [ 'audio' ] || 0 ) . open ( 'GET' , files [ i ] [ 'filename' ] ) ;
}
function processPackageData ( arrayBuffer ) {
assert ( arrayBuffer , 'Loading data file failed.' ) ;
assert ( arrayBuffer instanceof ArrayBuffer , 'bad input to processPackageData' ) ;
var byteArray = new Uint8Array ( arrayBuffer ) ;
var curr ;
// Reuse the bytearray from the XHR as the source for file reads.
DataRequest . prototype . byteArray = byteArray ;
var files = metadata [ 'files' ] ;
for ( var i = 0 ; i < files . length ; ++ i ) {
DataRequest . prototype . requests [ files [ i ] . filename ] . onload ( ) ;
} Module [ 'removeRunDependency' ] ( 'datafile_FinalProject.data' ) ;
} ;
Module [ 'addRunDependency' ] ( 'datafile_FinalProject.data' ) ;
if ( ! Module . preloadResults ) Module . preloadResults = { } ;
Module . preloadResults [ PACKAGE _NAME ] = { fromCache : false } ;
if ( fetched ) {
processPackageData ( fetched ) ;
fetched = null ;
} else {
fetchedCallback = processPackageData ;
}
}
if ( Module [ 'calledRun' ] ) {
runWithFS ( ) ;
} else {
if ( ! Module [ 'preRun' ] ) Module [ 'preRun' ] = [ ] ;
Module [ "preRun" ] . push ( runWithFS ) ; // FS is not initialized yet, wait for it
}
}
loadPackage ( { "files" : [ { "filename" : "/assets/test.txt" , "start" : 0 , "end" : 124 } ] , "remote_package_size" : 124 , "package_uuid" : "aab34abf-9015-4b8c-a044-ee68f0029d9d" } ) ;
} ) ( ) ;
// All the pre-js content up to here must remain later on, we need to run
// it.
if ( Module [ 'ENVIRONMENT_IS_PTHREAD' ] ) Module [ 'preRun' ] = [ ] ;
var necessaryPreJSTasks = Module [ 'preRun' ] . slice ( ) ;
if ( ! Module [ 'preRun' ] ) throw 'Module.preRun should exist because file support used it; did a pre-js delete it?' ;
necessaryPreJSTasks . forEach ( function ( task ) {
if ( Module [ 'preRun' ] . indexOf ( task ) < 0 ) throw 'All preRun tasks that exist before user pre-js code should remain after; did you replace Module or modify Module.preRun?' ;
} ) ;
// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object . assign ( { } , Module ) ;
var arguments _ = [ ] ;
var thisProgram = './this.program' ;
var quit _ = ( status , toThrow ) => {
throw toThrow ;
} ;
// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).
// Attempt to auto-detect the environment
var ENVIRONMENT _IS _WEB = typeof window == 'object' ;
var ENVIRONMENT _IS _WORKER = typeof importScripts == 'function' ;
// N.b. Electron.js environment is simultaneously a NODE-environment, but
// also a web environment.
var ENVIRONMENT _IS _NODE = typeof process == 'object' && typeof process . versions == 'object' && typeof process . versions . node == 'string' ;
var ENVIRONMENT _IS _SHELL = ! ENVIRONMENT _IS _WEB && ! ENVIRONMENT _IS _NODE && ! ENVIRONMENT _IS _WORKER ;
if ( Module [ 'ENVIRONMENT' ] ) {
throw new Error ( 'Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)' ) ;
}
// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = '' ;
function locateFile ( path ) {
if ( Module [ 'locateFile' ] ) {
return Module [ 'locateFile' ] ( path , scriptDirectory ) ;
}
return scriptDirectory + path ;
}
// Hooks that are implemented differently in different runtime environments.
var read _ ,
readAsync ,
readBinary ,
setWindowTitle ;
// Normally we don't log exceptions but instead let them bubble out the top
// level where the embedding environment (e.g. the browser) can handle
// them.
// However under v8 and node we sometimes exit the process direcly in which case
// its up to use us to log the exception before exiting.
// If we fix https://github.com/emscripten-core/emscripten/issues/15080
// this may no longer be needed under node.
function logExceptionOnExit ( e ) {
if ( e instanceof ExitStatus ) return ;
let toLog = e ;
if ( e && typeof e == 'object' && e . stack ) {
toLog = [ e , e . stack ] ;
}
err ( 'exiting due to exception: ' + toLog ) ;
}
var fs ;
var nodePath ;
var requireNodeFS ;
if ( ENVIRONMENT _IS _NODE ) {
if ( ! ( typeof process == 'object' && typeof require == 'function' ) ) throw new Error ( 'not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)' ) ;
if ( ENVIRONMENT _IS _WORKER ) {
scriptDirectory = require ( 'path' ) . dirname ( scriptDirectory ) + '/' ;
} else {
scriptDirectory = _ _dirname + '/' ;
}
// include: node_shell_read.js
requireNodeFS = ( ) => {
// Use nodePath as the indicator for these not being initialized,
// since in some environments a global fs may have already been
// created.
if ( ! nodePath ) {
fs = require ( 'fs' ) ;
nodePath = require ( 'path' ) ;
}
} ;
read _ = function shell _read ( filename , binary ) {
requireNodeFS ( ) ;
filename = nodePath [ 'normalize' ] ( filename ) ;
return fs . readFileSync ( filename , binary ? undefined : 'utf8' ) ;
} ;
readBinary = ( filename ) => {
var ret = read _ ( filename , true ) ;
if ( ! ret . buffer ) {
ret = new Uint8Array ( ret ) ;
}
assert ( ret . buffer ) ;
return ret ;
} ;
readAsync = ( filename , onload , onerror ) => {
requireNodeFS ( ) ;
filename = nodePath [ 'normalize' ] ( filename ) ;
fs . readFile ( filename , function ( err , data ) {
if ( err ) onerror ( err ) ;
else onload ( data . buffer ) ;
} ) ;
} ;
// end include: node_shell_read.js
if ( process [ 'argv' ] . length > 1 ) {
thisProgram = process [ 'argv' ] [ 1 ] . replace ( /\\/g , '/' ) ;
}
arguments _ = process [ 'argv' ] . slice ( 2 ) ;
if ( typeof module != 'undefined' ) {
module [ 'exports' ] = Module ;
}
process [ 'on' ] ( 'uncaughtException' , function ( ex ) {
// suppress ExitStatus exceptions from showing an error
if ( ! ( ex instanceof ExitStatus ) ) {
throw ex ;
}
} ) ;
// Without this older versions of node (< v15) will log unhandled rejections
// but return 0, which is not normally the desired behaviour. This is
// not be needed with node v15 and about because it is now the default
// behaviour:
// See https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
process [ 'on' ] ( 'unhandledRejection' , function ( reason ) { throw reason ; } ) ;
quit _ = ( status , toThrow ) => {
if ( keepRuntimeAlive ( ) ) {
process [ 'exitCode' ] = status ;
throw toThrow ;
}
logExceptionOnExit ( toThrow ) ;
process [ 'exit' ] ( status ) ;
} ;
Module [ 'inspect' ] = function ( ) { return '[Emscripten Module object]' ; } ;
} else
if ( ENVIRONMENT _IS _SHELL ) {
if ( ( typeof process == 'object' && typeof require === 'function' ) || typeof window == 'object' || typeof importScripts == 'function' ) throw new Error ( 'not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)' ) ;
if ( typeof read != 'undefined' ) {
read _ = function shell _read ( f ) {
return read ( f ) ;
} ;
}
readBinary = function readBinary ( f ) {
let data ;
if ( typeof readbuffer == 'function' ) {
return new Uint8Array ( readbuffer ( f ) ) ;
}
data = read ( f , 'binary' ) ;
assert ( typeof data == 'object' ) ;
return data ;
} ;
readAsync = function readAsync ( f , onload , onerror ) {
setTimeout ( ( ) => onload ( readBinary ( f ) ) , 0 ) ;
} ;
if ( typeof scriptArgs != 'undefined' ) {
arguments _ = scriptArgs ;
} else if ( typeof arguments != 'undefined' ) {
arguments _ = arguments ;
}
if ( typeof quit == 'function' ) {
quit _ = ( status , toThrow ) => {
// Unlike node which has process.exitCode, d8 has no such mechanism. So we
// have no way to set the exit code and then let the program exit with
// that code when it naturally stops running (say, when all setTimeouts
// have completed). For that reason we must call `quit` - the only way to
// set the exit code - but quit also halts immediately, so we need to be
// careful of whether the runtime is alive or not, which is why this code
// path looks different than node. It also has the downside that it will
// halt the entire program when no code remains to run, which means this
// is not friendly for bundling this code into a larger codebase, and for
// that reason the "shell" environment is mainly useful for testing whole
// programs by themselves, basically.
if ( runtimeKeepaliveCounter ) {
throw toThrow ;
}
logExceptionOnExit ( toThrow ) ;
quit ( status ) ;
} ;
}
if ( typeof print != 'undefined' ) {
// Prefer to use print/printErr where they exist, as they usually work better.
if ( typeof console == 'undefined' ) console = /** @type{!Console} */ ( { } ) ;
console . log = /** @type{!function(this:Console, ...*): undefined} */ ( print ) ;
console . warn = console . error = /** @type{!function(this:Console, ...*): undefined} */ ( typeof printErr != 'undefined' ? printErr : print ) ;
}
} else
// Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if ( ENVIRONMENT _IS _WEB || ENVIRONMENT _IS _WORKER ) {
if ( ENVIRONMENT _IS _WORKER ) { // Check worker, not web, since window could be polyfilled
scriptDirectory = self . location . href ;
} else if ( typeof document != 'undefined' && document . currentScript ) { // web
scriptDirectory = document . currentScript . src ;
}
// blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
// otherwise, slice off the final part of the url to find the script directory.
// if scriptDirectory does not contain a slash, lastIndexOf will return -1,
// and scriptDirectory will correctly be replaced with an empty string.
// If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
// they are removed because they could contain a slash.
if ( scriptDirectory . indexOf ( 'blob:' ) !== 0 ) {
scriptDirectory = scriptDirectory . substr ( 0 , scriptDirectory . replace ( /[?#].*/ , "" ) . lastIndexOf ( '/' ) + 1 ) ;
} else {
scriptDirectory = '' ;
}
if ( ! ( typeof window == 'object' || typeof importScripts == 'function' ) ) throw new Error ( 'not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)' ) ;
// Differentiate the Web Worker from the Node Worker case, as reading must
// be done differently.
{
// include: web_or_worker_shell_read.js
read _ = ( url ) => {
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , url , false ) ;
xhr . send ( null ) ;
return xhr . responseText ;
}
if ( ENVIRONMENT _IS _WORKER ) {
readBinary = ( url ) => {
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , url , false ) ;
xhr . responseType = 'arraybuffer' ;
xhr . send ( null ) ;
return new Uint8Array ( /** @type{!ArrayBuffer} */ ( xhr . response ) ) ;
} ;
}
readAsync = ( url , onload , onerror ) => {
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , url , true ) ;
xhr . responseType = 'arraybuffer' ;
xhr . onload = ( ) => {
if ( xhr . status == 200 || ( xhr . status == 0 && xhr . response ) ) { // file URLs can return 0
onload ( xhr . response ) ;
return ;
}
onerror ( ) ;
} ;
xhr . onerror = onerror ;
xhr . send ( null ) ;
}
// end include: web_or_worker_shell_read.js
}
setWindowTitle = ( title ) => document . title = title ;
} else
{
throw new Error ( 'environment detection error' ) ;
}
var out = Module [ 'print' ] || console . log . bind ( console ) ;
var err = Module [ 'printErr' ] || console . warn . bind ( console ) ;
// Merge back in the overrides
Object . assign ( Module , moduleOverrides ) ;
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
moduleOverrides = null ;
checkIncomingModuleAPI ( ) ;
// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.
if ( Module [ 'arguments' ] ) arguments _ = Module [ 'arguments' ] ; legacyModuleProp ( 'arguments' , 'arguments_' ) ;
if ( Module [ 'thisProgram' ] ) thisProgram = Module [ 'thisProgram' ] ; legacyModuleProp ( 'thisProgram' , 'thisProgram' ) ;
if ( Module [ 'quit' ] ) quit _ = Module [ 'quit' ] ; legacyModuleProp ( 'quit' , 'quit_' ) ;
// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
assert ( typeof Module [ 'memoryInitializerPrefixURL' ] == 'undefined' , 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead' ) ;
assert ( typeof Module [ 'pthreadMainPrefixURL' ] == 'undefined' , 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead' ) ;
assert ( typeof Module [ 'cdInitializerPrefixURL' ] == 'undefined' , 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead' ) ;
assert ( typeof Module [ 'filePackagePrefixURL' ] == 'undefined' , 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead' ) ;
assert ( typeof Module [ 'read' ] == 'undefined' , 'Module.read option was removed (modify read_ in JS)' ) ;
assert ( typeof Module [ 'readAsync' ] == 'undefined' , 'Module.readAsync option was removed (modify readAsync in JS)' ) ;
assert ( typeof Module [ 'readBinary' ] == 'undefined' , 'Module.readBinary option was removed (modify readBinary in JS)' ) ;
assert ( typeof Module [ 'setWindowTitle' ] == 'undefined' , 'Module.setWindowTitle option was removed (modify setWindowTitle in JS)' ) ;
assert ( typeof Module [ 'TOTAL_MEMORY' ] == 'undefined' , 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY' ) ;
legacyModuleProp ( 'read' , 'read_' ) ;
legacyModuleProp ( 'readAsync' , 'readAsync' ) ;
legacyModuleProp ( 'readBinary' , 'readBinary' ) ;
legacyModuleProp ( 'setWindowTitle' , 'setWindowTitle' ) ;
var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js' ;
var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js' ;
var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js' ;
var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js' ;
assert ( ! ENVIRONMENT _IS _SHELL , "shell environment detected but not enabled at build time. Add 'shell' to `-s ENVIRONMENT` to enable." ) ;
var STACK _ALIGN = 16 ;
var POINTER _SIZE = 4 ;
function getNativeTypeSize ( type ) {
switch ( type ) {
case 'i1' : case 'i8' : return 1 ;
case 'i16' : return 2 ;
case 'i32' : return 4 ;
case 'i64' : return 8 ;
case 'float' : return 4 ;
case 'double' : return 8 ;
default : {
if ( type [ type . length - 1 ] === '*' ) {
return POINTER _SIZE ;
} else if ( type [ 0 ] === 'i' ) {
const bits = Number ( type . substr ( 1 ) ) ;
assert ( bits % 8 === 0 , 'getNativeTypeSize invalid bits ' + bits + ', type ' + type ) ;
return bits / 8 ;
} else {
return 0 ;
}
}
}
}
function warnOnce ( text ) {
if ( ! warnOnce . shown ) warnOnce . shown = { } ;
if ( ! warnOnce . shown [ text ] ) {
warnOnce . shown [ text ] = 1 ;
err ( text ) ;
}
}
// include: runtime_functions.js
// Wraps a JS function as a wasm function with a given signature.
function convertJsFunctionToWasm ( func , sig ) {
// If the type reflection proposal is available, use the new
// "WebAssembly.Function" constructor.
// Otherwise, construct a minimal wasm module importing the JS function and
// re-exporting it.
if ( typeof WebAssembly . Function == "function" ) {
var typeNames = {
'i' : 'i32' ,
'j' : 'i64' ,
'f' : 'f32' ,
'd' : 'f64'
} ;
var type = {
parameters : [ ] ,
results : sig [ 0 ] == 'v' ? [ ] : [ typeNames [ sig [ 0 ] ] ]
} ;
for ( var i = 1 ; i < sig . length ; ++ i ) {
type . parameters . push ( typeNames [ sig [ i ] ] ) ;
}
return new WebAssembly . Function ( type , func ) ;
}
// The module is static, with the exception of the type section, which is
// generated based on the signature passed in.
var typeSection = [
0x01 , // id: section,
0x00 , // length: 0 (placeholder)
0x01 , // count: 1
0x60 , // form: func
] ;
var sigRet = sig . slice ( 0 , 1 ) ;
var sigParam = sig . slice ( 1 ) ;
var typeCodes = {
'i' : 0x7f , // i32
'j' : 0x7e , // i64
'f' : 0x7d , // f32
'd' : 0x7c , // f64
} ;
// Parameters, length + signatures
typeSection . push ( sigParam . length ) ;
for ( var i = 0 ; i < sigParam . length ; ++ i ) {
typeSection . push ( typeCodes [ sigParam [ i ] ] ) ;
}
// Return values, length + signatures
// With no multi-return in MVP, either 0 (void) or 1 (anything else)
if ( sigRet == 'v' ) {
typeSection . push ( 0x00 ) ;
} else {
typeSection = typeSection . concat ( [ 0x01 , typeCodes [ sigRet ] ] ) ;
}
// Write the overall length of the type section back into the section header
// (excepting the 2 bytes for the section id and length)
typeSection [ 1 ] = typeSection . length - 2 ;
// Rest of the module is static
var bytes = new Uint8Array ( [
0x00 , 0x61 , 0x73 , 0x6d , // magic ("\0asm")
0x01 , 0x00 , 0x00 , 0x00 , // version: 1
] . concat ( typeSection , [
0x02 , 0x07 , // import section
// (import "e" "f" (func 0 (type 0)))
0x01 , 0x01 , 0x65 , 0x01 , 0x66 , 0x00 , 0x00 ,
0x07 , 0x05 , // export section
// (export "f" (func 0 (type 0)))
0x01 , 0x01 , 0x66 , 0x00 , 0x00 ,
] ) ) ;
// We can compile this wasm module synchronously because it is very small.
// This accepts an import (at "e.f"), that it reroutes to an export (at "f")
var module = new WebAssembly . Module ( bytes ) ;
var instance = new WebAssembly . Instance ( module , {
'e' : {
'f' : func
}
} ) ;
var wrappedFunc = instance . exports [ 'f' ] ;
return wrappedFunc ;
}
var freeTableIndexes = [ ] ;
// Weak map of functions in the table to their indexes, created on first use.
var functionsInTableMap ;
function getEmptyTableSlot ( ) {
// Reuse a free index if there is one, otherwise grow.
if ( freeTableIndexes . length ) {
return freeTableIndexes . pop ( ) ;
}
// Grow the table
try {
wasmTable . grow ( 1 ) ;
} catch ( err ) {
if ( ! ( err instanceof RangeError ) ) {
throw err ;
}
throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.' ;
}
return wasmTable . length - 1 ;
}
function updateTableMap ( offset , count ) {
for ( var i = offset ; i < offset + count ; i ++ ) {
var item = getWasmTableEntry ( i ) ;
// Ignore null values.
if ( item ) {
functionsInTableMap . set ( item , i ) ;
}
}
}
/ * *
* Add a function to the table .
* 'sig' parameter is required if the function being added is a JS function .
* @ param { string = } sig
* /
function addFunction ( func , sig ) {
assert ( typeof func != 'undefined' ) ;
// Check if the function is already in the table, to ensure each function
// gets a unique index. First, create the map if this is the first use.
if ( ! functionsInTableMap ) {
functionsInTableMap = new WeakMap ( ) ;
updateTableMap ( 0 , wasmTable . length ) ;
}
if ( functionsInTableMap . has ( func ) ) {
return functionsInTableMap . get ( func ) ;
}
// It's not in the table, add it now.
var ret = getEmptyTableSlot ( ) ;
// Set the new value.
try {
// Attempting to call this with JS function will cause of table.set() to fail
setWasmTableEntry ( ret , func ) ;
} catch ( err ) {
if ( ! ( err instanceof TypeError ) ) {
throw err ;
}
assert ( typeof sig != 'undefined' , 'Missing signature argument to addFunction: ' + func ) ;
var wrapped = convertJsFunctionToWasm ( func , sig ) ;
setWasmTableEntry ( ret , wrapped ) ;
}
functionsInTableMap . set ( func , ret ) ;
return ret ;
}
function removeFunction ( index ) {
functionsInTableMap . delete ( getWasmTableEntry ( index ) ) ;
freeTableIndexes . push ( index ) ;
}
// end include: runtime_functions.js
// include: runtime_debug.js
function legacyModuleProp ( prop , newName ) {
if ( ! Object . getOwnPropertyDescriptor ( Module , prop ) ) {
Object . defineProperty ( Module , prop , {
configurable : true ,
get : function ( ) {
abort ( 'Module.' + prop + ' has been replaced with plain ' + newName + ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' ) ;
}
} ) ;
}
}
function ignoredModuleProp ( prop ) {
if ( Object . getOwnPropertyDescriptor ( Module , prop ) ) {
abort ( '`Module.' + prop + '` was supplied but `' + prop + '` not included in INCOMING_MODULE_JS_API' ) ;
}
}
function unexportedMessage ( sym , isFSSybol ) {
var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)" ;
if ( isFSSybol ) {
msg += '. Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you' ;
}
return msg ;
}
function unexportedRuntimeSymbol ( sym , isFSSybol ) {
if ( ! Object . getOwnPropertyDescriptor ( Module , sym ) ) {
Object . defineProperty ( Module , sym , {
configurable : true ,
get : function ( ) {
abort ( unexportedMessage ( sym , isFSSybol ) ) ;
}
} ) ;
}
}
function unexportedRuntimeFunction ( sym , isFSSybol ) {
if ( ! Object . getOwnPropertyDescriptor ( Module , sym ) ) {
Module [ sym ] = ( ) => abort ( unexportedMessage ( sym , isFSSybol ) ) ;
}
}
// end include: runtime_debug.js
var tempRet0 = 0 ;
var setTempRet0 = ( value ) => { tempRet0 = value ; } ;
var getTempRet0 = ( ) => tempRet0 ;
// === Preamble library stuff ===
// Documentation for the public APIs defined in this file must be updated in:
// site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
// site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
var wasmBinary ;
if ( Module [ 'wasmBinary' ] ) wasmBinary = Module [ 'wasmBinary' ] ; legacyModuleProp ( 'wasmBinary' , 'wasmBinary' ) ;
var noExitRuntime = Module [ 'noExitRuntime' ] || true ; legacyModuleProp ( 'noExitRuntime' , 'noExitRuntime' ) ;
if ( typeof WebAssembly != 'object' ) {
abort ( 'no native wasm support detected' ) ;
}
// include: runtime_safe_heap.js
// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.
// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)
/ * * @ p a r a m { n u m b e r } p t r
@ param { number } value
@ param { string } type
@ param { number | boolean = } noSafe * /
function setValue ( ptr , value , type = 'i8' , noSafe ) {
if ( type . charAt ( type . length - 1 ) === '*' ) type = 'i32' ;
switch ( type ) {
case 'i1' : HEAP8 [ ( ( ptr ) >> 0 ) ] = value ; break ;
case 'i8' : HEAP8 [ ( ( ptr ) >> 0 ) ] = value ; break ;
case 'i16' : HEAP16 [ ( ( ptr ) >> 1 ) ] = value ; break ;
case 'i32' : HEAP32 [ ( ( ptr ) >> 2 ) ] = value ; break ;
case 'i64' : ( tempI64 = [ value >>> 0 , ( tempDouble = value , ( + ( Math . abs ( tempDouble ) ) ) >= 1.0 ? ( tempDouble > 0.0 ? ( ( Math . min ( ( + ( Math . floor ( ( tempDouble ) / 4294967296.0 ) ) ) , 4294967295.0 ) ) | 0 ) >>> 0 : ( ~ ~ ( ( + ( Math . ceil ( ( tempDouble - + ( ( ( ~ ~ ( tempDouble ) ) ) >>> 0 ) ) / 4294967296.0 ) ) ) ) ) >>> 0 ) : 0 ) ] , HEAP32 [ ( ( ptr ) >> 2 ) ] = tempI64 [ 0 ] , HEAP32 [ ( ( ( ptr ) + ( 4 ) ) >> 2 ) ] = tempI64 [ 1 ] ) ; break ;
case 'float' : HEAPF32 [ ( ( ptr ) >> 2 ) ] = value ; break ;
case 'double' : HEAPF64 [ ( ( ptr ) >> 3 ) ] = value ; break ;
default : abort ( 'invalid type for setValue: ' + type ) ;
}
}
/ * * @ p a r a m { n u m b e r } p t r
@ param { string } type
@ param { number | boolean = } noSafe * /
function getValue ( ptr , type = 'i8' , noSafe ) {
if ( type . charAt ( type . length - 1 ) === '*' ) type = 'i32' ;
switch ( type ) {
case 'i1' : return HEAP8 [ ( ( ptr ) >> 0 ) ] ;
case 'i8' : return HEAP8 [ ( ( ptr ) >> 0 ) ] ;
case 'i16' : return HEAP16 [ ( ( ptr ) >> 1 ) ] ;
case 'i32' : return HEAP32 [ ( ( ptr ) >> 2 ) ] ;
case 'i64' : return HEAP32 [ ( ( ptr ) >> 2 ) ] ;
case 'float' : return HEAPF32 [ ( ( ptr ) >> 2 ) ] ;
case 'double' : return Number ( HEAPF64 [ ( ( ptr ) >> 3 ) ] ) ;
default : abort ( 'invalid type for getValue: ' + type ) ;
}
return null ;
}
// end include: runtime_safe_heap.js
// Wasm globals
var wasmMemory ;
//========================================
// Runtime essentials
//========================================
// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false ;
// set by exit() and abort(). Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS ;
/** @type {function(*, string=)} */
function assert ( condition , text ) {
if ( ! condition ) {
abort ( 'Assertion failed' + ( text ? ': ' + text : '' ) ) ;
}
}
// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
function getCFunc ( ident ) {
var func = Module [ '_' + ident ] ; // closure exported function
assert ( func , 'Cannot call unknown function ' + ident + ', make sure it is exported' ) ;
return func ;
}
// C calling interface.
/ * * @ p a r a m { s t r i n g | n u l l = } r e t u r n T y p e
@ param { Array = } argTypes
@ param { Arguments | Array = } args
@ param { Object = } opts * /
function ccall ( ident , returnType , argTypes , args , opts ) {
// For fast lookup of conversion functions
var toC = {
'string' : function ( str ) {
var ret = 0 ;
if ( str !== null && str !== undefined && str !== 0 ) { // null string
// at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
var len = ( str . length << 2 ) + 1 ;
ret = stackAlloc ( len ) ;
stringToUTF8 ( str , ret , len ) ;
}
return ret ;
} ,
'array' : function ( arr ) {
var ret = stackAlloc ( arr . length ) ;
writeArrayToMemory ( arr , ret ) ;
return ret ;
}
} ;
function convertReturnValue ( ret ) {
if ( returnType === 'string' ) return UTF8ToString ( ret ) ;
if ( returnType === 'boolean' ) return Boolean ( ret ) ;
return ret ;
}
var func = getCFunc ( ident ) ;
var cArgs = [ ] ;
var stack = 0 ;
assert ( returnType !== 'array' , 'Return type should not be "array".' ) ;
if ( args ) {
for ( var i = 0 ; i < args . length ; i ++ ) {
var converter = toC [ argTypes [ i ] ] ;
if ( converter ) {
if ( stack === 0 ) stack = stackSave ( ) ;
cArgs [ i ] = converter ( args [ i ] ) ;
} else {
cArgs [ i ] = args [ i ] ;
}
}
}
var ret = func . apply ( null , cArgs ) ;
function onDone ( ret ) {
if ( stack !== 0 ) stackRestore ( stack ) ;
return convertReturnValue ( ret ) ;
}
ret = onDone ( ret ) ;
return ret ;
}
/ * * @ p a r a m { s t r i n g = } r e t u r n T y p e
@ param { Array = } argTypes
@ param { Object = } opts * /
function cwrap ( ident , returnType , argTypes , opts ) {
return function ( ) {
return ccall ( ident , returnType , argTypes , arguments , opts ) ;
}
}
// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.
// include: runtime_legacy.js
var ALLOC _NORMAL = 0 ; // Tries to use _malloc()
var ALLOC _STACK = 1 ; // Lives for the duration of the current function call
/ * *
* allocate ( ) : This function is no longer used by emscripten but is kept around to avoid
* breaking external users .
* You should normally not use allocate ( ) , and instead allocate
* memory using _malloc ( ) / stackAlloc ( ) , initialize it with
* setValue ( ) , and so forth .
* @ param { ( Uint8Array | Array < number > ) } slab : An array of data .
* @ param { number = } allocator : How to allocate memory , see ALLOC _ *
* /
function allocate ( slab , allocator ) {
var ret ;
assert ( typeof allocator == 'number' , 'allocate no longer takes a type argument' )
assert ( typeof slab != 'number' , 'allocate no longer takes a number as arg0' )
if ( allocator == ALLOC _STACK ) {
ret = stackAlloc ( slab . length ) ;
} else {
ret = _malloc ( slab . length ) ;
}
if ( ! slab . subarray && ! slab . slice ) {
slab = new Uint8Array ( slab ) ;
}
HEAPU8 . set ( slab , ret ) ;
return ret ;
}
// end include: runtime_legacy.js
// include: runtime_strings.js
// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.
// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
// a copy of that string as a Javascript String object.
var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder ( 'utf8' ) : undefined ;
/ * *
* @ param { number } idx
* @ param { number = } maxBytesToRead
* @ return { string }
* /
function UTF8ArrayToString ( heap , idx , maxBytesToRead ) {
var endIdx = idx + maxBytesToRead ;
var endPtr = idx ;
// TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
// Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
// (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
while ( heap [ endPtr ] && ! ( endPtr >= endIdx ) ) ++ endPtr ;
if ( endPtr - idx > 16 && heap . subarray && UTF8Decoder ) {
return UTF8Decoder . decode ( heap . subarray ( idx , endPtr ) ) ;
} else {
var str = '' ;
// If building with TextDecoder, we have already computed the string length above, so test loop end condition against that
while ( idx < endPtr ) {
// For UTF8 byte structure, see:
// http://en.wikipedia.org/wiki/UTF-8#Description
// https://www.ietf.org/rfc/rfc2279.txt
// https://tools.ietf.org/html/rfc3629
var u0 = heap [ idx ++ ] ;
if ( ! ( u0 & 0x80 ) ) { str += String . fromCharCode ( u0 ) ; continue ; }
var u1 = heap [ idx ++ ] & 63 ;
if ( ( u0 & 0xE0 ) == 0xC0 ) { str += String . fromCharCode ( ( ( u0 & 31 ) << 6 ) | u1 ) ; continue ; }
var u2 = heap [ idx ++ ] & 63 ;
if ( ( u0 & 0xF0 ) == 0xE0 ) {
u0 = ( ( u0 & 15 ) << 12 ) | ( u1 << 6 ) | u2 ;
} else {
if ( ( u0 & 0xF8 ) != 0xF0 ) warnOnce ( 'Invalid UTF-8 leading byte 0x' + u0 . toString ( 16 ) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!' ) ;
u0 = ( ( u0 & 7 ) << 18 ) | ( u1 << 12 ) | ( u2 << 6 ) | ( heap [ idx ++ ] & 63 ) ;
}
if ( u0 < 0x10000 ) {
str += String . fromCharCode ( u0 ) ;
} else {
var ch = u0 - 0x10000 ;
str += String . fromCharCode ( 0xD800 | ( ch >> 10 ) , 0xDC00 | ( ch & 0x3FF ) ) ;
}
}
}
return str ;
}
// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
// copy of that string as a Javascript String object.
// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
// this parameter to scan the string until the first \0 byte. If maxBytesToRead is
// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
// not produce a string of exact length [ptr, ptr+maxBytesToRead[)
// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
// throw JS JIT optimizations off, so it is worth to consider consistently using one
// style or the other.
/ * *
* @ param { number } ptr
* @ param { number = } maxBytesToRead
* @ return { string }
* /
function UTF8ToString ( ptr , maxBytesToRead ) {
;
return ptr ? UTF8ArrayToString ( HEAPU8 , ptr , maxBytesToRead ) : '' ;
}
// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
// str: the Javascript string to copy.
// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element.
// outIdx: The starting offset in the array to begin the copying.
// maxBytesToWrite: The maximum number of bytes this function can write to the array.
// This count should include the null terminator,
// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function stringToUTF8Array ( str , heap , outIdx , maxBytesToWrite ) {
if ( ! ( maxBytesToWrite > 0 ) ) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
return 0 ;
var startIdx = outIdx ;
var endIdx = outIdx + maxBytesToWrite - 1 ; // -1 for string null terminator.
for ( var i = 0 ; i < str . length ; ++ i ) {
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
// See http://unicode.org/faq/utf_bom.html#utf16-3
// For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
var u = str . charCodeAt ( i ) ; // possibly a lead surrogate
if ( u >= 0xD800 && u <= 0xDFFF ) {
var u1 = str . charCodeAt ( ++ i ) ;
u = 0x10000 + ( ( u & 0x3FF ) << 10 ) | ( u1 & 0x3FF ) ;
}
if ( u <= 0x7F ) {
if ( outIdx >= endIdx ) break ;
heap [ outIdx ++ ] = u ;
} else if ( u <= 0x7FF ) {
if ( outIdx + 1 >= endIdx ) break ;
heap [ outIdx ++ ] = 0xC0 | ( u >> 6 ) ;
heap [ outIdx ++ ] = 0x80 | ( u & 63 ) ;
} else if ( u <= 0xFFFF ) {
if ( outIdx + 2 >= endIdx ) break ;
heap [ outIdx ++ ] = 0xE0 | ( u >> 12 ) ;
heap [ outIdx ++ ] = 0x80 | ( ( u >> 6 ) & 63 ) ;
heap [ outIdx ++ ] = 0x80 | ( u & 63 ) ;
} else {
if ( outIdx + 3 >= endIdx ) break ;
if ( u > 0x10FFFF ) warnOnce ( 'Invalid Unicode code point 0x' + u . toString ( 16 ) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).' ) ;
heap [ outIdx ++ ] = 0xF0 | ( u >> 18 ) ;
heap [ outIdx ++ ] = 0x80 | ( ( u >> 12 ) & 63 ) ;
heap [ outIdx ++ ] = 0x80 | ( ( u >> 6 ) & 63 ) ;
heap [ outIdx ++ ] = 0x80 | ( u & 63 ) ;
}
}
// Null-terminate the pointer to the buffer.
heap [ outIdx ] = 0 ;
return outIdx - startIdx ;
}
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
// Returns the number of bytes written, EXCLUDING the null terminator.
function stringToUTF8 ( str , outPtr , maxBytesToWrite ) {
assert ( typeof maxBytesToWrite == 'number' , 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!' ) ;
return stringToUTF8Array ( str , HEAPU8 , outPtr , maxBytesToWrite ) ;
}
// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
function lengthBytesUTF8 ( str ) {
var len = 0 ;
for ( var i = 0 ; i < str . length ; ++ i ) {
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
// See http://unicode.org/faq/utf_bom.html#utf16-3
var u = str . charCodeAt ( i ) ; // possibly a lead surrogate
if ( u >= 0xD800 && u <= 0xDFFF ) u = 0x10000 + ( ( u & 0x3FF ) << 10 ) | ( str . charCodeAt ( ++ i ) & 0x3FF ) ;
if ( u <= 0x7F ) ++ len ;
else if ( u <= 0x7FF ) len += 2 ;
else if ( u <= 0xFFFF ) len += 3 ;
else len += 4 ;
}
return len ;
}
// end include: runtime_strings.js
// include: runtime_strings_extra.js
// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.
// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.
function AsciiToString ( ptr ) {
var str = '' ;
while ( 1 ) {
var ch = HEAPU8 [ ( ( ptr ++ ) >> 0 ) ] ;
if ( ! ch ) return str ;
str += String . fromCharCode ( ch ) ;
}
}
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.
function stringToAscii ( str , outPtr ) {
return writeAsciiToMemory ( str , outPtr , false ) ;
}
// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
// a copy of that string as a Javascript String object.
var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder ( 'utf-16le' ) : undefined ;
function UTF16ToString ( ptr , maxBytesToRead ) {
assert ( ptr % 2 == 0 , 'Pointer passed to UTF16ToString must be aligned to two bytes!' ) ;
var endPtr = ptr ;
// TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
// Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
var idx = endPtr >> 1 ;
var maxIdx = idx + maxBytesToRead / 2 ;
// If maxBytesToRead is not passed explicitly, it will be undefined, and this
// will always evaluate to true. This saves on code size.
while ( ! ( idx >= maxIdx ) && HEAPU16 [ idx ] ) ++ idx ;
endPtr = idx << 1 ;
if ( endPtr - ptr > 32 && UTF16Decoder ) {
return UTF16Decoder . decode ( HEAPU8 . subarray ( ptr , endPtr ) ) ;
} else {
var str = '' ;
// If maxBytesToRead is not passed explicitly, it will be undefined, and the for-loop's condition
// will always evaluate to true. The loop is then terminated on the first null char.
for ( var i = 0 ; ! ( i >= maxBytesToRead / 2 ) ; ++ i ) {
var codeUnit = HEAP16 [ ( ( ( ptr ) + ( i * 2 ) ) >> 1 ) ] ;
if ( codeUnit == 0 ) break ;
// fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
str += String . fromCharCode ( codeUnit ) ;
}
return str ;
}
}
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
// str: the Javascript string to copy.
// outPtr: Byte address in Emscripten HEAP where to write the string to.
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function stringToUTF16 ( str , outPtr , maxBytesToWrite ) {
assert ( outPtr % 2 == 0 , 'Pointer passed to stringToUTF16 must be aligned to two bytes!' ) ;
assert ( typeof maxBytesToWrite == 'number' , 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!' ) ;
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
if ( maxBytesToWrite === undefined ) {
maxBytesToWrite = 0x7FFFFFFF ;
}
if ( maxBytesToWrite < 2 ) return 0 ;
maxBytesToWrite -= 2 ; // Null terminator.
var startPtr = outPtr ;
var numCharsToWrite = ( maxBytesToWrite < str . length * 2 ) ? ( maxBytesToWrite / 2 ) : str . length ;
for ( var i = 0 ; i < numCharsToWrite ; ++ i ) {
// charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
var codeUnit = str . charCodeAt ( i ) ; // possibly a lead surrogate
HEAP16 [ ( ( outPtr ) >> 1 ) ] = codeUnit ;
outPtr += 2 ;
}
// Null-terminate the pointer to the HEAP.
HEAP16 [ ( ( outPtr ) >> 1 ) ] = 0 ;
return outPtr - startPtr ;
}
// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
function lengthBytesUTF16 ( str ) {
return str . length * 2 ;
}
function UTF32ToString ( ptr , maxBytesToRead ) {
assert ( ptr % 4 == 0 , 'Pointer passed to UTF32ToString must be aligned to four bytes!' ) ;
var i = 0 ;
var str = '' ;
// If maxBytesToRead is not passed explicitly, it will be undefined, and this
// will always evaluate to true. This saves on code size.
while ( ! ( i >= maxBytesToRead / 4 ) ) {
var utf32 = HEAP32 [ ( ( ( ptr ) + ( i * 4 ) ) >> 2 ) ] ;
if ( utf32 == 0 ) break ;
++ i ;
// Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
// See http://unicode.org/faq/utf_bom.html#utf16-3
if ( utf32 >= 0x10000 ) {
var ch = utf32 - 0x10000 ;
str += String . fromCharCode ( 0xD800 | ( ch >> 10 ) , 0xDC00 | ( ch & 0x3FF ) ) ;
} else {
str += String . fromCharCode ( utf32 ) ;
}
}
return str ;
}
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
// Parameters:
// str: the Javascript string to copy.
// outPtr: Byte address in Emscripten HEAP where to write the string to.
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
// Returns the number of bytes written, EXCLUDING the null terminator.
function stringToUTF32 ( str , outPtr , maxBytesToWrite ) {
assert ( outPtr % 4 == 0 , 'Pointer passed to stringToUTF32 must be aligned to four bytes!' ) ;
assert ( typeof maxBytesToWrite == 'number' , 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!' ) ;
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
if ( maxBytesToWrite === undefined ) {
maxBytesToWrite = 0x7FFFFFFF ;
}
if ( maxBytesToWrite < 4 ) return 0 ;
var startPtr = outPtr ;
var endPtr = startPtr + maxBytesToWrite - 4 ;
for ( var i = 0 ; i < str . length ; ++ i ) {
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
// See http://unicode.org/faq/utf_bom.html#utf16-3
var codeUnit = str . charCodeAt ( i ) ; // possibly a lead surrogate
if ( codeUnit >= 0xD800 && codeUnit <= 0xDFFF ) {
var trailSurrogate = str . charCodeAt ( ++ i ) ;
codeUnit = 0x10000 + ( ( codeUnit & 0x3FF ) << 10 ) | ( trailSurrogate & 0x3FF ) ;
}
HEAP32 [ ( ( outPtr ) >> 2 ) ] = codeUnit ;
outPtr += 4 ;
if ( outPtr + 4 > endPtr ) break ;
}
// Null-terminate the pointer to the HEAP.
HEAP32 [ ( ( outPtr ) >> 2 ) ] = 0 ;
return outPtr - startPtr ;
}
// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
function lengthBytesUTF32 ( str ) {
var len = 0 ;
for ( var i = 0 ; i < str . length ; ++ i ) {
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
// See http://unicode.org/faq/utf_bom.html#utf16-3
var codeUnit = str . charCodeAt ( i ) ;
if ( codeUnit >= 0xD800 && codeUnit <= 0xDFFF ) ++ i ; // possibly a lead surrogate, so skip over the tail surrogate.
len += 4 ;
}
return len ;
}
// Allocate heap space for a JS string, and write it there.
// It is the responsibility of the caller to free() that memory.
function allocateUTF8 ( str ) {
var size = lengthBytesUTF8 ( str ) + 1 ;
var ret = _malloc ( size ) ;
if ( ret ) stringToUTF8Array ( str , HEAP8 , ret , size ) ;
return ret ;
}
// Allocate stack space for a JS string, and write it there.
function allocateUTF8OnStack ( str ) {
var size = lengthBytesUTF8 ( str ) + 1 ;
var ret = stackAlloc ( size ) ;
stringToUTF8Array ( str , HEAP8 , ret , size ) ;
return ret ;
}
// Deprecated: This function should not be called because it is unsafe and does not provide
// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
// function stringToUTF8Array() instead, which takes in a maximum length that can be used
// to be secure from out of bounds writes.
/ * * @ d e p r e c a t e d
@ param { boolean = } dontAddNull * /
function writeStringToMemory ( string , buffer , dontAddNull ) {
warnOnce ( 'writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!' ) ;
var /** @type {number} */ lastChar , /** @type {number} */ end ;
if ( dontAddNull ) {
// stringToUTF8Array always appends null. If we don't want to do that, remember the
// character that existed at the location where the null will be placed, and restore
// that after the write (below).
end = buffer + lengthBytesUTF8 ( string ) ;
lastChar = HEAP8 [ end ] ;
}
stringToUTF8 ( string , buffer , Infinity ) ;
if ( dontAddNull ) HEAP8 [ end ] = lastChar ; // Restore the value under the null character.
}
function writeArrayToMemory ( array , buffer ) {
assert ( array . length >= 0 , 'writeArrayToMemory array must have a length (should be an array or typed array)' )
HEAP8 . set ( array , buffer ) ;
}
/** @param {boolean=} dontAddNull */
function writeAsciiToMemory ( str , buffer , dontAddNull ) {
for ( var i = 0 ; i < str . length ; ++ i ) {
assert ( str . charCodeAt ( i ) === ( str . charCodeAt ( i ) & 0xff ) ) ;
HEAP8 [ ( ( buffer ++ ) >> 0 ) ] = str . charCodeAt ( i ) ;
}
// Null-terminate the pointer to the HEAP.
if ( ! dontAddNull ) HEAP8 [ ( ( buffer ) >> 0 ) ] = 0 ;
}
// end include: runtime_strings_extra.js
// Memory management
var HEAP ,
/** @type {!ArrayBuffer} */
buffer ,
/** @type {!Int8Array} */
HEAP8 ,
/** @type {!Uint8Array} */
HEAPU8 ,
/** @type {!Int16Array} */
HEAP16 ,
/** @type {!Uint16Array} */
HEAPU16 ,
/** @type {!Int32Array} */
HEAP32 ,
/** @type {!Uint32Array} */
HEAPU32 ,
/** @type {!Float32Array} */
HEAPF32 ,
/** @type {!Float64Array} */
HEAPF64 ;
function updateGlobalBufferAndViews ( buf ) {
buffer = buf ;
Module [ 'HEAP8' ] = HEAP8 = new Int8Array ( buf ) ;
Module [ 'HEAP16' ] = HEAP16 = new Int16Array ( buf ) ;
Module [ 'HEAP32' ] = HEAP32 = new Int32Array ( buf ) ;
Module [ 'HEAPU8' ] = HEAPU8 = new Uint8Array ( buf ) ;
Module [ 'HEAPU16' ] = HEAPU16 = new Uint16Array ( buf ) ;
Module [ 'HEAPU32' ] = HEAPU32 = new Uint32Array ( buf ) ;
Module [ 'HEAPF32' ] = HEAPF32 = new Float32Array ( buf ) ;
Module [ 'HEAPF64' ] = HEAPF64 = new Float64Array ( buf ) ;
}
var TOTAL _STACK = 5242880 ;
if ( Module [ 'TOTAL_STACK' ] ) assert ( TOTAL _STACK === Module [ 'TOTAL_STACK' ] , 'the stack size can no longer be determined at runtime' )
var INITIAL _MEMORY = Module [ 'INITIAL_MEMORY' ] || 16777216 ; legacyModuleProp ( 'INITIAL_MEMORY' , 'INITIAL_MEMORY' ) ;
assert ( INITIAL _MEMORY >= TOTAL _STACK , 'INITIAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL _MEMORY + '! (TOTAL_STACK=' + TOTAL _STACK + ')' ) ;
// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
assert ( typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array . prototype . subarray != undefined && Int32Array . prototype . set != undefined ,
'JS engine does not provide full typed array support' ) ;
// If memory is defined in wasm, the user can't provide it.
assert ( ! Module [ 'wasmMemory' ] , 'Use of `wasmMemory` detected. Use -s IMPORTED_MEMORY to define wasmMemory externally' ) ;
assert ( INITIAL _MEMORY == 16777216 , 'Detected runtime INITIAL_MEMORY setting. Use -s IMPORTED_MEMORY to define wasmMemory dynamically' ) ;
// include: runtime_init_table.js
// In regular non-RELOCATABLE mode the table is exported
// from the wasm module and this will be assigned once
// the exports are available.
var wasmTable ;
// end include: runtime_init_table.js
// include: runtime_stack_check.js
// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie ( ) {
var max = _emscripten _stack _get _end ( ) ;
assert ( ( max & 3 ) == 0 ) ;
// The stack grows downwards
HEAP32 [ ( ( max + 4 ) >> 2 ) ] = 0x2135467 ;
HEAP32 [ ( ( max + 8 ) >> 2 ) ] = 0x89BACDFE ;
// Also test the global address 0 for integrity.
HEAP32 [ 0 ] = 0x63736d65 ; /* 'emsc' */
}
function checkStackCookie ( ) {
if ( ABORT ) return ;
var max = _emscripten _stack _get _end ( ) ;
var cookie1 = HEAPU32 [ ( ( max + 4 ) >> 2 ) ] ;
var cookie2 = HEAPU32 [ ( ( max + 8 ) >> 2 ) ] ;
if ( cookie1 != 0x2135467 || cookie2 != 0x89BACDFE ) {
abort ( 'Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x' + cookie2 . toString ( 16 ) + ' 0x' + cookie1 . toString ( 16 ) ) ;
}
// Also test the global address 0 for integrity.
if ( HEAP32 [ 0 ] !== 0x63736d65 /* 'emsc' */ ) abort ( 'Runtime error: The application has corrupted its heap memory area (address zero)!' ) ;
}
// end include: runtime_stack_check.js
// include: runtime_assertions.js
// Endianness check
( function ( ) {
var h16 = new Int16Array ( 1 ) ;
var h8 = new Int8Array ( h16 . buffer ) ;
h16 [ 0 ] = 0x6373 ;
if ( h8 [ 0 ] !== 0x73 || h8 [ 1 ] !== 0x63 ) throw 'Runtime error: expected the system to be little-endian! (Run with -s SUPPORT_BIG_ENDIAN=1 to bypass)' ;
} ) ( ) ;
// end include: runtime_assertions.js
var _ _ATPRERUN _ _ = [ ] ; // functions called before the runtime is initialized
var _ _ATINIT _ _ = [ ] ; // functions called during startup
var _ _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 ;
var runtimeKeepaliveCounter = 0 ;
function keepRuntimeAlive ( ) {
return noExitRuntime || runtimeKeepaliveCounter > 0 ;
}
function preRun ( ) {
if ( Module [ 'preRun' ] ) {
if ( typeof Module [ 'preRun' ] == 'function' ) Module [ 'preRun' ] = [ Module [ 'preRun' ] ] ;
while ( Module [ 'preRun' ] . length ) {
addOnPreRun ( Module [ 'preRun' ] . shift ( ) ) ;
}
}
callRuntimeCallbacks ( _ _ATPRERUN _ _ ) ;
}
function initRuntime ( ) {
checkStackCookie ( ) ;
assert ( ! runtimeInitialized ) ;
runtimeInitialized = true ;
if ( ! Module [ "noFSInit" ] && ! FS . init . initialized )
FS . init ( ) ;
FS . ignorePermissions = false ;
TTY . init ( ) ;
callRuntimeCallbacks ( _ _ATINIT _ _ ) ;
}
function preMain ( ) {
checkStackCookie ( ) ;
callRuntimeCallbacks ( _ _ATMAIN _ _ ) ;
}
function exitRuntime ( ) {
checkStackCookie ( ) ;
runtimeExited = true ;
}
function postRun ( ) {
checkStackCookie ( ) ;
if ( Module [ 'postRun' ] ) {
if ( typeof Module [ 'postRun' ] == 'function' ) Module [ 'postRun' ] = [ Module [ 'postRun' ] ] ;
while ( Module [ 'postRun' ] . length ) {
addOnPostRun ( Module [ 'postRun' ] . shift ( ) ) ;
}
}
callRuntimeCallbacks ( _ _ATPOSTRUN _ _ ) ;
}
function addOnPreRun ( cb ) {
_ _ATPRERUN _ _ . unshift ( cb ) ;
}
function addOnInit ( cb ) {
_ _ATINIT _ _ . unshift ( cb ) ;
}
function addOnPreMain ( cb ) {
_ _ATMAIN _ _ . unshift ( cb ) ;
}
function addOnExit ( cb ) {
}
function addOnPostRun ( cb ) {
_ _ATPOSTRUN _ _ . unshift ( cb ) ;
}
// include: runtime_math.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
assert ( Math . imul , 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill' ) ;
assert ( Math . fround , 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill' ) ;
assert ( Math . clz32 , 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill' ) ;
assert ( Math . trunc , 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill' ) ;
// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0 ;
var runDependencyWatcher = null ;
var dependenciesFulfilled = null ; // overridden to take different actions when all run dependencies are fulfilled
var runDependencyTracking = { } ;
function getUniqueRunDependency ( id ) {
var orig = id ;
while ( 1 ) {
if ( ! runDependencyTracking [ id ] ) return id ;
id = orig + Math . random ( ) ;
}
}
function addRunDependency ( id ) {
runDependencies ++ ;
if ( Module [ 'monitorRunDependencies' ] ) {
Module [ 'monitorRunDependencies' ] ( runDependencies ) ;
}
if ( id ) {
assert ( ! runDependencyTracking [ id ] ) ;
runDependencyTracking [ id ] = 1 ;
if ( runDependencyWatcher === null && typeof setInterval != 'undefined' ) {
// Check for missing dependencies every few seconds
runDependencyWatcher = setInterval ( function ( ) {
if ( ABORT ) {
clearInterval ( runDependencyWatcher ) ;
runDependencyWatcher = null ;
return ;
}
var shown = false ;
for ( var dep in runDependencyTracking ) {
if ( ! shown ) {
shown = true ;
err ( 'still waiting on run dependencies:' ) ;
}
err ( 'dependency: ' + dep ) ;
}
if ( shown ) {
err ( '(end of list)' ) ;
}
} , 10000 ) ;
}
} else {
err ( 'warning: run dependency added without ID' ) ;
}
}
function removeRunDependency ( id ) {
runDependencies -- ;
if ( Module [ 'monitorRunDependencies' ] ) {
Module [ 'monitorRunDependencies' ] ( runDependencies ) ;
}
if ( id ) {
assert ( runDependencyTracking [ id ] ) ;
delete runDependencyTracking [ id ] ;
} else {
err ( 'warning: run dependency removed without ID' ) ;
}
if ( runDependencies == 0 ) {
if ( runDependencyWatcher !== null ) {
clearInterval ( runDependencyWatcher ) ;
runDependencyWatcher = null ;
}
if ( dependenciesFulfilled ) {
var callback = dependenciesFulfilled ;
dependenciesFulfilled = null ;
callback ( ) ; // can add another dependenciesFulfilled
}
}
}
Module [ "preloadedImages" ] = { } ; // maps url to image data
Module [ "preloadedAudios" ] = { } ; // maps url to audio data
/** @param {string|number=} what */
function abort ( what ) {
{
if ( Module [ 'onAbort' ] ) {
Module [ 'onAbort' ] ( what ) ;
}
}
what = 'Aborted(' + what + ')' ;
// TODO(sbc): Should we remove printing and leave it up to whoever
// catches the exception?
err ( what ) ;
ABORT = true ;
EXITSTATUS = 1 ;
// Use a wasm runtime error, because a JS error might be seen as a foreign
// exception, which means we'd run destructors on it. We need the error to
// simply make the program stop.
// Suppress closure compiler warning here. Closure compiler's builtin extern
// defintion for WebAssembly.RuntimeError claims it takes no arguments even
// though it can.
// TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
/** @suppress {checkTypes} */
var e = new WebAssembly . RuntimeError ( what ) ;
// Throw the error whether or not MODULARIZE is set because abort is used
// in code paths apart from instantiation where an exception is expected
// to be thrown when abort is called.
throw e ;
}
// {{MEM_INITIALIZER}}
// include: memoryprofiler.js
// end include: memoryprofiler.js
// include: URIUtils.js
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = 'data:application/octet-stream;base64,' ;
// Indicates whether filename is a base64 data URI.
function isDataURI ( filename ) {
// Prefix of data URIs emitted by SINGLE_FILE and related options.
return filename . startsWith ( dataURIPrefix ) ;
}
// Indicates whether filename is delivered via file protocol (as opposed to http/https)
function isFileURI ( filename ) {
return filename . startsWith ( 'file://' ) ;
}
// end include: URIUtils.js
/** @param {boolean=} fixedasm */
function createExportWrapper ( name , fixedasm ) {
return function ( ) {
var displayName = name ;
var asm = fixedasm ;
if ( ! fixedasm ) {
asm = Module [ 'asm' ] ;
}
assert ( runtimeInitialized , 'native function `' + displayName + '` called before runtime initialization' ) ;
assert ( ! runtimeExited , 'native function `' + displayName + '` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)' ) ;
if ( ! asm [ name ] ) {
assert ( asm [ name ] , 'exported native function `' + displayName + '` not found' ) ;
}
return asm [ name ] . apply ( null , arguments ) ;
} ;
}
var wasmBinaryFile ;
wasmBinaryFile = 'FinalProject.wasm' ;
if ( ! isDataURI ( wasmBinaryFile ) ) {
wasmBinaryFile = locateFile ( wasmBinaryFile ) ;
}
function getBinary ( file ) {
try {
if ( file == wasmBinaryFile && wasmBinary ) {
return new Uint8Array ( wasmBinary ) ;
}
if ( readBinary ) {
return readBinary ( file ) ;
} else {
throw "both async and sync fetching of the wasm failed" ;
}
}
catch ( err ) {
abort ( err ) ;
}
}
function getBinaryPromise ( ) {
// If we don't have the binary yet, try to to load it asynchronously.
// Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
// See https://github.com/github/fetch/pull/92#issuecomment-140665932
// Cordova or Electron apps are typically loaded from a file:// url.
// So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
if ( ! wasmBinary && ( ENVIRONMENT _IS _WEB || ENVIRONMENT _IS _WORKER ) ) {
if ( typeof fetch == 'function'
&& ! isFileURI ( wasmBinaryFile )
) {
return fetch ( wasmBinaryFile , { credentials : 'same-origin' } ) . then ( function ( response ) {
if ( ! response [ 'ok' ] ) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'" ;
}
return response [ 'arrayBuffer' ] ( ) ;
} ) . catch ( function ( ) {
return getBinary ( wasmBinaryFile ) ;
} ) ;
}
else {
if ( readAsync ) {
// fetch is not available or url is file => try XHR (readAsync uses XHR internally)
return new Promise ( function ( resolve , reject ) {
readAsync ( wasmBinaryFile , function ( response ) { resolve ( new Uint8Array ( /** @type{!ArrayBuffer} */ ( response ) ) ) } , reject )
} ) ;
}
}
}
// Otherwise, getBinary should be able to get it synchronously
return Promise . resolve ( ) . then ( function ( ) { return getBinary ( wasmBinaryFile ) ; } ) ;
}
// Create the wasm instance.
// Receives the wasm imports, returns the exports.
function createWasm ( ) {
// prepare imports
var info = {
'env' : asmLibraryArg ,
'wasi_snapshot_preview1' : asmLibraryArg ,
} ;
// Load the wasm module and create an instance of using native support in the JS engine.
// handle a generated wasm instance, receiving its exports and
// performing other necessary setup
/** @param {WebAssembly.Module=} module*/
function receiveInstance ( instance , module ) {
var exports = instance . exports ;
Module [ 'asm' ] = exports ;
wasmMemory = Module [ 'asm' ] [ 'memory' ] ;
assert ( wasmMemory , "memory not found in wasm exports" ) ;
// This assertion doesn't hold when emscripten is run in --post-link
// mode.
// TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.
//assert(wasmMemory.buffer.byteLength === 16777216);
updateGlobalBufferAndViews ( wasmMemory . buffer ) ;
wasmTable = Module [ 'asm' ] [ '__indirect_function_table' ] ;
assert ( wasmTable , "table not found in wasm exports" ) ;
addOnInit ( Module [ 'asm' ] [ '__wasm_call_ctors' ] ) ;
removeRunDependency ( 'wasm-instantiate' ) ;
}
// we can't run yet (except in a pthread, where we have a custom sync instantiator)
addRunDependency ( 'wasm-instantiate' ) ;
// Prefer streaming instantiation if available.
// Async compilation can be confusing when an error on the page overwrites Module
// (for example, if the order of elements is wrong, and the one defining Module is
// later), so we save Module and check it later.
var trueModule = Module ;
function receiveInstantiationResult ( result ) {
// 'result' is a ResultObject object which has both the module and instance.
// receiveInstance() will swap in the exports (to Module.asm) so they can be called
assert ( Module === trueModule , 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?' ) ;
trueModule = null ;
// TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
// When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
receiveInstance ( result [ 'instance' ] ) ;
}
function instantiateArrayBuffer ( receiver ) {
return getBinaryPromise ( ) . then ( function ( binary ) {
return WebAssembly . instantiate ( binary , info ) ;
} ) . then ( function ( instance ) {
return instance ;
} ) . then ( receiver , function ( reason ) {
err ( 'failed to asynchronously prepare wasm: ' + reason ) ;
// Warn on some common problems.
if ( isFileURI ( wasmBinaryFile ) ) {
err ( 'warning: Loading from a file URI (' + wasmBinaryFile + ') is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing' ) ;
}
abort ( reason ) ;
} ) ;
}
function instantiateAsync ( ) {
if ( ! wasmBinary &&
typeof WebAssembly . instantiateStreaming == 'function' &&
! isDataURI ( wasmBinaryFile ) &&
// Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
! isFileURI ( wasmBinaryFile ) &&
typeof fetch == 'function' ) {
return fetch ( wasmBinaryFile , { credentials : 'same-origin' } ) . then ( function ( response ) {
// Suppress closure warning here since the upstream definition for
// instantiateStreaming only allows Promise<Repsponse> rather than
// an actual Response.
// TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
/** @suppress {checkTypes} */
var result = WebAssembly . instantiateStreaming ( response , info ) ;
return result . then (
receiveInstantiationResult ,
function ( reason ) {
// We expect the most common failure cause to be a bad MIME type for the binary,
// in which case falling back to ArrayBuffer instantiation should work.
err ( 'wasm streaming compile failed: ' + reason ) ;
err ( 'falling back to ArrayBuffer instantiation' ) ;
return instantiateArrayBuffer ( receiveInstantiationResult ) ;
} ) ;
} ) ;
} else {
return instantiateArrayBuffer ( receiveInstantiationResult ) ;
}
}
// User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
// to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
// to any other async startup actions they are performing.
if ( Module [ 'instantiateWasm' ] ) {
try {
var exports = Module [ 'instantiateWasm' ] ( info , receiveInstance ) ;
return exports ;
} catch ( e ) {
err ( 'Module.instantiateWasm callback failed with error: ' + e ) ;
return false ;
}
}
instantiateAsync ( ) ;
return { } ; // no exports yet; we'll fill them in later
}
// Globals used by JS i64 conversions (see makeSetValue)
var tempDouble ;
var tempI64 ;
// === Body ===
var ASM _CONSTS = {
} ;
function callRuntimeCallbacks ( callbacks ) {
while ( callbacks . length > 0 ) {
var callback = callbacks . shift ( ) ;
if ( typeof callback == 'function' ) {
callback ( Module ) ; // Pass the module as the first argument.
continue ;
}
var func = callback . func ;
if ( typeof func == 'number' ) {
if ( callback . arg === undefined ) {
getWasmTableEntry ( func ) ( ) ;
} else {
getWasmTableEntry ( func ) ( callback . arg ) ;
}
} else {
func ( callback . arg === undefined ? null : callback . arg ) ;
}
}
}
function withStackSave ( f ) {
var stack = stackSave ( ) ;
var ret = f ( ) ;
stackRestore ( stack ) ;
return ret ;
}
function demangle ( func ) {
warnOnce ( 'warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling' ) ;
return func ;
}
function demangleAll ( text ) {
var regex =
/\b_Z[\w\d_]+/g ;
return text . replace ( regex ,
function ( x ) {
var y = demangle ( x ) ;
return x === y ? x : ( y + ' [' + x + ']' ) ;
} ) ;
}
var wasmTableMirror = [ ] ;
function getWasmTableEntry ( funcPtr ) {
var func = wasmTableMirror [ funcPtr ] ;
if ( ! func ) {
if ( funcPtr >= wasmTableMirror . length ) wasmTableMirror . length = funcPtr + 1 ;
wasmTableMirror [ funcPtr ] = func = wasmTable . get ( funcPtr ) ;
}
assert ( wasmTable . get ( funcPtr ) == func , "JavaScript-side Wasm function table mirror is out of date!" ) ;
return func ;
}
function handleException ( e ) {
// Certain exception types we do not treat as errors since they are used for
// internal control flow.
// 1. ExitStatus, which is thrown by exit()
// 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
// that wish to return to JS event loop.
if ( e instanceof ExitStatus || e == 'unwind' ) {
return EXITSTATUS ;
}
quit _ ( 1 , e ) ;
}
function jsStackTrace ( ) {
var error = new Error ( ) ;
if ( ! error . stack ) {
// IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
// so try that as a special-case.
try {
throw new Error ( ) ;
} catch ( e ) {
error = e ;
}
if ( ! error . stack ) {
return '(no stack trace available)' ;
}
}
return error . stack . toString ( ) ;
}
function setWasmTableEntry ( idx , func ) {
wasmTable . set ( idx , func ) ;
wasmTableMirror [ idx ] = func ;
}
function stackTrace ( ) {
var js = jsStackTrace ( ) ;
if ( Module [ 'extraStackTrace' ] ) js += '\n' + Module [ 'extraStackTrace' ] ( ) ;
return demangleAll ( js ) ;
}
function _ _ _cxa _allocate _exception ( size ) {
// Thrown object is prepended by exception metadata block
return _malloc ( size + 16 ) + 16 ;
}
/** @constructor */
function ExceptionInfo ( excPtr ) {
this . excPtr = excPtr ;
this . ptr = excPtr - 16 ;
this . set _type = function ( type ) {
HEAP32 [ ( ( ( this . ptr ) + ( 4 ) ) >> 2 ) ] = type ;
} ;
this . get _type = function ( ) {
return HEAP32 [ ( ( ( this . ptr ) + ( 4 ) ) >> 2 ) ] ;
} ;
this . set _destructor = function ( destructor ) {
HEAP32 [ ( ( ( this . ptr ) + ( 8 ) ) >> 2 ) ] = destructor ;
} ;
this . get _destructor = function ( ) {
return HEAP32 [ ( ( ( this . ptr ) + ( 8 ) ) >> 2 ) ] ;
} ;
this . set _refcount = function ( refcount ) {
HEAP32 [ ( ( this . ptr ) >> 2 ) ] = refcount ;
} ;
this . set _caught = function ( caught ) {
caught = caught ? 1 : 0 ;
HEAP8 [ ( ( ( this . ptr ) + ( 12 ) ) >> 0 ) ] = caught ;
} ;
this . get _caught = function ( ) {
return HEAP8 [ ( ( ( this . ptr ) + ( 12 ) ) >> 0 ) ] != 0 ;
} ;
this . set _rethrown = function ( rethrown ) {
rethrown = rethrown ? 1 : 0 ;
HEAP8 [ ( ( ( this . ptr ) + ( 13 ) ) >> 0 ) ] = rethrown ;
} ;
this . get _rethrown = function ( ) {
return HEAP8 [ ( ( ( this . ptr ) + ( 13 ) ) >> 0 ) ] != 0 ;
} ;
// Initialize native structure fields. Should be called once after allocated.
this . init = function ( type , destructor ) {
this . set _type ( type ) ;
this . set _destructor ( destructor ) ;
this . set _refcount ( 0 ) ;
this . set _caught ( false ) ;
this . set _rethrown ( false ) ;
}
this . add _ref = function ( ) {
var value = HEAP32 [ ( ( this . ptr ) >> 2 ) ] ;
HEAP32 [ ( ( this . ptr ) >> 2 ) ] = value + 1 ;
} ;
// Returns true if last reference released.
this . release _ref = function ( ) {
var prev = HEAP32 [ ( ( this . ptr ) >> 2 ) ] ;
HEAP32 [ ( ( this . ptr ) >> 2 ) ] = prev - 1 ;
assert ( prev > 0 ) ;
return prev === 1 ;
} ;
}
var exceptionLast = 0 ;
var uncaughtExceptionCount = 0 ;
function _ _ _cxa _throw ( ptr , type , destructor ) {
var info = new ExceptionInfo ( ptr ) ;
// Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.
info . init ( type , destructor ) ;
exceptionLast = ptr ;
uncaughtExceptionCount ++ ;
throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s NO_DISABLE_EXCEPTION_CATCHING or -s EXCEPTION_CATCHING_ALLOWED=[..] to catch." ;
}
function setErrNo ( value ) {
HEAP32 [ ( ( _ _ _errno _location ( ) ) >> 2 ) ] = value ;
return value ;
}
var PATH = { splitPath : function ( filename ) {
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/ ;
return splitPathRe . exec ( filename ) . slice ( 1 ) ;
} , normalizeArray : function ( parts , allowAboveRoot ) {
// if the path tries to go above the root, `up` ends up > 0
var up = 0 ;
for ( var i = parts . length - 1 ; i >= 0 ; i -- ) {
var last = parts [ i ] ;
if ( last === '.' ) {
parts . splice ( i , 1 ) ;
} else if ( last === '..' ) {
parts . splice ( i , 1 ) ;
up ++ ;
} else if ( up ) {
parts . splice ( i , 1 ) ;
up -- ;
}
}
// if the path is allowed to go above the root, restore leading ..s
if ( allowAboveRoot ) {
for ( ; up ; up -- ) {
parts . unshift ( '..' ) ;
}
}
return parts ;
} , normalize : function ( path ) {
var isAbsolute = path . charAt ( 0 ) === '/' ,
trailingSlash = path . substr ( - 1 ) === '/' ;
// Normalize the path
path = PATH . normalizeArray ( path . split ( '/' ) . filter ( function ( p ) {
return ! ! p ;
} ) , ! isAbsolute ) . join ( '/' ) ;
if ( ! path && ! isAbsolute ) {
path = '.' ;
}
if ( path && trailingSlash ) {
path += '/' ;
}
return ( isAbsolute ? '/' : '' ) + path ;
} , dirname : function ( path ) {
var result = PATH . splitPath ( path ) ,
root = result [ 0 ] ,
dir = result [ 1 ] ;
if ( ! root && ! dir ) {
// No dirname whatsoever
return '.' ;
}
if ( dir ) {
// It has a dirname, strip trailing slash
dir = dir . substr ( 0 , dir . length - 1 ) ;
}
return root + dir ;
} , basename : function ( path ) {
// EMSCRIPTEN return '/'' for '/', not an empty string
if ( path === '/' ) return '/' ;
path = PATH . normalize ( path ) ;
path = path . replace ( /\/$/ , "" ) ;
var lastSlash = path . lastIndexOf ( '/' ) ;
if ( lastSlash === - 1 ) return path ;
return path . substr ( lastSlash + 1 ) ;
} , extname : function ( path ) {
return PATH . splitPath ( path ) [ 3 ] ;
} , join : function ( ) {
var paths = Array . prototype . slice . call ( arguments , 0 ) ;
return PATH . normalize ( paths . join ( '/' ) ) ;
} , join2 : function ( l , r ) {
return PATH . normalize ( l + '/' + r ) ;
} } ;
function getRandomDevice ( ) {
if ( typeof crypto == 'object' && typeof crypto [ 'getRandomValues' ] == 'function' ) {
// for modern web browsers
var randomBuffer = new Uint8Array ( 1 ) ;
return function ( ) { crypto . getRandomValues ( randomBuffer ) ; return randomBuffer [ 0 ] ; } ;
} else
if ( ENVIRONMENT _IS _NODE ) {
// for nodejs with or without crypto support included
try {
var crypto _module = require ( 'crypto' ) ;
// nodejs has crypto support
return function ( ) { return crypto _module [ 'randomBytes' ] ( 1 ) [ 0 ] ; } ;
} catch ( e ) {
// nodejs doesn't have crypto support
}
}
// we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096
return function ( ) { abort ( "no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };" ) ; } ;
}
var PATH _FS = { resolve : function ( ) {
var resolvedPath = '' ,
resolvedAbsolute = false ;
for ( var i = arguments . length - 1 ; i >= - 1 && ! resolvedAbsolute ; i -- ) {
var path = ( i >= 0 ) ? arguments [ i ] : FS . cwd ( ) ;
// Skip empty and invalid entries
if ( typeof path != 'string' ) {
throw new TypeError ( 'Arguments to path.resolve must be strings' ) ;
} else if ( ! path ) {
return '' ; // an invalid portion invalidates the whole thing
}
resolvedPath = path + '/' + resolvedPath ;
resolvedAbsolute = path . charAt ( 0 ) === '/' ;
}
// At this point the path should be resolved to a full absolute path, but
// handle relative paths to be safe (might happen when process.cwd() fails)
resolvedPath = PATH . normalizeArray ( resolvedPath . split ( '/' ) . filter ( function ( p ) {
return ! ! p ;
} ) , ! resolvedAbsolute ) . join ( '/' ) ;
return ( ( resolvedAbsolute ? '/' : '' ) + resolvedPath ) || '.' ;
} , relative : function ( from , to ) {
from = PATH _FS . resolve ( from ) . substr ( 1 ) ;
to = PATH _FS . resolve ( to ) . substr ( 1 ) ;
function trim ( arr ) {
var start = 0 ;
for ( ; start < arr . length ; start ++ ) {
if ( arr [ start ] !== '' ) break ;
}
var end = arr . length - 1 ;
for ( ; end >= 0 ; end -- ) {
if ( arr [ end ] !== '' ) break ;
}
if ( start > end ) return [ ] ;
return arr . slice ( start , end - start + 1 ) ;
}
var fromParts = trim ( from . split ( '/' ) ) ;
var toParts = trim ( to . split ( '/' ) ) ;
var length = Math . min ( fromParts . length , toParts . length ) ;
var samePartsLength = length ;
for ( var i = 0 ; i < length ; i ++ ) {
if ( fromParts [ i ] !== toParts [ i ] ) {
samePartsLength = i ;
break ;
}
}
var outputParts = [ ] ;
for ( var i = samePartsLength ; i < fromParts . length ; i ++ ) {
outputParts . push ( '..' ) ;
}
outputParts = outputParts . concat ( toParts . slice ( samePartsLength ) ) ;
return outputParts . join ( '/' ) ;
} } ;
var TTY = { ttys : [ ] , init : function ( ) {
// https://github.com/emscripten-core/emscripten/pull/1555
// if (ENVIRONMENT_IS_NODE) {
// // currently, FS.init does not distinguish if process.stdin is a file or TTY
// // device, it always assumes it's a TTY device. because of this, we're forcing
// // process.stdin to UTF8 encoding to at least make stdin reading compatible
// // with text files until FS.init can be refactored.
// process['stdin']['setEncoding']('utf8');
// }
} , shutdown : function ( ) {
// https://github.com/emscripten-core/emscripten/pull/1555
// if (ENVIRONMENT_IS_NODE) {
// // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
// // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
// // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
// // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
// // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
// process['stdin']['pause']();
// }
} , register : function ( dev , ops ) {
TTY . ttys [ dev ] = { input : [ ] , output : [ ] , ops : ops } ;
FS . registerDevice ( dev , TTY . stream _ops ) ;
} , stream _ops : { open : function ( stream ) {
var tty = TTY . ttys [ stream . node . rdev ] ;
if ( ! tty ) {
throw new FS . ErrnoError ( 43 ) ;
}
stream . tty = tty ;
stream . seekable = false ;
} , close : function ( stream ) {
// flush any pending line data
stream . tty . ops . flush ( stream . tty ) ;
} , flush : function ( stream ) {
stream . tty . ops . flush ( stream . tty ) ;
} , read : function ( stream , buffer , offset , length , pos /* ignored */ ) {
if ( ! stream . tty || ! stream . tty . ops . get _char ) {
throw new FS . ErrnoError ( 60 ) ;
}
var bytesRead = 0 ;
for ( var i = 0 ; i < length ; i ++ ) {
var result ;
try {
result = stream . tty . ops . get _char ( stream . tty ) ;
} catch ( e ) {
throw new FS . ErrnoError ( 29 ) ;
}
if ( result === undefined && bytesRead === 0 ) {
throw new FS . ErrnoError ( 6 ) ;
}
if ( result === null || result === undefined ) break ;
bytesRead ++ ;
buffer [ offset + i ] = result ;
}
if ( bytesRead ) {
stream . node . timestamp = Date . now ( ) ;
}
return bytesRead ;
} , write : function ( stream , buffer , offset , length , pos ) {
if ( ! stream . tty || ! stream . tty . ops . put _char ) {
throw new FS . ErrnoError ( 60 ) ;
}
try {
for ( var i = 0 ; i < length ; i ++ ) {
stream . tty . ops . put _char ( stream . tty , buffer [ offset + i ] ) ;
}
} catch ( e ) {
throw new FS . ErrnoError ( 29 ) ;
}
if ( length ) {
stream . node . timestamp = Date . now ( ) ;
}
return i ;
} } , default _tty _ops : { get _char : function ( tty ) {
if ( ! tty . input . length ) {
var result = null ;
if ( ENVIRONMENT _IS _NODE ) {
// we will read data by chunks of BUFSIZE
var BUFSIZE = 256 ;
var buf = Buffer . alloc ( BUFSIZE ) ;
var bytesRead = 0 ;
try {
bytesRead = fs . readSync ( process . stdin . fd , buf , 0 , BUFSIZE , - 1 ) ;
} catch ( e ) {
// Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
// reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.
if ( e . toString ( ) . includes ( 'EOF' ) ) bytesRead = 0 ;
else throw e ;
}
if ( bytesRead > 0 ) {
result = buf . slice ( 0 , bytesRead ) . toString ( 'utf-8' ) ;
} else {
result = null ;
}
} else
if ( typeof window != 'undefined' &&
typeof window . prompt == 'function' ) {
// Browser.
result = window . prompt ( 'Input: ' ) ; // returns null on cancel
if ( result !== null ) {
result += '\n' ;
}
} else if ( typeof readline == 'function' ) {
// Command line.
result = readline ( ) ;
if ( result !== null ) {
result += '\n' ;
}
}
if ( ! result ) {
return null ;
}
tty . input = intArrayFromString ( result , true ) ;
}
return tty . input . shift ( ) ;
} , put _char : function ( tty , val ) {
if ( val === null || val === 10 ) {
out ( UTF8ArrayToString ( tty . output , 0 ) ) ;
tty . output = [ ] ;
} else {
if ( val != 0 ) tty . output . push ( val ) ; // val == 0 would cut text output off in the middle.
}
} , flush : function ( tty ) {
if ( tty . output && tty . output . length > 0 ) {
out ( UTF8ArrayToString ( tty . output , 0 ) ) ;
tty . output = [ ] ;
}
} } , default _tty1 _ops : { put _char : function ( tty , val ) {
if ( val === null || val === 10 ) {
err ( UTF8ArrayToString ( tty . output , 0 ) ) ;
tty . output = [ ] ;
} else {
if ( val != 0 ) tty . output . push ( val ) ;
}
} , flush : function ( tty ) {
if ( tty . output && tty . output . length > 0 ) {
err ( UTF8ArrayToString ( tty . output , 0 ) ) ;
tty . output = [ ] ;
}
} } } ;
function zeroMemory ( address , size ) {
HEAPU8 . fill ( 0 , address , address + size ) ;
}
function alignMemory ( size , alignment ) {
assert ( alignment , "alignment argument is required" ) ;
return Math . ceil ( size / alignment ) * alignment ;
}
function mmapAlloc ( size ) {
abort ( 'internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported' ) ;
}
var MEMFS = { ops _table : null , mount : function ( mount ) {
return MEMFS . createNode ( null , '/' , 16384 | 511 /* 0777 */ , 0 ) ;
} , createNode : function ( parent , name , mode , dev ) {
if ( FS . isBlkdev ( mode ) || FS . isFIFO ( mode ) ) {
// no supported
throw new FS . ErrnoError ( 63 ) ;
}
if ( ! MEMFS . ops _table ) {
MEMFS . ops _table = {
dir : {
node : {
getattr : MEMFS . node _ops . getattr ,
setattr : MEMFS . node _ops . setattr ,
lookup : MEMFS . node _ops . lookup ,
mknod : MEMFS . node _ops . mknod ,
rename : MEMFS . node _ops . rename ,
unlink : MEMFS . node _ops . unlink ,
rmdir : MEMFS . node _ops . rmdir ,
readdir : MEMFS . node _ops . readdir ,
symlink : MEMFS . node _ops . symlink
} ,
stream : {
llseek : MEMFS . stream _ops . llseek
}
} ,
file : {
node : {
getattr : MEMFS . node _ops . getattr ,
setattr : MEMFS . node _ops . setattr
} ,
stream : {
llseek : MEMFS . stream _ops . llseek ,
read : MEMFS . stream _ops . read ,
write : MEMFS . stream _ops . write ,
allocate : MEMFS . stream _ops . allocate ,
mmap : MEMFS . stream _ops . mmap ,
msync : MEMFS . stream _ops . msync
}
} ,
link : {
node : {
getattr : MEMFS . node _ops . getattr ,
setattr : MEMFS . node _ops . setattr ,
readlink : MEMFS . node _ops . readlink
} ,
stream : { }
} ,
chrdev : {
node : {
getattr : MEMFS . node _ops . getattr ,
setattr : MEMFS . node _ops . setattr
} ,
stream : FS . chrdev _stream _ops
}
} ;
}
var node = FS . createNode ( parent , name , mode , dev ) ;
if ( FS . isDir ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . dir . node ;
node . stream _ops = MEMFS . ops _table . dir . stream ;
node . contents = { } ;
} else if ( FS . isFile ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . file . node ;
node . stream _ops = MEMFS . ops _table . file . stream ;
node . usedBytes = 0 ; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity.
// When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred
// for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size
// penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme.
node . contents = null ;
} else if ( FS . isLink ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . link . node ;
node . stream _ops = MEMFS . ops _table . link . stream ;
} else if ( FS . isChrdev ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . chrdev . node ;
node . stream _ops = MEMFS . ops _table . chrdev . stream ;
}
node . timestamp = Date . now ( ) ;
// add the new node to the parent
if ( parent ) {
parent . contents [ name ] = node ;
parent . timestamp = node . timestamp ;
}
return node ;
} , getFileDataAsTypedArray : function ( node ) {
if ( ! node . contents ) return new Uint8Array ( 0 ) ;
if ( node . contents . subarray ) return node . contents . subarray ( 0 , node . usedBytes ) ; // Make sure to not return excess unused bytes.
return new Uint8Array ( node . contents ) ;
} , expandFileStorage : function ( node , newCapacity ) {
var prevCapacity = node . contents ? node . contents . length : 0 ;
if ( prevCapacity >= newCapacity ) return ; // No need to expand, the storage was already large enough.
// Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity.
// For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to
// avoid overshooting the allocation cap by a very large margin.
var CAPACITY _DOUBLING _MAX = 1024 * 1024 ;
newCapacity = Math . max ( newCapacity , ( prevCapacity * ( prevCapacity < CAPACITY _DOUBLING _MAX ? 2.0 : 1.125 ) ) >>> 0 ) ;
if ( prevCapacity != 0 ) newCapacity = Math . max ( newCapacity , 256 ) ; // At minimum allocate 256b for each file when expanding.
var oldContents = node . contents ;
node . contents = new Uint8Array ( newCapacity ) ; // Allocate new storage.
if ( node . usedBytes > 0 ) node . contents . set ( oldContents . subarray ( 0 , node . usedBytes ) , 0 ) ; // Copy old data over to the new storage.
} , resizeFileStorage : function ( node , newSize ) {
if ( node . usedBytes == newSize ) return ;
if ( newSize == 0 ) {
node . contents = null ; // Fully decommit when requesting a resize to zero.
node . usedBytes = 0 ;
} else {
var oldContents = node . contents ;
node . contents = new Uint8Array ( newSize ) ; // Allocate new storage.
if ( oldContents ) {
node . contents . set ( oldContents . subarray ( 0 , Math . min ( newSize , node . usedBytes ) ) ) ; // Copy old data over to the new storage.
}
node . usedBytes = newSize ;
}
} , node _ops : { getattr : function ( node ) {
var attr = { } ;
// device numbers reuse inode numbers.
attr . dev = FS . isChrdev ( node . mode ) ? node . id : 1 ;
attr . ino = node . id ;
attr . mode = node . mode ;
attr . nlink = 1 ;
attr . uid = 0 ;
attr . gid = 0 ;
attr . rdev = node . rdev ;
if ( FS . isDir ( node . mode ) ) {
attr . size = 4096 ;
} else if ( FS . isFile ( node . mode ) ) {
attr . size = node . usedBytes ;
} else if ( FS . isLink ( node . mode ) ) {
attr . size = node . link . length ;
} else {
attr . size = 0 ;
}
attr . atime = new Date ( node . timestamp ) ;
attr . mtime = new Date ( node . timestamp ) ;
attr . ctime = new Date ( node . timestamp ) ;
// NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
// but this is not required by the standard.
attr . blksize = 4096 ;
attr . blocks = Math . ceil ( attr . size / attr . blksize ) ;
return attr ;
} , setattr : function ( node , attr ) {
if ( attr . mode !== undefined ) {
node . mode = attr . mode ;
}
if ( attr . timestamp !== undefined ) {
node . timestamp = attr . timestamp ;
}
if ( attr . size !== undefined ) {
MEMFS . resizeFileStorage ( node , attr . size ) ;
}
} , lookup : function ( parent , name ) {
throw FS . genericErrors [ 44 ] ;
} , mknod : function ( parent , name , mode , dev ) {
return MEMFS . createNode ( parent , name , mode , dev ) ;
} , rename : function ( old _node , new _dir , new _name ) {
// if we're overwriting a directory at new_name, make sure it's empty.
if ( FS . isDir ( old _node . mode ) ) {
var new _node ;
try {
new _node = FS . lookupNode ( new _dir , new _name ) ;
} catch ( e ) {
}
if ( new _node ) {
for ( var i in new _node . contents ) {
throw new FS . ErrnoError ( 55 ) ;
}
}
}
// do the internal rewiring
delete old _node . parent . contents [ old _node . name ] ;
old _node . parent . timestamp = Date . now ( )
old _node . name = new _name ;
new _dir . contents [ new _name ] = old _node ;
new _dir . timestamp = old _node . parent . timestamp ;
old _node . parent = new _dir ;
} , unlink : function ( parent , name ) {
delete parent . contents [ name ] ;
parent . timestamp = Date . now ( ) ;
} , rmdir : function ( parent , name ) {
var node = FS . lookupNode ( parent , name ) ;
for ( var i in node . contents ) {
throw new FS . ErrnoError ( 55 ) ;
}
delete parent . contents [ name ] ;
parent . timestamp = Date . now ( ) ;
} , readdir : function ( node ) {
var entries = [ '.' , '..' ] ;
for ( var key in node . contents ) {
if ( ! node . contents . hasOwnProperty ( key ) ) {
continue ;
}
entries . push ( key ) ;
}
return entries ;
} , symlink : function ( parent , newname , oldpath ) {
var node = MEMFS . createNode ( parent , newname , 511 /* 0777 */ | 40960 , 0 ) ;
node . link = oldpath ;
return node ;
} , readlink : function ( node ) {
if ( ! FS . isLink ( node . mode ) ) {
throw new FS . ErrnoError ( 28 ) ;
}
return node . link ;
} } , stream _ops : { read : function ( stream , buffer , offset , length , position ) {
var contents = stream . node . contents ;
if ( position >= stream . node . usedBytes ) return 0 ;
var size = Math . min ( stream . node . usedBytes - position , length ) ;
assert ( size >= 0 ) ;
if ( size > 8 && contents . subarray ) { // non-trivial, and typed array
buffer . set ( contents . subarray ( position , position + size ) , offset ) ;
} else {
for ( var i = 0 ; i < size ; i ++ ) buffer [ offset + i ] = contents [ position + i ] ;
}
return size ;
} , write : function ( stream , buffer , offset , length , position , canOwn ) {
// The data buffer should be a typed array view
assert ( ! ( buffer instanceof ArrayBuffer ) ) ;
if ( ! length ) return 0 ;
var node = stream . node ;
node . timestamp = Date . now ( ) ;
if ( buffer . subarray && ( ! node . contents || node . contents . subarray ) ) { // This write is from a typed array to a typed array?
if ( canOwn ) {
assert ( position === 0 , 'canOwn must imply no weird position inside the file' ) ;
node . contents = buffer . subarray ( offset , offset + length ) ;
node . usedBytes = length ;
return length ;
} else if ( node . usedBytes === 0 && position === 0 ) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data.
node . contents = buffer . slice ( offset , offset + length ) ;
node . usedBytes = length ;
return length ;
} else if ( position + length <= node . usedBytes ) { // Writing to an already allocated and used subrange of the file?
node . contents . set ( buffer . subarray ( offset , offset + length ) , position ) ;
return length ;
}
}
// Appending to an existing file and we need to reallocate, or source data did not come as a typed array.
MEMFS . expandFileStorage ( node , position + length ) ;
if ( node . contents . subarray && buffer . subarray ) {
// Use typed array write which is available.
node . contents . set ( buffer . subarray ( offset , offset + length ) , position ) ;
} else {
for ( var i = 0 ; i < length ; i ++ ) {
node . contents [ position + i ] = buffer [ offset + i ] ; // Or fall back to manual write if not.
}
}
node . usedBytes = Math . max ( node . usedBytes , position + length ) ;
return length ;
} , llseek : function ( stream , offset , whence ) {
var position = offset ;
if ( whence === 1 ) {
position += stream . position ;
} else if ( whence === 2 ) {
if ( FS . isFile ( stream . node . mode ) ) {
position += stream . node . usedBytes ;
}
}
if ( position < 0 ) {
throw new FS . ErrnoError ( 28 ) ;
}
return position ;
} , allocate : function ( stream , offset , length ) {
MEMFS . expandFileStorage ( stream . node , offset + length ) ;
stream . node . usedBytes = Math . max ( stream . node . usedBytes , offset + length ) ;
} , mmap : function ( stream , address , length , position , prot , flags ) {
if ( address !== 0 ) {
// We don't currently support location hints for the address of the mapping
throw new FS . ErrnoError ( 28 ) ;
}
if ( ! FS . isFile ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 43 ) ;
}
var ptr ;
var allocated ;
var contents = stream . node . contents ;
// Only make a new copy when MAP_PRIVATE is specified.
if ( ! ( flags & 2 ) && contents . buffer === buffer ) {
// We can't emulate MAP_SHARED when the file is not backed by the buffer
// we're mapping to (e.g. the HEAP buffer).
allocated = false ;
ptr = contents . byteOffset ;
} else {
// Try to avoid unnecessary slices.
if ( position > 0 || position + length < contents . length ) {
if ( contents . subarray ) {
contents = contents . subarray ( position , position + length ) ;
} else {
contents = Array . prototype . slice . call ( contents , position , position + length ) ;
}
}
allocated = true ;
ptr = mmapAlloc ( length ) ;
if ( ! ptr ) {
throw new FS . ErrnoError ( 48 ) ;
}
HEAP8 . set ( contents , ptr ) ;
}
return { ptr : ptr , allocated : allocated } ;
} , msync : function ( stream , buffer , offset , length , mmapFlags ) {
if ( ! FS . isFile ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 43 ) ;
}
if ( mmapFlags & 2 ) {
// MAP_PRIVATE calls need not to be synced back to underlying fs
return 0 ;
}
var bytesWritten = MEMFS . stream _ops . write ( stream , buffer , 0 , length , offset , false ) ;
// should we check if bytesWritten and length are the same?
return 0 ;
} } } ;
/** @param {boolean=} noRunDep */
function asyncLoad ( url , onload , onerror , noRunDep ) {
var dep = ! noRunDep ? getUniqueRunDependency ( 'al ' + url ) : '' ;
readAsync ( url , function ( arrayBuffer ) {
assert ( arrayBuffer , 'Loading data file "' + url + '" failed (no arrayBuffer).' ) ;
onload ( new Uint8Array ( arrayBuffer ) ) ;
if ( dep ) removeRunDependency ( dep ) ;
} , function ( event ) {
if ( onerror ) {
onerror ( ) ;
} else {
throw 'Loading data file "' + url + '" failed.' ;
}
} ) ;
if ( dep ) addRunDependency ( dep ) ;
}
var ERRNO _MESSAGES = { 0 : "Success" , 1 : "Arg list too long" , 2 : "Permission denied" , 3 : "Address already in use" , 4 : "Address not available" , 5 : "Address family not supported by protocol family" , 6 : "No more processes" , 7 : "Socket already connected" , 8 : "Bad file number" , 9 : "Trying to read unreadable message" , 10 : "Mount device busy" , 11 : "Operation canceled" , 12 : "No children" , 13 : "Connection aborted" , 14 : "Connection refused" , 15 : "Connection reset by peer" , 16 : "File locking deadlock error" , 17 : "Destination address required" , 18 : "Math arg out of domain of func" , 19 : "Quota exceeded" , 20 : "File exists" , 21 : "Bad address" , 22 : "File too large" , 23 : "Host is unreachable" , 24 : "Identifier removed" , 25 : "Illegal byte sequence" , 26 : "Connection already in progress" , 27 : "Interrupted system call" , 28 : "Invalid argument" , 29 : "I/O error" , 30 : "Socket is already connected" , 31 : "Is a directory" , 32 : "Too many symbolic links" , 33 : "Too many open files" , 34 : "Too many links" , 35 : "Message too long" , 36 : "Multihop attempted" , 37 : "File or path name too long" , 38 : "Network interface is not configured" , 39 : "Connection reset by network" , 40 : "Network is unreachable" , 41 : "Too many open files in system" , 42 : "No buffer space available" , 43 : "No such device" , 44 : "No such file or directory" , 45 : "Exec format error" , 46 : "No record locks available" , 47 : "The link has been severed" , 48 : "Not enough core" , 49 : "No message of desired type" , 50 : "Protocol not available" , 51 : "No space left on device" , 52 : "Function not implemented" , 53 : "Socket is not connected" , 54 : "Not a directory" , 55 : "Directory not empty" , 56 : "State not recoverable" , 57 : "Socket operation on non-socket" , 59 : "Not a typewriter" , 60 : "No such device or address" , 61 : "Value too large for defined data type" , 62 : "Previous owner died" , 63 : "Not super-user" , 64 : "Broken pipe" , 65 : "Protocol error" , 66 : "Unknown protocol" , 67 : "Protocol wrong type for socket" , 68 : "Math result not representable" , 69 : "Read only file system" , 70 : "Illegal seek" , 71 : "No such process" , 72 : "Stale file handle" , 73 : "Connection timed out" , 74 : "Text file busy" , 75 : "Cross-device link" , 100 : "Device not a stream" , 101 : "Bad font file fmt" , 102 : "Invalid slot" , 103 : "Invalid request code" , 104 : "No anode" , 105 : "Block device required" , 106 : "Channel number out of range" , 107 : "Level 3 halted" , 108 : "Level 3 reset" , 109 : "Link number out of range" , 110 : "Protocol driver not attached" , 111 : "No CSI structure available" , 112 : "Level 2 halted" , 113 : "Invalid exchange" , 114 : "Invalid request descriptor" , 115 : "Exchange full" , 116 : "No data (for no delay io)" , 117 : "Timer expired" , 118 : "Out of streams resources" , 119 : "Machine is not on the network" , 120 : "Package not installed" , 121 : "The object is remote" , 122 : "Advertise error" , 123 : "Srmount error" , 124 : "Communication error on send" , 125 : "Cross mount point (not really error)" , 126 : "Given log. name not unique" , 127 : "f.d. invalid for this operation" , 128 : "Remote address changed" , 129 : "Can access a needed shared lib" , 130 : "Accessing a corrupted shared lib" , 131 : ".lib section in a.out corrupted" , 132 : "Attempting to link in too many libs" , 133 : "Attempting to exec a shared library" , 135 : "Streams pipe error" , 136 : "Too many users" , 137 : "Socket type not supported" , 138 : "Not supported" , 139 : "Protocol family not supported" , 140 : "Can't send after socket shutdown" , 141 : "Too many references" , 142 : "Host is down" , 148 : "No medium (in tape drive)" , 156 : "Level 2 not synchronized" } ;
var ERRNO _CODES = { } ;
var FS = { root : null , mounts : [ ] , devices : { } , streams : [ ] , nextInode : 1 , nameTable : null , currentPath : "/" , initialized : false , ignorePermissions : true , ErrnoError : null , genericErrors : { } , filesystems : null , syncFSRequests : 0 , lookupPath : ( path , opts = { } ) => {
path = PATH _FS . resolve ( FS . cwd ( ) , path ) ;
if ( ! path ) return { path : '' , node : null } ;
var defaults = {
follow _mount : true ,
recurse _count : 0
} ;
for ( var key in defaults ) {
if ( opts [ key ] === undefined ) {
opts [ key ] = defaults [ key ] ;
}
}
if ( opts . recurse _count > 8 ) { // max recursive lookup of 8
throw new FS . ErrnoError ( 32 ) ;
}
// split the path
var parts = PATH . normalizeArray ( path . split ( '/' ) . filter ( ( p ) => ! ! p ) , false ) ;
// start at the root
var current = FS . root ;
var current _path = '/' ;
for ( var i = 0 ; i < parts . length ; i ++ ) {
var islast = ( i === parts . length - 1 ) ;
if ( islast && opts . parent ) {
// stop resolving
break ;
}
current = FS . lookupNode ( current , parts [ i ] ) ;
current _path = PATH . join2 ( current _path , parts [ i ] ) ;
// jump to the mount's root node if this is a mountpoint
if ( FS . isMountpoint ( current ) ) {
if ( ! islast || ( islast && opts . follow _mount ) ) {
current = current . mounted . root ;
}
}
// by default, lookupPath will not follow a symlink if it is the final path component.
// setting opts.follow = true will override this behavior.
if ( ! islast || opts . follow ) {
var count = 0 ;
while ( FS . isLink ( current . mode ) ) {
var link = FS . readlink ( current _path ) ;
current _path = PATH _FS . resolve ( PATH . dirname ( current _path ) , link ) ;
var lookup = FS . lookupPath ( current _path , { recurse _count : opts . recurse _count } ) ;
current = lookup . node ;
if ( count ++ > 40 ) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
throw new FS . ErrnoError ( 32 ) ;
}
}
}
}
return { path : current _path , node : current } ;
} , getPath : ( node ) => {
var path ;
while ( true ) {
if ( FS . isRoot ( node ) ) {
var mount = node . mount . mountpoint ;
if ( ! path ) return mount ;
return mount [ mount . length - 1 ] !== '/' ? mount + '/' + path : mount + path ;
}
path = path ? node . name + '/' + path : node . name ;
node = node . parent ;
}
} , hashName : ( parentid , name ) => {
var hash = 0 ;
for ( var i = 0 ; i < name . length ; i ++ ) {
hash = ( ( hash << 5 ) - hash + name . charCodeAt ( i ) ) | 0 ;
}
return ( ( parentid + hash ) >>> 0 ) % FS . nameTable . length ;
} , hashAddNode : ( node ) => {
var hash = FS . hashName ( node . parent . id , node . name ) ;
node . name _next = FS . nameTable [ hash ] ;
FS . nameTable [ hash ] = node ;
} , hashRemoveNode : ( node ) => {
var hash = FS . hashName ( node . parent . id , node . name ) ;
if ( FS . nameTable [ hash ] === node ) {
FS . nameTable [ hash ] = node . name _next ;
} else {
var current = FS . nameTable [ hash ] ;
while ( current ) {
if ( current . name _next === node ) {
current . name _next = node . name _next ;
break ;
}
current = current . name _next ;
}
}
} , lookupNode : ( parent , name ) => {
var errCode = FS . mayLookup ( parent ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode , parent ) ;
}
var hash = FS . hashName ( parent . id , name ) ;
for ( var node = FS . nameTable [ hash ] ; node ; node = node . name _next ) {
var nodeName = node . name ;
if ( node . parent . id === parent . id && nodeName === name ) {
return node ;
}
}
// if we failed to find it in the cache, call into the VFS
return FS . lookup ( parent , name ) ;
} , createNode : ( parent , name , mode , rdev ) => {
assert ( typeof parent == 'object' )
var node = new FS . FSNode ( parent , name , mode , rdev ) ;
FS . hashAddNode ( node ) ;
return node ;
} , destroyNode : ( node ) => {
FS . hashRemoveNode ( node ) ;
} , isRoot : ( node ) => {
return node === node . parent ;
} , isMountpoint : ( node ) => {
return ! ! node . mounted ;
} , isFile : ( mode ) => {
return ( mode & 61440 ) === 32768 ;
} , isDir : ( mode ) => {
return ( mode & 61440 ) === 16384 ;
} , isLink : ( mode ) => {
return ( mode & 61440 ) === 40960 ;
} , isChrdev : ( mode ) => {
return ( mode & 61440 ) === 8192 ;
} , isBlkdev : ( mode ) => {
return ( mode & 61440 ) === 24576 ;
} , isFIFO : ( mode ) => {
return ( mode & 61440 ) === 4096 ;
} , isSocket : ( mode ) => {
return ( mode & 49152 ) === 49152 ;
} , flagModes : { "r" : 0 , "r+" : 2 , "w" : 577 , "w+" : 578 , "a" : 1089 , "a+" : 1090 } , modeStringToFlags : ( str ) => {
var flags = FS . flagModes [ str ] ;
if ( typeof flags == 'undefined' ) {
throw new Error ( 'Unknown file open mode: ' + str ) ;
}
return flags ;
} , flagsToPermissionString : ( flag ) => {
var perms = [ 'r' , 'w' , 'rw' ] [ flag & 3 ] ;
if ( ( flag & 512 ) ) {
perms += 'w' ;
}
return perms ;
} , nodePermissions : ( node , perms ) => {
if ( FS . ignorePermissions ) {
return 0 ;
}
// return 0 if any user, group or owner bits are set.
if ( perms . includes ( 'r' ) && ! ( node . mode & 292 ) ) {
return 2 ;
} else if ( perms . includes ( 'w' ) && ! ( node . mode & 146 ) ) {
return 2 ;
} else if ( perms . includes ( 'x' ) && ! ( node . mode & 73 ) ) {
return 2 ;
}
return 0 ;
} , mayLookup : ( dir ) => {
var errCode = FS . nodePermissions ( dir , 'x' ) ;
if ( errCode ) return errCode ;
if ( ! dir . node _ops . lookup ) return 2 ;
return 0 ;
} , mayCreate : ( dir , name ) => {
try {
var node = FS . lookupNode ( dir , name ) ;
return 20 ;
} catch ( e ) {
}
return FS . nodePermissions ( dir , 'wx' ) ;
} , mayDelete : ( dir , name , isdir ) => {
var node ;
try {
node = FS . lookupNode ( dir , name ) ;
} catch ( e ) {
return e . errno ;
}
var errCode = FS . nodePermissions ( dir , 'wx' ) ;
if ( errCode ) {
return errCode ;
}
if ( isdir ) {
if ( ! FS . isDir ( node . mode ) ) {
return 54 ;
}
if ( FS . isRoot ( node ) || FS . getPath ( node ) === FS . cwd ( ) ) {
return 10 ;
}
} else {
if ( FS . isDir ( node . mode ) ) {
return 31 ;
}
}
return 0 ;
} , mayOpen : ( node , flags ) => {
if ( ! node ) {
return 44 ;
}
if ( FS . isLink ( node . mode ) ) {
return 32 ;
} else if ( FS . isDir ( node . mode ) ) {
if ( FS . flagsToPermissionString ( flags ) !== 'r' || // opening for write
( flags & 512 ) ) { // TODO: check for O_SEARCH? (== search for dir only)
return 31 ;
}
}
return FS . nodePermissions ( node , FS . flagsToPermissionString ( flags ) ) ;
} , MAX _OPEN _FDS : 4096 , nextfd : ( fd _start = 0 , fd _end = FS . MAX _OPEN _FDS ) => {
for ( var fd = fd _start ; fd <= fd _end ; fd ++ ) {
if ( ! FS . streams [ fd ] ) {
return fd ;
}
}
throw new FS . ErrnoError ( 33 ) ;
} , getStream : ( fd ) => FS . streams [ fd ] , createStream : ( stream , fd _start , fd _end ) => {
if ( ! FS . FSStream ) {
FS . FSStream = /** @constructor */ function ( ) { } ;
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
stream = Object . assign ( new FS . FSStream ( ) , stream ) ;
var fd = FS . nextfd ( fd _start , fd _end ) ;
stream . fd = fd ;
FS . streams [ fd ] = stream ;
return stream ;
} , closeStream : ( fd ) => {
FS . streams [ fd ] = null ;
} , chrdev _stream _ops : { open : ( stream ) => {
var device = FS . getDevice ( stream . node . rdev ) ;
// override node's stream ops with the device's
stream . stream _ops = device . stream _ops ;
// forward the open call
if ( stream . stream _ops . open ) {
stream . stream _ops . open ( stream ) ;
}
} , llseek : ( ) => {
throw new FS . ErrnoError ( 70 ) ;
} } , major : ( dev ) => ( ( dev ) >> 8 ) , minor : ( dev ) => ( ( dev ) & 0xff ) , makedev : ( ma , mi ) => ( ( ma ) << 8 | ( mi ) ) , registerDevice : ( dev , ops ) => {
FS . devices [ dev ] = { stream _ops : ops } ;
} , getDevice : ( dev ) => FS . devices [ dev ] , getMounts : ( mount ) => {
var mounts = [ ] ;
var check = [ mount ] ;
while ( check . length ) {
var m = check . pop ( ) ;
mounts . push ( m ) ;
check . push . apply ( check , m . mounts ) ;
}
return mounts ;
} , syncfs : ( populate , callback ) => {
if ( typeof populate == 'function' ) {
callback = populate ;
populate = false ;
}
FS . syncFSRequests ++ ;
if ( FS . syncFSRequests > 1 ) {
err ( 'warning: ' + FS . syncFSRequests + ' FS.syncfs operations in flight at once, probably just doing extra work' ) ;
}
var mounts = FS . getMounts ( FS . root . mount ) ;
var completed = 0 ;
function doCallback ( errCode ) {
assert ( FS . syncFSRequests > 0 ) ;
FS . syncFSRequests -- ;
return callback ( errCode ) ;
}
function done ( errCode ) {
if ( errCode ) {
if ( ! done . errored ) {
done . errored = true ;
return doCallback ( errCode ) ;
}
return ;
}
if ( ++ completed >= mounts . length ) {
doCallback ( null ) ;
}
} ;
// sync all mounts
mounts . forEach ( ( mount ) => {
if ( ! mount . type . syncfs ) {
return done ( null ) ;
}
mount . type . syncfs ( mount , populate , done ) ;
} ) ;
} , mount : ( type , opts , mountpoint ) => {
if ( typeof type == 'string' ) {
// The filesystem was not included, and instead we have an error
// message stored in the variable.
throw type ;
}
var root = mountpoint === '/' ;
var pseudo = ! mountpoint ;
var node ;
if ( root && FS . root ) {
throw new FS . ErrnoError ( 10 ) ;
} else if ( ! root && ! pseudo ) {
var lookup = FS . lookupPath ( mountpoint , { follow _mount : false } ) ;
mountpoint = lookup . path ; // use the absolute path
node = lookup . node ;
if ( FS . isMountpoint ( node ) ) {
throw new FS . ErrnoError ( 10 ) ;
}
if ( ! FS . isDir ( node . mode ) ) {
throw new FS . ErrnoError ( 54 ) ;
}
}
var mount = {
type : type ,
opts : opts ,
mountpoint : mountpoint ,
mounts : [ ]
} ;
// create a root node for the fs
var mountRoot = type . mount ( mount ) ;
mountRoot . mount = mount ;
mount . root = mountRoot ;
if ( root ) {
FS . root = mountRoot ;
} else if ( node ) {
// set as a mountpoint
node . mounted = mount ;
// add the new mount to the current mount's children
if ( node . mount ) {
node . mount . mounts . push ( mount ) ;
}
}
return mountRoot ;
} , unmount : ( mountpoint ) => {
var lookup = FS . lookupPath ( mountpoint , { follow _mount : false } ) ;
if ( ! FS . isMountpoint ( lookup . node ) ) {
throw new FS . ErrnoError ( 28 ) ;
}
// destroy the nodes for this mount, and all its child mounts
var node = lookup . node ;
var mount = node . mounted ;
var mounts = FS . getMounts ( mount ) ;
Object . keys ( FS . nameTable ) . forEach ( ( hash ) => {
var current = FS . nameTable [ hash ] ;
while ( current ) {
var next = current . name _next ;
if ( mounts . includes ( current . mount ) ) {
FS . destroyNode ( current ) ;
}
current = next ;
}
} ) ;
// no longer a mountpoint
node . mounted = null ;
// remove this mount from the child mounts
var idx = node . mount . mounts . indexOf ( mount ) ;
assert ( idx !== - 1 ) ;
node . mount . mounts . splice ( idx , 1 ) ;
} , lookup : ( parent , name ) => {
return parent . node _ops . lookup ( parent , name ) ;
} , mknod : ( path , mode , dev ) => {
var lookup = FS . lookupPath ( path , { parent : true } ) ;
var parent = lookup . node ;
var name = PATH . basename ( path ) ;
if ( ! name || name === '.' || name === '..' ) {
throw new FS . ErrnoError ( 28 ) ;
}
var errCode = FS . mayCreate ( parent , name ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
if ( ! parent . node _ops . mknod ) {
throw new FS . ErrnoError ( 63 ) ;
}
return parent . node _ops . mknod ( parent , name , mode , dev ) ;
} , create : ( path , mode ) => {
mode = mode !== undefined ? mode : 438 /* 0666 */ ;
mode &= 4095 ;
mode |= 32768 ;
return FS . mknod ( path , mode , 0 ) ;
} , mkdir : ( path , mode ) => {
mode = mode !== undefined ? mode : 511 /* 0777 */ ;
mode &= 511 | 512 ;
mode |= 16384 ;
return FS . mknod ( path , mode , 0 ) ;
} , mkdirTree : ( path , mode ) => {
var dirs = path . split ( '/' ) ;
var d = '' ;
for ( var i = 0 ; i < dirs . length ; ++ i ) {
if ( ! dirs [ i ] ) continue ;
d += '/' + dirs [ i ] ;
try {
FS . mkdir ( d , mode ) ;
} catch ( e ) {
if ( e . errno != 20 ) throw e ;
}
}
} , mkdev : ( path , mode , dev ) => {
if ( typeof dev == 'undefined' ) {
dev = mode ;
mode = 438 /* 0666 */ ;
}
mode |= 8192 ;
return FS . mknod ( path , mode , dev ) ;
} , symlink : ( oldpath , newpath ) => {
if ( ! PATH _FS . resolve ( oldpath ) ) {
throw new FS . ErrnoError ( 44 ) ;
}
var lookup = FS . lookupPath ( newpath , { parent : true } ) ;
var parent = lookup . node ;
if ( ! parent ) {
throw new FS . ErrnoError ( 44 ) ;
}
var newname = PATH . basename ( newpath ) ;
var errCode = FS . mayCreate ( parent , newname ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
if ( ! parent . node _ops . symlink ) {
throw new FS . ErrnoError ( 63 ) ;
}
return parent . node _ops . symlink ( parent , newname , oldpath ) ;
} , rename : ( old _path , new _path ) => {
var old _dirname = PATH . dirname ( old _path ) ;
var new _dirname = PATH . dirname ( new _path ) ;
var old _name = PATH . basename ( old _path ) ;
var new _name = PATH . basename ( new _path ) ;
// parents must exist
var lookup , old _dir , new _dir ;
// let the errors from non existant directories percolate up
lookup = FS . lookupPath ( old _path , { parent : true } ) ;
old _dir = lookup . node ;
lookup = FS . lookupPath ( new _path , { parent : true } ) ;
new _dir = lookup . node ;
if ( ! old _dir || ! new _dir ) throw new FS . ErrnoError ( 44 ) ;
// need to be part of the same mount
if ( old _dir . mount !== new _dir . mount ) {
throw new FS . ErrnoError ( 75 ) ;
}
// source must exist
var old _node = FS . lookupNode ( old _dir , old _name ) ;
// old path should not be an ancestor of the new path
var relative = PATH _FS . relative ( old _path , new _dirname ) ;
if ( relative . charAt ( 0 ) !== '.' ) {
throw new FS . ErrnoError ( 28 ) ;
}
// new path should not be an ancestor of the old path
relative = PATH _FS . relative ( new _path , old _dirname ) ;
if ( relative . charAt ( 0 ) !== '.' ) {
throw new FS . ErrnoError ( 55 ) ;
}
// see if the new path already exists
var new _node ;
try {
new _node = FS . lookupNode ( new _dir , new _name ) ;
} catch ( e ) {
// not fatal
}
// early out if nothing needs to change
if ( old _node === new _node ) {
return ;
}
// we'll need to delete the old entry
var isdir = FS . isDir ( old _node . mode ) ;
var errCode = FS . mayDelete ( old _dir , old _name , isdir ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
// need delete permissions if we'll be overwriting.
// need create permissions if new doesn't already exist.
errCode = new _node ?
FS . mayDelete ( new _dir , new _name , isdir ) :
FS . mayCreate ( new _dir , new _name ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
if ( ! old _dir . node _ops . rename ) {
throw new FS . ErrnoError ( 63 ) ;
}
if ( FS . isMountpoint ( old _node ) || ( new _node && FS . isMountpoint ( new _node ) ) ) {
throw new FS . ErrnoError ( 10 ) ;
}
// if we are going to change the parent, check write permissions
if ( new _dir !== old _dir ) {
errCode = FS . nodePermissions ( old _dir , 'w' ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
}
// remove the node from the lookup hash
FS . hashRemoveNode ( old _node ) ;
// do the underlying fs rename
try {
old _dir . node _ops . rename ( old _node , new _dir , new _name ) ;
} catch ( e ) {
throw e ;
} finally {
// add the node back to the hash (in case node_ops.rename
// changed its name)
FS . hashAddNode ( old _node ) ;
}
} , rmdir : ( path ) => {
var lookup = FS . lookupPath ( path , { parent : true } ) ;
var parent = lookup . node ;
var name = PATH . basename ( path ) ;
var node = FS . lookupNode ( parent , name ) ;
var errCode = FS . mayDelete ( parent , name , true ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
if ( ! parent . node _ops . rmdir ) {
throw new FS . ErrnoError ( 63 ) ;
}
if ( FS . isMountpoint ( node ) ) {
throw new FS . ErrnoError ( 10 ) ;
}
parent . node _ops . rmdir ( parent , name ) ;
FS . destroyNode ( node ) ;
} , readdir : ( path ) => {
var lookup = FS . lookupPath ( path , { follow : true } ) ;
var node = lookup . node ;
if ( ! node . node _ops . readdir ) {
throw new FS . ErrnoError ( 54 ) ;
}
return node . node _ops . readdir ( node ) ;
} , unlink : ( path ) => {
var lookup = FS . lookupPath ( path , { parent : true } ) ;
var parent = lookup . node ;
if ( ! parent ) {
throw new FS . ErrnoError ( 44 ) ;
}
var name = PATH . basename ( path ) ;
var node = FS . lookupNode ( parent , name ) ;
var errCode = FS . mayDelete ( parent , name , false ) ;
if ( errCode ) {
// According to POSIX, we should map EISDIR to EPERM, but
// we instead do what Linux does (and we must, as we use
// the musl linux libc).
throw new FS . ErrnoError ( errCode ) ;
}
if ( ! parent . node _ops . unlink ) {
throw new FS . ErrnoError ( 63 ) ;
}
if ( FS . isMountpoint ( node ) ) {
throw new FS . ErrnoError ( 10 ) ;
}
parent . node _ops . unlink ( parent , name ) ;
FS . destroyNode ( node ) ;
} , readlink : ( path ) => {
var lookup = FS . lookupPath ( path ) ;
var link = lookup . node ;
if ( ! link ) {
throw new FS . ErrnoError ( 44 ) ;
}
if ( ! link . node _ops . readlink ) {
throw new FS . ErrnoError ( 28 ) ;
}
return PATH _FS . resolve ( FS . getPath ( link . parent ) , link . node _ops . readlink ( link ) ) ;
} , stat : ( path , dontFollow ) => {
var lookup = FS . lookupPath ( path , { follow : ! dontFollow } ) ;
var node = lookup . node ;
if ( ! node ) {
throw new FS . ErrnoError ( 44 ) ;
}
if ( ! node . node _ops . getattr ) {
throw new FS . ErrnoError ( 63 ) ;
}
return node . node _ops . getattr ( node ) ;
} , lstat : ( path ) => {
return FS . stat ( path , true ) ;
} , chmod : ( path , mode , dontFollow ) => {
var node ;
if ( typeof path == 'string' ) {
var lookup = FS . lookupPath ( path , { follow : ! dontFollow } ) ;
node = lookup . node ;
} else {
node = path ;
}
if ( ! node . node _ops . setattr ) {
throw new FS . ErrnoError ( 63 ) ;
}
node . node _ops . setattr ( node , {
mode : ( mode & 4095 ) | ( node . mode & ~ 4095 ) ,
timestamp : Date . now ( )
} ) ;
} , lchmod : ( path , mode ) => {
FS . chmod ( path , mode , true ) ;
} , fchmod : ( fd , mode ) => {
var stream = FS . getStream ( fd ) ;
if ( ! stream ) {
throw new FS . ErrnoError ( 8 ) ;
}
FS . chmod ( stream . node , mode ) ;
} , chown : ( path , uid , gid , dontFollow ) => {
var node ;
if ( typeof path == 'string' ) {
var lookup = FS . lookupPath ( path , { follow : ! dontFollow } ) ;
node = lookup . node ;
} else {
node = path ;
}
if ( ! node . node _ops . setattr ) {
throw new FS . ErrnoError ( 63 ) ;
}
node . node _ops . setattr ( node , {
timestamp : Date . now ( )
// we ignore the uid / gid for now
} ) ;
} , lchown : ( path , uid , gid ) => {
FS . chown ( path , uid , gid , true ) ;
} , fchown : ( fd , uid , gid ) => {
var stream = FS . getStream ( fd ) ;
if ( ! stream ) {
throw new FS . ErrnoError ( 8 ) ;
}
FS . chown ( stream . node , uid , gid ) ;
} , truncate : ( path , len ) => {
if ( len < 0 ) {
throw new FS . ErrnoError ( 28 ) ;
}
var node ;
if ( typeof path == 'string' ) {
var lookup = FS . lookupPath ( path , { follow : true } ) ;
node = lookup . node ;
} else {
node = path ;
}
if ( ! node . node _ops . setattr ) {
throw new FS . ErrnoError ( 63 ) ;
}
if ( FS . isDir ( node . mode ) ) {
throw new FS . ErrnoError ( 31 ) ;
}
if ( ! FS . isFile ( node . mode ) ) {
throw new FS . ErrnoError ( 28 ) ;
}
var errCode = FS . nodePermissions ( node , 'w' ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
node . node _ops . setattr ( node , {
size : len ,
timestamp : Date . now ( )
} ) ;
} , ftruncate : ( fd , len ) => {
var stream = FS . getStream ( fd ) ;
if ( ! stream ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( ( stream . flags & 2097155 ) === 0 ) {
throw new FS . ErrnoError ( 28 ) ;
}
FS . truncate ( stream . node , len ) ;
} , utime : ( path , atime , mtime ) => {
var lookup = FS . lookupPath ( path , { follow : true } ) ;
var node = lookup . node ;
node . node _ops . setattr ( node , {
timestamp : Math . max ( atime , mtime )
} ) ;
} , open : ( path , flags , mode , fd _start , fd _end ) => {
if ( path === "" ) {
throw new FS . ErrnoError ( 44 ) ;
}
flags = typeof flags == 'string' ? FS . modeStringToFlags ( flags ) : flags ;
mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode ;
if ( ( flags & 64 ) ) {
mode = ( mode & 4095 ) | 32768 ;
} else {
mode = 0 ;
}
var node ;
if ( typeof path == 'object' ) {
node = path ;
} else {
path = PATH . normalize ( path ) ;
try {
var lookup = FS . lookupPath ( path , {
follow : ! ( flags & 131072 )
} ) ;
node = lookup . node ;
} catch ( e ) {
// ignore
}
}
// perhaps we need to create the node
var created = false ;
if ( ( flags & 64 ) ) {
if ( node ) {
// if O_CREAT and O_EXCL are set, error out if the node already exists
if ( ( flags & 128 ) ) {
throw new FS . ErrnoError ( 20 ) ;
}
} else {
// node doesn't exist, try to create it
node = FS . mknod ( path , mode , 0 ) ;
created = true ;
}
}
if ( ! node ) {
throw new FS . ErrnoError ( 44 ) ;
}
// can't truncate a device
if ( FS . isChrdev ( node . mode ) ) {
flags &= ~ 512 ;
}
// if asked only for a directory, then this must be one
if ( ( flags & 65536 ) && ! FS . isDir ( node . mode ) ) {
throw new FS . ErrnoError ( 54 ) ;
}
// check permissions, if this is not a file we just created now (it is ok to
// create and write to a file with read-only permissions; it is read-only
// for later use)
if ( ! created ) {
var errCode = FS . mayOpen ( node , flags ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
}
// do truncation if necessary
if ( ( flags & 512 ) ) {
FS . truncate ( node , 0 ) ;
}
// we've already handled these, don't pass down to the underlying vfs
flags &= ~ ( 128 | 512 | 131072 ) ;
// register the stream with the filesystem
var stream = FS . createStream ( {
node : node ,
path : FS . getPath ( node ) , // we want the absolute path to the node
flags : flags ,
seekable : true ,
position : 0 ,
stream _ops : node . stream _ops ,
// used by the file family libc calls (fopen, fwrite, ferror, etc.)
ungotten : [ ] ,
error : false
} , fd _start , fd _end ) ;
// call the new stream's open function
if ( stream . stream _ops . open ) {
stream . stream _ops . open ( stream ) ;
}
if ( Module [ 'logReadFiles' ] && ! ( flags & 1 ) ) {
if ( ! FS . readFiles ) FS . readFiles = { } ;
if ( ! ( path in FS . readFiles ) ) {
FS . readFiles [ path ] = 1 ;
}
}
return stream ;
} , close : ( stream ) => {
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( stream . getdents ) stream . getdents = null ; // free readdir state
try {
if ( stream . stream _ops . close ) {
stream . stream _ops . close ( stream ) ;
}
} catch ( e ) {
throw e ;
} finally {
FS . closeStream ( stream . fd ) ;
}
stream . fd = null ;
} , isClosed : ( stream ) => {
return stream . fd === null ;
} , llseek : ( stream , offset , whence ) => {
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( ! stream . seekable || ! stream . stream _ops . llseek ) {
throw new FS . ErrnoError ( 70 ) ;
}
if ( whence != 0 && whence != 1 && whence != 2 ) {
throw new FS . ErrnoError ( 28 ) ;
}
stream . position = stream . stream _ops . llseek ( stream , offset , whence ) ;
stream . ungotten = [ ] ;
return stream . position ;
} , read : ( stream , buffer , offset , length , position ) => {
if ( length < 0 || position < 0 ) {
throw new FS . ErrnoError ( 28 ) ;
}
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( ( stream . flags & 2097155 ) === 1 ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( FS . isDir ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 31 ) ;
}
if ( ! stream . stream _ops . read ) {
throw new FS . ErrnoError ( 28 ) ;
}
var seeking = typeof position != 'undefined' ;
if ( ! seeking ) {
position = stream . position ;
} else if ( ! stream . seekable ) {
throw new FS . ErrnoError ( 70 ) ;
}
var bytesRead = stream . stream _ops . read ( stream , buffer , offset , length , position ) ;
if ( ! seeking ) stream . position += bytesRead ;
return bytesRead ;
} , write : ( stream , buffer , offset , length , position , canOwn ) => {
if ( length < 0 || position < 0 ) {
throw new FS . ErrnoError ( 28 ) ;
}
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( ( stream . flags & 2097155 ) === 0 ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( FS . isDir ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 31 ) ;
}
if ( ! stream . stream _ops . write ) {
throw new FS . ErrnoError ( 28 ) ;
}
if ( stream . seekable && stream . flags & 1024 ) {
// seek to the end before writing in append mode
FS . llseek ( stream , 0 , 2 ) ;
}
var seeking = typeof position != 'undefined' ;
if ( ! seeking ) {
position = stream . position ;
} else if ( ! stream . seekable ) {
throw new FS . ErrnoError ( 70 ) ;
}
var bytesWritten = stream . stream _ops . write ( stream , buffer , offset , length , position , canOwn ) ;
if ( ! seeking ) stream . position += bytesWritten ;
return bytesWritten ;
} , allocate : ( stream , offset , length ) => {
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( offset < 0 || length <= 0 ) {
throw new FS . ErrnoError ( 28 ) ;
}
if ( ( stream . flags & 2097155 ) === 0 ) {
throw new FS . ErrnoError ( 8 ) ;
}
if ( ! FS . isFile ( stream . node . mode ) && ! FS . isDir ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 43 ) ;
}
if ( ! stream . stream _ops . allocate ) {
throw new FS . ErrnoError ( 138 ) ;
}
stream . stream _ops . allocate ( stream , offset , length ) ;
} , mmap : ( stream , address , length , position , prot , flags ) => {
// User requests writing to file (prot & PROT_WRITE != 0).
// Checking if we have permissions to write to the file unless
// MAP_PRIVATE flag is set. According to POSIX spec it is possible
// to write to file opened in read-only mode with MAP_PRIVATE flag,
// as all modifications will be visible only in the memory of
// the current process.
if ( ( prot & 2 ) !== 0
&& ( flags & 2 ) === 0
&& ( stream . flags & 2097155 ) !== 2 ) {
throw new FS . ErrnoError ( 2 ) ;
}
if ( ( stream . flags & 2097155 ) === 1 ) {
throw new FS . ErrnoError ( 2 ) ;
}
if ( ! stream . stream _ops . mmap ) {
throw new FS . ErrnoError ( 43 ) ;
}
return stream . stream _ops . mmap ( stream , address , length , position , prot , flags ) ;
} , msync : ( stream , buffer , offset , length , mmapFlags ) => {
if ( ! stream || ! stream . stream _ops . msync ) {
return 0 ;
}
return stream . stream _ops . msync ( stream , buffer , offset , length , mmapFlags ) ;
} , munmap : ( stream ) => 0 , ioctl : ( stream , cmd , arg ) => {
if ( ! stream . stream _ops . ioctl ) {
throw new FS . ErrnoError ( 59 ) ;
}
return stream . stream _ops . ioctl ( stream , cmd , arg ) ;
} , readFile : ( path , opts = { } ) => {
opts . flags = opts . flags || 0 ;
opts . encoding = opts . encoding || 'binary' ;
if ( opts . encoding !== 'utf8' && opts . encoding !== 'binary' ) {
throw new Error ( 'Invalid encoding type "' + opts . encoding + '"' ) ;
}
var ret ;
var stream = FS . open ( path , opts . flags ) ;
var stat = FS . stat ( path ) ;
var length = stat . size ;
var buf = new Uint8Array ( length ) ;
FS . read ( stream , buf , 0 , length , 0 ) ;
if ( opts . encoding === 'utf8' ) {
ret = UTF8ArrayToString ( buf , 0 ) ;
} else if ( opts . encoding === 'binary' ) {
ret = buf ;
}
FS . close ( stream ) ;
return ret ;
} , writeFile : ( path , data , opts = { } ) => {
opts . flags = opts . flags || 577 ;
var stream = FS . open ( path , opts . flags , opts . mode ) ;
if ( typeof data == 'string' ) {
var buf = new Uint8Array ( lengthBytesUTF8 ( data ) + 1 ) ;
var actualNumBytes = stringToUTF8Array ( data , buf , 0 , buf . length ) ;
FS . write ( stream , buf , 0 , actualNumBytes , undefined , opts . canOwn ) ;
} else if ( ArrayBuffer . isView ( data ) ) {
FS . write ( stream , data , 0 , data . byteLength , undefined , opts . canOwn ) ;
} else {
throw new Error ( 'Unsupported data type' ) ;
}
FS . close ( stream ) ;
} , cwd : ( ) => FS . currentPath , chdir : ( path ) => {
var lookup = FS . lookupPath ( path , { follow : true } ) ;
if ( lookup . node === null ) {
throw new FS . ErrnoError ( 44 ) ;
}
if ( ! FS . isDir ( lookup . node . mode ) ) {
throw new FS . ErrnoError ( 54 ) ;
}
var errCode = FS . nodePermissions ( lookup . node , 'x' ) ;
if ( errCode ) {
throw new FS . ErrnoError ( errCode ) ;
}
FS . currentPath = lookup . path ;
} , createDefaultDirectories : ( ) => {
FS . mkdir ( '/tmp' ) ;
FS . mkdir ( '/home' ) ;
FS . mkdir ( '/home/web_user' ) ;
} , createDefaultDevices : ( ) => {
// create /dev
FS . mkdir ( '/dev' ) ;
// setup /dev/null
FS . registerDevice ( FS . makedev ( 1 , 3 ) , {
read : ( ) => 0 ,
write : ( stream , buffer , offset , length , pos ) => length ,
} ) ;
FS . mkdev ( '/dev/null' , FS . makedev ( 1 , 3 ) ) ;
// setup /dev/tty and /dev/tty1
// stderr needs to print output using err() rather than out()
// so we register a second tty just for it.
TTY . register ( FS . makedev ( 5 , 0 ) , TTY . default _tty _ops ) ;
TTY . register ( FS . makedev ( 6 , 0 ) , TTY . default _tty1 _ops ) ;
FS . mkdev ( '/dev/tty' , FS . makedev ( 5 , 0 ) ) ;
FS . mkdev ( '/dev/tty1' , FS . makedev ( 6 , 0 ) ) ;
// setup /dev/[u]random
var random _device = getRandomDevice ( ) ;
FS . createDevice ( '/dev' , 'random' , random _device ) ;
FS . createDevice ( '/dev' , 'urandom' , random _device ) ;
// we're not going to emulate the actual shm device,
// just create the tmp dirs that reside in it commonly
FS . mkdir ( '/dev/shm' ) ;
FS . mkdir ( '/dev/shm/tmp' ) ;
} , createSpecialDirectories : ( ) => {
// create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the
// name of the stream for fd 6 (see test_unistd_ttyname)
FS . mkdir ( '/proc' ) ;
var proc _self = FS . mkdir ( '/proc/self' ) ;
FS . mkdir ( '/proc/self/fd' ) ;
FS . mount ( {
mount : ( ) => {
var node = FS . createNode ( proc _self , 'fd' , 16384 | 511 /* 0777 */ , 73 ) ;
node . node _ops = {
lookup : ( parent , name ) => {
var fd = + name ;
var stream = FS . getStream ( fd ) ;
if ( ! stream ) throw new FS . ErrnoError ( 8 ) ;
var ret = {
parent : null ,
mount : { mountpoint : 'fake' } ,
node _ops : { readlink : ( ) => stream . path } ,
} ;
ret . parent = ret ; // make it look like a simple root node
return ret ;
}
} ;
return node ;
}
} , { } , '/proc/self/fd' ) ;
} , createStandardStreams : ( ) => {
// TODO deprecate the old functionality of a single
// input / output callback and that utilizes FS.createDevice
// and instead require a unique set of stream ops
// by default, we symlink the standard streams to the
// default tty devices. however, if the standard streams
// have been overwritten we create a unique device for
// them instead.
if ( Module [ 'stdin' ] ) {
FS . createDevice ( '/dev' , 'stdin' , Module [ 'stdin' ] ) ;
} else {
FS . symlink ( '/dev/tty' , '/dev/stdin' ) ;
}
if ( Module [ 'stdout' ] ) {
FS . createDevice ( '/dev' , 'stdout' , null , Module [ 'stdout' ] ) ;
} else {
FS . symlink ( '/dev/tty' , '/dev/stdout' ) ;
}
if ( Module [ 'stderr' ] ) {
FS . createDevice ( '/dev' , 'stderr' , null , Module [ 'stderr' ] ) ;
} else {
FS . symlink ( '/dev/tty1' , '/dev/stderr' ) ;
}
// open default streams for the stdin, stdout and stderr devices
var stdin = FS . open ( '/dev/stdin' , 0 ) ;
var stdout = FS . open ( '/dev/stdout' , 1 ) ;
var stderr = FS . open ( '/dev/stderr' , 1 ) ;
assert ( stdin . fd === 0 , 'invalid handle for stdin (' + stdin . fd + ')' ) ;
assert ( stdout . fd === 1 , 'invalid handle for stdout (' + stdout . fd + ')' ) ;
assert ( stderr . fd === 2 , 'invalid handle for stderr (' + stderr . fd + ')' ) ;
} , ensureErrnoError : ( ) => {
if ( FS . ErrnoError ) return ;
FS . ErrnoError = /** @this{Object} */ function ErrnoError ( errno , node ) {
this . node = node ;
this . setErrno = /** @this{Object} */ function ( errno ) {
this . errno = errno ;
for ( var key in ERRNO _CODES ) {
if ( ERRNO _CODES [ key ] === errno ) {
this . code = key ;
break ;
}
}
} ;
this . setErrno ( errno ) ;
this . message = ERRNO _MESSAGES [ errno ] ;
// Try to get a maximally helpful stack trace. On Node.js, getting Error.stack
// now ensures it shows what we want.
if ( this . stack ) {
// Define the stack property for Node.js 4, which otherwise errors on the next line.
Object . defineProperty ( this , "stack" , { value : ( new Error ) . stack , writable : true } ) ;
this . stack = demangleAll ( this . stack ) ;
}
} ;
FS . ErrnoError . prototype = new Error ( ) ;
FS . ErrnoError . prototype . constructor = FS . ErrnoError ;
// Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
[ 44 ] . forEach ( ( code ) => {
FS . genericErrors [ code ] = new FS . ErrnoError ( code ) ;
FS . genericErrors [ code ] . stack = '<generic error, no stack>' ;
} ) ;
} , staticInit : ( ) => {
FS . ensureErrnoError ( ) ;
FS . nameTable = new Array ( 4096 ) ;
FS . mount ( MEMFS , { } , '/' ) ;
FS . createDefaultDirectories ( ) ;
FS . createDefaultDevices ( ) ;
FS . createSpecialDirectories ( ) ;
FS . filesystems = {
'MEMFS' : MEMFS ,
} ;
} , init : ( input , output , error ) => {
assert ( ! FS . init . initialized , 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)' ) ;
FS . init . initialized = true ;
FS . ensureErrnoError ( ) ;
// Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
Module [ 'stdin' ] = input || Module [ 'stdin' ] ;
Module [ 'stdout' ] = output || Module [ 'stdout' ] ;
Module [ 'stderr' ] = error || Module [ 'stderr' ] ;
FS . createStandardStreams ( ) ;
} , quit : ( ) => {
FS . init . initialized = false ;
// Call musl-internal function to close all stdio streams, so nothing is
// left in internal buffers.
_ _ _stdio _exit ( ) ;
// close all of our streams
for ( var i = 0 ; i < FS . streams . length ; i ++ ) {
var stream = FS . streams [ i ] ;
if ( ! stream ) {
continue ;
}
FS . close ( stream ) ;
}
} , getMode : ( canRead , canWrite ) => {
var mode = 0 ;
if ( canRead ) mode |= 292 | 73 ;
if ( canWrite ) mode |= 146 ;
return mode ;
} , findObject : ( path , dontResolveLastLink ) => {
var ret = FS . analyzePath ( path , dontResolveLastLink ) ;
if ( ret . exists ) {
return ret . object ;
} else {
return null ;
}
} , analyzePath : ( path , dontResolveLastLink ) => {
// operate from within the context of the symlink's target
try {
var lookup = FS . lookupPath ( path , { follow : ! dontResolveLastLink } ) ;
path = lookup . path ;
} catch ( e ) {
}
var ret = {
isRoot : false , exists : false , error : 0 , name : null , path : null , object : null ,
parentExists : false , parentPath : null , parentObject : null
} ;
try {
var lookup = FS . lookupPath ( path , { parent : true } ) ;
ret . parentExists = true ;
ret . parentPath = lookup . path ;
ret . parentObject = lookup . node ;
ret . name = PATH . basename ( path ) ;
lookup = FS . lookupPath ( path , { follow : ! dontResolveLastLink } ) ;
ret . exists = true ;
ret . path = lookup . path ;
ret . object = lookup . node ;
ret . name = lookup . node . name ;
ret . isRoot = lookup . path === '/' ;
} catch ( e ) {
ret . error = e . errno ;
} ;
return ret ;
} , createPath : ( parent , path , canRead , canWrite ) => {
parent = typeof parent == 'string' ? parent : FS . getPath ( parent ) ;
var parts = path . split ( '/' ) . reverse ( ) ;
while ( parts . length ) {
var part = parts . pop ( ) ;
if ( ! part ) continue ;
var current = PATH . join2 ( parent , part ) ;
try {
FS . mkdir ( current ) ;
} catch ( e ) {
// ignore EEXIST
}
parent = current ;
}
return current ;
} , createFile : ( parent , name , properties , canRead , canWrite ) => {
var path = PATH . join2 ( typeof parent == 'string' ? parent : FS . getPath ( parent ) , name ) ;
var mode = FS . getMode ( canRead , canWrite ) ;
return FS . create ( path , mode ) ;
} , createDataFile : ( parent , name , data , canRead , canWrite , canOwn ) => {
var path = name ;
if ( parent ) {
parent = typeof parent == 'string' ? parent : FS . getPath ( parent ) ;
path = name ? PATH . join2 ( parent , name ) : parent ;
}
var mode = FS . getMode ( canRead , canWrite ) ;
var node = FS . create ( path , mode ) ;
if ( data ) {
if ( typeof data == 'string' ) {
var arr = new Array ( data . length ) ;
for ( var i = 0 , len = data . length ; i < len ; ++ i ) arr [ i ] = data . charCodeAt ( i ) ;
data = arr ;
}
// make sure we can write to the file
FS . chmod ( node , mode | 146 ) ;
var stream = FS . open ( node , 577 ) ;
FS . write ( stream , data , 0 , data . length , 0 , canOwn ) ;
FS . close ( stream ) ;
FS . chmod ( node , mode ) ;
}
return node ;
} , createDevice : ( parent , name , input , output ) => {
var path = PATH . join2 ( typeof parent == 'string' ? parent : FS . getPath ( parent ) , name ) ;
var mode = FS . getMode ( ! ! input , ! ! output ) ;
if ( ! FS . createDevice . major ) FS . createDevice . major = 64 ;
var dev = FS . makedev ( FS . createDevice . major ++ , 0 ) ;
// Create a fake device that a set of stream ops to emulate
// the old behavior.
FS . registerDevice ( dev , {
open : ( stream ) => {
stream . seekable = false ;
} ,
close : ( stream ) => {
// flush any pending line data
if ( output && output . buffer && output . buffer . length ) {
output ( 10 ) ;
}
} ,
read : ( stream , buffer , offset , length , pos /* ignored */ ) => {
var bytesRead = 0 ;
for ( var i = 0 ; i < length ; i ++ ) {
var result ;
try {
result = input ( ) ;
} catch ( e ) {
throw new FS . ErrnoError ( 29 ) ;
}
if ( result === undefined && bytesRead === 0 ) {
throw new FS . ErrnoError ( 6 ) ;
}
if ( result === null || result === undefined ) break ;
bytesRead ++ ;
buffer [ offset + i ] = result ;
}
if ( bytesRead ) {
stream . node . timestamp = Date . now ( ) ;
}
return bytesRead ;
} ,
write : ( stream , buffer , offset , length , pos ) => {
for ( var i = 0 ; i < length ; i ++ ) {
try {
output ( buffer [ offset + i ] ) ;
} catch ( e ) {
throw new FS . ErrnoError ( 29 ) ;
}
}
if ( length ) {
stream . node . timestamp = Date . now ( ) ;
}
return i ;
}
} ) ;
return FS . mkdev ( path , mode , dev ) ;
} , forceLoadFile : ( obj ) => {
if ( obj . isDevice || obj . isFolder || obj . link || obj . contents ) return true ;
if ( typeof XMLHttpRequest != 'undefined' ) {
throw new Error ( "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread." ) ;
} else if ( read _ ) {
// Command-line.
try {
// WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
// read() will try to parse UTF8.
obj . contents = intArrayFromString ( read _ ( obj . url ) , true ) ;
obj . usedBytes = obj . contents . length ;
} catch ( e ) {
throw new FS . ErrnoError ( 29 ) ;
}
} else {
throw new Error ( 'Cannot load without read() or XMLHttpRequest.' ) ;
}
} , createLazyFile : ( parent , name , url , canRead , canWrite ) => {
// Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
/** @constructor */
function LazyUint8Array ( ) {
this . lengthKnown = false ;
this . chunks = [ ] ; // Loaded chunks. Index is the chunk number
}
LazyUint8Array . prototype . get = /** @this{Object} */ function LazyUint8Array _get ( idx ) {
if ( idx > this . length - 1 || idx < 0 ) {
return undefined ;
}
var chunkOffset = idx % this . chunkSize ;
var chunkNum = ( idx / this . chunkSize ) | 0 ;
return this . getter ( chunkNum ) [ chunkOffset ] ;
} ;
LazyUint8Array . prototype . setDataGetter = function LazyUint8Array _setDataGetter ( getter ) {
this . getter = getter ;
} ;
LazyUint8Array . prototype . cacheLength = function LazyUint8Array _cacheLength ( ) {
// Find length
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'HEAD' , url , false ) ;
xhr . send ( null ) ;
if ( ! ( xhr . status >= 200 && xhr . status < 300 || xhr . status === 304 ) ) throw new Error ( "Couldn't load " + url + ". Status: " + xhr . status ) ;
var datalength = Number ( xhr . getResponseHeader ( "Content-length" ) ) ;
var header ;
var hasByteServing = ( header = xhr . getResponseHeader ( "Accept-Ranges" ) ) && header === "bytes" ;
var usesGzip = ( header = xhr . getResponseHeader ( "Content-Encoding" ) ) && header === "gzip" ;
var chunkSize = 1024 * 1024 ; // Chunk size in bytes
if ( ! hasByteServing ) chunkSize = datalength ;
// Function to get a range from the remote URL.
var doXHR = ( from , to ) => {
if ( from > to ) throw new Error ( "invalid range (" + from + ", " + to + ") or no bytes requested!" ) ;
if ( to > datalength - 1 ) throw new Error ( "only " + datalength + " bytes available! programmer error!" ) ;
// TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , url , false ) ;
if ( datalength !== chunkSize ) xhr . setRequestHeader ( "Range" , "bytes=" + from + "-" + to ) ;
// Some hints to the browser that we want binary data.
xhr . responseType = 'arraybuffer' ;
if ( xhr . overrideMimeType ) {
xhr . overrideMimeType ( 'text/plain; charset=x-user-defined' ) ;
}
xhr . send ( null ) ;
if ( ! ( xhr . status >= 200 && xhr . status < 300 || xhr . status === 304 ) ) throw new Error ( "Couldn't load " + url + ". Status: " + xhr . status ) ;
if ( xhr . response !== undefined ) {
return new Uint8Array ( /** @type{Array<number>} */ ( xhr . response || [ ] ) ) ;
} else {
return intArrayFromString ( xhr . responseText || '' , true ) ;
}
} ;
var lazyArray = this ;
lazyArray . setDataGetter ( ( chunkNum ) => {
var start = chunkNum * chunkSize ;
var end = ( chunkNum + 1 ) * chunkSize - 1 ; // including this byte
end = Math . min ( end , datalength - 1 ) ; // if datalength-1 is selected, this is the last block
if ( typeof lazyArray . chunks [ chunkNum ] == 'undefined' ) {
lazyArray . chunks [ chunkNum ] = doXHR ( start , end ) ;
}
if ( typeof lazyArray . chunks [ chunkNum ] == 'undefined' ) throw new Error ( 'doXHR failed!' ) ;
return lazyArray . chunks [ chunkNum ] ;
} ) ;
if ( usesGzip || ! datalength ) {
// if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length
chunkSize = datalength = 1 ; // this will force getter(0)/doXHR do download the whole file
datalength = this . getter ( 0 ) . length ;
chunkSize = datalength ;
out ( "LazyFiles on gzip forces download of the whole file when length is accessed" ) ;
}
this . _length = datalength ;
this . _chunkSize = chunkSize ;
this . lengthKnown = true ;
} ;
if ( typeof XMLHttpRequest != 'undefined' ) {
if ( ! ENVIRONMENT _IS _WORKER ) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc' ;
var lazyArray = new LazyUint8Array ( ) ;
Object . defineProperties ( lazyArray , {
length : {
get : /** @this{Object} */ function ( ) {
if ( ! this . lengthKnown ) {
this . cacheLength ( ) ;
}
return this . _length ;
}
} ,
chunkSize : {
get : /** @this{Object} */ function ( ) {
if ( ! this . lengthKnown ) {
this . cacheLength ( ) ;
}
return this . _chunkSize ;
}
}
} ) ;
var properties = { isDevice : false , contents : lazyArray } ;
} else {
var properties = { isDevice : false , url : url } ;
}
var node = FS . createFile ( parent , name , properties , canRead , canWrite ) ;
// This is a total hack, but I want to get this lazy file code out of the
// core of MEMFS. If we want to keep this lazy file concept I feel it should
// be its own thin LAZYFS proxying calls to MEMFS.
if ( properties . contents ) {
node . contents = properties . contents ;
} else if ( properties . url ) {
node . contents = null ;
node . url = properties . url ;
}
// Add a function that defers querying the file size until it is asked the first time.
Object . defineProperties ( node , {
usedBytes : {
get : /** @this {FSNode} */ function ( ) { return this . contents . length ; }
}
} ) ;
// override each stream op with one that tries to force load the lazy file first
var stream _ops = { } ;
var keys = Object . keys ( node . stream _ops ) ;
keys . forEach ( ( key ) => {
var fn = node . stream _ops [ key ] ;
stream _ops [ key ] = function forceLoadLazyFile ( ) {
FS . forceLoadFile ( node ) ;
return fn . apply ( null , arguments ) ;
} ;
} ) ;
// use a custom read function
stream _ops . read = ( stream , buffer , offset , length , position ) => {
FS . forceLoadFile ( node ) ;
var contents = stream . node . contents ;
if ( position >= contents . length )
return 0 ;
var size = Math . min ( contents . length - position , length ) ;
assert ( size >= 0 ) ;
if ( contents . slice ) { // normal array
for ( var i = 0 ; i < size ; i ++ ) {
buffer [ offset + i ] = contents [ position + i ] ;
}
} else {
for ( var i = 0 ; i < size ; i ++ ) { // LazyUint8Array from sync binary XHR
buffer [ offset + i ] = contents . get ( position + i ) ;
}
}
return size ;
} ;
node . stream _ops = stream _ops ;
return node ;
} , createPreloadedFile : ( parent , name , url , canRead , canWrite , onload , onerror , dontCreateFile , canOwn , preFinish ) => {
// TODO we should allow people to just pass in a complete filename instead
// of parent and name being that we just join them anyways
var fullname = name ? PATH _FS . resolve ( PATH . join2 ( parent , name ) ) : parent ;
var dep = getUniqueRunDependency ( 'cp ' + fullname ) ; // might have several active requests for the same fullname
function processData ( byteArray ) {
function finish ( byteArray ) {
if ( preFinish ) preFinish ( ) ;
if ( ! dontCreateFile ) {
FS . createDataFile ( parent , name , byteArray , canRead , canWrite , canOwn ) ;
}
if ( onload ) onload ( ) ;
removeRunDependency ( dep ) ;
}
if ( Browser . handledByPreloadPlugin ( byteArray , fullname , finish , ( ) => {
if ( onerror ) onerror ( ) ;
removeRunDependency ( dep ) ;
} ) ) {
return ;
}
finish ( byteArray ) ;
}
addRunDependency ( dep ) ;
if ( typeof url == 'string' ) {
asyncLoad ( url , ( byteArray ) => processData ( byteArray ) , onerror ) ;
} else {
processData ( url ) ;
}
} , indexedDB : ( ) => {
return window . indexedDB || window . mozIndexedDB || window . webkitIndexedDB || window . msIndexedDB ;
} , DB _NAME : ( ) => {
return 'EM_FS_' + window . location . pathname ;
} , DB _VERSION : 20 , DB _STORE _NAME : "FILE_DATA" , saveFilesToDB : ( paths , onload , onerror ) => {
onload = onload || ( ( ) => { } ) ;
onerror = onerror || ( ( ) => { } ) ;
var indexedDB = FS . indexedDB ( ) ;
try {
var openRequest = indexedDB . open ( FS . DB _NAME ( ) , FS . DB _VERSION ) ;
} catch ( e ) {
return onerror ( e ) ;
}
openRequest . onupgradeneeded = ( ) => {
out ( 'creating db' ) ;
var db = openRequest . result ;
db . createObjectStore ( FS . DB _STORE _NAME ) ;
} ;
openRequest . onsuccess = ( ) => {
var db = openRequest . result ;
var transaction = db . transaction ( [ FS . DB _STORE _NAME ] , 'readwrite' ) ;
var files = transaction . objectStore ( FS . DB _STORE _NAME ) ;
var ok = 0 , fail = 0 , total = paths . length ;
function finish ( ) {
if ( fail == 0 ) onload ( ) ; else onerror ( ) ;
}
paths . forEach ( ( path ) => {
var putRequest = files . put ( FS . analyzePath ( path ) . object . contents , path ) ;
putRequest . onsuccess = ( ) => { ok ++ ; if ( ok + fail == total ) finish ( ) } ;
putRequest . onerror = ( ) => { fail ++ ; if ( ok + fail == total ) finish ( ) } ;
} ) ;
transaction . onerror = onerror ;
} ;
openRequest . onerror = onerror ;
} , loadFilesFromDB : ( paths , onload , onerror ) => {
onload = onload || ( ( ) => { } ) ;
onerror = onerror || ( ( ) => { } ) ;
var indexedDB = FS . indexedDB ( ) ;
try {
var openRequest = indexedDB . open ( FS . DB _NAME ( ) , FS . DB _VERSION ) ;
} catch ( e ) {
return onerror ( e ) ;
}
openRequest . onupgradeneeded = onerror ; // no database to load from
openRequest . onsuccess = ( ) => {
var db = openRequest . result ;
try {
var transaction = db . transaction ( [ FS . DB _STORE _NAME ] , 'readonly' ) ;
} catch ( e ) {
onerror ( e ) ;
return ;
}
var files = transaction . objectStore ( FS . DB _STORE _NAME ) ;
var ok = 0 , fail = 0 , total = paths . length ;
function finish ( ) {
if ( fail == 0 ) onload ( ) ; else onerror ( ) ;
}
paths . forEach ( ( path ) => {
var getRequest = files . get ( path ) ;
getRequest . onsuccess = ( ) => {
if ( FS . analyzePath ( path ) . exists ) {
FS . unlink ( path ) ;
}
FS . createDataFile ( PATH . dirname ( path ) , PATH . basename ( path ) , getRequest . result , true , true , true ) ;
ok ++ ;
if ( ok + fail == total ) finish ( ) ;
} ;
getRequest . onerror = ( ) => { fail ++ ; if ( ok + fail == total ) finish ( ) } ;
} ) ;
transaction . onerror = onerror ;
} ;
openRequest . onerror = onerror ;
} , absolutePath : ( ) => {
abort ( 'FS.absolutePath has been removed; use PATH_FS.resolve instead' ) ;
} , createFolder : ( ) => {
abort ( 'FS.createFolder has been removed; use FS.mkdir instead' ) ;
} , createLink : ( ) => {
abort ( 'FS.createLink has been removed; use FS.symlink instead' ) ;
} , joinPath : ( ) => {
abort ( 'FS.joinPath has been removed; use PATH.join instead' ) ;
} , mmapAlloc : ( ) => {
abort ( 'FS.mmapAlloc has been replaced by the top level function mmapAlloc' ) ;
} , standardizePath : ( ) => {
abort ( 'FS.standardizePath has been removed; use PATH.normalize instead' ) ;
} } ;
var SYSCALLS = { DEFAULT _POLLMASK : 5 , calculateAt : function ( dirfd , path , allowEmpty ) {
if ( path [ 0 ] === '/' ) {
return path ;
}
// relative path
var dir ;
if ( dirfd === - 100 ) {
dir = FS . cwd ( ) ;
} else {
var dirstream = FS . getStream ( dirfd ) ;
if ( ! dirstream ) throw new FS . ErrnoError ( 8 ) ;
dir = dirstream . path ;
}
if ( path . length == 0 ) {
if ( ! allowEmpty ) {
throw new FS . ErrnoError ( 44 ) ; ;
}
return dir ;
}
return PATH . join2 ( dir , path ) ;
} , doStat : function ( func , path , buf ) {
try {
var stat = func ( path ) ;
} catch ( e ) {
if ( e && e . node && PATH . normalize ( path ) !== PATH . normalize ( FS . getPath ( e . node ) ) ) {
// an error occurred while trying to look up the path; we should just report ENOTDIR
return - 54 ;
}
throw e ;
}
HEAP32 [ ( ( buf ) >> 2 ) ] = stat . dev ;
HEAP32 [ ( ( ( buf ) + ( 4 ) ) >> 2 ) ] = 0 ;
HEAP32 [ ( ( ( buf ) + ( 8 ) ) >> 2 ) ] = stat . ino ;
HEAP32 [ ( ( ( buf ) + ( 12 ) ) >> 2 ) ] = stat . mode ;
HEAP32 [ ( ( ( buf ) + ( 16 ) ) >> 2 ) ] = stat . nlink ;
HEAP32 [ ( ( ( buf ) + ( 20 ) ) >> 2 ) ] = stat . uid ;
HEAP32 [ ( ( ( buf ) + ( 24 ) ) >> 2 ) ] = stat . gid ;
HEAP32 [ ( ( ( buf ) + ( 28 ) ) >> 2 ) ] = stat . rdev ;
HEAP32 [ ( ( ( buf ) + ( 32 ) ) >> 2 ) ] = 0 ;
( tempI64 = [ stat . size >>> 0 , ( tempDouble = stat . size , ( + ( Math . abs ( tempDouble ) ) ) >= 1.0 ? ( tempDouble > 0.0 ? ( ( Math . min ( ( + ( Math . floor ( ( tempDouble ) / 4294967296.0 ) ) ) , 4294967295.0 ) ) | 0 ) >>> 0 : ( ~ ~ ( ( + ( Math . ceil ( ( tempDouble - + ( ( ( ~ ~ ( tempDouble ) ) ) >>> 0 ) ) / 4294967296.0 ) ) ) ) ) >>> 0 ) : 0 ) ] , HEAP32 [ ( ( ( buf ) + ( 40 ) ) >> 2 ) ] = tempI64 [ 0 ] , HEAP32 [ ( ( ( buf ) + ( 44 ) ) >> 2 ) ] = tempI64 [ 1 ] ) ;
HEAP32 [ ( ( ( buf ) + ( 48 ) ) >> 2 ) ] = 4096 ;
HEAP32 [ ( ( ( buf ) + ( 52 ) ) >> 2 ) ] = stat . blocks ;
HEAP32 [ ( ( ( buf ) + ( 56 ) ) >> 2 ) ] = ( stat . atime . getTime ( ) / 1000 ) | 0 ;
HEAP32 [ ( ( ( buf ) + ( 60 ) ) >> 2 ) ] = 0 ;
HEAP32 [ ( ( ( buf ) + ( 64 ) ) >> 2 ) ] = ( stat . mtime . getTime ( ) / 1000 ) | 0 ;
HEAP32 [ ( ( ( buf ) + ( 68 ) ) >> 2 ) ] = 0 ;
HEAP32 [ ( ( ( buf ) + ( 72 ) ) >> 2 ) ] = ( stat . ctime . getTime ( ) / 1000 ) | 0 ;
HEAP32 [ ( ( ( buf ) + ( 76 ) ) >> 2 ) ] = 0 ;
( tempI64 = [ stat . ino >>> 0 , ( tempDouble = stat . ino , ( + ( Math . abs ( tempDouble ) ) ) >= 1.0 ? ( tempDouble > 0.0 ? ( ( Math . min ( ( + ( Math . floor ( ( tempDouble ) / 4294967296.0 ) ) ) , 4294967295.0 ) ) | 0 ) >>> 0 : ( ~ ~ ( ( + ( Math . ceil ( ( tempDouble - + ( ( ( ~ ~ ( tempDouble ) ) ) >>> 0 ) ) / 4294967296.0 ) ) ) ) ) >>> 0 ) : 0 ) ] , HEAP32 [ ( ( ( buf ) + ( 80 ) ) >> 2 ) ] = tempI64 [ 0 ] , HEAP32 [ ( ( ( buf ) + ( 84 ) ) >> 2 ) ] = tempI64 [ 1 ] ) ;
return 0 ;
} , doMsync : function ( addr , stream , len , flags , offset ) {
var buffer = HEAPU8 . slice ( addr , addr + len ) ;
FS . msync ( stream , buffer , offset , len , flags ) ;
} , doMkdir : function ( path , mode ) {
// remove a trailing slash, if one - /a/b/ has basename of '', but
// we want to create b in the context of this function
path = PATH . normalize ( path ) ;
if ( path [ path . length - 1 ] === '/' ) path = path . substr ( 0 , path . length - 1 ) ;
FS . mkdir ( path , mode , 0 ) ;
return 0 ;
} , doMknod : function ( path , mode , dev ) {
// we don't want this in the JS API as it uses mknod to create all nodes.
switch ( mode & 61440 ) {
case 32768 :
case 8192 :
case 24576 :
case 4096 :
case 49152 :
break ;
default : return - 28 ;
}
FS . mknod ( path , mode , dev ) ;
return 0 ;
} , doReadlink : function ( path , buf , bufsize ) {
if ( bufsize <= 0 ) return - 28 ;
var ret = FS . readlink ( path ) ;
var len = Math . min ( bufsize , lengthBytesUTF8 ( ret ) ) ;
var endChar = HEAP8 [ buf + len ] ;
stringToUTF8 ( ret , buf , bufsize + 1 ) ;
// readlink is one of the rare functions that write out a C string, but does never append a null to the output buffer(!)
// stringToUTF8() always appends a null byte, so restore the character under the null byte after the write.
HEAP8 [ buf + len ] = endChar ;
return len ;
} , doAccess : function ( path , amode ) {
if ( amode & ~ 7 ) {
// need a valid mode
return - 28 ;
}
var lookup = FS . lookupPath ( path , { follow : true } ) ;
var node = lookup . node ;
if ( ! node ) {
return - 44 ;
}
var perms = '' ;
if ( amode & 4 ) perms += 'r' ;
if ( amode & 2 ) perms += 'w' ;
if ( amode & 1 ) perms += 'x' ;
if ( perms /* otherwise, they've just passed F_OK */ && FS . nodePermissions ( node , perms ) ) {
return - 2 ;
}
return 0 ;
} , doDup : function ( path , flags , suggestFD ) {
var suggest = FS . getStream ( suggestFD ) ;
if ( suggest ) FS . close ( suggest ) ;
return FS . open ( path , flags , 0 , suggestFD , suggestFD ) . fd ;
} , doReadv : function ( stream , iov , iovcnt , offset ) {
var ret = 0 ;
for ( var i = 0 ; i < iovcnt ; i ++ ) {
var ptr = HEAP32 [ ( ( ( iov ) + ( i * 8 ) ) >> 2 ) ] ;
var len = HEAP32 [ ( ( ( iov ) + ( i * 8 + 4 ) ) >> 2 ) ] ;
var curr = FS . read ( stream , HEAP8 , ptr , len , offset ) ;
if ( curr < 0 ) return - 1 ;
ret += curr ;
if ( curr < len ) break ; // nothing more to read
}
return ret ;
} , doWritev : function ( stream , iov , iovcnt , offset ) {
var ret = 0 ;
for ( var i = 0 ; i < iovcnt ; i ++ ) {
var ptr = HEAP32 [ ( ( ( iov ) + ( i * 8 ) ) >> 2 ) ] ;
var len = HEAP32 [ ( ( ( iov ) + ( i * 8 + 4 ) ) >> 2 ) ] ;
var curr = FS . write ( stream , HEAP8 , ptr , len , offset ) ;
if ( curr < 0 ) return - 1 ;
ret += curr ;
}
return ret ;
} , varargs : undefined , get : function ( ) {
assert ( SYSCALLS . varargs != undefined ) ;
SYSCALLS . varargs += 4 ;
var ret = HEAP32 [ ( ( ( SYSCALLS . varargs ) - ( 4 ) ) >> 2 ) ] ;
return ret ;
} , getStr : function ( ptr ) {
var ret = UTF8ToString ( ptr ) ;
return ret ;
} , getStreamFromFD : function ( fd ) {
var stream = FS . getStream ( fd ) ;
if ( ! stream ) throw new FS . ErrnoError ( 8 ) ;
return stream ;
} , get64 : function ( low , high ) {
if ( low >= 0 ) assert ( high === 0 ) ;
else assert ( high === - 1 ) ;
return low ;
} } ;
function _ _ _syscall _fcntl64 ( fd , cmd , varargs ) {
SYSCALLS . varargs = varargs ;
try {
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
switch ( cmd ) {
case 0 : {
var arg = SYSCALLS . get ( ) ;
if ( arg < 0 ) {
return - 28 ;
}
var newStream ;
newStream = FS . 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 5 :
/* case 5: Currently in musl F_GETLK64 has same value as F_GETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */ {
var arg = SYSCALLS . get ( ) ;
var offset = 0 ;
// We're always unlocked.
HEAP16 [ ( ( ( arg ) + ( offset ) ) >> 1 ) ] = 2 ;
return 0 ;
}
case 6 :
case 7 :
/* case 6: Currently in musl F_SETLK64 has same value as F_SETLK, so omitted to avoid duplicate case blocks. If that changes, uncomment this */
/* case 7: Currently in musl F_SETLKW64 has same value as F_SETLKW, so omitted to avoid duplicate case blocks. If that changes, uncomment this */
return 0 ; // Pretend that the locking is successful.
case 16 :
case 8 :
return - 28 ; // These are for sockets. We don't have them fully implemented yet.
case 9 :
// musl trusts getown return values, due to a bug where they must be, as they overlap with errors. just return -1 here, so fnctl() returns that, and we set errno ourselves.
setErrNo ( 28 ) ;
return - 1 ;
default : {
return - 28 ;
}
}
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _fstat64 ( fd , buf ) {
try {
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
return SYSCALLS . doStat ( FS . stat , stream . path , buf ) ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _fstatat64 ( dirfd , path , buf , flags ) {
try {
path = SYSCALLS . getStr ( path ) ;
var nofollow = flags & 256 ;
var allowEmpty = flags & 4096 ;
flags = flags & ( ~ 4352 ) ;
assert ( ! flags , flags ) ;
path = SYSCALLS . calculateAt ( dirfd , path , allowEmpty ) ;
return SYSCALLS . doStat ( nofollow ? FS . lstat : FS . stat , path , buf ) ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _ioctl ( fd , op , varargs ) {
SYSCALLS . varargs = varargs ;
try {
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
switch ( op ) {
case 21509 :
case 21505 : {
if ( ! stream . tty ) return - 59 ;
return 0 ;
}
case 21510 :
case 21511 :
case 21512 :
case 21506 :
case 21507 :
case 21508 : {
if ( ! stream . tty ) return - 59 ;
return 0 ; // no-op, not actually adjusting terminal settings
}
case 21519 : {
if ( ! stream . tty ) return - 59 ;
var argp = SYSCALLS . get ( ) ;
HEAP32 [ ( ( argp ) >> 2 ) ] = 0 ;
return 0 ;
}
case 21520 : {
if ( ! stream . tty ) return - 59 ;
return - 28 ; // 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 - 59 ;
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 - 59 ;
return 0 ;
}
default : abort ( 'bad ioctl syscall ' + op ) ;
}
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _lstat64 ( path , buf ) {
try {
path = SYSCALLS . getStr ( path ) ;
return SYSCALLS . doStat ( FS . lstat , path , buf ) ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _mkdir ( path , mode ) {
try {
path = SYSCALLS . getStr ( path ) ;
return SYSCALLS . doMkdir ( path , mode ) ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _open ( path , flags , varargs ) {
SYSCALLS . varargs = varargs ;
try {
var pathname = SYSCALLS . getStr ( path ) ;
var mode = varargs ? SYSCALLS . get ( ) : 0 ;
var stream = FS . open ( pathname , flags , mode ) ;
return stream . fd ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _ _syscall _stat64 ( path , buf ) {
try {
path = SYSCALLS . getStr ( path ) ;
return SYSCALLS . doStat ( FS . stat , path , buf ) ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return - e . errno ;
}
}
function _ _localtime _js ( time , tmPtr ) {
var date = new Date ( HEAP32 [ ( ( time ) >> 2 ) ] * 1000 ) ;
HEAP32 [ ( ( tmPtr ) >> 2 ) ] = date . getSeconds ( ) ;
HEAP32 [ ( ( ( tmPtr ) + ( 4 ) ) >> 2 ) ] = date . getMinutes ( ) ;
HEAP32 [ ( ( ( tmPtr ) + ( 8 ) ) >> 2 ) ] = date . getHours ( ) ;
HEAP32 [ ( ( ( tmPtr ) + ( 12 ) ) >> 2 ) ] = date . getDate ( ) ;
HEAP32 [ ( ( ( tmPtr ) + ( 16 ) ) >> 2 ) ] = date . getMonth ( ) ;
HEAP32 [ ( ( ( tmPtr ) + ( 20 ) ) >> 2 ) ] = date . getFullYear ( ) - 1900 ;
HEAP32 [ ( ( ( tmPtr ) + ( 24 ) ) >> 2 ) ] = date . getDay ( ) ;
var start = new Date ( date . getFullYear ( ) , 0 , 1 ) ;
var yday = ( ( date . getTime ( ) - start . getTime ( ) ) / ( 1000 * 60 * 60 * 24 ) ) | 0 ;
HEAP32 [ ( ( ( tmPtr ) + ( 28 ) ) >> 2 ) ] = yday ;
HEAP32 [ ( ( ( tmPtr ) + ( 36 ) ) >> 2 ) ] = - ( date . getTimezoneOffset ( ) * 60 ) ;
// Attention: DST is in December in South, and some regions don't have DST at all.
var summerOffset = new Date ( date . getFullYear ( ) , 6 , 1 ) . getTimezoneOffset ( ) ;
var winterOffset = start . getTimezoneOffset ( ) ;
var dst = ( summerOffset != winterOffset && date . getTimezoneOffset ( ) == Math . min ( winterOffset , summerOffset ) ) | 0 ;
HEAP32 [ ( ( ( tmPtr ) + ( 32 ) ) >> 2 ) ] = dst ;
}
function _tzset _impl ( timezone , daylight , tzname ) {
var currentYear = new Date ( ) . getFullYear ( ) ;
var winter = new Date ( currentYear , 0 , 1 ) ;
var summer = new Date ( currentYear , 6 , 1 ) ;
var winterOffset = winter . getTimezoneOffset ( ) ;
var summerOffset = summer . getTimezoneOffset ( ) ;
// Local standard timezone offset. Local standard time is not adjusted for daylight savings.
// This code uses the fact that getTimezoneOffset returns a greater value during Standard Time versus Daylight Saving Time (DST).
// Thus it determines the expected output during Standard Time, and it compares whether the output of the given date the same (Standard) or less (DST).
var stdTimezoneOffset = Math . max ( winterOffset , summerOffset ) ;
// timezone is specified as seconds west of UTC ("The external variable
// `timezone` shall be set to the difference, in seconds, between
// Coordinated Universal Time (UTC) and local standard time."), the same
// as returned by stdTimezoneOffset.
// See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
HEAP32 [ ( ( timezone ) >> 2 ) ] = stdTimezoneOffset * 60 ;
HEAP32 [ ( ( daylight ) >> 2 ) ] = Number ( winterOffset != summerOffset ) ;
function extractZone ( date ) {
var match = date . toTimeString ( ) . match ( /\(([A-Za-z ]+)\)$/ ) ;
return match ? match [ 1 ] : "GMT" ;
} ;
var winterName = extractZone ( winter ) ;
var summerName = extractZone ( summer ) ;
var winterNamePtr = allocateUTF8 ( winterName ) ;
var summerNamePtr = allocateUTF8 ( summerName ) ;
if ( summerOffset < winterOffset ) {
// Northern hemisphere
HEAP32 [ ( ( tzname ) >> 2 ) ] = winterNamePtr ;
HEAP32 [ ( ( ( tzname ) + ( 4 ) ) >> 2 ) ] = summerNamePtr ;
} else {
HEAP32 [ ( ( tzname ) >> 2 ) ] = summerNamePtr ;
HEAP32 [ ( ( ( tzname ) + ( 4 ) ) >> 2 ) ] = winterNamePtr ;
}
}
function _ _tzset _js ( timezone , daylight , tzname ) {
// TODO: Use (malleable) environment variables instead of system settings.
if ( _ _tzset _js . called ) return ;
_ _tzset _js . called = true ;
_tzset _impl ( timezone , daylight , tzname ) ;
}
function _abort ( ) {
abort ( 'native code called abort()' ) ;
}
function _emscripten _memcpy _big ( dest , src , num ) {
HEAPU8 . copyWithin ( dest , src , src + num ) ;
}
function _emscripten _get _heap _max ( ) {
return HEAPU8 . length ;
}
function abortOnCannotGrowMemory ( requestedSize ) {
abort ( 'Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with -s INITIAL_MEMORY=X with X higher than the current value ' + HEAP8 . length + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ' ) ;
}
function _emscripten _resize _heap ( requestedSize ) {
var oldSize = HEAPU8 . length ;
requestedSize = requestedSize >>> 0 ;
abortOnCannotGrowMemory ( requestedSize ) ;
}
/** @param {boolean=} synchronous */
function callUserCallback ( func , synchronous ) {
if ( runtimeExited || ABORT ) {
err ( 'user callback triggered after runtime exited or application aborted. Ignoring.' ) ;
return ;
}
// For synchronous calls, let any exceptions propagate, and don't let the runtime exit.
if ( synchronous ) {
func ( ) ;
return ;
}
try {
func ( ) ;
} catch ( e ) {
handleException ( e ) ;
}
}
function runtimeKeepalivePush ( ) {
runtimeKeepaliveCounter += 1 ;
}
function runtimeKeepalivePop ( ) {
assert ( runtimeKeepaliveCounter > 0 ) ;
runtimeKeepaliveCounter -= 1 ;
}
/** @param {number=} timeout */
function safeSetTimeout ( func , timeout ) {
return setTimeout ( function ( ) {
callUserCallback ( func ) ;
} , timeout ) ;
}
var Browser = { mainLoop : { running : false , scheduler : null , method : "" , currentlyRunningMainloop : 0 , func : null , arg : 0 , timingMode : 0 , timingValue : 0 , currentFrameNumber : 0 , queue : [ ] , pause : function ( ) {
Browser . mainLoop . scheduler = null ;
// Incrementing this signals the previous main loop that it's now become old, and it must return.
Browser . mainLoop . currentlyRunningMainloop ++ ;
} , resume : function ( ) {
Browser . mainLoop . currentlyRunningMainloop ++ ;
var timingMode = Browser . mainLoop . timingMode ;
var timingValue = Browser . mainLoop . timingValue ;
var func = Browser . mainLoop . func ;
Browser . mainLoop . func = null ;
// do not set timing and call scheduler, we will do it on the next lines
setMainLoop ( func , 0 , false , Browser . mainLoop . arg , true ) ;
_emscripten _set _main _loop _timing ( timingMode , timingValue ) ;
Browser . mainLoop . scheduler ( ) ;
} , updateStatus : function ( ) {
if ( Module [ 'setStatus' ] ) {
var message = Module [ 'statusMessage' ] || 'Please wait...' ;
var remaining = Browser . mainLoop . remainingBlockers ;
var expected = Browser . mainLoop . expectedBlockers ;
if ( remaining ) {
if ( remaining < expected ) {
Module [ 'setStatus' ] ( message + ' (' + ( expected - remaining ) + '/' + expected + ')' ) ;
} else {
Module [ 'setStatus' ] ( message ) ;
}
} else {
Module [ 'setStatus' ] ( '' ) ;
}
}
} , runIter : function ( func ) {
if ( ABORT ) return ;
if ( Module [ 'preMainLoop' ] ) {
var preRet = Module [ 'preMainLoop' ] ( ) ;
if ( preRet === false ) {
return ; // |return false| skips a frame
}
}
callUserCallback ( func ) ;
if ( Module [ 'postMainLoop' ] ) Module [ 'postMainLoop' ] ( ) ;
} } , isFullscreen : false , pointerLock : false , moduleContextCreatedCallbacks : [ ] , workers : [ ] , init : function ( ) {
if ( ! Module [ "preloadPlugins" ] ) Module [ "preloadPlugins" ] = [ ] ; // needs to exist even in workers
if ( Browser . initted ) return ;
Browser . initted = true ;
try {
new Blob ( ) ;
Browser . hasBlobConstructor = true ;
} catch ( e ) {
Browser . hasBlobConstructor = false ;
out ( "warning: no blob constructor, cannot create blobs with mimetypes" ) ;
}
Browser . BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : ( typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : ( ! Browser . hasBlobConstructor ? out ( "warning: no BlobBuilder" ) : null ) ) ;
Browser . URLObject = typeof window != "undefined" ? ( window . URL ? window . URL : window . webkitURL ) : undefined ;
if ( ! Module . noImageDecoding && typeof Browser . URLObject == 'undefined' ) {
out ( "warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available." ) ;
Module . noImageDecoding = true ;
}
// Support for plugins that can process preloaded files. You can add more of these to
// your app by creating and appending to Module.preloadPlugins.
//
// Each plugin is asked if it can handle a file based on the file's name. If it can,
// it is given the file's raw data. When it is done, it calls a callback with the file's
// (possibly modified) data. For example, a plugin might decompress a file, or it
// might create some side data structure for use later (like an Image element, etc.).
var imagePlugin = { } ;
imagePlugin [ 'canHandle' ] = function imagePlugin _canHandle ( name ) {
return ! Module . noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i . test ( name ) ;
} ;
imagePlugin [ 'handle' ] = function imagePlugin _handle ( byteArray , name , onload , onerror ) {
var b = null ;
if ( Browser . hasBlobConstructor ) {
try {
b = new Blob ( [ byteArray ] , { type : Browser . getMimetype ( name ) } ) ;
if ( b . size !== byteArray . length ) { // Safari bug #118630
// Safari's Blob can only take an ArrayBuffer
b = new Blob ( [ ( new Uint8Array ( byteArray ) ) . buffer ] , { type : Browser . getMimetype ( name ) } ) ;
}
} catch ( e ) {
warnOnce ( 'Blob constructor present but fails: ' + e + '; falling back to blob builder' ) ;
}
}
if ( ! b ) {
var bb = new Browser . BlobBuilder ( ) ;
bb . append ( ( new Uint8Array ( byteArray ) ) . buffer ) ; // we need to pass a buffer, and must copy the array to get the right data range
b = bb . getBlob ( ) ;
}
var url = Browser . URLObject . createObjectURL ( b ) ;
assert ( typeof url == 'string' , 'createObjectURL must return a url as a string' ) ;
var img = new Image ( ) ;
img . onload = ( ) => {
assert ( img . complete , 'Image ' + name + ' could not be decoded' ) ;
var canvas = /** @type {!HTMLCanvasElement} */ ( document . createElement ( 'canvas' ) ) ;
canvas . width = img . width ;
canvas . height = img . height ;
var ctx = canvas . getContext ( '2d' ) ;
ctx . drawImage ( img , 0 , 0 ) ;
Module [ "preloadedImages" ] [ name ] = canvas ;
Browser . URLObject . revokeObjectURL ( url ) ;
if ( onload ) onload ( byteArray ) ;
} ;
img . onerror = ( event ) => {
out ( 'Image ' + url + ' could not be decoded' ) ;
if ( onerror ) onerror ( ) ;
} ;
img . src = url ;
} ;
Module [ 'preloadPlugins' ] . push ( imagePlugin ) ;
var audioPlugin = { } ;
audioPlugin [ 'canHandle' ] = function audioPlugin _canHandle ( name ) {
return ! Module . noAudioDecoding && name . substr ( - 4 ) in { '.ogg' : 1 , '.wav' : 1 , '.mp3' : 1 } ;
} ;
audioPlugin [ 'handle' ] = function audioPlugin _handle ( byteArray , name , onload , onerror ) {
var done = false ;
function finish ( audio ) {
if ( done ) return ;
done = true ;
Module [ "preloadedAudios" ] [ name ] = audio ;
if ( onload ) onload ( byteArray ) ;
}
function fail ( ) {
if ( done ) return ;
done = true ;
Module [ "preloadedAudios" ] [ name ] = new Audio ( ) ; // empty shim
if ( onerror ) onerror ( ) ;
}
if ( Browser . hasBlobConstructor ) {
try {
var b = new Blob ( [ byteArray ] , { type : Browser . getMimetype ( name ) } ) ;
} catch ( e ) {
return fail ( ) ;
}
var url = Browser . URLObject . createObjectURL ( b ) ; // XXX we never revoke this!
assert ( typeof url == 'string' , 'createObjectURL must return a url as a string' ) ;
var audio = new Audio ( ) ;
audio . addEventListener ( 'canplaythrough' , function ( ) { finish ( audio ) } , false ) ; // use addEventListener due to chromium bug 124926
audio . onerror = function audio _onerror ( event ) {
if ( done ) return ;
out ( 'warning: browser could not fully decode audio ' + name + ', trying slower base64 approach' ) ;
function encode64 ( data ) {
var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' ;
var PAD = '=' ;
var ret = '' ;
var leftchar = 0 ;
var leftbits = 0 ;
for ( var i = 0 ; i < data . length ; i ++ ) {
leftchar = ( leftchar << 8 ) | data [ i ] ;
leftbits += 8 ;
while ( leftbits >= 6 ) {
var curr = ( leftchar >> ( leftbits - 6 ) ) & 0x3f ;
leftbits -= 6 ;
ret += BASE [ curr ] ;
}
}
if ( leftbits == 2 ) {
ret += BASE [ ( leftchar & 3 ) << 4 ] ;
ret += PAD + PAD ;
} else if ( leftbits == 4 ) {
ret += BASE [ ( leftchar & 0xf ) << 2 ] ;
ret += PAD ;
}
return ret ;
}
audio . src = 'data:audio/x-' + name . substr ( - 3 ) + ';base64,' + encode64 ( byteArray ) ;
finish ( audio ) ; // we don't wait for confirmation this worked - but it's worth trying
} ;
audio . src = url ;
// workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
safeSetTimeout ( function ( ) {
finish ( audio ) ; // try to use it even though it is not necessarily ready to play
} , 10000 ) ;
} else {
return fail ( ) ;
}
} ;
Module [ 'preloadPlugins' ] . push ( audioPlugin ) ;
// Canvas event setup
function pointerLockChange ( ) {
Browser . pointerLock = document [ 'pointerLockElement' ] === Module [ 'canvas' ] ||
document [ 'mozPointerLockElement' ] === Module [ 'canvas' ] ||
document [ 'webkitPointerLockElement' ] === Module [ 'canvas' ] ||
document [ 'msPointerLockElement' ] === Module [ 'canvas' ] ;
}
var canvas = Module [ 'canvas' ] ;
if ( canvas ) {
// forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
// Module['forcedAspectRatio'] = 4 / 3;
canvas . requestPointerLock = canvas [ 'requestPointerLock' ] ||
canvas [ 'mozRequestPointerLock' ] ||
canvas [ 'webkitRequestPointerLock' ] ||
canvas [ 'msRequestPointerLock' ] ||
function ( ) { } ;
canvas . exitPointerLock = document [ 'exitPointerLock' ] ||
document [ 'mozExitPointerLock' ] ||
document [ 'webkitExitPointerLock' ] ||
document [ 'msExitPointerLock' ] ||
function ( ) { } ; // no-op if function does not exist
canvas . exitPointerLock = canvas . exitPointerLock . bind ( document ) ;
document . addEventListener ( 'pointerlockchange' , pointerLockChange , false ) ;
document . addEventListener ( 'mozpointerlockchange' , pointerLockChange , false ) ;
document . addEventListener ( 'webkitpointerlockchange' , pointerLockChange , false ) ;
document . addEventListener ( 'mspointerlockchange' , pointerLockChange , false ) ;
if ( Module [ 'elementPointerLock' ] ) {
canvas . addEventListener ( "click" , function ( ev ) {
if ( ! Browser . pointerLock && Module [ 'canvas' ] . requestPointerLock ) {
Module [ 'canvas' ] . requestPointerLock ( ) ;
ev . preventDefault ( ) ;
}
} , false ) ;
}
}
} , handledByPreloadPlugin : function ( byteArray , fullname , finish , onerror ) {
// Ensure plugins are ready.
Browser . init ( ) ;
var handled = false ;
Module [ 'preloadPlugins' ] . forEach ( function ( plugin ) {
if ( handled ) return ;
if ( plugin [ 'canHandle' ] ( fullname ) ) {
plugin [ 'handle' ] ( byteArray , fullname , finish , onerror ) ;
handled = true ;
}
} ) ;
return handled ;
} , createContext : function ( /** @type {HTMLCanvasElement} */ canvas , useWebGL , setInModule , webGLContextAttributes ) {
if ( useWebGL && Module . ctx && canvas == Module . canvas ) return Module . ctx ; // no need to recreate GL context if it's already been created for this canvas.
var ctx ;
var contextHandle ;
if ( useWebGL ) {
// For GLES2/desktop GL compatibility, adjust a few defaults to be different to WebGL defaults, so that they align better with the desktop defaults.
var contextAttributes = {
antialias : false ,
alpha : false ,
majorVersion : ( typeof WebGL2RenderingContext != 'undefined' ) ? 2 : 1 ,
} ;
if ( webGLContextAttributes ) {
for ( var attribute in webGLContextAttributes ) {
contextAttributes [ attribute ] = webGLContextAttributes [ attribute ] ;
}
}
// This check of existence of GL is here to satisfy Closure compiler, which yells if variable GL is referenced below but GL object is not
// actually compiled in because application is not doing any GL operations. TODO: Ideally if GL is not being used, this function
// Browser.createContext() should not even be emitted.
if ( typeof GL != 'undefined' ) {
contextHandle = GL . createContext ( canvas , contextAttributes ) ;
if ( contextHandle ) {
ctx = GL . getContext ( contextHandle ) . GLctx ;
}
}
} else {
ctx = canvas . getContext ( '2d' ) ;
}
if ( ! ctx ) return null ;
if ( setInModule ) {
if ( ! useWebGL ) assert ( typeof GLctx == 'undefined' , 'cannot set in module if GLctx is used, but we are a non-GL context that would replace it' ) ;
Module . ctx = ctx ;
if ( useWebGL ) GL . makeContextCurrent ( contextHandle ) ;
Module . useWebGL = useWebGL ;
Browser . moduleContextCreatedCallbacks . forEach ( function ( callback ) { callback ( ) } ) ;
Browser . init ( ) ;
}
return ctx ;
} , destroyContext : function ( canvas , useWebGL , setInModule ) { } , fullscreenHandlersInstalled : false , lockPointer : undefined , resizeCanvas : undefined , requestFullscreen : function ( lockPointer , resizeCanvas ) {
Browser . lockPointer = lockPointer ;
Browser . resizeCanvas = resizeCanvas ;
if ( typeof Browser . lockPointer == 'undefined' ) Browser . lockPointer = true ;
if ( typeof Browser . resizeCanvas == 'undefined' ) Browser . resizeCanvas = false ;
var canvas = Module [ 'canvas' ] ;
function fullscreenChange ( ) {
Browser . isFullscreen = false ;
var canvasContainer = canvas . parentNode ;
if ( ( document [ 'fullscreenElement' ] || document [ 'mozFullScreenElement' ] ||
document [ 'msFullscreenElement' ] || document [ 'webkitFullscreenElement' ] ||
document [ 'webkitCurrentFullScreenElement' ] ) === canvasContainer ) {
canvas . exitFullscreen = Browser . exitFullscreen ;
if ( Browser . lockPointer ) canvas . requestPointerLock ( ) ;
Browser . isFullscreen = true ;
if ( Browser . resizeCanvas ) {
Browser . setFullscreenCanvasSize ( ) ;
} else {
Browser . updateCanvasDimensions ( canvas ) ;
}
} else {
// remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
canvasContainer . parentNode . insertBefore ( canvas , canvasContainer ) ;
canvasContainer . parentNode . removeChild ( canvasContainer ) ;
if ( Browser . resizeCanvas ) {
Browser . setWindowedCanvasSize ( ) ;
} else {
Browser . updateCanvasDimensions ( canvas ) ;
}
}
if ( Module [ 'onFullScreen' ] ) Module [ 'onFullScreen' ] ( Browser . isFullscreen ) ;
if ( Module [ 'onFullscreen' ] ) Module [ 'onFullscreen' ] ( Browser . isFullscreen ) ;
}
if ( ! Browser . fullscreenHandlersInstalled ) {
Browser . fullscreenHandlersInstalled = true ;
document . addEventListener ( 'fullscreenchange' , fullscreenChange , false ) ;
document . addEventListener ( 'mozfullscreenchange' , fullscreenChange , false ) ;
document . addEventListener ( 'webkitfullscreenchange' , fullscreenChange , false ) ;
document . addEventListener ( 'MSFullscreenChange' , fullscreenChange , false ) ;
}
// create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
var canvasContainer = document . createElement ( "div" ) ;
canvas . parentNode . insertBefore ( canvasContainer , canvas ) ;
canvasContainer . appendChild ( canvas ) ;
// use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
canvasContainer . requestFullscreen = canvasContainer [ 'requestFullscreen' ] ||
canvasContainer [ 'mozRequestFullScreen' ] ||
canvasContainer [ 'msRequestFullscreen' ] ||
( canvasContainer [ 'webkitRequestFullscreen' ] ? function ( ) { canvasContainer [ 'webkitRequestFullscreen' ] ( Element [ 'ALLOW_KEYBOARD_INPUT' ] ) } : null ) ||
( canvasContainer [ 'webkitRequestFullScreen' ] ? function ( ) { canvasContainer [ 'webkitRequestFullScreen' ] ( Element [ 'ALLOW_KEYBOARD_INPUT' ] ) } : null ) ;
canvasContainer . requestFullscreen ( ) ;
} , requestFullScreen : function ( ) {
abort ( 'Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)' ) ;
} , exitFullscreen : function ( ) {
// This is workaround for chrome. Trying to exit from fullscreen
// not in fullscreen state will cause "TypeError: Document not active"
// in chrome. See https://github.com/emscripten-core/emscripten/pull/8236
if ( ! Browser . isFullscreen ) {
return false ;
}
var CFS = document [ 'exitFullscreen' ] ||
document [ 'cancelFullScreen' ] ||
document [ 'mozCancelFullScreen' ] ||
document [ 'msExitFullscreen' ] ||
document [ 'webkitCancelFullScreen' ] ||
( function ( ) { } ) ;
CFS . apply ( document , [ ] ) ;
return true ;
} , nextRAF : 0 , fakeRequestAnimationFrame : function ( func ) {
// try to keep 60fps between calls to here
var now = Date . now ( ) ;
if ( Browser . nextRAF === 0 ) {
Browser . nextRAF = now + 1000 / 60 ;
} else {
while ( now + 2 >= Browser . nextRAF ) { // fudge a little, to avoid timer jitter causing us to do lots of delay:0
Browser . nextRAF += 1000 / 60 ;
}
}
var delay = Math . max ( Browser . nextRAF - now , 0 ) ;
setTimeout ( func , delay ) ;
} , requestAnimationFrame : function ( func ) {
if ( typeof requestAnimationFrame == 'function' ) {
requestAnimationFrame ( func ) ;
return ;
}
var RAF = Browser . fakeRequestAnimationFrame ;
RAF ( func ) ;
} , safeSetTimeout : function ( func ) {
// Legacy function, this is used by the SDL2 port so we need to keep it
// around at least until that is updated.
return safeSetTimeout ( func ) ;
} , safeRequestAnimationFrame : function ( func ) {
return Browser . requestAnimationFrame ( function ( ) {
callUserCallback ( func ) ;
} ) ;
} , getMimetype : function ( name ) {
return {
'jpg' : 'image/jpeg' ,
'jpeg' : 'image/jpeg' ,
'png' : 'image/png' ,
'bmp' : 'image/bmp' ,
'ogg' : 'audio/ogg' ,
'wav' : 'audio/wav' ,
'mp3' : 'audio/mpeg'
} [ name . substr ( name . lastIndexOf ( '.' ) + 1 ) ] ;
} , getUserMedia : function ( func ) {
if ( ! window . getUserMedia ) {
window . getUserMedia = navigator [ 'getUserMedia' ] ||
navigator [ 'mozGetUserMedia' ] ;
}
window . getUserMedia ( func ) ;
} , getMovementX : function ( event ) {
return event [ 'movementX' ] ||
event [ 'mozMovementX' ] ||
event [ 'webkitMovementX' ] ||
0 ;
} , getMovementY : function ( event ) {
return event [ 'movementY' ] ||
event [ 'mozMovementY' ] ||
event [ 'webkitMovementY' ] ||
0 ;
} , getMouseWheelDelta : function ( event ) {
var delta = 0 ;
switch ( event . type ) {
case 'DOMMouseScroll' :
// 3 lines make up a step
delta = event . detail / 3 ;
break ;
case 'mousewheel' :
// 120 units make up a step
delta = event . wheelDelta / 120 ;
break ;
case 'wheel' :
delta = event . deltaY
switch ( event . deltaMode ) {
case 0 :
// DOM_DELTA_PIXEL: 100 pixels make up a step
delta /= 100 ;
break ;
case 1 :
// DOM_DELTA_LINE: 3 lines make up a step
delta /= 3 ;
break ;
case 2 :
// DOM_DELTA_PAGE: A page makes up 80 steps
delta *= 80 ;
break ;
default :
throw 'unrecognized mouse wheel delta mode: ' + event . deltaMode ;
}
break ;
default :
throw 'unrecognized mouse wheel event: ' + event . type ;
}
return delta ;
} , mouseX : 0 , mouseY : 0 , mouseMovementX : 0 , mouseMovementY : 0 , touches : { } , lastTouches : { } , calculateMouseEvent : function ( event ) { // event should be mousemove, mousedown or mouseup
if ( Browser . pointerLock ) {
// When the pointer is locked, calculate the coordinates
// based on the movement of the mouse.
// Workaround for Firefox bug 764498
if ( event . type != 'mousemove' &&
( 'mozMovementX' in event ) ) {
Browser . mouseMovementX = Browser . mouseMovementY = 0 ;
} else {
Browser . mouseMovementX = Browser . getMovementX ( event ) ;
Browser . mouseMovementY = Browser . getMovementY ( event ) ;
}
// check if SDL is available
if ( typeof SDL != "undefined" ) {
Browser . mouseX = SDL . mouseX + Browser . mouseMovementX ;
Browser . mouseY = SDL . mouseY + Browser . mouseMovementY ;
} else {
// just add the mouse delta to the current absolut mouse position
// FIXME: ideally this should be clamped against the canvas size and zero
Browser . mouseX += Browser . mouseMovementX ;
Browser . mouseY += Browser . mouseMovementY ;
}
} else {
// Otherwise, calculate the movement based on the changes
// in the coordinates.
var rect = Module [ "canvas" ] . getBoundingClientRect ( ) ;
var cw = Module [ "canvas" ] . width ;
var ch = Module [ "canvas" ] . height ;
// Neither .scrollX or .pageXOffset are defined in a spec, but
// we prefer .scrollX because it is currently in a spec draft.
// (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
var scrollX = ( ( typeof window . scrollX != 'undefined' ) ? window . scrollX : window . pageXOffset ) ;
var scrollY = ( ( typeof window . scrollY != 'undefined' ) ? window . scrollY : window . pageYOffset ) ;
// If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset
// and we have no viable fallback.
assert ( ( typeof scrollX != 'undefined' ) && ( typeof scrollY != 'undefined' ) , 'Unable to retrieve scroll position, mouse positions likely broken.' ) ;
if ( event . type === 'touchstart' || event . type === 'touchend' || event . type === 'touchmove' ) {
var touch = event . touch ;
if ( touch === undefined ) {
return ; // the "touch" property is only defined in SDL
}
var adjustedX = touch . pageX - ( scrollX + rect . left ) ;
var adjustedY = touch . pageY - ( scrollY + rect . top ) ;
adjustedX = adjustedX * ( cw / rect . width ) ;
adjustedY = adjustedY * ( ch / rect . height ) ;
var coords = { x : adjustedX , y : adjustedY } ;
if ( event . type === 'touchstart' ) {
Browser . lastTouches [ touch . identifier ] = coords ;
Browser . touches [ touch . identifier ] = coords ;
} else if ( event . type === 'touchend' || event . type === 'touchmove' ) {
var last = Browser . touches [ touch . identifier ] ;
if ( ! last ) last = coords ;
Browser . lastTouches [ touch . identifier ] = last ;
Browser . touches [ touch . identifier ] = coords ;
}
return ;
}
var x = event . pageX - ( scrollX + rect . left ) ;
var y = event . pageY - ( scrollY + rect . top ) ;
// the canvas might be CSS-scaled compared to its backbuffer;
// SDL-using content will want mouse coordinates in terms
// of backbuffer units.
x = x * ( cw / rect . width ) ;
y = y * ( ch / rect . height ) ;
Browser . mouseMovementX = x - Browser . mouseX ;
Browser . mouseMovementY = y - Browser . mouseY ;
Browser . mouseX = x ;
Browser . mouseY = y ;
}
} , resizeListeners : [ ] , updateResizeListeners : function ( ) {
var canvas = Module [ 'canvas' ] ;
Browser . resizeListeners . forEach ( function ( listener ) {
listener ( canvas . width , canvas . height ) ;
} ) ;
} , setCanvasSize : function ( width , height , noUpdates ) {
var canvas = Module [ 'canvas' ] ;
Browser . updateCanvasDimensions ( canvas , width , height ) ;
if ( ! noUpdates ) Browser . updateResizeListeners ( ) ;
} , windowedWidth : 0 , windowedHeight : 0 , setFullscreenCanvasSize : function ( ) {
// check if SDL is available
if ( typeof SDL != "undefined" ) {
var flags = HEAPU32 [ ( ( SDL . screen ) >> 2 ) ] ;
flags = flags | 0x00800000 ; // set SDL_FULLSCREEN flag
HEAP32 [ ( ( SDL . screen ) >> 2 ) ] = flags ;
}
Browser . updateCanvasDimensions ( Module [ 'canvas' ] ) ;
Browser . updateResizeListeners ( ) ;
} , setWindowedCanvasSize : function ( ) {
// check if SDL is available
if ( typeof SDL != "undefined" ) {
var flags = HEAPU32 [ ( ( SDL . screen ) >> 2 ) ] ;
flags = flags & ~ 0x00800000 ; // clear SDL_FULLSCREEN flag
HEAP32 [ ( ( SDL . screen ) >> 2 ) ] = flags ;
}
Browser . updateCanvasDimensions ( Module [ 'canvas' ] ) ;
Browser . updateResizeListeners ( ) ;
} , updateCanvasDimensions : function ( canvas , wNative , hNative ) {
if ( wNative && hNative ) {
canvas . widthNative = wNative ;
canvas . heightNative = hNative ;
} else {
wNative = canvas . widthNative ;
hNative = canvas . heightNative ;
}
var w = wNative ;
var h = hNative ;
if ( Module [ 'forcedAspectRatio' ] && Module [ 'forcedAspectRatio' ] > 0 ) {
if ( w / h < Module [ 'forcedAspectRatio' ] ) {
w = Math . round ( h * Module [ 'forcedAspectRatio' ] ) ;
} else {
h = Math . round ( w / Module [ 'forcedAspectRatio' ] ) ;
}
}
if ( ( ( document [ 'fullscreenElement' ] || document [ 'mozFullScreenElement' ] ||
document [ 'msFullscreenElement' ] || document [ 'webkitFullscreenElement' ] ||
document [ 'webkitCurrentFullScreenElement' ] ) === canvas . parentNode ) && ( typeof screen != 'undefined' ) ) {
var factor = Math . min ( screen . width / w , screen . height / h ) ;
w = Math . round ( w * factor ) ;
h = Math . round ( h * factor ) ;
}
if ( Browser . resizeCanvas ) {
if ( canvas . width != w ) canvas . width = w ;
if ( canvas . height != h ) canvas . height = h ;
if ( typeof canvas . style != 'undefined' ) {
canvas . style . removeProperty ( "width" ) ;
canvas . style . removeProperty ( "height" ) ;
}
} else {
if ( canvas . width != wNative ) canvas . width = wNative ;
if ( canvas . height != hNative ) canvas . height = hNative ;
if ( typeof canvas . style != 'undefined' ) {
if ( w != wNative || h != hNative ) {
canvas . style . setProperty ( "width" , w + "px" , "important" ) ;
canvas . style . setProperty ( "height" , h + "px" , "important" ) ;
} else {
canvas . style . removeProperty ( "width" ) ;
canvas . style . removeProperty ( "height" ) ;
}
}
}
} } ;
function _emscripten _set _main _loop _timing ( mode , value ) {
Browser . mainLoop . timingMode = mode ;
Browser . mainLoop . timingValue = value ;
if ( ! Browser . mainLoop . func ) {
err ( 'emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.' ) ;
return 1 ; // Return non-zero on failure, can't set timing mode when there is no main loop.
}
if ( ! Browser . mainLoop . running ) {
Browser . mainLoop . running = true ;
}
if ( mode == 0 /*EM_TIMING_SETTIMEOUT*/ ) {
Browser . mainLoop . scheduler = function Browser _mainLoop _scheduler _setTimeout ( ) {
var timeUntilNextTick = Math . max ( 0 , Browser . mainLoop . tickStartTime + value - _emscripten _get _now ( ) ) | 0 ;
setTimeout ( Browser . mainLoop . runner , timeUntilNextTick ) ; // doing this each time means that on exception, we stop
} ;
Browser . mainLoop . method = 'timeout' ;
} else if ( mode == 1 /*EM_TIMING_RAF*/ ) {
Browser . mainLoop . scheduler = function Browser _mainLoop _scheduler _rAF ( ) {
Browser . requestAnimationFrame ( Browser . mainLoop . runner ) ;
} ;
Browser . mainLoop . method = 'rAF' ;
} else if ( mode == 2 /*EM_TIMING_SETIMMEDIATE*/ ) {
if ( typeof setImmediate == 'undefined' ) {
// Emulate setImmediate. (note: not a complete polyfill, we don't emulate clearImmediate() to keep code size to minimum, since not needed)
var setImmediates = [ ] ;
var emscriptenMainLoopMessageId = 'setimmediate' ;
var Browser _setImmediate _messageHandler = function ( /** @type {Event} */ event ) {
// When called in current thread or Worker, the main loop ID is structured slightly different to accommodate for --proxy-to-worker runtime listening to Worker events,
// so check for both cases.
if ( event . data === emscriptenMainLoopMessageId || event . data . target === emscriptenMainLoopMessageId ) {
event . stopPropagation ( ) ;
setImmediates . shift ( ) ( ) ;
}
}
addEventListener ( "message" , Browser _setImmediate _messageHandler , true ) ;
setImmediate = /** @type{function(function(): ?, ...?): number} */ ( function Browser _emulated _setImmediate ( func ) {
setImmediates . push ( func ) ;
if ( ENVIRONMENT _IS _WORKER ) {
if ( Module [ 'setImmediates' ] === undefined ) Module [ 'setImmediates' ] = [ ] ;
Module [ 'setImmediates' ] . push ( func ) ;
postMessage ( { target : emscriptenMainLoopMessageId } ) ; // In --proxy-to-worker, route the message via proxyClient.js
} else postMessage ( emscriptenMainLoopMessageId , "*" ) ; // On the main thread, can just send the message to itself.
} )
}
Browser . mainLoop . scheduler = function Browser _mainLoop _scheduler _setImmediate ( ) {
setImmediate ( Browser . mainLoop . runner ) ;
} ;
Browser . mainLoop . method = 'immediate' ;
}
return 0 ;
}
var _emscripten _get _now ; if ( ENVIRONMENT _IS _NODE ) {
_emscripten _get _now = ( ) => {
var t = process [ 'hrtime' ] ( ) ;
return t [ 0 ] * 1e3 + t [ 1 ] / 1e6 ;
} ;
} else _emscripten _get _now = ( ) => performance . now ( ) ;
;
function _exit ( status ) {
// void _exit(int status);
// http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
exit ( status ) ;
}
function maybeExit ( ) {
if ( ! keepRuntimeAlive ( ) ) {
try {
_exit ( EXITSTATUS ) ;
} catch ( e ) {
handleException ( e ) ;
}
}
}
/ * *
* @ param { number = } arg
* @ param { boolean = } noSetTiming
* /
function setMainLoop ( browserIterationFunc , fps , simulateInfiniteLoop , arg , noSetTiming ) {
assert ( ! Browser . mainLoop . func , 'emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.' ) ;
Browser . mainLoop . func = browserIterationFunc ;
Browser . mainLoop . arg = arg ;
var thisMainLoopId = Browser . mainLoop . currentlyRunningMainloop ;
function checkIsRunning ( ) {
if ( thisMainLoopId < Browser . mainLoop . currentlyRunningMainloop ) {
maybeExit ( ) ;
return false ;
}
return true ;
}
// We create the loop runner here but it is not actually running until
// _emscripten_set_main_loop_timing is called (which might happen a
// later time). This member signifies that the current runner has not
// yet been started so that we can call runtimeKeepalivePush when it
// gets it timing set for the first time.
Browser . mainLoop . running = false ;
Browser . mainLoop . runner = function Browser _mainLoop _runner ( ) {
if ( ABORT ) return ;
if ( Browser . mainLoop . queue . length > 0 ) {
var start = Date . now ( ) ;
var blocker = Browser . mainLoop . queue . shift ( ) ;
blocker . func ( blocker . arg ) ;
if ( Browser . mainLoop . remainingBlockers ) {
var remaining = Browser . mainLoop . remainingBlockers ;
var next = remaining % 1 == 0 ? remaining - 1 : Math . floor ( remaining ) ;
if ( blocker . counted ) {
Browser . mainLoop . remainingBlockers = next ;
} else {
// not counted, but move the progress along a tiny bit
next = next + 0.5 ; // do not steal all the next one's progress
Browser . mainLoop . remainingBlockers = ( 8 * remaining + next ) / 9 ;
}
}
out ( 'main loop blocker "' + blocker . name + '" took ' + ( Date . now ( ) - start ) + ' ms' ) ; //, left: ' + Browser.mainLoop.remainingBlockers);
Browser . mainLoop . updateStatus ( ) ;
// catches pause/resume main loop from blocker execution
if ( ! checkIsRunning ( ) ) return ;
setTimeout ( Browser . mainLoop . runner , 0 ) ;
return ;
}
// catch pauses from non-main loop sources
if ( ! checkIsRunning ( ) ) return ;
// Implement very basic swap interval control
Browser . mainLoop . currentFrameNumber = Browser . mainLoop . currentFrameNumber + 1 | 0 ;
if ( Browser . mainLoop . timingMode == 1 /*EM_TIMING_RAF*/ && Browser . mainLoop . timingValue > 1 && Browser . mainLoop . currentFrameNumber % Browser . mainLoop . timingValue != 0 ) {
// Not the scheduled time to render this frame - skip.
Browser . mainLoop . scheduler ( ) ;
return ;
} else if ( Browser . mainLoop . timingMode == 0 /*EM_TIMING_SETTIMEOUT*/ ) {
Browser . mainLoop . tickStartTime = _emscripten _get _now ( ) ;
}
// Signal GL rendering layer that processing of a new frame is about to start. This helps it optimize
// VBO double-buffering and reduce GPU stalls.
if ( Browser . mainLoop . method === 'timeout' && Module . ctx ) {
warnOnce ( 'Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!' ) ;
Browser . mainLoop . method = '' ; // just warn once per call to set main loop
}
Browser . mainLoop . runIter ( browserIterationFunc ) ;
checkStackCookie ( ) ;
// catch pauses from the main loop itself
if ( ! checkIsRunning ( ) ) return ;
// Queue new audio data. This is important to be right after the main loop invocation, so that we will immediately be able
// to queue the newest produced audio samples.
// TODO: Consider adding pre- and post- rAF callbacks so that GL.newRenderingFrameStarted() and SDL.audio.queueNewAudioData()
// do not need to be hardcoded into this function, but can be more generic.
if ( typeof SDL == 'object' && SDL . audio && SDL . audio . queueNewAudioData ) SDL . audio . queueNewAudioData ( ) ;
Browser . mainLoop . scheduler ( ) ;
}
if ( ! noSetTiming ) {
if ( fps && fps > 0 ) _emscripten _set _main _loop _timing ( 0 /*EM_TIMING_SETTIMEOUT*/ , 1000.0 / fps ) ;
else _emscripten _set _main _loop _timing ( 1 /*EM_TIMING_RAF*/ , 1 ) ; // Do rAF by rendering each frame (no decimating)
Browser . mainLoop . scheduler ( ) ;
}
if ( simulateInfiniteLoop ) {
throw 'unwind' ;
}
}
function _emscripten _set _main _loop ( func , fps , simulateInfiniteLoop ) {
var browserIterationFunc = getWasmTableEntry ( func ) ;
setMainLoop ( browserIterationFunc , fps , simulateInfiniteLoop ) ;
}
var ENV = { } ;
function getExecutableName ( ) {
return thisProgram || './this.program' ;
}
function getEnvStrings ( ) {
if ( ! getEnvStrings . strings ) {
// Default values.
// Browser language detection #8751
var lang = ( ( typeof navigator == 'object' && navigator . languages && navigator . languages [ 0 ] ) || 'C' ) . replace ( '-' , '_' ) + '.UTF-8' ;
var env = {
'USER' : 'web_user' ,
'LOGNAME' : 'web_user' ,
'PATH' : '/' ,
'PWD' : '/' ,
'HOME' : '/home/web_user' ,
'LANG' : lang ,
'_' : getExecutableName ( )
} ;
// Apply the user-provided values, if any.
for ( var x in ENV ) {
// x is a key in ENV; if ENV[x] is undefined, that means it was
// explicitly set to be so. We allow user code to do that to
// force variables with default values to remain unset.
if ( ENV [ x ] === undefined ) delete env [ x ] ;
else env [ x ] = ENV [ x ] ;
}
var strings = [ ] ;
for ( var x in env ) {
strings . push ( x + '=' + env [ x ] ) ;
}
getEnvStrings . strings = strings ;
}
return getEnvStrings . strings ;
}
function _environ _get ( _ _environ , environ _buf ) {
var bufSize = 0 ;
getEnvStrings ( ) . forEach ( function ( string , i ) {
var ptr = environ _buf + bufSize ;
HEAP32 [ ( ( ( _ _environ ) + ( i * 4 ) ) >> 2 ) ] = ptr ;
writeAsciiToMemory ( string , ptr ) ;
bufSize += string . length + 1 ;
} ) ;
return 0 ;
}
function _environ _sizes _get ( penviron _count , penviron _buf _size ) {
var strings = getEnvStrings ( ) ;
HEAP32 [ ( ( penviron _count ) >> 2 ) ] = strings . length ;
var bufSize = 0 ;
strings . forEach ( function ( string ) {
bufSize += string . length + 1 ;
} ) ;
HEAP32 [ ( ( penviron _buf _size ) >> 2 ) ] = bufSize ;
return 0 ;
}
function _fd _close ( fd ) {
try {
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
FS . close ( stream ) ;
return 0 ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return e . errno ;
}
}
function _fd _read ( fd , iov , iovcnt , pnum ) {
try {
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
var num = SYSCALLS . doReadv ( stream , iov , iovcnt ) ;
HEAP32 [ ( ( pnum ) >> 2 ) ] = num ;
return 0 ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return e . errno ;
}
}
function _fd _seek ( fd , offset _low , offset _high , whence , newOffset ) {
try {
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
var HIGH _OFFSET = 0x100000000 ; // 2^32
// use an unsigned operator on low and shift high by 32-bits
var offset = offset _high * HIGH _OFFSET + ( offset _low >>> 0 ) ;
var DOUBLE _LIMIT = 0x20000000000000 ; // 2^53
// we also check for equality since DOUBLE_LIMIT + 1 == DOUBLE_LIMIT
if ( offset <= - DOUBLE _LIMIT || offset >= DOUBLE _LIMIT ) {
return - 61 ;
}
FS . llseek ( stream , offset , whence ) ;
( tempI64 = [ stream . position >>> 0 , ( tempDouble = stream . position , ( + ( Math . abs ( tempDouble ) ) ) >= 1.0 ? ( tempDouble > 0.0 ? ( ( Math . min ( ( + ( Math . floor ( ( tempDouble ) / 4294967296.0 ) ) ) , 4294967295.0 ) ) | 0 ) >>> 0 : ( ~ ~ ( ( + ( Math . ceil ( ( tempDouble - + ( ( ( ~ ~ ( tempDouble ) ) ) >>> 0 ) ) / 4294967296.0 ) ) ) ) ) >>> 0 ) : 0 ) ] , HEAP32 [ ( ( newOffset ) >> 2 ) ] = tempI64 [ 0 ] , HEAP32 [ ( ( ( newOffset ) + ( 4 ) ) >> 2 ) ] = tempI64 [ 1 ] ) ;
if ( stream . getdents && offset === 0 && whence === 0 ) stream . getdents = null ; // reset readdir state
return 0 ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return e . errno ;
}
}
function _fd _write ( fd , iov , iovcnt , pnum ) {
try {
;
var stream = SYSCALLS . getStreamFromFD ( fd ) ;
var num = SYSCALLS . doWritev ( stream , iov , iovcnt ) ;
HEAP32 [ ( ( pnum ) >> 2 ) ] = num ;
return 0 ;
} catch ( e ) {
if ( typeof FS == 'undefined' || ! ( e instanceof FS . ErrnoError ) ) throw e ;
return e . errno ;
}
}
function _ _webgl _enable _ANGLE _instanced _arrays ( ctx ) {
// Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2.
var ext = ctx . getExtension ( 'ANGLE_instanced_arrays' ) ;
if ( ext ) {
ctx [ 'vertexAttribDivisor' ] = function ( index , divisor ) { ext [ 'vertexAttribDivisorANGLE' ] ( index , divisor ) ; } ;
ctx [ 'drawArraysInstanced' ] = function ( mode , first , count , primcount ) { ext [ 'drawArraysInstancedANGLE' ] ( mode , first , count , primcount ) ; } ;
ctx [ 'drawElementsInstanced' ] = function ( mode , count , type , indices , primcount ) { ext [ 'drawElementsInstancedANGLE' ] ( mode , count , type , indices , primcount ) ; } ;
return 1 ;
}
}
function _ _webgl _enable _OES _vertex _array _object ( ctx ) {
// Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2.
var ext = ctx . getExtension ( 'OES_vertex_array_object' ) ;
if ( ext ) {
ctx [ 'createVertexArray' ] = function ( ) { return ext [ 'createVertexArrayOES' ] ( ) ; } ;
ctx [ 'deleteVertexArray' ] = function ( vao ) { ext [ 'deleteVertexArrayOES' ] ( vao ) ; } ;
ctx [ 'bindVertexArray' ] = function ( vao ) { ext [ 'bindVertexArrayOES' ] ( vao ) ; } ;
ctx [ 'isVertexArray' ] = function ( vao ) { return ext [ 'isVertexArrayOES' ] ( vao ) ; } ;
return 1 ;
}
}
function _ _webgl _enable _WEBGL _draw _buffers ( ctx ) {
// Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2.
var ext = ctx . getExtension ( 'WEBGL_draw_buffers' ) ;
if ( ext ) {
ctx [ 'drawBuffers' ] = function ( n , bufs ) { ext [ 'drawBuffersWEBGL' ] ( n , bufs ) ; } ;
return 1 ;
}
}
function _ _webgl _enable _WEBGL _draw _instanced _base _vertex _base _instance ( ctx ) {
// Closure is expected to be allowed to minify the '.dibvbi' property, so not accessing it quoted.
return ! ! ( ctx . dibvbi = ctx . getExtension ( 'WEBGL_draw_instanced_base_vertex_base_instance' ) ) ;
}
function _ _webgl _enable _WEBGL _multi _draw _instanced _base _vertex _base _instance ( ctx ) {
// Closure is expected to be allowed to minify the '.mdibvbi' property, so not accessing it quoted.
return ! ! ( ctx . mdibvbi = ctx . getExtension ( 'WEBGL_multi_draw_instanced_base_vertex_base_instance' ) ) ;
}
function _ _webgl _enable _WEBGL _multi _draw ( ctx ) {
// Closure is expected to be allowed to minify the '.multiDrawWebgl' property, so not accessing it quoted.
return ! ! ( ctx . multiDrawWebgl = ctx . getExtension ( 'WEBGL_multi_draw' ) ) ;
}
var GL = { counter : 1 , buffers : [ ] , programs : [ ] , framebuffers : [ ] , renderbuffers : [ ] , textures : [ ] , shaders : [ ] , vaos : [ ] , contexts : [ ] , offscreenCanvases : { } , queries : [ ] , samplers : [ ] , transformFeedbacks : [ ] , syncs : [ ] , stringCache : { } , stringiCache : { } , unpackAlignment : 4 , recordError : function recordError ( errorCode ) {
if ( ! GL . lastError ) {
GL . lastError = errorCode ;
}
} , getNewId : function ( table ) {
var ret = GL . counter ++ ;
for ( var i = table . length ; i < ret ; i ++ ) {
table [ i ] = null ;
}
return ret ;
} , getSource : function ( shader , count , string , length ) {
var source = '' ;
for ( var i = 0 ; i < count ; ++ i ) {
var len = length ? HEAP32 [ ( ( ( length ) + ( i * 4 ) ) >> 2 ) ] : - 1 ;
source += UTF8ToString ( HEAP32 [ ( ( ( string ) + ( i * 4 ) ) >> 2 ) ] , len < 0 ? undefined : len ) ;
}
return source ;
} , createContext : function ( /** @type {HTMLCanvasElement} */ canvas , webGLContextAttributes ) {
// BUG: Workaround Safari WebGL issue: After successfully acquiring WebGL context on a canvas,
// calling .getContext() will always return that context independent of which 'webgl' or 'webgl2'
// context version was passed. See https://bugs.webkit.org/show_bug.cgi?id=222758 and
// https://github.com/emscripten-core/emscripten/issues/13295.
// TODO: Once the bug is fixed and shipped in Safari, adjust the Safari version field in above check.
if ( ! canvas . getContextSafariWebGL2Fixed ) {
canvas . getContextSafariWebGL2Fixed = canvas . getContext ;
/** @type {function(this:HTMLCanvasElement, string, (Object|null)=): (Object|null)} */
function fixedGetContext ( ver , attrs ) {
var gl = canvas . getContextSafariWebGL2Fixed ( ver , attrs ) ;
return ( ( ver == 'webgl' ) == ( gl instanceof WebGLRenderingContext ) ) ? gl : null ;
}
canvas . getContext = fixedGetContext ;
}
var ctx =
( webGLContextAttributes . majorVersion > 1 )
?
canvas . getContext ( "webgl2" , webGLContextAttributes )
:
( canvas . getContext ( "webgl" , webGLContextAttributes )
// https://caniuse.com/#feat=webgl
) ;
if ( ! ctx ) return 0 ;
var handle = GL . registerContext ( ctx , webGLContextAttributes ) ;
return handle ;
} , registerContext : function ( ctx , webGLContextAttributes ) {
// without pthreads a context is just an integer ID
var handle = GL . getNewId ( GL . contexts ) ;
var context = {
handle : handle ,
attributes : webGLContextAttributes ,
version : webGLContextAttributes . majorVersion ,
GLctx : ctx
} ;
// Store the created context object so that we can access the context given a canvas without having to pass the parameters again.
if ( ctx . canvas ) ctx . canvas . GLctxObject = context ;
GL . contexts [ handle ] = context ;
if ( typeof webGLContextAttributes . enableExtensionsByDefault == 'undefined' || webGLContextAttributes . enableExtensionsByDefault ) {
GL . initExtensions ( context ) ;
}
return handle ;
} , makeContextCurrent : function ( contextHandle ) {
GL . currentContext = GL . contexts [ contextHandle ] ; // Active Emscripten GL layer context object.
Module . ctx = GLctx = GL . currentContext && GL . currentContext . GLctx ; // Active WebGL context object.
return ! ( contextHandle && ! GLctx ) ;
} , getContext : function ( contextHandle ) {
return GL . contexts [ contextHandle ] ;
} , deleteContext : function ( contextHandle ) {
if ( GL . currentContext === GL . contexts [ contextHandle ] ) GL . currentContext = null ;
if ( typeof JSEvents == 'object' ) JSEvents . removeAllHandlersOnTarget ( GL . contexts [ contextHandle ] . GLctx . canvas ) ; // Release all JS event handlers on the DOM element that the GL context is associated with since the context is now deleted.
if ( GL . contexts [ contextHandle ] && GL . contexts [ contextHandle ] . GLctx . canvas ) GL . contexts [ contextHandle ] . GLctx . canvas . GLctxObject = undefined ; // Make sure the canvas object no longer refers to the context object so there are no GC surprises.
GL . contexts [ contextHandle ] = null ;
} , initExtensions : function ( context ) {
// If this function is called without a specific context object, init the extensions of the currently active context.
if ( ! context ) context = GL . currentContext ;
if ( context . initExtensionsDone ) return ;
context . initExtensionsDone = true ;
var GLctx = context . GLctx ;
// Detect the presence of a few extensions manually, this GL interop layer itself will need to know if they exist.
// Extensions that are only available in WebGL 1 (the calls will be no-ops if called on a WebGL 2 context active)
_ _webgl _enable _ANGLE _instanced _arrays ( GLctx ) ;
_ _webgl _enable _OES _vertex _array _object ( GLctx ) ;
_ _webgl _enable _WEBGL _draw _buffers ( GLctx ) ;
// Extensions that are available from WebGL >= 2 (no-op if called on a WebGL 1 context active)
_ _webgl _enable _WEBGL _draw _instanced _base _vertex _base _instance ( GLctx ) ;
_ _webgl _enable _WEBGL _multi _draw _instanced _base _vertex _base _instance ( GLctx ) ;
// On WebGL 2, EXT_disjoint_timer_query is replaced with an alternative
// that's based on core APIs, and exposes only the queryCounterEXT()
// entrypoint.
if ( context . version >= 2 ) {
GLctx . disjointTimerQueryExt = GLctx . getExtension ( "EXT_disjoint_timer_query_webgl2" ) ;
}
// However, Firefox exposes the WebGL 1 version on WebGL 2 as well and
// thus we look for the WebGL 1 version again if the WebGL 2 version
// isn't present. https://bugzilla.mozilla.org/show_bug.cgi?id=1328882
if ( context . version < 2 || ! GLctx . disjointTimerQueryExt )
{
GLctx . disjointTimerQueryExt = GLctx . getExtension ( "EXT_disjoint_timer_query" ) ;
}
_ _webgl _enable _WEBGL _multi _draw ( GLctx ) ;
// .getSupportedExtensions() can return null if context is lost, so coerce to empty array.
var exts = GLctx . getSupportedExtensions ( ) || [ ] ;
exts . forEach ( function ( ext ) {
// WEBGL_lose_context, WEBGL_debug_renderer_info and WEBGL_debug_shaders are not enabled by default.
if ( ! ext . includes ( 'lose_context' ) && ! ext . includes ( 'debug' ) ) {
// Call .getExtension() to enable that extension permanently.
GLctx . getExtension ( ext ) ;
}
} ) ;
} } ;
function _glViewport ( x0 , x1 , x2 , x3 ) { GLctx [ 'viewport' ] ( x0 , x1 , x2 , x3 ) }
/** @constructor */
function GLFW _Window ( id , width , height , title , monitor , share ) {
this . id = id ;
this . x = 0 ;
this . y = 0 ;
this . fullscreen = false ; // Used to determine if app in fullscreen mode
this . storedX = 0 ; // Used to store X before fullscreen
this . storedY = 0 ; // Used to store Y before fullscreen
this . width = width ;
this . height = height ;
this . storedWidth = width ; // Used to store width before fullscreen
this . storedHeight = height ; // Used to store height before fullscreen
this . title = title ;
this . monitor = monitor ;
this . share = share ;
this . attributes = GLFW . hints ;
this . inputModes = {
0x00033001 : 0x00034001 , // GLFW_CURSOR (GLFW_CURSOR_NORMAL)
0x00033002 : 0 , // GLFW_STICKY_KEYS
0x00033003 : 0 , // GLFW_STICKY_MOUSE_BUTTONS
} ;
this . buttons = 0 ;
this . keys = new Array ( ) ;
this . domKeys = new Array ( ) ;
this . shouldClose = 0 ;
this . title = null ;
this . windowPosFunc = null ; // GLFWwindowposfun
this . windowSizeFunc = null ; // GLFWwindowsizefun
this . windowCloseFunc = null ; // GLFWwindowclosefun
this . windowRefreshFunc = null ; // GLFWwindowrefreshfun
this . windowFocusFunc = null ; // GLFWwindowfocusfun
this . windowIconifyFunc = null ; // GLFWwindowiconifyfun
this . framebufferSizeFunc = null ; // GLFWframebuffersizefun
this . mouseButtonFunc = null ; // GLFWmousebuttonfun
this . cursorPosFunc = null ; // GLFWcursorposfun
this . cursorEnterFunc = null ; // GLFWcursorenterfun
this . scrollFunc = null ; // GLFWscrollfun
this . dropFunc = null ; // GLFWdropfun
this . keyFunc = null ; // GLFWkeyfun
this . charFunc = null ; // GLFWcharfun
this . userptr = null ;
}
var GLFW = { WindowFromId : function ( id ) {
if ( id <= 0 || ! GLFW . windows ) return null ;
return GLFW . windows [ id - 1 ] ;
} , joystickFunc : null , errorFunc : null , monitorFunc : null , active : null , windows : null , monitors : null , monitorString : null , versionString : null , initialTime : null , extensions : null , hints : null , defaultHints : { 131073 : 0 , 131074 : 0 , 131075 : 1 , 131076 : 1 , 131077 : 1 , 135169 : 8 , 135170 : 8 , 135171 : 8 , 135172 : 8 , 135173 : 24 , 135174 : 8 , 135175 : 0 , 135176 : 0 , 135177 : 0 , 135178 : 0 , 135179 : 0 , 135180 : 0 , 135181 : 0 , 135182 : 0 , 135183 : 0 , 139265 : 196609 , 139266 : 1 , 139267 : 0 , 139268 : 0 , 139269 : 0 , 139270 : 0 , 139271 : 0 , 139272 : 0 } , DOMToGLFWKeyCode : function ( keycode ) {
switch ( keycode ) {
// these keycodes are only defined for GLFW3, assume they are the same for GLFW2
case 0x20 : return 32 ; // DOM_VK_SPACE -> GLFW_KEY_SPACE
case 0xDE : return 39 ; // DOM_VK_QUOTE -> GLFW_KEY_APOSTROPHE
case 0xBC : return 44 ; // DOM_VK_COMMA -> GLFW_KEY_COMMA
case 0xAD : return 45 ; // DOM_VK_HYPHEN_MINUS -> GLFW_KEY_MINUS
case 0xBD : return 45 ; // DOM_VK_MINUS -> GLFW_KEY_MINUS
case 0xBE : return 46 ; // DOM_VK_PERIOD -> GLFW_KEY_PERIOD
case 0xBF : return 47 ; // DOM_VK_SLASH -> GLFW_KEY_SLASH
case 0x30 : return 48 ; // DOM_VK_0 -> GLFW_KEY_0
case 0x31 : return 49 ; // DOM_VK_1 -> GLFW_KEY_1
case 0x32 : return 50 ; // DOM_VK_2 -> GLFW_KEY_2
case 0x33 : return 51 ; // DOM_VK_3 -> GLFW_KEY_3
case 0x34 : return 52 ; // DOM_VK_4 -> GLFW_KEY_4
case 0x35 : return 53 ; // DOM_VK_5 -> GLFW_KEY_5
case 0x36 : return 54 ; // DOM_VK_6 -> GLFW_KEY_6
case 0x37 : return 55 ; // DOM_VK_7 -> GLFW_KEY_7
case 0x38 : return 56 ; // DOM_VK_8 -> GLFW_KEY_8
case 0x39 : return 57 ; // DOM_VK_9 -> GLFW_KEY_9
case 0x3B : return 59 ; // DOM_VK_SEMICOLON -> GLFW_KEY_SEMICOLON
case 0x3D : return 61 ; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL
case 0xBB : return 61 ; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL
case 0x41 : return 65 ; // DOM_VK_A -> GLFW_KEY_A
case 0x42 : return 66 ; // DOM_VK_B -> GLFW_KEY_B
case 0x43 : return 67 ; // DOM_VK_C -> GLFW_KEY_C
case 0x44 : return 68 ; // DOM_VK_D -> GLFW_KEY_D
case 0x45 : return 69 ; // DOM_VK_E -> GLFW_KEY_E
case 0x46 : return 70 ; // DOM_VK_F -> GLFW_KEY_F
case 0x47 : return 71 ; // DOM_VK_G -> GLFW_KEY_G
case 0x48 : return 72 ; // DOM_VK_H -> GLFW_KEY_H
case 0x49 : return 73 ; // DOM_VK_I -> GLFW_KEY_I
case 0x4A : return 74 ; // DOM_VK_J -> GLFW_KEY_J
case 0x4B : return 75 ; // DOM_VK_K -> GLFW_KEY_K
case 0x4C : return 76 ; // DOM_VK_L -> GLFW_KEY_L
case 0x4D : return 77 ; // DOM_VK_M -> GLFW_KEY_M
case 0x4E : return 78 ; // DOM_VK_N -> GLFW_KEY_N
case 0x4F : return 79 ; // DOM_VK_O -> GLFW_KEY_O
case 0x50 : return 80 ; // DOM_VK_P -> GLFW_KEY_P
case 0x51 : return 81 ; // DOM_VK_Q -> GLFW_KEY_Q
case 0x52 : return 82 ; // DOM_VK_R -> GLFW_KEY_R
case 0x53 : return 83 ; // DOM_VK_S -> GLFW_KEY_S
case 0x54 : return 84 ; // DOM_VK_T -> GLFW_KEY_T
case 0x55 : return 85 ; // DOM_VK_U -> GLFW_KEY_U
case 0x56 : return 86 ; // DOM_VK_V -> GLFW_KEY_V
case 0x57 : return 87 ; // DOM_VK_W -> GLFW_KEY_W
case 0x58 : return 88 ; // DOM_VK_X -> GLFW_KEY_X
case 0x59 : return 89 ; // DOM_VK_Y -> GLFW_KEY_Y
case 0x5a : return 90 ; // DOM_VK_Z -> GLFW_KEY_Z
case 0xDB : return 91 ; // DOM_VK_OPEN_BRACKET -> GLFW_KEY_LEFT_BRACKET
case 0xDC : return 92 ; // DOM_VK_BACKSLASH -> GLFW_KEY_BACKSLASH
case 0xDD : return 93 ; // DOM_VK_CLOSE_BRACKET -> GLFW_KEY_RIGHT_BRACKET
case 0xC0 : return 96 ; // DOM_VK_BACK_QUOTE -> GLFW_KEY_GRAVE_ACCENT
case 0x1B : return 256 ; // DOM_VK_ESCAPE -> GLFW_KEY_ESCAPE
case 0x0D : return 257 ; // DOM_VK_RETURN -> GLFW_KEY_ENTER
case 0x09 : return 258 ; // DOM_VK_TAB -> GLFW_KEY_TAB
case 0x08 : return 259 ; // DOM_VK_BACK -> GLFW_KEY_BACKSPACE
case 0x2D : return 260 ; // DOM_VK_INSERT -> GLFW_KEY_INSERT
case 0x2E : return 261 ; // DOM_VK_DELETE -> GLFW_KEY_DELETE
case 0x27 : return 262 ; // DOM_VK_RIGHT -> GLFW_KEY_RIGHT
case 0x25 : return 263 ; // DOM_VK_LEFT -> GLFW_KEY_LEFT
case 0x28 : return 264 ; // DOM_VK_DOWN -> GLFW_KEY_DOWN
case 0x26 : return 265 ; // DOM_VK_UP -> GLFW_KEY_UP
case 0x21 : return 266 ; // DOM_VK_PAGE_UP -> GLFW_KEY_PAGE_UP
case 0x22 : return 267 ; // DOM_VK_PAGE_DOWN -> GLFW_KEY_PAGE_DOWN
case 0x24 : return 268 ; // DOM_VK_HOME -> GLFW_KEY_HOME
case 0x23 : return 269 ; // DOM_VK_END -> GLFW_KEY_END
case 0x14 : return 280 ; // DOM_VK_CAPS_LOCK -> GLFW_KEY_CAPS_LOCK
case 0x91 : return 281 ; // DOM_VK_SCROLL_LOCK -> GLFW_KEY_SCROLL_LOCK
case 0x90 : return 282 ; // DOM_VK_NUM_LOCK -> GLFW_KEY_NUM_LOCK
case 0x2C : return 283 ; // DOM_VK_SNAPSHOT -> GLFW_KEY_PRINT_SCREEN
case 0x13 : return 284 ; // DOM_VK_PAUSE -> GLFW_KEY_PAUSE
case 0x70 : return 290 ; // DOM_VK_F1 -> GLFW_KEY_F1
case 0x71 : return 291 ; // DOM_VK_F2 -> GLFW_KEY_F2
case 0x72 : return 292 ; // DOM_VK_F3 -> GLFW_KEY_F3
case 0x73 : return 293 ; // DOM_VK_F4 -> GLFW_KEY_F4
case 0x74 : return 294 ; // DOM_VK_F5 -> GLFW_KEY_F5
case 0x75 : return 295 ; // DOM_VK_F6 -> GLFW_KEY_F6
case 0x76 : return 296 ; // DOM_VK_F7 -> GLFW_KEY_F7
case 0x77 : return 297 ; // DOM_VK_F8 -> GLFW_KEY_F8
case 0x78 : return 298 ; // DOM_VK_F9 -> GLFW_KEY_F9
case 0x79 : return 299 ; // DOM_VK_F10 -> GLFW_KEY_F10
case 0x7A : return 300 ; // DOM_VK_F11 -> GLFW_KEY_F11
case 0x7B : return 301 ; // DOM_VK_F12 -> GLFW_KEY_F12
case 0x7C : return 302 ; // DOM_VK_F13 -> GLFW_KEY_F13
case 0x7D : return 303 ; // DOM_VK_F14 -> GLFW_KEY_F14
case 0x7E : return 304 ; // DOM_VK_F15 -> GLFW_KEY_F15
case 0x7F : return 305 ; // DOM_VK_F16 -> GLFW_KEY_F16
case 0x80 : return 306 ; // DOM_VK_F17 -> GLFW_KEY_F17
case 0x81 : return 307 ; // DOM_VK_F18 -> GLFW_KEY_F18
case 0x82 : return 308 ; // DOM_VK_F19 -> GLFW_KEY_F19
case 0x83 : return 309 ; // DOM_VK_F20 -> GLFW_KEY_F20
case 0x84 : return 310 ; // DOM_VK_F21 -> GLFW_KEY_F21
case 0x85 : return 311 ; // DOM_VK_F22 -> GLFW_KEY_F22
case 0x86 : return 312 ; // DOM_VK_F23 -> GLFW_KEY_F23
case 0x87 : return 313 ; // DOM_VK_F24 -> GLFW_KEY_F24
case 0x88 : return 314 ; // 0x88 (not used?) -> GLFW_KEY_F25
case 0x60 : return 320 ; // DOM_VK_NUMPAD0 -> GLFW_KEY_KP_0
case 0x61 : return 321 ; // DOM_VK_NUMPAD1 -> GLFW_KEY_KP_1
case 0x62 : return 322 ; // DOM_VK_NUMPAD2 -> GLFW_KEY_KP_2
case 0x63 : return 323 ; // DOM_VK_NUMPAD3 -> GLFW_KEY_KP_3
case 0x64 : return 324 ; // DOM_VK_NUMPAD4 -> GLFW_KEY_KP_4
case 0x65 : return 325 ; // DOM_VK_NUMPAD5 -> GLFW_KEY_KP_5
case 0x66 : return 326 ; // DOM_VK_NUMPAD6 -> GLFW_KEY_KP_6
case 0x67 : return 327 ; // DOM_VK_NUMPAD7 -> GLFW_KEY_KP_7
case 0x68 : return 328 ; // DOM_VK_NUMPAD8 -> GLFW_KEY_KP_8
case 0x69 : return 329 ; // DOM_VK_NUMPAD9 -> GLFW_KEY_KP_9
case 0x6E : return 330 ; // DOM_VK_DECIMAL -> GLFW_KEY_KP_DECIMAL
case 0x6F : return 331 ; // DOM_VK_DIVIDE -> GLFW_KEY_KP_DIVIDE
case 0x6A : return 332 ; // DOM_VK_MULTIPLY -> GLFW_KEY_KP_MULTIPLY
case 0x6D : return 333 ; // DOM_VK_SUBTRACT -> GLFW_KEY_KP_SUBTRACT
case 0x6B : return 334 ; // DOM_VK_ADD -> GLFW_KEY_KP_ADD
// case 0x0D:return 335; // DOM_VK_RETURN -> GLFW_KEY_KP_ENTER (DOM_KEY_LOCATION_RIGHT)
// case 0x61:return 336; // DOM_VK_EQUALS -> GLFW_KEY_KP_EQUAL (DOM_KEY_LOCATION_RIGHT)
case 0x10 : return 340 ; // DOM_VK_SHIFT -> GLFW_KEY_LEFT_SHIFT
case 0x11 : return 341 ; // DOM_VK_CONTROL -> GLFW_KEY_LEFT_CONTROL
case 0x12 : return 342 ; // DOM_VK_ALT -> GLFW_KEY_LEFT_ALT
case 0x5B : return 343 ; // DOM_VK_WIN -> GLFW_KEY_LEFT_SUPER
// case 0x10:return 344; // DOM_VK_SHIFT -> GLFW_KEY_RIGHT_SHIFT (DOM_KEY_LOCATION_RIGHT)
// case 0x11:return 345; // DOM_VK_CONTROL -> GLFW_KEY_RIGHT_CONTROL (DOM_KEY_LOCATION_RIGHT)
// case 0x12:return 346; // DOM_VK_ALT -> GLFW_KEY_RIGHT_ALT (DOM_KEY_LOCATION_RIGHT)
// case 0x5B:return 347; // DOM_VK_WIN -> GLFW_KEY_RIGHT_SUPER (DOM_KEY_LOCATION_RIGHT)
case 0x5D : return 348 ; // DOM_VK_CONTEXT_MENU -> GLFW_KEY_MENU
// XXX: GLFW_KEY_WORLD_1, GLFW_KEY_WORLD_2 what are these?
default : return - 1 ; // GLFW_KEY_UNKNOWN
} ;
} , getModBits : function ( win ) {
var mod = 0 ;
if ( win . keys [ 340 ] ) mod |= 0x0001 ; // GLFW_MOD_SHIFT
if ( win . keys [ 341 ] ) mod |= 0x0002 ; // GLFW_MOD_CONTROL
if ( win . keys [ 342 ] ) mod |= 0x0004 ; // GLFW_MOD_ALT
if ( win . keys [ 343 ] ) mod |= 0x0008 ; // GLFW_MOD_SUPER
return mod ;
} , onKeyPress : function ( event ) {
if ( ! GLFW . active || ! GLFW . active . charFunc ) return ;
if ( event . ctrlKey || event . metaKey ) return ;
// correct unicode charCode is only available with onKeyPress event
var charCode = event . charCode ;
if ( charCode == 0 || ( charCode >= 0x00 && charCode <= 0x1F ) ) return ;
getWasmTableEntry ( GLFW . active . charFunc ) ( GLFW . active . id , charCode ) ;
} , onKeyChanged : function ( keyCode , status ) {
if ( ! GLFW . active ) return ;
var key = GLFW . DOMToGLFWKeyCode ( keyCode ) ;
if ( key == - 1 ) return ;
var repeat = status && GLFW . active . keys [ key ] ;
GLFW . active . keys [ key ] = status ;
GLFW . active . domKeys [ keyCode ] = status ;
if ( ! GLFW . active . keyFunc ) return ;
if ( repeat ) status = 2 ; // GLFW_REPEAT
getWasmTableEntry ( GLFW . active . keyFunc ) ( GLFW . active . id , key , keyCode , status , GLFW . getModBits ( GLFW . active ) ) ;
} , onGamepadConnected : function ( event ) {
GLFW . refreshJoysticks ( ) ;
} , onGamepadDisconnected : function ( event ) {
GLFW . refreshJoysticks ( ) ;
} , onKeydown : function ( event ) {
GLFW . onKeyChanged ( event . keyCode , 1 ) ; // GLFW_PRESS or GLFW_REPEAT
// This logic comes directly from the sdl implementation. We cannot
// call preventDefault on all keydown events otherwise onKeyPress will
// not get called
if ( event . keyCode === 8 /* backspace */ || event . keyCode === 9 /* tab */ ) {
event . preventDefault ( ) ;
}
} , onKeyup : function ( event ) {
GLFW . onKeyChanged ( event . keyCode , 0 ) ; // GLFW_RELEASE
} , onBlur : function ( event ) {
if ( ! GLFW . active ) return ;
for ( var i = 0 ; i < GLFW . active . domKeys . length ; ++ i ) {
if ( GLFW . active . domKeys [ i ] ) {
GLFW . onKeyChanged ( i , 0 ) ; // GLFW_RELEASE
}
}
} , onMousemove : function ( event ) {
if ( ! GLFW . active ) return ;
Browser . calculateMouseEvent ( event ) ;
if ( event . target != Module [ "canvas" ] || ! GLFW . active . cursorPosFunc ) return ;
getWasmTableEntry ( GLFW . active . cursorPosFunc ) ( GLFW . active . id , Browser . mouseX , Browser . mouseY ) ;
} , DOMToGLFWMouseButton : function ( event ) {
// DOM and glfw have different button codes.
// See http://www.w3schools.com/jsref/event_button.asp.
var eventButton = event [ 'button' ] ;
if ( eventButton > 0 ) {
if ( eventButton == 1 ) {
eventButton = 2 ;
} else {
eventButton = 1 ;
}
}
return eventButton ;
} , onMouseenter : function ( event ) {
if ( ! GLFW . active ) return ;
if ( event . target != Module [ "canvas" ] || ! GLFW . active . cursorEnterFunc ) return ;
getWasmTableEntry ( GLFW . active . cursorEnterFunc ) ( GLFW . active . id , 1 ) ;
} , onMouseleave : function ( event ) {
if ( ! GLFW . active ) return ;
if ( event . target != Module [ "canvas" ] || ! GLFW . active . cursorEnterFunc ) return ;
getWasmTableEntry ( GLFW . active . cursorEnterFunc ) ( GLFW . active . id , 0 ) ;
} , onMouseButtonChanged : function ( event , status ) {
if ( ! GLFW . active ) return ;
Browser . calculateMouseEvent ( event ) ;
if ( event . target != Module [ "canvas" ] ) return ;
var eventButton = GLFW . DOMToGLFWMouseButton ( event ) ;
if ( status == 1 ) { // GLFW_PRESS
GLFW . active . buttons |= ( 1 << eventButton ) ;
try {
event . target . setCapture ( ) ;
} catch ( e ) { }
} else { // GLFW_RELEASE
GLFW . active . buttons &= ~ ( 1 << eventButton ) ;
}
if ( ! GLFW . active . mouseButtonFunc ) return ;
getWasmTableEntry ( GLFW . active . mouseButtonFunc ) ( GLFW . active . id , eventButton , status , GLFW . getModBits ( GLFW . active ) ) ;
} , onMouseButtonDown : function ( event ) {
if ( ! GLFW . active ) return ;
GLFW . onMouseButtonChanged ( event , 1 ) ; // GLFW_PRESS
} , onMouseButtonUp : function ( event ) {
if ( ! GLFW . active ) return ;
GLFW . onMouseButtonChanged ( event , 0 ) ; // GLFW_RELEASE
} , onMouseWheel : function ( event ) {
// Note the minus sign that flips browser wheel direction (positive direction scrolls page down) to native wheel direction (positive direction is mouse wheel up)
var delta = - Browser . getMouseWheelDelta ( event ) ;
delta = ( delta == 0 ) ? 0 : ( delta > 0 ? Math . max ( delta , 1 ) : Math . min ( delta , - 1 ) ) ; // Quantize to integer so that minimum scroll is at least +/- 1.
GLFW . wheelPos += delta ;
if ( ! GLFW . active || ! GLFW . active . scrollFunc || event . target != Module [ 'canvas' ] ) return ;
var sx = 0 ;
var sy = 0 ;
if ( event . type == 'mousewheel' ) {
sx = event . wheelDeltaX ;
sy = event . wheelDeltaY ;
} else {
sx = event . deltaX ;
sy = event . deltaY ;
}
getWasmTableEntry ( GLFW . active . scrollFunc ) ( GLFW . active . id , sx , sy ) ;
event . preventDefault ( ) ;
} , onCanvasResize : function ( width , height ) {
if ( ! GLFW . active ) return ;
var resizeNeeded = true ;
// If the client is requesting fullscreen mode
if ( document [ "fullscreen" ] || document [ "fullScreen" ] || document [ "mozFullScreen" ] || document [ "webkitIsFullScreen" ] ) {
GLFW . active . storedX = GLFW . active . x ;
GLFW . active . storedY = GLFW . active . y ;
GLFW . active . storedWidth = GLFW . active . width ;
GLFW . active . storedHeight = GLFW . active . height ;
GLFW . active . x = GLFW . active . y = 0 ;
GLFW . active . width = screen . width ;
GLFW . active . height = screen . height ;
GLFW . active . fullscreen = true ;
// If the client is reverting from fullscreen mode
} else if ( GLFW . active . fullscreen == true ) {
GLFW . active . x = GLFW . active . storedX ;
GLFW . active . y = GLFW . active . storedY ;
GLFW . active . width = GLFW . active . storedWidth ;
GLFW . active . height = GLFW . active . storedHeight ;
GLFW . active . fullscreen = false ;
// If the width/height values do not match current active window sizes
} else if ( GLFW . active . width != width || GLFW . active . height != height ) {
GLFW . active . width = width ;
GLFW . active . height = height ;
} else {
resizeNeeded = false ;
}
// If any of the above conditions were true, we need to resize the canvas
if ( resizeNeeded ) {
// resets the canvas size to counter the aspect preservation of Browser.updateCanvasDimensions
Browser . setCanvasSize ( GLFW . active . width , GLFW . active . height , true ) ;
// TODO: Client dimensions (clientWidth/clientHeight) vs pixel dimensions (width/height) of
// the canvas should drive window and framebuffer size respectfully.
GLFW . onWindowSizeChanged ( ) ;
GLFW . onFramebufferSizeChanged ( ) ;
}
} , onWindowSizeChanged : function ( ) {
if ( ! GLFW . active ) return ;
if ( ! GLFW . active . windowSizeFunc ) return ;
callUserCallback ( function ( ) {
getWasmTableEntry ( GLFW . active . windowSizeFunc ) ( GLFW . active . id , GLFW . active . width , GLFW . active . height ) ;
} ) ;
} , onFramebufferSizeChanged : function ( ) {
if ( ! GLFW . active ) return ;
if ( ! GLFW . active . framebufferSizeFunc ) return ;
callUserCallback ( function ( ) {
getWasmTableEntry ( GLFW . active . framebufferSizeFunc ) ( GLFW . active . id , GLFW . active . width , GLFW . active . height ) ;
} ) ;
} , getTime : function ( ) {
return _emscripten _get _now ( ) / 1000 ;
} , setWindowTitle : function ( winid , title ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return ;
win . title = UTF8ToString ( title ) ;
if ( GLFW . active . id == win . id ) {
document . title = win . title ;
}
} , setJoystickCallback : function ( cbfun ) {
GLFW . joystickFunc = cbfun ;
GLFW . refreshJoysticks ( ) ;
} , joys : { } , lastGamepadState : [ ] , lastGamepadStateFrame : null , refreshJoysticks : function ( ) {
// Produce a new Gamepad API sample if we are ticking a new game frame, or if not using emscripten_set_main_loop() at all to drive animation.
if ( Browser . mainLoop . currentFrameNumber !== GLFW . lastGamepadStateFrame || ! Browser . mainLoop . currentFrameNumber ) {
GLFW . lastGamepadState = navigator . getGamepads ? navigator . getGamepads ( ) : ( navigator . webkitGetGamepads ? navigator . webkitGetGamepads : [ ] ) ;
GLFW . lastGamepadStateFrame = Browser . mainLoop . currentFrameNumber ;
for ( var joy = 0 ; joy < GLFW . lastGamepadState . length ; ++ joy ) {
var gamepad = GLFW . lastGamepadState [ joy ] ;
if ( gamepad ) {
if ( ! GLFW . joys [ joy ] ) {
out ( 'glfw joystick connected:' , joy ) ;
GLFW . joys [ joy ] = {
id : allocateUTF8 ( gamepad . id ) ,
buttonsCount : gamepad . buttons . length ,
axesCount : gamepad . axes . length ,
buttons : _malloc ( gamepad . buttons . length ) ,
axes : _malloc ( gamepad . axes . length * 4 ) ,
} ;
if ( GLFW . joystickFunc ) {
getWasmTableEntry ( GLFW . joystickFunc ) ( joy , 0x00040001 ) ; // GLFW_CONNECTED
}
}
var data = GLFW . joys [ joy ] ;
for ( var i = 0 ; i < gamepad . buttons . length ; ++ i ) {
setValue ( data . buttons + i , gamepad . buttons [ i ] . pressed , 'i8' ) ;
}
for ( var i = 0 ; i < gamepad . axes . length ; ++ i ) {
setValue ( data . axes + i * 4 , gamepad . axes [ i ] , 'float' ) ;
}
} else {
if ( GLFW . joys [ joy ] ) {
out ( 'glfw joystick disconnected' , joy ) ;
if ( GLFW . joystickFunc ) {
getWasmTableEntry ( GLFW . joystickFunc ) ( joy , 0x00040002 ) ; // GLFW_DISCONNECTED
}
_free ( GLFW . joys [ joy ] . id ) ;
_free ( GLFW . joys [ joy ] . buttons ) ;
_free ( GLFW . joys [ joy ] . axes ) ;
delete GLFW . joys [ joy ] ;
}
}
}
}
} , setKeyCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . keyFunc ;
win . keyFunc = cbfun ;
return prevcbfun ;
} , setCharCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . charFunc ;
win . charFunc = cbfun ;
return prevcbfun ;
} , setMouseButtonCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . mouseButtonFunc ;
win . mouseButtonFunc = cbfun ;
return prevcbfun ;
} , setCursorPosCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . cursorPosFunc ;
win . cursorPosFunc = cbfun ;
return prevcbfun ;
} , setScrollCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . scrollFunc ;
win . scrollFunc = cbfun ;
return prevcbfun ;
} , setDropCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . dropFunc ;
win . dropFunc = cbfun ;
return prevcbfun ;
} , onDrop : function ( event ) {
if ( ! GLFW . active || ! GLFW . active . dropFunc ) return ;
if ( ! event . dataTransfer || ! event . dataTransfer . files || event . dataTransfer . files . length == 0 ) return ;
event . preventDefault ( ) ;
var filenames = _malloc ( event . dataTransfer . files . length * 4 ) ;
var filenamesArray = [ ] ;
var count = event . dataTransfer . files . length ;
// Read and save the files to emscripten's FS
var written = 0 ;
var drop _dir = '.glfw_dropped_files' ;
FS . createPath ( '/' , drop _dir ) ;
function save ( file ) {
var path = '/' + drop _dir + '/' + file . name . replace ( /\//g , '_' ) ;
var reader = new FileReader ( ) ;
reader . onloadend = ( e ) => {
if ( reader . readyState != 2 ) { // not DONE
++ written ;
out ( 'failed to read dropped file: ' + file . name + ': ' + reader . error ) ;
return ;
}
var data = e . target . result ;
FS . writeFile ( path , new Uint8Array ( data ) ) ;
if ( ++ written === count ) {
getWasmTableEntry ( GLFW . active . dropFunc ) ( GLFW . active . id , count , filenames ) ;
for ( var i = 0 ; i < filenamesArray . length ; ++ i ) {
_free ( filenamesArray [ i ] ) ;
}
_free ( filenames ) ;
}
} ;
reader . readAsArrayBuffer ( file ) ;
var filename = allocateUTF8 ( path ) ;
filenamesArray . push ( filename ) ;
setValue ( filenames + i * 4 , filename , 'i8*' ) ;
}
for ( var i = 0 ; i < count ; ++ i ) {
save ( event . dataTransfer . files [ i ] ) ;
}
return false ;
} , onDragover : function ( event ) {
if ( ! GLFW . active || ! GLFW . active . dropFunc ) return ;
event . preventDefault ( ) ;
return false ;
} , setWindowSizeCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . windowSizeFunc ;
win . windowSizeFunc = cbfun ;
return prevcbfun ;
} , setWindowCloseCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . windowCloseFunc ;
win . windowCloseFunc = cbfun ;
return prevcbfun ;
} , setWindowRefreshCallback : function ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . windowRefreshFunc ;
win . windowRefreshFunc = cbfun ;
return prevcbfun ;
} , onClickRequestPointerLock : function ( e ) {
if ( ! Browser . pointerLock && Module [ 'canvas' ] . requestPointerLock ) {
Module [ 'canvas' ] . requestPointerLock ( ) ;
e . preventDefault ( ) ;
}
} , setInputMode : function ( winid , mode , value ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return ;
switch ( mode ) {
case 0x00033001 : { // GLFW_CURSOR
switch ( value ) {
case 0x00034001 : { // GLFW_CURSOR_NORMAL
win . inputModes [ mode ] = value ;
Module [ 'canvas' ] . removeEventListener ( 'click' , GLFW . onClickRequestPointerLock , true ) ;
Module [ 'canvas' ] . exitPointerLock ( ) ;
break ;
}
case 0x00034002 : { // GLFW_CURSOR_HIDDEN
out ( "glfwSetInputMode called with GLFW_CURSOR_HIDDEN value not implemented." ) ;
break ;
}
case 0x00034003 : { // GLFW_CURSOR_DISABLED
win . inputModes [ mode ] = value ;
Module [ 'canvas' ] . addEventListener ( 'click' , GLFW . onClickRequestPointerLock , true ) ;
Module [ 'canvas' ] . requestPointerLock ( ) ;
break ;
}
default : {
out ( "glfwSetInputMode called with unknown value parameter value: " + value + "." ) ;
break ;
}
}
break ;
}
case 0x00033002 : { // GLFW_STICKY_KEYS
out ( "glfwSetInputMode called with GLFW_STICKY_KEYS mode not implemented." ) ;
break ;
}
case 0x00033003 : { // GLFW_STICKY_MOUSE_BUTTONS
out ( "glfwSetInputMode called with GLFW_STICKY_MOUSE_BUTTONS mode not implemented." ) ;
break ;
}
default : {
out ( "glfwSetInputMode called with unknown mode parameter value: " + mode + "." ) ;
break ;
}
}
} , getKey : function ( winid , key ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return 0 ;
return win . keys [ key ] ;
} , getMouseButton : function ( winid , button ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return 0 ;
return ( win . buttons & ( 1 << button ) ) > 0 ;
} , getCursorPos : function ( winid , x , y ) {
setValue ( x , Browser . mouseX , 'double' ) ;
setValue ( y , Browser . mouseY , 'double' ) ;
} , getMousePos : function ( winid , x , y ) {
setValue ( x , Browser . mouseX , 'i32' ) ;
setValue ( y , Browser . mouseY , 'i32' ) ;
} , setCursorPos : function ( winid , x , y ) {
} , getWindowPos : function ( winid , x , y ) {
var wx = 0 ;
var wy = 0 ;
var win = GLFW . WindowFromId ( winid ) ;
if ( win ) {
wx = win . x ;
wy = win . y ;
}
if ( x ) {
setValue ( x , wx , 'i32' ) ;
}
if ( y ) {
setValue ( y , wy , 'i32' ) ;
}
} , setWindowPos : function ( winid , x , y ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return ;
win . x = x ;
win . y = y ;
} , getWindowSize : function ( winid , width , height ) {
var ww = 0 ;
var wh = 0 ;
var win = GLFW . WindowFromId ( winid ) ;
if ( win ) {
ww = win . width ;
wh = win . height ;
}
if ( width ) {
setValue ( width , ww , 'i32' ) ;
}
if ( height ) {
setValue ( height , wh , 'i32' ) ;
}
} , setWindowSize : function ( winid , width , height ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return ;
if ( GLFW . active . id == win . id ) {
if ( width == screen . width && height == screen . height ) {
Browser . requestFullscreen ( ) ;
} else {
Browser . exitFullscreen ( ) ;
Browser . setCanvasSize ( width , height ) ;
win . width = width ;
win . height = height ;
}
}
if ( ! win . windowSizeFunc ) return ;
getWasmTableEntry ( win . windowSizeFunc ) ( win . id , width , height ) ;
} , createWindow : function ( width , height , title , monitor , share ) {
var i , id ;
for ( i = 0 ; i < GLFW . windows . length && GLFW . windows [ i ] !== null ; i ++ ) {
// no-op
}
if ( i > 0 ) throw "glfwCreateWindow only supports one window at time currently" ;
// id for window
id = i + 1 ;
// not valid
if ( width <= 0 || height <= 0 ) return 0 ;
if ( monitor ) {
Browser . requestFullscreen ( ) ;
} else {
Browser . setCanvasSize ( width , height ) ;
}
// Create context when there are no existing alive windows
for ( i = 0 ; i < GLFW . windows . length && GLFW . windows [ i ] == null ; i ++ ) {
// no-op
}
var useWebGL = GLFW . hints [ 0x00022001 ] > 0 ; // Use WebGL when we are told to based on GLFW_CLIENT_API
if ( i == GLFW . windows . length ) {
if ( useWebGL ) {
var contextAttributes = {
antialias : ( GLFW . hints [ 0x0002100D ] > 1 ) , // GLFW_SAMPLES
depth : ( GLFW . hints [ 0x00021005 ] > 0 ) , // GLFW_DEPTH_BITS
stencil : ( GLFW . hints [ 0x00021006 ] > 0 ) , // GLFW_STENCIL_BITS
alpha : ( GLFW . hints [ 0x00021004 ] > 0 ) // GLFW_ALPHA_BITS
}
Module . ctx = Browser . createContext ( Module [ 'canvas' ] , true , true , contextAttributes ) ;
} else {
Browser . init ( ) ;
}
}
// If context creation failed, do not return a valid window
if ( ! Module . ctx && useWebGL ) return 0 ;
// Get non alive id
var win = new GLFW _Window ( id , width , height , title , monitor , share ) ;
// Set window to array
if ( id - 1 == GLFW . windows . length ) {
GLFW . windows . push ( win ) ;
} else {
GLFW . windows [ id - 1 ] = win ;
}
GLFW . active = win ;
return win . id ;
} , destroyWindow : function ( winid ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return ;
if ( win . windowCloseFunc )
getWasmTableEntry ( win . windowCloseFunc ) ( win . id ) ;
GLFW . windows [ win . id - 1 ] = null ;
if ( GLFW . active . id == win . id )
GLFW . active = null ;
// Destroy context when no alive windows
for ( var i = 0 ; i < GLFW . windows . length ; i ++ )
if ( GLFW . windows [ i ] !== null ) return ;
Module . ctx = Browser . destroyContext ( Module [ 'canvas' ] , true , true ) ;
} , swapBuffers : function ( winid ) {
} , GLFW2ParamToGLFW3Param : function ( param ) {
var table = {
0x00030001 : 0 , // GLFW_MOUSE_CURSOR
0x00030002 : 0 , // GLFW_STICKY_KEYS
0x00030003 : 0 , // GLFW_STICKY_MOUSE_BUTTONS
0x00030004 : 0 , // GLFW_SYSTEM_KEYS
0x00030005 : 0 , // GLFW_KEY_REPEAT
0x00030006 : 0 , // GLFW_AUTO_POLL_EVENTS
0x00020001 : 0 , // GLFW_OPENED
0x00020002 : 0 , // GLFW_ACTIVE
0x00020003 : 0 , // GLFW_ICONIFIED
0x00020004 : 0 , // GLFW_ACCELERATED
0x00020005 : 0x00021001 , // GLFW_RED_BITS
0x00020006 : 0x00021002 , // GLFW_GREEN_BITS
0x00020007 : 0x00021003 , // GLFW_BLUE_BITS
0x00020008 : 0x00021004 , // GLFW_ALPHA_BITS
0x00020009 : 0x00021005 , // GLFW_DEPTH_BITS
0x0002000A : 0x00021006 , // GLFW_STENCIL_BITS
0x0002000B : 0x0002100F , // GLFW_REFRESH_RATE
0x0002000C : 0x00021007 , // GLFW_ACCUM_RED_BITS
0x0002000D : 0x00021008 , // GLFW_ACCUM_GREEN_BITS
0x0002000E : 0x00021009 , // GLFW_ACCUM_BLUE_BITS
0x0002000F : 0x0002100A , // GLFW_ACCUM_ALPHA_BITS
0x00020010 : 0x0002100B , // GLFW_AUX_BUFFERS
0x00020011 : 0x0002100C , // GLFW_STEREO
0x00020012 : 0 , // GLFW_WINDOW_NO_RESIZE
0x00020013 : 0x0002100D , // GLFW_FSAA_SAMPLES
0x00020014 : 0x00022002 , // GLFW_OPENGL_VERSION_MAJOR
0x00020015 : 0x00022003 , // GLFW_OPENGL_VERSION_MINOR
0x00020016 : 0x00022006 , // GLFW_OPENGL_FORWARD_COMPAT
0x00020017 : 0x00022007 , // GLFW_OPENGL_DEBUG_CONTEXT
0x00020018 : 0x00022008 , // GLFW_OPENGL_PROFILE
} ;
return table [ param ] ;
} } ;
function _glfwCreateWindow ( width , height , title , monitor , share ) {
return GLFW . createWindow ( width , height , title , monitor , share ) ;
}
function _glfwDestroyWindow ( winid ) {
return GLFW . destroyWindow ( winid ) ;
}
function _glfwInit ( ) {
if ( GLFW . windows ) return 1 ; // GL_TRUE
GLFW . initialTime = GLFW . getTime ( ) ;
GLFW . hints = GLFW . defaultHints ;
GLFW . windows = new Array ( )
GLFW . active = null ;
window . addEventListener ( "gamepadconnected" , GLFW . onGamepadConnected , true ) ;
window . addEventListener ( "gamepaddisconnected" , GLFW . onGamepadDisconnected , true ) ;
window . addEventListener ( "keydown" , GLFW . onKeydown , true ) ;
window . addEventListener ( "keypress" , GLFW . onKeyPress , true ) ;
window . addEventListener ( "keyup" , GLFW . onKeyup , true ) ;
window . addEventListener ( "blur" , GLFW . onBlur , true ) ;
Module [ "canvas" ] . addEventListener ( "touchmove" , GLFW . onMousemove , true ) ;
Module [ "canvas" ] . addEventListener ( "touchstart" , GLFW . onMouseButtonDown , true ) ;
Module [ "canvas" ] . addEventListener ( "touchcancel" , GLFW . onMouseButtonUp , true ) ;
Module [ "canvas" ] . addEventListener ( "touchend" , GLFW . onMouseButtonUp , true ) ;
Module [ "canvas" ] . addEventListener ( "mousemove" , GLFW . onMousemove , true ) ;
Module [ "canvas" ] . addEventListener ( "mousedown" , GLFW . onMouseButtonDown , true ) ;
Module [ "canvas" ] . addEventListener ( "mouseup" , GLFW . onMouseButtonUp , true ) ;
Module [ "canvas" ] . addEventListener ( 'wheel' , GLFW . onMouseWheel , true ) ;
Module [ "canvas" ] . addEventListener ( 'mousewheel' , GLFW . onMouseWheel , true ) ;
Module [ "canvas" ] . addEventListener ( 'mouseenter' , GLFW . onMouseenter , true ) ;
Module [ "canvas" ] . addEventListener ( 'mouseleave' , GLFW . onMouseleave , true ) ;
Module [ "canvas" ] . addEventListener ( 'drop' , GLFW . onDrop , true ) ;
Module [ "canvas" ] . addEventListener ( 'dragover' , GLFW . onDragover , true ) ;
Browser . resizeListeners . push ( function ( width , height ) {
GLFW . onCanvasResize ( width , height ) ;
} ) ;
return 1 ; // GL_TRUE
}
function _glfwMakeContextCurrent ( winid ) { }
function _glfwPollEvents ( ) { }
function _glfwSetErrorCallback ( cbfun ) {
var prevcbfun = GLFW . errorFunc ;
GLFW . errorFunc = cbfun ;
return prevcbfun ;
}
function _glfwSetFramebufferSizeCallback ( winid , cbfun ) {
var win = GLFW . WindowFromId ( winid ) ;
if ( ! win ) return null ;
var prevcbfun = win . framebufferSizeFunc ;
win . framebufferSizeFunc = cbfun ;
return prevcbfun ;
}
function _glfwSetKeyCallback ( winid , cbfun ) {
return GLFW . setKeyCallback ( winid , cbfun ) ;
}
function _glfwSetMouseButtonCallback ( winid , cbfun ) {
return GLFW . setMouseButtonCallback ( winid , cbfun ) ;
}
function _glfwSwapBuffers ( winid ) {
GLFW . swapBuffers ( winid ) ;
}
function _glfwSwapInterval ( interval ) {
interval = Math . abs ( interval ) ; // GLFW uses negative values to enable GLX_EXT_swap_control_tear, which we don't have, so just treat negative and positive the same.
if ( interval == 0 ) _emscripten _set _main _loop _timing ( 0 /*EM_TIMING_SETTIMEOUT*/ , 0 ) ;
else _emscripten _set _main _loop _timing ( 1 /*EM_TIMING_RAF*/ , interval ) ;
}
function _glfwTerminate ( ) {
window . removeEventListener ( "gamepadconnected" , GLFW . onGamepadConnected , true ) ;
window . removeEventListener ( "gamepaddisconnected" , GLFW . onGamepadDisconnected , true ) ;
window . removeEventListener ( "keydown" , GLFW . onKeydown , true ) ;
window . removeEventListener ( "keypress" , GLFW . onKeyPress , true ) ;
window . removeEventListener ( "keyup" , GLFW . onKeyup , true ) ;
window . removeEventListener ( "blur" , GLFW . onBlur , true ) ;
Module [ "canvas" ] . removeEventListener ( "touchmove" , GLFW . onMousemove , true ) ;
Module [ "canvas" ] . removeEventListener ( "touchstart" , GLFW . onMouseButtonDown , true ) ;
Module [ "canvas" ] . removeEventListener ( "touchcancel" , GLFW . onMouseButtonUp , true ) ;
Module [ "canvas" ] . removeEventListener ( "touchend" , GLFW . onMouseButtonUp , true ) ;
Module [ "canvas" ] . removeEventListener ( "mousemove" , GLFW . onMousemove , true ) ;
Module [ "canvas" ] . removeEventListener ( "mousedown" , GLFW . onMouseButtonDown , true ) ;
Module [ "canvas" ] . removeEventListener ( "mouseup" , GLFW . onMouseButtonUp , true ) ;
Module [ "canvas" ] . removeEventListener ( 'wheel' , GLFW . onMouseWheel , true ) ;
Module [ "canvas" ] . removeEventListener ( 'mousewheel' , GLFW . onMouseWheel , true ) ;
Module [ "canvas" ] . removeEventListener ( 'mouseenter' , GLFW . onMouseenter , true ) ;
Module [ "canvas" ] . removeEventListener ( 'mouseleave' , GLFW . onMouseleave , true ) ;
Module [ "canvas" ] . removeEventListener ( 'drop' , GLFW . onDrop , true ) ;
Module [ "canvas" ] . removeEventListener ( 'dragover' , GLFW . onDragover , true ) ;
Module [ "canvas" ] . width = Module [ "canvas" ] . height = 1 ;
GLFW . windows = null ;
GLFW . active = null ;
}
function _glfwWindowHint ( target , hint ) {
GLFW . hints [ target ] = hint ;
}
function _setTempRet0 ( val ) {
setTempRet0 ( val ) ;
}
function _ _isLeapYear ( year ) {
return year % 4 === 0 && ( year % 100 !== 0 || year % 400 === 0 ) ;
}
function _ _arraySum ( array , index ) {
var sum = 0 ;
for ( var i = 0 ; i <= index ; sum += array [ i ++ ] ) {
// no-op
}
return sum ;
}
var _ _MONTH _DAYS _LEAP = [ 31 , 29 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 ] ;
var _ _MONTH _DAYS _REGULAR = [ 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 ] ;
function _ _addDays ( date , days ) {
var newDate = new Date ( date . getTime ( ) ) ;
while ( days > 0 ) {
var leap = _ _isLeapYear ( newDate . getFullYear ( ) ) ;
var currentMonth = newDate . getMonth ( ) ;
var daysInCurrentMonth = ( leap ? _ _MONTH _DAYS _LEAP : _ _MONTH _DAYS _REGULAR ) [ currentMonth ] ;
if ( days > daysInCurrentMonth - newDate . getDate ( ) ) {
// we spill over to next month
days -= ( daysInCurrentMonth - newDate . getDate ( ) + 1 ) ;
newDate . setDate ( 1 ) ;
if ( currentMonth < 11 ) {
newDate . setMonth ( currentMonth + 1 )
} else {
newDate . setMonth ( 0 ) ;
newDate . setFullYear ( newDate . getFullYear ( ) + 1 ) ;
}
} else {
// we stay in current month
newDate . setDate ( newDate . getDate ( ) + days ) ;
return newDate ;
}
}
return newDate ;
}
function _strftime ( s , maxsize , format , tm ) {
// size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
// http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
var tm _zone = HEAP32 [ ( ( ( tm ) + ( 40 ) ) >> 2 ) ] ;
var date = {
tm _sec : HEAP32 [ ( ( tm ) >> 2 ) ] ,
tm _min : HEAP32 [ ( ( ( tm ) + ( 4 ) ) >> 2 ) ] ,
tm _hour : HEAP32 [ ( ( ( tm ) + ( 8 ) ) >> 2 ) ] ,
tm _mday : HEAP32 [ ( ( ( tm ) + ( 12 ) ) >> 2 ) ] ,
tm _mon : HEAP32 [ ( ( ( tm ) + ( 16 ) ) >> 2 ) ] ,
tm _year : HEAP32 [ ( ( ( tm ) + ( 20 ) ) >> 2 ) ] ,
tm _wday : HEAP32 [ ( ( ( tm ) + ( 24 ) ) >> 2 ) ] ,
tm _yday : HEAP32 [ ( ( ( tm ) + ( 28 ) ) >> 2 ) ] ,
tm _isdst : HEAP32 [ ( ( ( tm ) + ( 32 ) ) >> 2 ) ] ,
tm _gmtoff : HEAP32 [ ( ( ( tm ) + ( 36 ) ) >> 2 ) ] ,
tm _zone : tm _zone ? UTF8ToString ( tm _zone ) : ''
} ;
var pattern = UTF8ToString ( format ) ;
// expand format
var EXPANSION _RULES _1 = {
'%c' : '%a %b %d %H:%M:%S %Y' , // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013
'%D' : '%m/%d/%y' , // Equivalent to %m / %d / %y
'%F' : '%Y-%m-%d' , // Equivalent to %Y - %m - %d
'%h' : '%b' , // Equivalent to %b
'%r' : '%I:%M:%S %p' , // Replaced by the time in a.m. and p.m. notation
'%R' : '%H:%M' , // Replaced by the time in 24-hour notation
'%T' : '%H:%M:%S' , // Replaced by the time
'%x' : '%m/%d/%y' , // Replaced by the locale's appropriate date representation
'%X' : '%H:%M:%S' , // Replaced by the locale's appropriate time representation
// Modified Conversion Specifiers
'%Ec' : '%c' , // Replaced by the locale's alternative appropriate date and time representation.
'%EC' : '%C' , // Replaced by the name of the base year (period) in the locale's alternative representation.
'%Ex' : '%m/%d/%y' , // Replaced by the locale's alternative date representation.
'%EX' : '%H:%M:%S' , // Replaced by the locale's alternative time representation.
'%Ey' : '%y' , // Replaced by the offset from %EC (year only) in the locale's alternative representation.
'%EY' : '%Y' , // Replaced by the full alternative year representation.
'%Od' : '%d' , // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading zeros if there is any alternative symbol for zero; otherwise, with leading <space> characters.
'%Oe' : '%e' , // Replaced by the day of the month, using the locale's alternative numeric symbols, filled as needed with leading <space> characters.
'%OH' : '%H' , // Replaced by the hour (24-hour clock) using the locale's alternative numeric symbols.
'%OI' : '%I' , // Replaced by the hour (12-hour clock) using the locale's alternative numeric symbols.
'%Om' : '%m' , // Replaced by the month using the locale's alternative numeric symbols.
'%OM' : '%M' , // Replaced by the minutes using the locale's alternative numeric symbols.
'%OS' : '%S' , // Replaced by the seconds using the locale's alternative numeric symbols.
'%Ou' : '%u' , // Replaced by the weekday as a number in the locale's alternative representation (Monday=1).
'%OU' : '%U' , // Replaced by the week number of the year (Sunday as the first day of the week, rules corresponding to %U ) using the locale's alternative numeric symbols.
'%OV' : '%V' , // Replaced by the week number of the year (Monday as the first day of the week, rules corresponding to %V ) using the locale's alternative numeric symbols.
'%Ow' : '%w' , // Replaced by the number of the weekday (Sunday=0) using the locale's alternative numeric symbols.
'%OW' : '%W' , // Replaced by the week number of the year (Monday as the first day of the week) using the locale's alternative numeric symbols.
'%Oy' : '%y' , // Replaced by the year (offset from %C ) using the locale's alternative numeric symbols.
} ;
for ( var rule in EXPANSION _RULES _1 ) {
pattern = pattern . replace ( new RegExp ( rule , 'g' ) , EXPANSION _RULES _1 [ rule ] ) ;
}
var WEEKDAYS = [ 'Sunday' , 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' , 'Saturday' ] ;
var MONTHS = [ 'January' , 'February' , 'March' , 'April' , 'May' , 'June' , 'July' , 'August' , 'September' , 'October' , 'November' , 'December' ] ;
function leadingSomething ( value , digits , character ) {
var str = typeof value == 'number' ? value . toString ( ) : ( value || '' ) ;
while ( str . length < digits ) {
str = character [ 0 ] + str ;
}
return str ;
}
function leadingNulls ( value , digits ) {
return leadingSomething ( value , digits , '0' ) ;
}
function compareByDay ( date1 , date2 ) {
function sgn ( value ) {
return value < 0 ? - 1 : ( value > 0 ? 1 : 0 ) ;
}
var compare ;
if ( ( compare = sgn ( date1 . getFullYear ( ) - date2 . getFullYear ( ) ) ) === 0 ) {
if ( ( compare = sgn ( date1 . getMonth ( ) - date2 . getMonth ( ) ) ) === 0 ) {
compare = sgn ( date1 . getDate ( ) - date2 . getDate ( ) ) ;
}
}
return compare ;
}
function getFirstWeekStartDate ( janFourth ) {
switch ( janFourth . getDay ( ) ) {
case 0 : // Sunday
return new Date ( janFourth . getFullYear ( ) - 1 , 11 , 29 ) ;
case 1 : // Monday
return janFourth ;
case 2 : // Tuesday
return new Date ( janFourth . getFullYear ( ) , 0 , 3 ) ;
case 3 : // Wednesday
return new Date ( janFourth . getFullYear ( ) , 0 , 2 ) ;
case 4 : // Thursday
return new Date ( janFourth . getFullYear ( ) , 0 , 1 ) ;
case 5 : // Friday
return new Date ( janFourth . getFullYear ( ) - 1 , 11 , 31 ) ;
case 6 : // Saturday
return new Date ( janFourth . getFullYear ( ) - 1 , 11 , 30 ) ;
}
}
function getWeekBasedYear ( date ) {
var thisDate = _ _addDays ( new Date ( date . tm _year + 1900 , 0 , 1 ) , date . tm _yday ) ;
var janFourthThisYear = new Date ( thisDate . getFullYear ( ) , 0 , 4 ) ;
var janFourthNextYear = new Date ( thisDate . getFullYear ( ) + 1 , 0 , 4 ) ;
var firstWeekStartThisYear = getFirstWeekStartDate ( janFourthThisYear ) ;
var firstWeekStartNextYear = getFirstWeekStartDate ( janFourthNextYear ) ;
if ( compareByDay ( firstWeekStartThisYear , thisDate ) <= 0 ) {
// this date is after the start of the first week of this year
if ( compareByDay ( firstWeekStartNextYear , thisDate ) <= 0 ) {
return thisDate . getFullYear ( ) + 1 ;
} else {
return thisDate . getFullYear ( ) ;
}
} else {
return thisDate . getFullYear ( ) - 1 ;
}
}
var EXPANSION _RULES _2 = {
'%a' : function ( date ) {
return WEEKDAYS [ date . tm _wday ] . substring ( 0 , 3 ) ;
} ,
'%A' : function ( date ) {
return WEEKDAYS [ date . tm _wday ] ;
} ,
'%b' : function ( date ) {
return MONTHS [ date . tm _mon ] . substring ( 0 , 3 ) ;
} ,
'%B' : function ( date ) {
return MONTHS [ date . tm _mon ] ;
} ,
'%C' : function ( date ) {
var year = date . tm _year + 1900 ;
return leadingNulls ( ( year / 100 ) | 0 , 2 ) ;
} ,
'%d' : function ( date ) {
return leadingNulls ( date . tm _mday , 2 ) ;
} ,
'%e' : function ( date ) {
return leadingSomething ( date . tm _mday , 2 , ' ' ) ;
} ,
'%g' : function ( date ) {
// %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
// In this system, weeks begin on a Monday and week 1 of the year is the week that includes
// January 4th, which is also the week that includes the first Thursday of the year, and
// is also the first week that contains at least four days in the year.
// If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of
// the last week of the preceding year; thus, for Saturday 2nd January 1999,
// %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th,
// or 31st is a Monday, it and any following days are part of week 1 of the following year.
// Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01.
return getWeekBasedYear ( date ) . toString ( ) . substring ( 2 ) ;
} ,
'%G' : function ( date ) {
return getWeekBasedYear ( date ) ;
} ,
'%H' : function ( date ) {
return leadingNulls ( date . tm _hour , 2 ) ;
} ,
'%I' : function ( date ) {
var twelveHour = date . tm _hour ;
if ( twelveHour == 0 ) twelveHour = 12 ;
else if ( twelveHour > 12 ) twelveHour -= 12 ;
return leadingNulls ( twelveHour , 2 ) ;
} ,
'%j' : function ( date ) {
// Day of the year (001-366)
return leadingNulls ( date . tm _mday + _ _arraySum ( _ _isLeapYear ( date . tm _year + 1900 ) ? _ _MONTH _DAYS _LEAP : _ _MONTH _DAYS _REGULAR , date . tm _mon - 1 ) , 3 ) ;
} ,
'%m' : function ( date ) {
return leadingNulls ( date . tm _mon + 1 , 2 ) ;
} ,
'%M' : function ( date ) {
return leadingNulls ( date . tm _min , 2 ) ;
} ,
'%n' : function ( ) {
return '\n' ;
} ,
'%p' : function ( date ) {
if ( date . tm _hour >= 0 && date . tm _hour < 12 ) {
return 'AM' ;
} else {
return 'PM' ;
}
} ,
'%S' : function ( date ) {
return leadingNulls ( date . tm _sec , 2 ) ;
} ,
'%t' : function ( ) {
return '\t' ;
} ,
'%u' : function ( date ) {
return date . tm _wday || 7 ;
} ,
'%U' : function ( date ) {
// Replaced by the week number of the year as a decimal number [00,53].
// The first Sunday of January is the first day of week 1;
// days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
var janFirst = new Date ( date . tm _year + 1900 , 0 , 1 ) ;
var firstSunday = janFirst . getDay ( ) === 0 ? janFirst : _ _addDays ( janFirst , 7 - janFirst . getDay ( ) ) ;
var endDate = new Date ( date . tm _year + 1900 , date . tm _mon , date . tm _mday ) ;
// is target date after the first Sunday?
if ( compareByDay ( firstSunday , endDate ) < 0 ) {
// calculate difference in days between first Sunday and endDate
var februaryFirstUntilEndMonth = _ _arraySum ( _ _isLeapYear ( endDate . getFullYear ( ) ) ? _ _MONTH _DAYS _LEAP : _ _MONTH _DAYS _REGULAR , endDate . getMonth ( ) - 1 ) - 31 ;
var firstSundayUntilEndJanuary = 31 - firstSunday . getDate ( ) ;
var days = firstSundayUntilEndJanuary + februaryFirstUntilEndMonth + endDate . getDate ( ) ;
return leadingNulls ( Math . ceil ( days / 7 ) , 2 ) ;
}
return compareByDay ( firstSunday , janFirst ) === 0 ? '01' : '00' ;
} ,
'%V' : function ( date ) {
// Replaced by the week number of the year (Monday as the first day of the week)
// as a decimal number [01,53]. If the week containing 1 January has four
// or more days in the new year, then it is considered week 1.
// Otherwise, it is the last week of the previous year, and the next week is week 1.
// Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday]
var janFourthThisYear = new Date ( date . tm _year + 1900 , 0 , 4 ) ;
var janFourthNextYear = new Date ( date . tm _year + 1901 , 0 , 4 ) ;
var firstWeekStartThisYear = getFirstWeekStartDate ( janFourthThisYear ) ;
var firstWeekStartNextYear = getFirstWeekStartDate ( janFourthNextYear ) ;
var endDate = _ _addDays ( new Date ( date . tm _year + 1900 , 0 , 1 ) , date . tm _yday ) ;
if ( compareByDay ( endDate , firstWeekStartThisYear ) < 0 ) {
// if given date is before this years first week, then it belongs to the 53rd week of last year
return '53' ;
}
if ( compareByDay ( firstWeekStartNextYear , endDate ) <= 0 ) {
// if given date is after next years first week, then it belongs to the 01th week of next year
return '01' ;
}
// given date is in between CW 01..53 of this calendar year
var daysDifference ;
if ( firstWeekStartThisYear . getFullYear ( ) < date . tm _year + 1900 ) {
// first CW of this year starts last year
daysDifference = date . tm _yday + 32 - firstWeekStartThisYear . getDate ( )
} else {
// first CW of this year starts this year
daysDifference = date . tm _yday + 1 - firstWeekStartThisYear . getDate ( ) ;
}
return leadingNulls ( Math . ceil ( daysDifference / 7 ) , 2 ) ;
} ,
'%w' : function ( date ) {
return date . tm _wday ;
} ,
'%W' : function ( date ) {
// Replaced by the week number of the year as a decimal number [00,53].
// The first Monday of January is the first day of week 1;
// days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
var janFirst = new Date ( date . tm _year , 0 , 1 ) ;
var firstMonday = janFirst . getDay ( ) === 1 ? janFirst : _ _addDays ( janFirst , janFirst . getDay ( ) === 0 ? 1 : 7 - janFirst . getDay ( ) + 1 ) ;
var endDate = new Date ( date . tm _year + 1900 , date . tm _mon , date . tm _mday ) ;
// is target date after the first Monday?
if ( compareByDay ( firstMonday , endDate ) < 0 ) {
var februaryFirstUntilEndMonth = _ _arraySum ( _ _isLeapYear ( endDate . getFullYear ( ) ) ? _ _MONTH _DAYS _LEAP : _ _MONTH _DAYS _REGULAR , endDate . getMonth ( ) - 1 ) - 31 ;
var firstMondayUntilEndJanuary = 31 - firstMonday . getDate ( ) ;
var days = firstMondayUntilEndJanuary + februaryFirstUntilEndMonth + endDate . getDate ( ) ;
return leadingNulls ( Math . ceil ( days / 7 ) , 2 ) ;
}
return compareByDay ( firstMonday , janFirst ) === 0 ? '01' : '00' ;
} ,
'%y' : function ( date ) {
// Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
return ( date . tm _year + 1900 ) . toString ( ) . substring ( 2 ) ;
} ,
'%Y' : function ( date ) {
// Replaced by the year as a decimal number (for example, 1997). [ tm_year]
return date . tm _year + 1900 ;
} ,
'%z' : function ( date ) {
// Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ).
// For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
var off = date . tm _gmtoff ;
var ahead = off >= 0 ;
off = Math . abs ( off ) / 60 ;
// convert from minutes into hhmm format (which means 60 minutes = 100 units)
off = ( off / 60 ) * 100 + ( off % 60 ) ;
return ( ahead ? '+' : '-' ) + String ( "0000" + off ) . slice ( - 4 ) ;
} ,
'%Z' : function ( date ) {
return date . tm _zone ;
} ,
'%%' : function ( ) {
return '%' ;
}
} ;
// Replace %% with a pair of NULLs (which cannot occur in a C string), then
// re-inject them after processing.
pattern = pattern . replace ( /%%/g , '\0\0' )
for ( var rule in EXPANSION _RULES _2 ) {
if ( pattern . includes ( rule ) ) {
pattern = pattern . replace ( new RegExp ( rule , 'g' ) , EXPANSION _RULES _2 [ rule ] ( date ) ) ;
}
}
pattern = pattern . replace ( /\0\0/g , '%' )
var bytes = intArrayFromString ( pattern , false ) ;
if ( bytes . length > maxsize ) {
return 0 ;
}
writeArrayToMemory ( bytes , s ) ;
return bytes . length - 1 ;
}
function _strftime _l ( s , maxsize , format , tm ) {
return _strftime ( s , maxsize , format , tm ) ; // no locale support yet
}
function _time ( ptr ) {
;
var ret = ( Date . now ( ) / 1000 ) | 0 ;
if ( ptr ) {
HEAP32 [ ( ( ptr ) >> 2 ) ] = ret ;
}
return ret ;
}
var FSNode = /** @constructor */ function ( parent , name , mode , rdev ) {
if ( ! parent ) {
parent = this ; // root node sets parent to itself
}
this . parent = parent ;
this . mount = parent . mount ;
this . mounted = null ;
this . id = FS . nextInode ++ ;
this . name = name ;
this . mode = mode ;
this . node _ops = { } ;
this . stream _ops = { } ;
this . rdev = rdev ;
} ;
var readMode = 292 /*292*/ | 73 /*73*/ ;
var writeMode = 146 /*146*/ ;
Object . defineProperties ( FSNode . prototype , {
read : {
get : /** @this{FSNode} */ function ( ) {
return ( this . mode & readMode ) === readMode ;
} ,
set : /** @this{FSNode} */ function ( val ) {
val ? this . mode |= readMode : this . mode &= ~ readMode ;
}
} ,
write : {
get : /** @this{FSNode} */ function ( ) {
return ( this . mode & writeMode ) === writeMode ;
} ,
set : /** @this{FSNode} */ function ( val ) {
val ? this . mode |= writeMode : this . mode &= ~ writeMode ;
}
} ,
isFolder : {
get : /** @this{FSNode} */ function ( ) {
return FS . isDir ( this . mode ) ;
}
} ,
isDevice : {
get : /** @this{FSNode} */ function ( ) {
return FS . isChrdev ( this . mode ) ;
}
}
} ) ;
FS . FSNode = FSNode ;
FS . staticInit ( ) ; Module [ "FS_createPath" ] = FS . createPath ; Module [ "FS_createDataFile" ] = FS . createDataFile ; Module [ "FS_createPreloadedFile" ] = FS . createPreloadedFile ; Module [ "FS_createLazyFile" ] = FS . createLazyFile ; Module [ "FS_createDevice" ] = FS . createDevice ; Module [ "FS_unlink" ] = FS . unlink ; ;
ERRNO _CODES = {
'EPERM' : 63 ,
'ENOENT' : 44 ,
'ESRCH' : 71 ,
'EINTR' : 27 ,
'EIO' : 29 ,
'ENXIO' : 60 ,
'E2BIG' : 1 ,
'ENOEXEC' : 45 ,
'EBADF' : 8 ,
'ECHILD' : 12 ,
'EAGAIN' : 6 ,
'EWOULDBLOCK' : 6 ,
'ENOMEM' : 48 ,
'EACCES' : 2 ,
'EFAULT' : 21 ,
'ENOTBLK' : 105 ,
'EBUSY' : 10 ,
'EEXIST' : 20 ,
'EXDEV' : 75 ,
'ENODEV' : 43 ,
'ENOTDIR' : 54 ,
'EISDIR' : 31 ,
'EINVAL' : 28 ,
'ENFILE' : 41 ,
'EMFILE' : 33 ,
'ENOTTY' : 59 ,
'ETXTBSY' : 74 ,
'EFBIG' : 22 ,
'ENOSPC' : 51 ,
'ESPIPE' : 70 ,
'EROFS' : 69 ,
'EMLINK' : 34 ,
'EPIPE' : 64 ,
'EDOM' : 18 ,
'ERANGE' : 68 ,
'ENOMSG' : 49 ,
'EIDRM' : 24 ,
'ECHRNG' : 106 ,
'EL2NSYNC' : 156 ,
'EL3HLT' : 107 ,
'EL3RST' : 108 ,
'ELNRNG' : 109 ,
'EUNATCH' : 110 ,
'ENOCSI' : 111 ,
'EL2HLT' : 112 ,
'EDEADLK' : 16 ,
'ENOLCK' : 46 ,
'EBADE' : 113 ,
'EBADR' : 114 ,
'EXFULL' : 115 ,
'ENOANO' : 104 ,
'EBADRQC' : 103 ,
'EBADSLT' : 102 ,
'EDEADLOCK' : 16 ,
'EBFONT' : 101 ,
'ENOSTR' : 100 ,
'ENODATA' : 116 ,
'ETIME' : 117 ,
'ENOSR' : 118 ,
'ENONET' : 119 ,
'ENOPKG' : 120 ,
'EREMOTE' : 121 ,
'ENOLINK' : 47 ,
'EADV' : 122 ,
'ESRMNT' : 123 ,
'ECOMM' : 124 ,
'EPROTO' : 65 ,
'EMULTIHOP' : 36 ,
'EDOTDOT' : 125 ,
'EBADMSG' : 9 ,
'ENOTUNIQ' : 126 ,
'EBADFD' : 127 ,
'EREMCHG' : 128 ,
'ELIBACC' : 129 ,
'ELIBBAD' : 130 ,
'ELIBSCN' : 131 ,
'ELIBMAX' : 132 ,
'ELIBEXEC' : 133 ,
'ENOSYS' : 52 ,
'ENOTEMPTY' : 55 ,
'ENAMETOOLONG' : 37 ,
'ELOOP' : 32 ,
'EOPNOTSUPP' : 138 ,
'EPFNOSUPPORT' : 139 ,
'ECONNRESET' : 15 ,
'ENOBUFS' : 42 ,
'EAFNOSUPPORT' : 5 ,
'EPROTOTYPE' : 67 ,
'ENOTSOCK' : 57 ,
'ENOPROTOOPT' : 50 ,
'ESHUTDOWN' : 140 ,
'ECONNREFUSED' : 14 ,
'EADDRINUSE' : 3 ,
'ECONNABORTED' : 13 ,
'ENETUNREACH' : 40 ,
'ENETDOWN' : 38 ,
'ETIMEDOUT' : 73 ,
'EHOSTDOWN' : 142 ,
'EHOSTUNREACH' : 23 ,
'EINPROGRESS' : 26 ,
'EALREADY' : 7 ,
'EDESTADDRREQ' : 17 ,
'EMSGSIZE' : 35 ,
'EPROTONOSUPPORT' : 66 ,
'ESOCKTNOSUPPORT' : 137 ,
'EADDRNOTAVAIL' : 4 ,
'ENETRESET' : 39 ,
'EISCONN' : 30 ,
'ENOTCONN' : 53 ,
'ETOOMANYREFS' : 141 ,
'EUSERS' : 136 ,
'EDQUOT' : 19 ,
'ESTALE' : 72 ,
'ENOTSUP' : 138 ,
'ENOMEDIUM' : 148 ,
'EILSEQ' : 25 ,
'EOVERFLOW' : 61 ,
'ECANCELED' : 11 ,
'ENOTRECOVERABLE' : 56 ,
'EOWNERDEAD' : 62 ,
'ESTRPIPE' : 135 ,
} ; ;
Module [ "requestFullscreen" ] = function Module _requestFullscreen ( lockPointer , resizeCanvas ) { Browser . requestFullscreen ( lockPointer , resizeCanvas ) } ;
Module [ "requestFullScreen" ] = function Module _requestFullScreen ( ) { Browser . requestFullScreen ( ) } ;
Module [ "requestAnimationFrame" ] = function Module _requestAnimationFrame ( func ) { Browser . requestAnimationFrame ( func ) } ;
Module [ "setCanvasSize" ] = function Module _setCanvasSize ( width , height , noUpdates ) { Browser . setCanvasSize ( width , height , noUpdates ) } ;
Module [ "pauseMainLoop" ] = function Module _pauseMainLoop ( ) { Browser . mainLoop . pause ( ) } ;
Module [ "resumeMainLoop" ] = function Module _resumeMainLoop ( ) { Browser . mainLoop . resume ( ) } ;
Module [ "getUserMedia" ] = function Module _getUserMedia ( ) { Browser . getUserMedia ( ) }
Module [ "createContext" ] = function Module _createContext ( canvas , useWebGL , setInModule , webGLContextAttributes ) { return Browser . createContext ( canvas , useWebGL , setInModule , webGLContextAttributes ) } ;
var GLctx ; ;
var ASSERTIONS = true ;
/** @type {function(string, boolean=, number=)} */
function intArrayFromString ( stringy , dontAddNull , length ) {
var len = length > 0 ? length : lengthBytesUTF8 ( stringy ) + 1 ;
var u8array = new Array ( len ) ;
var numBytesWritten = stringToUTF8Array ( stringy , u8array , 0 , u8array . length ) ;
if ( dontAddNull ) u8array . length = numBytesWritten ;
return u8array ;
}
function intArrayToString ( array ) {
var ret = [ ] ;
for ( var i = 0 ; i < array . length ; i ++ ) {
var chr = array [ i ] ;
if ( chr > 0xFF ) {
if ( ASSERTIONS ) {
assert ( false , 'Character code ' + chr + ' (' + String . fromCharCode ( chr ) + ') at offset ' + i + ' not in 0x00-0xFF.' ) ;
}
chr &= 0xFF ;
}
ret . push ( String . fromCharCode ( chr ) ) ;
}
return ret . join ( '' ) ;
}
// Copied from https://github.com/strophe/strophejs/blob/e06d027/src/polyfills.js#L149
// This code was written by Tyler Akins and has been placed in the
// public domain. It would be nice if you left this header intact.
// Base64 code from Tyler Akins -- http://rumkin.com
/ * *
* Decodes a base64 string .
* @ param { string } input The string to decode .
* /
var decodeBase64 = typeof atob == 'function' ? atob : function ( input ) {
var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' ;
var output = '' ;
var chr1 , chr2 , chr3 ;
var enc1 , enc2 , enc3 , enc4 ;
var i = 0 ;
// remove all characters that are not A-Z, a-z, 0-9, +, /, or =
input = input . replace ( /[^A-Za-z0-9\+\/\=]/g , '' ) ;
do {
enc1 = keyStr . indexOf ( input . charAt ( i ++ ) ) ;
enc2 = keyStr . indexOf ( input . charAt ( i ++ ) ) ;
enc3 = keyStr . indexOf ( input . charAt ( i ++ ) ) ;
enc4 = keyStr . indexOf ( input . charAt ( i ++ ) ) ;
chr1 = ( enc1 << 2 ) | ( enc2 >> 4 ) ;
chr2 = ( ( enc2 & 15 ) << 4 ) | ( enc3 >> 2 ) ;
chr3 = ( ( enc3 & 3 ) << 6 ) | enc4 ;
output = output + String . fromCharCode ( chr1 ) ;
if ( enc3 !== 64 ) {
output = output + String . fromCharCode ( chr2 ) ;
}
if ( enc4 !== 64 ) {
output = output + String . fromCharCode ( chr3 ) ;
}
} while ( i < input . length ) ;
return output ;
} ;
// Converts a string of base64 into a byte array.
// Throws error on invalid input.
function intArrayFromBase64 ( s ) {
if ( typeof ENVIRONMENT _IS _NODE == 'boolean' && ENVIRONMENT _IS _NODE ) {
var buf = Buffer . from ( s , 'base64' ) ;
return new Uint8Array ( buf [ 'buffer' ] , buf [ 'byteOffset' ] , buf [ 'byteLength' ] ) ;
}
try {
var decoded = decodeBase64 ( s ) ;
var bytes = new Uint8Array ( decoded . length ) ;
for ( var i = 0 ; i < decoded . length ; ++ i ) {
bytes [ i ] = decoded . charCodeAt ( i ) ;
}
return bytes ;
} catch ( _ ) {
throw new Error ( 'Converting base64 string to bytes failed.' ) ;
}
}
// If filename is a base64 data URI, parses and returns data (Buffer on node,
// Uint8Array otherwise). If filename is not a base64 data URI, returns undefined.
function tryParseAsDataURI ( filename ) {
if ( ! isDataURI ( filename ) ) {
return ;
}
return intArrayFromBase64 ( filename . slice ( dataURIPrefix . length ) ) ;
}
function checkIncomingModuleAPI ( ) {
ignoredModuleProp ( 'fetchSettings' ) ;
}
var asmLibraryArg = {
"__cxa_allocate_exception" : _ _ _cxa _allocate _exception ,
"__cxa_throw" : _ _ _cxa _throw ,
"__syscall_fcntl64" : _ _ _syscall _fcntl64 ,
"__syscall_fstat64" : _ _ _syscall _fstat64 ,
"__syscall_fstatat64" : _ _ _syscall _fstatat64 ,
"__syscall_ioctl" : _ _ _syscall _ioctl ,
"__syscall_lstat64" : _ _ _syscall _lstat64 ,
"__syscall_mkdir" : _ _ _syscall _mkdir ,
"__syscall_open" : _ _ _syscall _open ,
"__syscall_stat64" : _ _ _syscall _stat64 ,
"_localtime_js" : _ _localtime _js ,
"_tzset_js" : _ _tzset _js ,
"abort" : _abort ,
"emscripten_memcpy_big" : _emscripten _memcpy _big ,
"emscripten_resize_heap" : _emscripten _resize _heap ,
"emscripten_set_main_loop" : _emscripten _set _main _loop ,
"environ_get" : _environ _get ,
"environ_sizes_get" : _environ _sizes _get ,
"fd_close" : _fd _close ,
"fd_read" : _fd _read ,
"fd_seek" : _fd _seek ,
"fd_write" : _fd _write ,
"glViewport" : _glViewport ,
"glfwCreateWindow" : _glfwCreateWindow ,
"glfwDestroyWindow" : _glfwDestroyWindow ,
"glfwInit" : _glfwInit ,
"glfwMakeContextCurrent" : _glfwMakeContextCurrent ,
"glfwPollEvents" : _glfwPollEvents ,
"glfwSetErrorCallback" : _glfwSetErrorCallback ,
"glfwSetFramebufferSizeCallback" : _glfwSetFramebufferSizeCallback ,
"glfwSetKeyCallback" : _glfwSetKeyCallback ,
"glfwSetMouseButtonCallback" : _glfwSetMouseButtonCallback ,
"glfwSwapBuffers" : _glfwSwapBuffers ,
"glfwSwapInterval" : _glfwSwapInterval ,
"glfwTerminate" : _glfwTerminate ,
"glfwWindowHint" : _glfwWindowHint ,
"setTempRet0" : _setTempRet0 ,
"strftime_l" : _strftime _l ,
"time" : _time
} ;
var asm = createWasm ( ) ;
/** @type {function(...*):?} */
var _ _ _wasm _call _ctors = Module [ "___wasm_call_ctors" ] = createExportWrapper ( "__wasm_call_ctors" ) ;
/** @type {function(...*):?} */
var _main = Module [ "_main" ] = createExportWrapper ( "main" ) ;
/** @type {function(...*):?} */
var _ _ _errno _location = Module [ "___errno_location" ] = createExportWrapper ( "__errno_location" ) ;
/** @type {function(...*):?} */
var _ _ _stdio _exit = Module [ "___stdio_exit" ] = createExportWrapper ( "__stdio_exit" ) ;
/** @type {function(...*):?} */
var _malloc = Module [ "_malloc" ] = createExportWrapper ( "malloc" ) ;
/** @type {function(...*):?} */
var _free = Module [ "_free" ] = createExportWrapper ( "free" ) ;
/** @type {function(...*):?} */
var _emscripten _stack _init = Module [ "_emscripten_stack_init" ] = function ( ) {
return ( _emscripten _stack _init = Module [ "_emscripten_stack_init" ] = Module [ "asm" ] [ "emscripten_stack_init" ] ) . apply ( null , arguments ) ;
} ;
/** @type {function(...*):?} */
var _emscripten _stack _get _free = Module [ "_emscripten_stack_get_free" ] = function ( ) {
return ( _emscripten _stack _get _free = Module [ "_emscripten_stack_get_free" ] = Module [ "asm" ] [ "emscripten_stack_get_free" ] ) . apply ( null , arguments ) ;
} ;
/** @type {function(...*):?} */
var _emscripten _stack _get _base = Module [ "_emscripten_stack_get_base" ] = function ( ) {
return ( _emscripten _stack _get _base = Module [ "_emscripten_stack_get_base" ] = Module [ "asm" ] [ "emscripten_stack_get_base" ] ) . apply ( null , arguments ) ;
} ;
/** @type {function(...*):?} */
var _emscripten _stack _get _end = Module [ "_emscripten_stack_get_end" ] = function ( ) {
return ( _emscripten _stack _get _end = Module [ "_emscripten_stack_get_end" ] = Module [ "asm" ] [ "emscripten_stack_get_end" ] ) . apply ( null , arguments ) ;
} ;
/** @type {function(...*):?} */
var stackSave = Module [ "stackSave" ] = createExportWrapper ( "stackSave" ) ;
/** @type {function(...*):?} */
var stackRestore = Module [ "stackRestore" ] = createExportWrapper ( "stackRestore" ) ;
/** @type {function(...*):?} */
var stackAlloc = Module [ "stackAlloc" ] = createExportWrapper ( "stackAlloc" ) ;
/** @type {function(...*):?} */
var dynCall _jiji = Module [ "dynCall_jiji" ] = createExportWrapper ( "dynCall_jiji" ) ;
/** @type {function(...*):?} */
var dynCall _viijii = Module [ "dynCall_viijii" ] = createExportWrapper ( "dynCall_viijii" ) ;
/** @type {function(...*):?} */
var dynCall _iiiiij = Module [ "dynCall_iiiiij" ] = createExportWrapper ( "dynCall_iiiiij" ) ;
/** @type {function(...*):?} */
var dynCall _iiiiijj = Module [ "dynCall_iiiiijj" ] = createExportWrapper ( "dynCall_iiiiijj" ) ;
/** @type {function(...*):?} */
var dynCall _iiiiiijj = Module [ "dynCall_iiiiiijj" ] = createExportWrapper ( "dynCall_iiiiiijj" ) ;
// === Auto-generated postamble setup entry stuff ===
unexportedRuntimeFunction ( 'intArrayFromString' , false ) ;
unexportedRuntimeFunction ( 'intArrayToString' , false ) ;
unexportedRuntimeFunction ( 'ccall' , false ) ;
unexportedRuntimeFunction ( 'cwrap' , false ) ;
unexportedRuntimeFunction ( 'setValue' , false ) ;
unexportedRuntimeFunction ( 'getValue' , false ) ;
unexportedRuntimeFunction ( 'allocate' , false ) ;
unexportedRuntimeFunction ( 'UTF8ArrayToString' , false ) ;
unexportedRuntimeFunction ( 'UTF8ToString' , false ) ;
unexportedRuntimeFunction ( 'stringToUTF8Array' , false ) ;
unexportedRuntimeFunction ( 'stringToUTF8' , false ) ;
unexportedRuntimeFunction ( 'lengthBytesUTF8' , false ) ;
unexportedRuntimeFunction ( 'stackTrace' , false ) ;
unexportedRuntimeFunction ( 'addOnPreRun' , false ) ;
unexportedRuntimeFunction ( 'addOnInit' , false ) ;
unexportedRuntimeFunction ( 'addOnPreMain' , false ) ;
unexportedRuntimeFunction ( 'addOnExit' , false ) ;
unexportedRuntimeFunction ( 'addOnPostRun' , false ) ;
unexportedRuntimeFunction ( 'writeStringToMemory' , false ) ;
unexportedRuntimeFunction ( 'writeArrayToMemory' , false ) ;
unexportedRuntimeFunction ( 'writeAsciiToMemory' , false ) ;
Module [ "addRunDependency" ] = addRunDependency ;
Module [ "removeRunDependency" ] = removeRunDependency ;
unexportedRuntimeFunction ( 'FS_createFolder' , false ) ;
Module [ "FS_createPath" ] = FS . createPath ;
Module [ "FS_createDataFile" ] = FS . createDataFile ;
Module [ "FS_createPreloadedFile" ] = FS . createPreloadedFile ;
Module [ "FS_createLazyFile" ] = FS . createLazyFile ;
unexportedRuntimeFunction ( 'FS_createLink' , false ) ;
Module [ "FS_createDevice" ] = FS . createDevice ;
Module [ "FS_unlink" ] = FS . unlink ;
unexportedRuntimeFunction ( 'getLEB' , false ) ;
unexportedRuntimeFunction ( 'getFunctionTables' , false ) ;
unexportedRuntimeFunction ( 'alignFunctionTables' , false ) ;
unexportedRuntimeFunction ( 'registerFunctions' , false ) ;
unexportedRuntimeFunction ( 'addFunction' , false ) ;
unexportedRuntimeFunction ( 'removeFunction' , false ) ;
unexportedRuntimeFunction ( 'getFuncWrapper' , false ) ;
unexportedRuntimeFunction ( 'prettyPrint' , false ) ;
unexportedRuntimeFunction ( 'dynCall' , false ) ;
unexportedRuntimeFunction ( 'getCompilerSetting' , false ) ;
unexportedRuntimeFunction ( 'print' , false ) ;
unexportedRuntimeFunction ( 'printErr' , false ) ;
unexportedRuntimeFunction ( 'getTempRet0' , false ) ;
unexportedRuntimeFunction ( 'setTempRet0' , false ) ;
unexportedRuntimeFunction ( 'callMain' , false ) ;
unexportedRuntimeFunction ( 'abort' , false ) ;
unexportedRuntimeFunction ( 'keepRuntimeAlive' , false ) ;
unexportedRuntimeFunction ( 'zeroMemory' , false ) ;
unexportedRuntimeFunction ( 'stringToNewUTF8' , false ) ;
unexportedRuntimeFunction ( 'abortOnCannotGrowMemory' , false ) ;
unexportedRuntimeFunction ( 'emscripten_realloc_buffer' , false ) ;
unexportedRuntimeFunction ( 'ENV' , false ) ;
unexportedRuntimeFunction ( 'withStackSave' , false ) ;
unexportedRuntimeFunction ( 'ERRNO_CODES' , false ) ;
unexportedRuntimeFunction ( 'ERRNO_MESSAGES' , false ) ;
unexportedRuntimeFunction ( 'setErrNo' , false ) ;
unexportedRuntimeFunction ( 'inetPton4' , false ) ;
unexportedRuntimeFunction ( 'inetNtop4' , false ) ;
unexportedRuntimeFunction ( 'inetPton6' , false ) ;
unexportedRuntimeFunction ( 'inetNtop6' , false ) ;
unexportedRuntimeFunction ( 'readSockaddr' , false ) ;
unexportedRuntimeFunction ( 'writeSockaddr' , false ) ;
unexportedRuntimeFunction ( 'DNS' , false ) ;
unexportedRuntimeFunction ( 'getHostByName' , false ) ;
unexportedRuntimeFunction ( 'Protocols' , false ) ;
unexportedRuntimeFunction ( 'Sockets' , false ) ;
unexportedRuntimeFunction ( 'getRandomDevice' , false ) ;
unexportedRuntimeFunction ( 'traverseStack' , false ) ;
unexportedRuntimeFunction ( 'convertFrameToPC' , false ) ;
unexportedRuntimeFunction ( 'UNWIND_CACHE' , false ) ;
unexportedRuntimeFunction ( 'saveInUnwindCache' , false ) ;
unexportedRuntimeFunction ( 'convertPCtoSourceLocation' , false ) ;
unexportedRuntimeFunction ( 'readAsmConstArgsArray' , false ) ;
unexportedRuntimeFunction ( 'readAsmConstArgs' , false ) ;
unexportedRuntimeFunction ( 'mainThreadEM_ASM' , false ) ;
unexportedRuntimeFunction ( 'jstoi_q' , false ) ;
unexportedRuntimeFunction ( 'jstoi_s' , false ) ;
unexportedRuntimeFunction ( 'getExecutableName' , false ) ;
unexportedRuntimeFunction ( 'listenOnce' , false ) ;
unexportedRuntimeFunction ( 'autoResumeAudioContext' , false ) ;
unexportedRuntimeFunction ( 'dynCallLegacy' , false ) ;
unexportedRuntimeFunction ( 'getDynCaller' , false ) ;
unexportedRuntimeFunction ( 'dynCall' , false ) ;
unexportedRuntimeFunction ( 'callRuntimeCallbacks' , false ) ;
unexportedRuntimeFunction ( 'wasmTableMirror' , false ) ;
unexportedRuntimeFunction ( 'setWasmTableEntry' , false ) ;
unexportedRuntimeFunction ( 'getWasmTableEntry' , false ) ;
unexportedRuntimeFunction ( 'handleException' , false ) ;
unexportedRuntimeFunction ( 'runtimeKeepalivePush' , false ) ;
unexportedRuntimeFunction ( 'runtimeKeepalivePop' , false ) ;
unexportedRuntimeFunction ( 'callUserCallback' , false ) ;
unexportedRuntimeFunction ( 'maybeExit' , false ) ;
unexportedRuntimeFunction ( 'safeSetTimeout' , false ) ;
unexportedRuntimeFunction ( 'asmjsMangle' , false ) ;
unexportedRuntimeFunction ( 'asyncLoad' , false ) ;
unexportedRuntimeFunction ( 'alignMemory' , false ) ;
unexportedRuntimeFunction ( 'mmapAlloc' , false ) ;
unexportedRuntimeFunction ( 'reallyNegative' , false ) ;
unexportedRuntimeFunction ( 'unSign' , false ) ;
unexportedRuntimeFunction ( 'reSign' , false ) ;
unexportedRuntimeFunction ( 'formatString' , false ) ;
unexportedRuntimeFunction ( 'PATH' , false ) ;
unexportedRuntimeFunction ( 'PATH_FS' , false ) ;
unexportedRuntimeFunction ( 'SYSCALLS' , false ) ;
unexportedRuntimeFunction ( 'getSocketFromFD' , false ) ;
unexportedRuntimeFunction ( 'getSocketAddress' , false ) ;
unexportedRuntimeFunction ( 'JSEvents' , false ) ;
unexportedRuntimeFunction ( 'registerKeyEventCallback' , false ) ;
unexportedRuntimeFunction ( 'specialHTMLTargets' , false ) ;
unexportedRuntimeFunction ( 'maybeCStringToJsString' , false ) ;
unexportedRuntimeFunction ( 'findEventTarget' , false ) ;
unexportedRuntimeFunction ( 'findCanvasEventTarget' , false ) ;
unexportedRuntimeFunction ( 'getBoundingClientRect' , false ) ;
unexportedRuntimeFunction ( 'fillMouseEventData' , false ) ;
unexportedRuntimeFunction ( 'registerMouseEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerWheelEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerUiEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerFocusEventCallback' , false ) ;
unexportedRuntimeFunction ( 'fillDeviceOrientationEventData' , false ) ;
unexportedRuntimeFunction ( 'registerDeviceOrientationEventCallback' , false ) ;
unexportedRuntimeFunction ( 'fillDeviceMotionEventData' , false ) ;
unexportedRuntimeFunction ( 'registerDeviceMotionEventCallback' , false ) ;
unexportedRuntimeFunction ( 'screenOrientation' , false ) ;
unexportedRuntimeFunction ( 'fillOrientationChangeEventData' , false ) ;
unexportedRuntimeFunction ( 'registerOrientationChangeEventCallback' , false ) ;
unexportedRuntimeFunction ( 'fillFullscreenChangeEventData' , false ) ;
unexportedRuntimeFunction ( 'registerFullscreenChangeEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerRestoreOldStyle' , false ) ;
unexportedRuntimeFunction ( 'hideEverythingExceptGivenElement' , false ) ;
unexportedRuntimeFunction ( 'restoreHiddenElements' , false ) ;
unexportedRuntimeFunction ( 'setLetterbox' , false ) ;
unexportedRuntimeFunction ( 'currentFullscreenStrategy' , false ) ;
unexportedRuntimeFunction ( 'restoreOldWindowedStyle' , false ) ;
unexportedRuntimeFunction ( 'softFullscreenResizeWebGLRenderTarget' , false ) ;
unexportedRuntimeFunction ( 'doRequestFullscreen' , false ) ;
unexportedRuntimeFunction ( 'fillPointerlockChangeEventData' , false ) ;
unexportedRuntimeFunction ( 'registerPointerlockChangeEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerPointerlockErrorEventCallback' , false ) ;
unexportedRuntimeFunction ( 'requestPointerLock' , false ) ;
unexportedRuntimeFunction ( 'fillVisibilityChangeEventData' , false ) ;
unexportedRuntimeFunction ( 'registerVisibilityChangeEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerTouchEventCallback' , false ) ;
unexportedRuntimeFunction ( 'fillGamepadEventData' , false ) ;
unexportedRuntimeFunction ( 'registerGamepadEventCallback' , false ) ;
unexportedRuntimeFunction ( 'registerBeforeUnloadEventCallback' , false ) ;
unexportedRuntimeFunction ( 'fillBatteryEventData' , false ) ;
unexportedRuntimeFunction ( 'battery' , false ) ;
unexportedRuntimeFunction ( 'registerBatteryEventCallback' , false ) ;
unexportedRuntimeFunction ( 'setCanvasElementSize' , false ) ;
unexportedRuntimeFunction ( 'getCanvasElementSize' , false ) ;
unexportedRuntimeFunction ( 'demangle' , false ) ;
unexportedRuntimeFunction ( 'demangleAll' , false ) ;
unexportedRuntimeFunction ( 'jsStackTrace' , false ) ;
unexportedRuntimeFunction ( 'stackTrace' , false ) ;
unexportedRuntimeFunction ( 'getEnvStrings' , false ) ;
unexportedRuntimeFunction ( 'checkWasiClock' , false ) ;
unexportedRuntimeFunction ( 'writeI53ToI64' , false ) ;
unexportedRuntimeFunction ( 'writeI53ToI64Clamped' , false ) ;
unexportedRuntimeFunction ( 'writeI53ToI64Signaling' , false ) ;
unexportedRuntimeFunction ( 'writeI53ToU64Clamped' , false ) ;
unexportedRuntimeFunction ( 'writeI53ToU64Signaling' , false ) ;
unexportedRuntimeFunction ( 'readI53FromI64' , false ) ;
unexportedRuntimeFunction ( 'readI53FromU64' , false ) ;
unexportedRuntimeFunction ( 'convertI32PairToI53' , false ) ;
unexportedRuntimeFunction ( 'convertU32PairToI53' , false ) ;
unexportedRuntimeFunction ( 'setImmediateWrapped' , false ) ;
unexportedRuntimeFunction ( 'clearImmediateWrapped' , false ) ;
unexportedRuntimeFunction ( 'polyfillSetImmediate' , false ) ;
unexportedRuntimeFunction ( 'uncaughtExceptionCount' , false ) ;
unexportedRuntimeFunction ( 'exceptionLast' , false ) ;
unexportedRuntimeFunction ( 'exceptionCaught' , false ) ;
unexportedRuntimeFunction ( 'ExceptionInfo' , false ) ;
unexportedRuntimeFunction ( 'CatchInfo' , false ) ;
unexportedRuntimeFunction ( 'exception_addRef' , false ) ;
unexportedRuntimeFunction ( 'exception_decRef' , false ) ;
unexportedRuntimeFunction ( 'Browser' , false ) ;
unexportedRuntimeFunction ( 'funcWrappers' , false ) ;
unexportedRuntimeFunction ( 'getFuncWrapper' , false ) ;
unexportedRuntimeFunction ( 'setMainLoop' , false ) ;
unexportedRuntimeFunction ( 'wget' , false ) ;
unexportedRuntimeFunction ( 'FS' , false ) ;
unexportedRuntimeFunction ( 'MEMFS' , false ) ;
unexportedRuntimeFunction ( 'TTY' , false ) ;
unexportedRuntimeFunction ( 'PIPEFS' , false ) ;
unexportedRuntimeFunction ( 'SOCKFS' , false ) ;
unexportedRuntimeFunction ( '_setNetworkCallback' , false ) ;
unexportedRuntimeFunction ( 'tempFixedLengthArray' , false ) ;
unexportedRuntimeFunction ( 'miniTempWebGLFloatBuffers' , false ) ;
unexportedRuntimeFunction ( 'heapObjectForWebGLType' , false ) ;
unexportedRuntimeFunction ( 'heapAccessShiftForWebGLHeap' , false ) ;
unexportedRuntimeFunction ( 'GL' , false ) ;
unexportedRuntimeFunction ( 'emscriptenWebGLGet' , false ) ;
unexportedRuntimeFunction ( 'computeUnpackAlignedImageSize' , false ) ;
unexportedRuntimeFunction ( 'emscriptenWebGLGetTexPixelData' , false ) ;
unexportedRuntimeFunction ( 'emscriptenWebGLGetUniform' , false ) ;
unexportedRuntimeFunction ( 'webglGetUniformLocation' , false ) ;
unexportedRuntimeFunction ( 'webglPrepareUniformLocationsBeforeFirstUse' , false ) ;
unexportedRuntimeFunction ( 'webglGetLeftBracePos' , false ) ;
unexportedRuntimeFunction ( 'emscriptenWebGLGetVertexAttrib' , false ) ;
unexportedRuntimeFunction ( 'writeGLArray' , false ) ;
unexportedRuntimeFunction ( 'AL' , false ) ;
unexportedRuntimeFunction ( 'SDL_unicode' , false ) ;
unexportedRuntimeFunction ( 'SDL_ttfContext' , false ) ;
unexportedRuntimeFunction ( 'SDL_audio' , false ) ;
unexportedRuntimeFunction ( 'SDL' , false ) ;
unexportedRuntimeFunction ( 'SDL_gfx' , false ) ;
unexportedRuntimeFunction ( 'GLUT' , false ) ;
unexportedRuntimeFunction ( 'EGL' , false ) ;
unexportedRuntimeFunction ( 'GLFW_Window' , false ) ;
unexportedRuntimeFunction ( 'GLFW' , false ) ;
unexportedRuntimeFunction ( 'GLEW' , false ) ;
unexportedRuntimeFunction ( 'IDBStore' , false ) ;
unexportedRuntimeFunction ( 'runAndAbortIfError' , false ) ;
unexportedRuntimeFunction ( 'emscriptenWebGLGetIndexed' , false ) ;
unexportedRuntimeFunction ( 'warnOnce' , false ) ;
unexportedRuntimeFunction ( 'stackSave' , false ) ;
unexportedRuntimeFunction ( 'stackRestore' , false ) ;
unexportedRuntimeFunction ( 'stackAlloc' , false ) ;
unexportedRuntimeFunction ( 'AsciiToString' , false ) ;
unexportedRuntimeFunction ( 'stringToAscii' , false ) ;
unexportedRuntimeFunction ( 'UTF16ToString' , false ) ;
unexportedRuntimeFunction ( 'stringToUTF16' , false ) ;
unexportedRuntimeFunction ( 'lengthBytesUTF16' , false ) ;
unexportedRuntimeFunction ( 'UTF32ToString' , false ) ;
unexportedRuntimeFunction ( 'stringToUTF32' , false ) ;
unexportedRuntimeFunction ( 'lengthBytesUTF32' , false ) ;
unexportedRuntimeFunction ( 'allocateUTF8' , false ) ;
unexportedRuntimeFunction ( 'allocateUTF8OnStack' , false ) ;
Module [ "writeStackCookie" ] = writeStackCookie ;
Module [ "checkStackCookie" ] = checkStackCookie ;
unexportedRuntimeSymbol ( 'ALLOC_NORMAL' , false ) ;
unexportedRuntimeSymbol ( 'ALLOC_STACK' , false ) ;
var calledRun ;
/ * *
* @ constructor
* @ this { ExitStatus }
* /
function ExitStatus ( status ) {
this . name = "ExitStatus" ;
this . message = "Program terminated with exit(" + status + ")" ;
this . status = status ;
}
var calledMain = false ;
dependenciesFulfilled = function runCaller ( ) {
// If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
if ( ! calledRun ) run ( ) ;
if ( ! calledRun ) dependenciesFulfilled = runCaller ; // try this again later, after new deps are fulfilled
} ;
function callMain ( args ) {
assert ( runDependencies == 0 , 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])' ) ;
assert ( _ _ATPRERUN _ _ . length == 0 , 'cannot call main when preRun functions remain to be called' ) ;
var entryFunction = Module [ '_main' ] ;
args = args || [ ] ;
var argc = args . length + 1 ;
var argv = stackAlloc ( ( argc + 1 ) * 4 ) ;
HEAP32 [ argv >> 2 ] = allocateUTF8OnStack ( thisProgram ) ;
for ( var i = 1 ; i < argc ; i ++ ) {
HEAP32 [ ( argv >> 2 ) + i ] = allocateUTF8OnStack ( args [ i - 1 ] ) ;
}
HEAP32 [ ( argv >> 2 ) + argc ] = 0 ;
try {
var ret = entryFunction ( argc , argv ) ;
// In PROXY_TO_PTHREAD builds, we should never exit the runtime below, as
// execution is asynchronously handed off to a pthread.
// if we're not running an evented main loop, it's time to exit
exit ( ret , /* implicit = */ true ) ;
return ret ;
}
catch ( e ) {
return handleException ( e ) ;
} finally {
calledMain = true ;
}
}
function stackCheckInit ( ) {
// This is normally called automatically during __wasm_call_ctors but need to
// get these values before even running any of the ctors so we call it redundantly
// here.
// TODO(sbc): Move writeStackCookie to native to to avoid this.
_emscripten _stack _init ( ) ;
writeStackCookie ( ) ;
}
/** @type {function(Array=)} */
function run ( args ) {
args = args || arguments _ ;
if ( runDependencies > 0 ) {
return ;
}
stackCheckInit ( ) ;
preRun ( ) ;
// a preRun added a dependency, run will be called later
if ( runDependencies > 0 ) {
return ;
}
function doRun ( ) {
// run may have just been called through dependencies being fulfilled just in this very frame,
// or while the async setStatus time below was happening
if ( calledRun ) return ;
calledRun = true ;
Module [ 'calledRun' ] = true ;
if ( ABORT ) return ;
initRuntime ( ) ;
preMain ( ) ;
if ( Module [ 'onRuntimeInitialized' ] ) Module [ 'onRuntimeInitialized' ] ( ) ;
if ( shouldRunNow ) callMain ( args ) ;
postRun ( ) ;
}
if ( Module [ 'setStatus' ] ) {
Module [ 'setStatus' ] ( 'Running...' ) ;
setTimeout ( function ( ) {
setTimeout ( function ( ) {
Module [ 'setStatus' ] ( '' ) ;
} , 1 ) ;
doRun ( ) ;
} , 1 ) ;
} else
{
doRun ( ) ;
}
checkStackCookie ( ) ;
}
Module [ 'run' ] = run ;
function checkUnflushedContent ( ) {
// Compiler settings do not allow exiting the runtime, so flushing
// the streams is not possible. but in ASSERTIONS mode we check
// if there was something to flush, and if so tell the user they
// should request that the runtime be exitable.
// Normally we would not even include flush() at all, but in ASSERTIONS
// builds we do so just for this check, and here we see if there is any
// content to flush, that is, we check if there would have been
// something a non-ASSERTIONS build would have not seen.
// How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
// mode (which has its own special function for this; otherwise, all
// the code is inside libc)
var oldOut = out ;
var oldErr = err ;
var has = false ;
out = err = ( x ) => {
has = true ;
}
try { // it doesn't matter if it fails
_ _ _stdio _exit ( ) ;
// also flush in the JS FS layer
[ 'stdout' , 'stderr' ] . forEach ( function ( name ) {
var info = FS . analyzePath ( '/dev/' + name ) ;
if ( ! info ) return ;
var stream = info . object ;
var rdev = stream . rdev ;
var tty = TTY . ttys [ rdev ] ;
if ( tty && tty . output && tty . output . length ) {
has = true ;
}
} ) ;
} catch ( e ) { }
out = oldOut ;
err = oldErr ;
if ( has ) {
warnOnce ( 'stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.' ) ;
}
}
/** @param {boolean|number=} implicit */
function exit ( status , implicit ) {
EXITSTATUS = status ;
// Skip this check if the runtime is being kept alive deliberately.
// For example if `exit_with_live_runtime` is called.
if ( ! runtimeKeepaliveCounter ) {
checkUnflushedContent ( ) ;
}
if ( keepRuntimeAlive ( ) ) {
// if exit() was called, we may warn the user if the runtime isn't actually being shut down
if ( ! implicit ) {
var msg = 'program exited (with status: ' + status + '), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)' ;
err ( msg ) ;
}
} else {
exitRuntime ( ) ;
}
procExit ( status ) ;
}
function procExit ( code ) {
EXITSTATUS = code ;
if ( ! keepRuntimeAlive ( ) ) {
if ( Module [ 'onExit' ] ) Module [ 'onExit' ] ( code ) ;
ABORT = true ;
}
quit _ ( code , new ExitStatus ( code ) ) ;
}
if ( Module [ 'preInit' ] ) {
if ( typeof Module [ 'preInit' ] == 'function' ) Module [ 'preInit' ] = [ Module [ 'preInit' ] ] ;
while ( Module [ 'preInit' ] . length > 0 ) {
Module [ 'preInit' ] . pop ( ) ( ) ;
}
}
// shouldRunNow refers to calling main(), not run().
var shouldRunNow = true ;
if ( Module [ 'noInitialRun' ] ) shouldRunNow = false ;
run ( ) ;