2019-11-24 02:56:08 +01:00
var libarchive = ( function ( ) {
var _scriptDir =
typeof document !== 'undefined' && document . currentScript
? document . currentScript . src
: undefined
return function ( libarchive ) {
libarchive = libarchive || { }
2019-05-16 08:32:53 +02:00
2019-11-24 02:56:08 +01:00
var Module = typeof libarchive !== 'undefined' ? libarchive : { }
var moduleOverrides = { }
var key
for ( key in Module ) {
if ( Module . hasOwnProperty ( key ) ) {
moduleOverrides [ key ] = Module [ key ]
}
}
Module [ 'arguments' ] = [ ]
Module [ 'thisProgram' ] = './this.program'
Module [ 'quit' ] = function ( status , toThrow ) {
throw toThrow
}
Module [ 'preRun' ] = [ ]
Module [ 'postRun' ] = [ ]
var ENVIRONMENT _IS _WEB = false
var ENVIRONMENT _IS _WORKER = false
var ENVIRONMENT _IS _NODE = false
var ENVIRONMENT _IS _SHELL = false
ENVIRONMENT _IS _WEB = typeof window === 'object'
ENVIRONMENT _IS _WORKER = typeof importScripts === 'function'
ENVIRONMENT _IS _NODE =
typeof process === 'object' &&
typeof require === 'function' &&
! ENVIRONMENT _IS _WEB &&
! ENVIRONMENT _IS _WORKER
ENVIRONMENT _IS _SHELL =
! ENVIRONMENT _IS _WEB && ! ENVIRONMENT _IS _NODE && ! ENVIRONMENT _IS _WORKER
var scriptDirectory = ''
function locateFile ( path ) {
if ( Module [ 'locateFile' ] ) {
return Module [ 'locateFile' ] ( path , scriptDirectory )
} else {
return scriptDirectory + path
}
}
if ( ENVIRONMENT _IS _NODE ) {
scriptDirectory = _ _dirname + '/'
var nodeFS
var nodePath
Module [ 'read' ] = function shell _read ( filename , binary ) {
var ret
if ( ! nodeFS ) nodeFS = require ( 'fs' )
if ( ! nodePath ) nodePath = require ( 'path' )
filename = nodePath [ 'normalize' ] ( filename )
ret = nodeFS [ 'readFileSync' ] ( filename )
return binary ? ret : ret . toString ( )
}
Module [ 'readBinary' ] = function readBinary ( filename ) {
var ret = Module [ 'read' ] ( filename , true )
if ( ! ret . buffer ) {
ret = new Uint8Array ( ret )
}
assert ( ret . buffer )
return ret
}
if ( process [ 'argv' ] . length > 1 ) {
Module [ 'thisProgram' ] = process [ 'argv' ] [ 1 ] . replace ( /\\/g , '/' )
}
Module [ 'arguments' ] = process [ 'argv' ] . slice ( 2 )
process [ 'on' ] ( 'uncaughtException' , function ( ex ) {
if ( ! ( ex instanceof ExitStatus ) ) {
throw ex
}
} )
process [ 'on' ] ( 'unhandledRejection' , abort )
Module [ 'quit' ] = function ( status ) {
process [ 'exit' ] ( status )
}
Module [ 'inspect' ] = function ( ) {
return '[Emscripten Module object]'
}
} else if ( ENVIRONMENT _IS _SHELL ) {
if ( typeof read != 'undefined' ) {
Module [ 'read' ] = function shell _read ( f ) {
return read ( f )
}
}
Module [ 'readBinary' ] = function readBinary ( f ) {
var data
if ( typeof readbuffer === 'function' ) {
return new Uint8Array ( readbuffer ( f ) )
}
data = read ( f , 'binary' )
assert ( typeof data === 'object' )
return data
}
if ( typeof scriptArgs != 'undefined' ) {
Module [ 'arguments' ] = scriptArgs
} else if ( typeof arguments != 'undefined' ) {
Module [ 'arguments' ] = arguments
}
if ( typeof quit === 'function' ) {
Module [ 'quit' ] = function ( status ) {
quit ( status )
}
}
} else if ( ENVIRONMENT _IS _WEB || ENVIRONMENT _IS _WORKER ) {
if ( ENVIRONMENT _IS _WORKER ) {
scriptDirectory = self . location . href
} else if ( document . currentScript ) {
scriptDirectory = document . currentScript . src
}
if ( _scriptDir ) {
scriptDirectory = _scriptDir
}
if ( scriptDirectory . indexOf ( 'blob:' ) !== 0 ) {
scriptDirectory = scriptDirectory . substr ( 0 , scriptDirectory . lastIndexOf ( '/' ) + 1 )
} else {
scriptDirectory = ''
}
Module [ 'read' ] = function shell _read ( url ) {
var xhr = new XMLHttpRequest ( )
xhr . open ( 'GET' , url , false )
xhr . send ( null )
return xhr . responseText
}
if ( ENVIRONMENT _IS _WORKER ) {
Module [ 'readBinary' ] = function readBinary ( url ) {
var xhr = new XMLHttpRequest ( )
xhr . open ( 'GET' , url , false )
xhr . responseType = 'arraybuffer'
xhr . send ( null )
return new Uint8Array ( xhr . response )
}
}
Module [ 'readAsync' ] = function readAsync ( url , onload , onerror ) {
var xhr = new XMLHttpRequest ( )
xhr . open ( 'GET' , url , true )
xhr . responseType = 'arraybuffer'
xhr . onload = function xhr _onload ( ) {
if ( xhr . status == 200 || ( xhr . status == 0 && xhr . response ) ) {
onload ( xhr . response )
return
}
onerror ( )
}
xhr . onerror = onerror
xhr . send ( null )
}
Module [ 'setWindowTitle' ] = function ( title ) {
document . title = title
}
} else {
}
var out =
Module [ 'print' ] ||
( typeof console !== 'undefined'
? console . log . bind ( console )
: typeof print !== 'undefined'
? print
: null )
var err =
Module [ 'printErr' ] ||
( typeof printErr !== 'undefined'
? printErr
: ( typeof console !== 'undefined' && console . warn . bind ( console ) ) || out )
for ( key in moduleOverrides ) {
if ( moduleOverrides . hasOwnProperty ( key ) ) {
Module [ key ] = moduleOverrides [ key ]
}
}
moduleOverrides = undefined
function dynamicAlloc ( size ) {
var ret = HEAP32 [ DYNAMICTOP _PTR >> 2 ]
var end = ( ret + size + 15 ) & - 16
if ( end <= _emscripten _get _heap _size ( ) ) {
HEAP32 [ DYNAMICTOP _PTR >> 2 ] = end
} else {
var success = _emscripten _resize _heap ( end )
if ( ! success ) return 0
}
return ret
}
function getNativeTypeSize ( type ) {
switch ( type ) {
case 'i1' :
case 'i8' :
return 1
case 'i16' :
return 2
case 'i32' :
return 4
case 'i64' :
return 8
case 'float' :
return 4
case 'double' :
return 8
default : {
if ( type [ type . length - 1 ] === '*' ) {
return 4
} else if ( type [ 0 ] === 'i' ) {
var bits = parseInt ( type . substr ( 1 ) )
assert (
bits % 8 === 0 ,
'getNativeTypeSize invalid bits ' + bits + ', type ' + type
)
return bits / 8
} else {
return 0
}
}
}
}
var asm2wasmImports = {
'f64-rem' : function ( x , y ) {
return x % y
} ,
debugger : function ( ) {
debugger
} ,
}
var functionPointers = new Array ( 0 )
var tempRet0 = 0
var setTempRet0 = function ( value ) {
tempRet0 = value
}
if ( typeof WebAssembly !== 'object' ) {
err ( 'no native wasm support detected' )
}
var wasmMemory
var wasmTable
var ABORT = false
var EXITSTATUS = 0
function assert ( condition , text ) {
if ( ! condition ) {
abort ( 'Assertion failed: ' + text )
}
}
function getCFunc ( ident ) {
var func = Module [ '_' + ident ]
assert ( func , 'Cannot call unknown function ' + ident + ', make sure it is exported' )
return func
}
function ccall ( ident , returnType , argTypes , args , opts ) {
var toC = {
string : function ( str ) {
var ret = 0
if ( str !== null && str !== undefined && str !== 0 ) {
var len = ( str . length << 2 ) + 1
ret = stackAlloc ( len )
stringToUTF8 ( str , ret , len )
}
return ret
} ,
array : function ( arr ) {
var ret = stackAlloc ( arr . length )
writeArrayToMemory ( arr , ret )
return ret
} ,
}
function convertReturnValue ( ret ) {
if ( returnType === 'string' ) return UTF8ToString ( ret )
if ( returnType === 'boolean' ) return Boolean ( ret )
return ret
}
var func = getCFunc ( ident )
var cArgs = [ ]
var stack = 0
if ( args ) {
for ( var i = 0 ; i < args . length ; i ++ ) {
var converter = toC [ argTypes [ i ] ]
if ( converter ) {
if ( stack === 0 ) stack = stackSave ( )
cArgs [ i ] = converter ( args [ i ] )
} else {
cArgs [ i ] = args [ i ]
}
}
}
var ret = func . apply ( null , cArgs )
ret = convertReturnValue ( ret )
if ( stack !== 0 ) stackRestore ( stack )
return ret
}
function cwrap ( ident , returnType , argTypes , opts ) {
argTypes = argTypes || [ ]
var numericArgs = argTypes . every ( function ( type ) {
return type === 'number'
} )
var numericRet = returnType !== 'string'
if ( numericRet && numericArgs && ! opts ) {
return getCFunc ( ident )
}
return function ( ) {
return ccall ( ident , returnType , argTypes , arguments , opts )
}
}
function setValue ( ptr , value , type , noSafe ) {
type = type || 'i8'
if ( type . charAt ( type . length - 1 ) === '*' ) type = 'i32'
switch ( type ) {
case 'i1' :
HEAP8 [ ptr >> 0 ] = value
break
case 'i8' :
HEAP8 [ ptr >> 0 ] = value
break
case 'i16' :
HEAP16 [ ptr >> 1 ] = value
break
case 'i32' :
HEAP32 [ ptr >> 2 ] = value
break
case 'i64' :
; ( tempI64 = [
value >>> 0 ,
( ( tempDouble = value ) ,
+ Math _abs ( tempDouble ) >= 1
? tempDouble > 0
? ( Math _min ( + Math _floor ( tempDouble / 4294967296 ) , 4294967295 ) | 0 ) >>> 0
: ~ ~ + Math _ceil ( ( tempDouble - + ( ~ ~ tempDouble >>> 0 ) ) / 4294967296 ) >>> 0
: 0 ) ,
] ) ,
( HEAP32 [ ptr >> 2 ] = tempI64 [ 0 ] ) ,
( HEAP32 [ ( ptr + 4 ) >> 2 ] = tempI64 [ 1 ] )
break
case 'float' :
HEAPF32 [ ptr >> 2 ] = value
break
case 'double' :
HEAPF64 [ ptr >> 3 ] = value
break
default :
abort ( 'invalid type for setValue: ' + type )
}
}
var ALLOC _NORMAL = 0
var ALLOC _NONE = 3
function allocate ( slab , types , allocator , ptr ) {
var zeroinit , size
if ( typeof slab === 'number' ) {
zeroinit = true
size = slab
} else {
zeroinit = false
size = slab . length
}
var singleType = typeof types === 'string' ? types : null
var ret
if ( allocator == ALLOC _NONE ) {
ret = ptr
} else {
ret = [ _malloc , stackAlloc , dynamicAlloc ] [ allocator ] (
Math . max ( size , singleType ? 1 : types . length )
)
}
if ( zeroinit ) {
var stop
ptr = ret
assert ( ( ret & 3 ) == 0 )
stop = ret + ( size & ~ 3 )
for ( ; ptr < stop ; ptr += 4 ) {
HEAP32 [ ptr >> 2 ] = 0
}
stop = ret + size
while ( ptr < stop ) {
HEAP8 [ ptr ++ >> 0 ] = 0
}
return ret
}
if ( singleType === 'i8' ) {
if ( slab . subarray || slab . slice ) {
HEAPU8 . set ( slab , ret )
} else {
HEAPU8 . set ( new Uint8Array ( slab ) , ret )
}
return ret
}
var i = 0 ,
type ,
typeSize ,
previousType
while ( i < size ) {
var curr = slab [ i ]
type = singleType || types [ i ]
if ( type === 0 ) {
i ++
continue
}
if ( type == 'i64' ) type = 'i32'
setValue ( ret + i , curr , type )
if ( previousType !== type ) {
typeSize = getNativeTypeSize ( type )
previousType = type
}
i += typeSize
}
return ret
}
function getMemory ( size ) {
if ( ! runtimeInitialized ) return dynamicAlloc ( size )
return _malloc ( size )
}
var UTF8Decoder =
typeof TextDecoder !== 'undefined' ? new TextDecoder ( 'utf8' ) : undefined
function UTF8ArrayToString ( u8Array , idx , maxBytesToRead ) {
var endIdx = idx + maxBytesToRead
var endPtr = idx
while ( u8Array [ endPtr ] && ! ( endPtr >= endIdx ) ) ++ endPtr
if ( endPtr - idx > 16 && u8Array . subarray && UTF8Decoder ) {
return UTF8Decoder . decode ( u8Array . subarray ( idx , endPtr ) )
} else {
var str = ''
while ( idx < endPtr ) {
var u0 = u8Array [ idx ++ ]
if ( ! ( u0 & 128 ) ) {
str += String . fromCharCode ( u0 )
continue
}
var u1 = u8Array [ idx ++ ] & 63
if ( ( u0 & 224 ) == 192 ) {
str += String . fromCharCode ( ( ( u0 & 31 ) << 6 ) | u1 )
continue
}
var u2 = u8Array [ idx ++ ] & 63
if ( ( u0 & 240 ) == 224 ) {
u0 = ( ( u0 & 15 ) << 12 ) | ( u1 << 6 ) | u2
} else {
u0 = ( ( u0 & 7 ) << 18 ) | ( u1 << 12 ) | ( u2 << 6 ) | ( u8Array [ idx ++ ] & 63 )
}
if ( u0 < 65536 ) {
str += String . fromCharCode ( u0 )
} else {
var ch = u0 - 65536
str += String . fromCharCode ( 55296 | ( ch >> 10 ) , 56320 | ( ch & 1023 ) )
}
}
}
return str
}
function UTF8ToString ( ptr , maxBytesToRead ) {
return ptr ? UTF8ArrayToString ( HEAPU8 , ptr , maxBytesToRead ) : ''
}
function stringToUTF8Array ( str , outU8Array , outIdx , maxBytesToWrite ) {
if ( ! ( maxBytesToWrite > 0 ) ) return 0
var startIdx = outIdx
var endIdx = outIdx + maxBytesToWrite - 1
for ( var i = 0 ; i < str . length ; ++ i ) {
var u = str . charCodeAt ( i )
if ( u >= 55296 && u <= 57343 ) {
var u1 = str . charCodeAt ( ++ i )
u = ( 65536 + ( ( u & 1023 ) << 10 ) ) | ( u1 & 1023 )
}
if ( u <= 127 ) {
if ( outIdx >= endIdx ) break
outU8Array [ outIdx ++ ] = u
} else if ( u <= 2047 ) {
if ( outIdx + 1 >= endIdx ) break
outU8Array [ outIdx ++ ] = 192 | ( u >> 6 )
outU8Array [ outIdx ++ ] = 128 | ( u & 63 )
} else if ( u <= 65535 ) {
if ( outIdx + 2 >= endIdx ) break
outU8Array [ outIdx ++ ] = 224 | ( u >> 12 )
outU8Array [ outIdx ++ ] = 128 | ( ( u >> 6 ) & 63 )
outU8Array [ outIdx ++ ] = 128 | ( u & 63 )
} else {
if ( outIdx + 3 >= endIdx ) break
outU8Array [ outIdx ++ ] = 240 | ( u >> 18 )
outU8Array [ outIdx ++ ] = 128 | ( ( u >> 12 ) & 63 )
outU8Array [ outIdx ++ ] = 128 | ( ( u >> 6 ) & 63 )
outU8Array [ outIdx ++ ] = 128 | ( u & 63 )
}
}
outU8Array [ outIdx ] = 0
return outIdx - startIdx
}
function stringToUTF8 ( str , outPtr , maxBytesToWrite ) {
return stringToUTF8Array ( str , HEAPU8 , outPtr , maxBytesToWrite )
}
function lengthBytesUTF8 ( str ) {
var len = 0
for ( var i = 0 ; i < str . length ; ++ i ) {
var u = str . charCodeAt ( i )
if ( u >= 55296 && u <= 57343 )
u = ( 65536 + ( ( u & 1023 ) << 10 ) ) | ( str . charCodeAt ( ++ i ) & 1023 )
if ( u <= 127 ) ++ len
else if ( u <= 2047 ) len += 2
else if ( u <= 65535 ) len += 3
else len += 4
}
return len
}
var UTF16Decoder =
typeof TextDecoder !== 'undefined' ? new TextDecoder ( 'utf-16le' ) : undefined
function writeArrayToMemory ( array , buffer ) {
HEAP8 . set ( array , buffer )
}
function writeAsciiToMemory ( str , buffer , dontAddNull ) {
for ( var i = 0 ; i < str . length ; ++ i ) {
HEAP8 [ buffer ++ >> 0 ] = str . charCodeAt ( i )
}
if ( ! dontAddNull ) HEAP8 [ buffer >> 0 ] = 0
}
function demangle ( func ) {
return func
}
function demangleAll ( text ) {
var regex = /__Z[\w\d_]+/g
return text . replace ( regex , function ( x ) {
var y = demangle ( x )
return x === y ? x : y + ' [' + x + ']'
} )
}
function jsStackTrace ( ) {
var err = new Error ( )
if ( ! err . stack ) {
try {
throw new Error ( 0 )
} catch ( e ) {
err = e
}
if ( ! err . stack ) {
return '(no stack trace available)'
}
}
return err . stack . toString ( )
}
function stackTrace ( ) {
var js = jsStackTrace ( )
if ( Module [ 'extraStackTrace' ] ) js += '\n' + Module [ 'extraStackTrace' ] ( )
return demangleAll ( js )
}
var WASM _PAGE _SIZE = 65536
function alignUp ( x , multiple ) {
if ( x % multiple > 0 ) {
x += multiple - ( x % multiple )
}
return x
}
var buffer , HEAP8 , HEAPU8 , HEAP16 , HEAPU16 , HEAP32 , HEAPU32 , HEAPF32 , HEAPF64
function updateGlobalBufferViews ( ) {
Module [ 'HEAP8' ] = HEAP8 = new Int8Array ( buffer )
Module [ 'HEAP16' ] = HEAP16 = new Int16Array ( buffer )
Module [ 'HEAP32' ] = HEAP32 = new Int32Array ( buffer )
Module [ 'HEAPU8' ] = HEAPU8 = new Uint8Array ( buffer )
Module [ 'HEAPU16' ] = HEAPU16 = new Uint16Array ( buffer )
Module [ 'HEAPU32' ] = HEAPU32 = new Uint32Array ( buffer )
Module [ 'HEAPF32' ] = HEAPF32 = new Float32Array ( buffer )
Module [ 'HEAPF64' ] = HEAPF64 = new Float64Array ( buffer )
}
var DYNAMIC _BASE = 5520464 ,
DYNAMICTOP _PTR = 277552
var TOTAL _STACK = 5242880
var INITIAL _TOTAL _MEMORY = Module [ 'TOTAL_MEMORY' ] || 16777216
if ( INITIAL _TOTAL _ MEMORY < TOTAL _STACK )
err (
'TOTAL_MEMORY should be larger than TOTAL_STACK, was ' +
INITIAL _TOTAL _MEMORY +
'! (TOTAL_STACK=' +
TOTAL _STACK +
')'
)
if ( Module [ 'buffer' ] ) {
buffer = Module [ 'buffer' ]
} else {
if ( typeof WebAssembly === 'object' && typeof WebAssembly . Memory === 'function' ) {
wasmMemory = new WebAssembly . Memory ( {
initial : INITIAL _TOTAL _MEMORY / WASM _PAGE _SIZE ,
} )
buffer = wasmMemory . buffer
} else {
buffer = new ArrayBuffer ( INITIAL _TOTAL _MEMORY )
}
}
updateGlobalBufferViews ( )
HEAP32 [ DYNAMICTOP _PTR >> 2 ] = DYNAMIC _BASE
function callRuntimeCallbacks ( callbacks ) {
while ( callbacks . length > 0 ) {
var callback = callbacks . shift ( )
if ( typeof callback == 'function' ) {
callback ( )
continue
}
var func = callback . func
if ( typeof func === 'number' ) {
if ( callback . arg === undefined ) {
Module [ 'dynCall_v' ] ( func )
} else {
Module [ 'dynCall_vi' ] ( func , callback . arg )
}
} else {
func ( callback . arg === undefined ? null : callback . arg )
}
}
}
var _ _ATPRERUN _ _ = [ ]
var _ _ATINIT _ _ = [ ]
var _ _ATMAIN _ _ = [ ]
var _ _ATPOSTRUN _ _ = [ ]
var runtimeInitialized = false
var runtimeExited = false
function preRun ( ) {
if ( Module [ 'preRun' ] ) {
if ( typeof Module [ 'preRun' ] == 'function' ) Module [ 'preRun' ] = [ Module [ 'preRun' ] ]
while ( Module [ 'preRun' ] . length ) {
addOnPreRun ( Module [ 'preRun' ] . shift ( ) )
}
}
callRuntimeCallbacks ( _ _ATPRERUN _ _ )
}
function ensureInitRuntime ( ) {
if ( runtimeInitialized ) return
runtimeInitialized = true
if ( ! Module [ 'noFSInit' ] && ! FS . init . initialized ) FS . init ( )
TTY . init ( )
PIPEFS . root = FS . mount ( PIPEFS , { } , null )
callRuntimeCallbacks ( _ _ATINIT _ _ )
}
function preMain ( ) {
FS . ignorePermissions = false
callRuntimeCallbacks ( _ _ATMAIN _ _ )
}
function exitRuntime ( ) {
runtimeExited = true
}
function postRun ( ) {
if ( Module [ 'postRun' ] ) {
if ( typeof Module [ 'postRun' ] == 'function' )
Module [ 'postRun' ] = [ Module [ 'postRun' ] ]
while ( Module [ 'postRun' ] . length ) {
addOnPostRun ( Module [ 'postRun' ] . shift ( ) )
}
}
callRuntimeCallbacks ( _ _ATPOSTRUN _ _ )
}
function addOnPreRun ( cb ) {
_ _ATPRERUN _ _ . unshift ( cb )
}
function addOnPostRun ( cb ) {
_ _ATPOSTRUN _ _ . unshift ( cb )
}
var Math _abs = Math . abs
var Math _ceil = Math . ceil
var Math _floor = Math . floor
var Math _min = Math . min
var runDependencies = 0
var runDependencyWatcher = null
var dependenciesFulfilled = null
function getUniqueRunDependency ( id ) {
return id
}
function addRunDependency ( id ) {
runDependencies ++
if ( Module [ 'monitorRunDependencies' ] ) {
Module [ 'monitorRunDependencies' ] ( runDependencies )
}
}
function removeRunDependency ( id ) {
runDependencies --
if ( Module [ 'monitorRunDependencies' ] ) {
Module [ 'monitorRunDependencies' ] ( runDependencies )
}
if ( runDependencies == 0 ) {
if ( runDependencyWatcher !== null ) {
clearInterval ( runDependencyWatcher )
runDependencyWatcher = null
}
if ( dependenciesFulfilled ) {
var callback = dependenciesFulfilled
dependenciesFulfilled = null
callback ( )
}
}
}
Module [ 'preloadedImages' ] = { }
Module [ 'preloadedAudios' ] = { }
var dataURIPrefix = 'data:application/octet-stream;base64,'
function isDataURI ( filename ) {
return String . prototype . startsWith
? filename . startsWith ( dataURIPrefix )
: filename . indexOf ( dataURIPrefix ) === 0
}
var wasmBinaryFile = 'libarchive.wasm'
if ( ! isDataURI ( wasmBinaryFile ) ) {
wasmBinaryFile = locateFile ( wasmBinaryFile )
}
function getBinary ( ) {
try {
if ( Module [ 'wasmBinary' ] ) {
return new Uint8Array ( Module [ 'wasmBinary' ] )
}
if ( Module [ 'readBinary' ] ) {
return Module [ 'readBinary' ] ( wasmBinaryFile )
} else {
throw 'both async and sync fetching of the wasm failed'
}
} catch ( err ) {
abort ( err )
}
}
function getBinaryPromise ( ) {
if (
! Module [ 'wasmBinary' ] &&
( ENVIRONMENT _IS _WEB || ENVIRONMENT _IS _WORKER ) &&
typeof fetch === 'function'
) {
return fetch ( wasmBinaryFile , { credentials : 'same-origin' } )
. then ( function ( response ) {
if ( ! response [ 'ok' ] ) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
}
return response [ 'arrayBuffer' ] ( )
} )
. catch ( function ( ) {
return getBinary ( )
} )
}
return new Promise ( function ( resolve , reject ) {
resolve ( getBinary ( ) )
} )
}
function createWasm ( env ) {
var info = {
env : env ,
global : { NaN : NaN , Infinity : Infinity } ,
'global.Math' : Math ,
asm2wasm : asm2wasmImports ,
}
function receiveInstance ( instance , module ) {
var exports = instance . exports
Module [ 'asm' ] = exports
removeRunDependency ( 'wasm-instantiate' )
}
addRunDependency ( 'wasm-instantiate' )
if ( Module [ 'instantiateWasm' ] ) {
try {
return Module [ 'instantiateWasm' ] ( info , receiveInstance )
} catch ( e ) {
err ( 'Module.instantiateWasm callback failed with error: ' + e )
return false
}
}
function receiveInstantiatedSource ( output ) {
receiveInstance ( output [ 'instance' ] )
}
function instantiateArrayBuffer ( receiver ) {
getBinaryPromise ( )
. then ( function ( binary ) {
return WebAssembly . instantiate ( binary , info )
} )
. then ( receiver , function ( reason ) {
err ( 'failed to asynchronously prepare wasm: ' + reason )
abort ( reason )
} )
}
if (
! Module [ 'wasmBinary' ] &&
typeof WebAssembly . instantiateStreaming === 'function' &&
! isDataURI ( wasmBinaryFile ) &&
typeof fetch === 'function'
) {
WebAssembly . instantiateStreaming (
fetch ( wasmBinaryFile , { credentials : 'same-origin' } ) ,
info
) . then ( receiveInstantiatedSource , function ( reason ) {
err ( 'wasm streaming compile failed: ' + reason )
err ( 'falling back to ArrayBuffer instantiation' )
instantiateArrayBuffer ( receiveInstantiatedSource )
} )
} else {
instantiateArrayBuffer ( receiveInstantiatedSource )
}
return { }
}
Module [ 'asm' ] = function ( global , env , providedBuffer ) {
env [ 'memory' ] = wasmMemory
env [ 'table' ] = wasmTable = new WebAssembly . Table ( {
initial : 507 ,
maximum : 507 ,
element : 'anyfunc' ,
} )
env [ '__memory_base' ] = 1024
env [ '__table_base' ] = 0
var exports = createWasm ( env )
return exports
}
_ _ATINIT _ _ . push ( {
func : function ( ) {
_ _ _emscripten _environ _constructor ( )
} ,
} )
var ENV = { }
function _ _ _buildEnvironment ( environ ) {
var MAX _ENV _VALUES = 64
var TOTAL _ENV _SIZE = 1024
var poolPtr
var envPtr
if ( ! _ _ _buildEnvironment . called ) {
_ _ _buildEnvironment . called = true
ENV [ 'USER' ] = ENV [ 'LOGNAME' ] = 'web_user'
ENV [ 'PATH' ] = '/'
ENV [ 'PWD' ] = '/'
ENV [ 'HOME' ] = '/home/web_user'
ENV [ 'LANG' ] = 'C.UTF-8'
ENV [ '_' ] = Module [ 'thisProgram' ]
poolPtr = getMemory ( TOTAL _ENV _SIZE )
envPtr = getMemory ( MAX _ENV _VALUES * 4 )
HEAP32 [ envPtr >> 2 ] = poolPtr
HEAP32 [ environ >> 2 ] = envPtr
} else {
envPtr = HEAP32 [ environ >> 2 ]
poolPtr = HEAP32 [ envPtr >> 2 ]
}
var strings = [ ]
var totalSize = 0
for ( var key in ENV ) {
if ( typeof ENV [ key ] === 'string' ) {
var line = key + '=' + ENV [ key ]
strings . push ( line )
totalSize += line . length
}
}
if ( totalSize > TOTAL _ENV _SIZE ) {
throw new Error ( 'Environment size exceeded TOTAL_ENV_SIZE!' )
}
var ptrSize = 4
for ( var i = 0 ; i < strings . length ; i ++ ) {
var line = strings [ i ]
writeAsciiToMemory ( line , poolPtr )
HEAP32 [ ( envPtr + i * ptrSize ) >> 2 ] = poolPtr
poolPtr += line . length + 1
}
HEAP32 [ ( envPtr + strings . length * ptrSize ) >> 2 ] = 0
}
var PATH = {
splitPath : function ( filename ) {
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/
return splitPathRe . exec ( filename ) . slice ( 1 )
} ,
normalizeArray : function ( parts , allowAboveRoot ) {
var up = 0
for ( var i = parts . length - 1 ; i >= 0 ; i -- ) {
var last = parts [ i ]
if ( last === '.' ) {
parts . splice ( i , 1 )
} else if ( last === '..' ) {
parts . splice ( i , 1 )
up ++
} else if ( up ) {
parts . splice ( i , 1 )
up --
}
}
if ( allowAboveRoot ) {
for ( ; up ; up -- ) {
parts . unshift ( '..' )
}
}
return parts
} ,
normalize : function ( path ) {
var isAbsolute = path . charAt ( 0 ) === '/' ,
trailingSlash = path . substr ( - 1 ) === '/'
path = PATH . normalizeArray (
path . split ( '/' ) . filter ( function ( p ) {
return ! ! p
} ) ,
! isAbsolute
) . join ( '/' )
if ( ! path && ! isAbsolute ) {
path = '.'
}
if ( path && trailingSlash ) {
path += '/'
}
return ( isAbsolute ? '/' : '' ) + path
} ,
dirname : function ( path ) {
var result = PATH . splitPath ( path ) ,
root = result [ 0 ] ,
dir = result [ 1 ]
if ( ! root && ! dir ) {
return '.'
}
if ( dir ) {
dir = dir . substr ( 0 , dir . length - 1 )
}
return root + dir
} ,
basename : function ( path ) {
if ( path === '/' ) return '/'
var lastSlash = path . lastIndexOf ( '/' )
if ( lastSlash === - 1 ) return path
return path . substr ( lastSlash + 1 )
} ,
extname : function ( path ) {
return PATH . splitPath ( path ) [ 3 ]
} ,
join : function ( ) {
var paths = Array . prototype . slice . call ( arguments , 0 )
return PATH . normalize ( paths . join ( '/' ) )
} ,
join2 : function ( l , r ) {
return PATH . normalize ( l + '/' + r )
} ,
}
function _ _ _setErrNo ( value ) {
if ( Module [ '___errno_location' ] ) HEAP32 [ Module [ '___errno_location' ] ( ) >> 2 ] = value
return value
}
var PATH _FS = {
resolve : function ( ) {
var resolvedPath = '' ,
resolvedAbsolute = false
for ( var i = arguments . length - 1 ; i >= - 1 && ! resolvedAbsolute ; i -- ) {
var path = i >= 0 ? arguments [ i ] : FS . cwd ( )
if ( typeof path !== 'string' ) {
throw new TypeError ( 'Arguments to path.resolve must be strings' )
} else if ( ! path ) {
return ''
}
resolvedPath = path + '/' + resolvedPath
resolvedAbsolute = path . charAt ( 0 ) === '/'
}
resolvedPath = PATH . normalizeArray (
resolvedPath . split ( '/' ) . filter ( function ( p ) {
return ! ! p
} ) ,
! resolvedAbsolute
) . join ( '/' )
return ( resolvedAbsolute ? '/' : '' ) + resolvedPath || '.'
} ,
relative : function ( from , to ) {
from = PATH _FS . resolve ( from ) . substr ( 1 )
to = PATH _FS . resolve ( to ) . substr ( 1 )
function trim ( arr ) {
var start = 0
for ( ; start < arr . length ; start ++ ) {
if ( arr [ start ] !== '' ) break
}
var end = arr . length - 1
for ( ; end >= 0 ; end -- ) {
if ( arr [ end ] !== '' ) break
}
if ( start > end ) return [ ]
return arr . slice ( start , end - start + 1 )
}
var fromParts = trim ( from . split ( '/' ) )
var toParts = trim ( to . split ( '/' ) )
var length = Math . min ( fromParts . length , toParts . length )
var samePartsLength = length
for ( var i = 0 ; i < length ; i ++ ) {
if ( fromParts [ i ] !== toParts [ i ] ) {
samePartsLength = i
break
}
}
var outputParts = [ ]
for ( var i = samePartsLength ; i < fromParts . length ; i ++ ) {
outputParts . push ( '..' )
}
outputParts = outputParts . concat ( toParts . slice ( samePartsLength ) )
return outputParts . join ( '/' )
} ,
}
var TTY = {
ttys : [ ] ,
init : function ( ) { } ,
shutdown : function ( ) { } ,
register : function ( dev , ops ) {
TTY . ttys [ dev ] = { input : [ ] , output : [ ] , ops : ops }
FS . registerDevice ( dev , TTY . stream _ops )
} ,
stream _ops : {
open : function ( stream ) {
var tty = TTY . ttys [ stream . node . rdev ]
if ( ! tty ) {
throw new FS . ErrnoError ( 19 )
}
stream . tty = tty
stream . seekable = false
} ,
close : function ( stream ) {
stream . tty . ops . flush ( stream . tty )
} ,
flush : function ( stream ) {
stream . tty . ops . flush ( stream . tty )
} ,
read : function ( stream , buffer , offset , length , pos ) {
if ( ! stream . tty || ! stream . tty . ops . get _char ) {
throw new FS . ErrnoError ( 6 )
}
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 ( 5 )
}
if ( result === undefined && bytesRead === 0 ) {
throw new FS . ErrnoError ( 11 )
}
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 ( 6 )
}
try {
for ( var i = 0 ; i < length ; i ++ ) {
stream . tty . ops . put _char ( stream . tty , buffer [ offset + i ] )
}
} catch ( e ) {
throw new FS . ErrnoError ( 5 )
}
if ( length ) {
stream . node . timestamp = Date . now ( )
}
return i
} ,
} ,
default _tty _ops : {
get _char : function ( tty ) {
if ( ! tty . input . length ) {
var result = null
if ( ENVIRONMENT _IS _NODE ) {
var BUFSIZE = 256
var buf = new Buffer ( BUFSIZE )
var bytesRead = 0
var isPosixPlatform = process . platform != 'win32'
var fd = process . stdin . fd
if ( isPosixPlatform ) {
var usingDevice = false
try {
fd = fs . openSync ( '/dev/stdin' , 'r' )
usingDevice = true
} catch ( e ) { }
}
try {
bytesRead = fs . readSync ( fd , buf , 0 , BUFSIZE , null )
} catch ( e ) {
if ( e . toString ( ) . indexOf ( 'EOF' ) != - 1 ) bytesRead = 0
else throw e
}
if ( usingDevice ) {
fs . closeSync ( fd )
}
if ( bytesRead > 0 ) {
result = buf . slice ( 0 , bytesRead ) . toString ( 'utf-8' )
} else {
result = null
}
} else if (
typeof window != 'undefined' &&
typeof window . prompt == 'function'
) {
result = window . prompt ( 'Input: ' )
if ( result !== null ) {
result += '\n'
}
} else if ( typeof readline == 'function' ) {
result = readline ( )
if ( result !== null ) {
result += '\n'
}
}
if ( ! result ) {
return null
}
tty . input = intArrayFromString ( result , true )
}
return tty . input . shift ( )
} ,
put _char : function ( tty , val ) {
if ( val === null || val === 10 ) {
out ( UTF8ArrayToString ( tty . output , 0 ) )
tty . output = [ ]
} else {
if ( val != 0 ) tty . output . push ( val )
}
} ,
flush : function ( tty ) {
if ( tty . output && tty . output . length > 0 ) {
out ( UTF8ArrayToString ( tty . output , 0 ) )
tty . output = [ ]
}
} ,
} ,
default _tty1 _ops : {
put _char : function ( tty , val ) {
if ( val === null || val === 10 ) {
err ( UTF8ArrayToString ( tty . output , 0 ) )
tty . output = [ ]
} else {
if ( val != 0 ) tty . output . push ( val )
}
} ,
flush : function ( tty ) {
if ( tty . output && tty . output . length > 0 ) {
err ( UTF8ArrayToString ( tty . output , 0 ) )
tty . output = [ ]
}
} ,
} ,
}
var MEMFS = {
ops _table : null ,
mount : function ( mount ) {
return MEMFS . createNode ( null , '/' , 16384 | 511 , 0 )
} ,
createNode : function ( parent , name , mode , dev ) {
if ( FS . isBlkdev ( mode ) || FS . isFIFO ( mode ) ) {
throw new FS . ErrnoError ( 1 )
}
if ( ! MEMFS . ops _table ) {
MEMFS . ops _table = {
dir : {
node : {
getattr : MEMFS . node _ops . getattr ,
setattr : MEMFS . node _ops . setattr ,
lookup : MEMFS . node _ops . lookup ,
mknod : MEMFS . node _ops . mknod ,
rename : MEMFS . node _ops . rename ,
unlink : MEMFS . node _ops . unlink ,
rmdir : MEMFS . node _ops . rmdir ,
readdir : MEMFS . node _ops . readdir ,
symlink : MEMFS . node _ops . symlink ,
} ,
stream : { llseek : MEMFS . stream _ops . llseek } ,
} ,
file : {
node : { getattr : MEMFS . node _ops . getattr , setattr : MEMFS . node _ops . setattr } ,
stream : {
llseek : MEMFS . stream _ops . llseek ,
read : MEMFS . stream _ops . read ,
write : MEMFS . stream _ops . write ,
allocate : MEMFS . stream _ops . allocate ,
mmap : MEMFS . stream _ops . mmap ,
msync : MEMFS . stream _ops . msync ,
} ,
} ,
link : {
node : {
getattr : MEMFS . node _ops . getattr ,
setattr : MEMFS . node _ops . setattr ,
readlink : MEMFS . node _ops . readlink ,
} ,
stream : { } ,
} ,
chrdev : {
node : { getattr : MEMFS . node _ops . getattr , setattr : MEMFS . node _ops . setattr } ,
stream : FS . chrdev _stream _ops ,
} ,
}
}
var node = FS . createNode ( parent , name , mode , dev )
if ( FS . isDir ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . dir . node
node . stream _ops = MEMFS . ops _table . dir . stream
node . contents = { }
} else if ( FS . isFile ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . file . node
node . stream _ops = MEMFS . ops _table . file . stream
node . usedBytes = 0
node . contents = null
} else if ( FS . isLink ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . link . node
node . stream _ops = MEMFS . ops _table . link . stream
} else if ( FS . isChrdev ( node . mode ) ) {
node . node _ops = MEMFS . ops _table . chrdev . node
node . stream _ops = MEMFS . ops _table . chrdev . stream
}
node . timestamp = Date . now ( )
if ( parent ) {
parent . contents [ name ] = node
}
return node
} ,
getFileDataAsRegularArray : function ( node ) {
if ( node . contents && node . contents . subarray ) {
var arr = [ ]
for ( var i = 0 ; i < node . usedBytes ; ++ i ) arr . push ( node . contents [ i ] )
return arr
}
return node . contents
} ,
getFileDataAsTypedArray : function ( node ) {
if ( ! node . contents ) return new Uint8Array ( )
if ( node . contents . subarray ) return node . contents . subarray ( 0 , node . usedBytes )
return new Uint8Array ( node . contents )
} ,
expandFileStorage : function ( node , newCapacity ) {
var prevCapacity = node . contents ? node . contents . length : 0
if ( prevCapacity >= newCapacity ) return
var CAPACITY _DOUBLING _MAX = 1024 * 1024
newCapacity = Math . max (
newCapacity ,
( prevCapacity * ( prevCapacity < CAPACITY _DOUBLING _MAX ? 2 : 1.125 ) ) | 0
)
if ( prevCapacity != 0 ) newCapacity = Math . max ( newCapacity , 256 )
var oldContents = node . contents
node . contents = new Uint8Array ( newCapacity )
if ( node . usedBytes > 0 )
node . contents . set ( oldContents . subarray ( 0 , node . usedBytes ) , 0 )
return
} ,
resizeFileStorage : function ( node , newSize ) {
if ( node . usedBytes == newSize ) return
if ( newSize == 0 ) {
node . contents = null
node . usedBytes = 0
return
}
if ( ! node . contents || node . contents . subarray ) {
var oldContents = node . contents
node . contents = new Uint8Array ( new ArrayBuffer ( newSize ) )
if ( oldContents ) {
node . contents . set ( oldContents . subarray ( 0 , Math . min ( newSize , node . usedBytes ) ) )
}
node . usedBytes = newSize
return
}
if ( ! node . contents ) node . contents = [ ]
if ( node . contents . length > newSize ) node . contents . length = newSize
else while ( node . contents . length < newSize ) node . contents . push ( 0 )
node . usedBytes = newSize
} ,
node _ops : {
getattr : function ( node ) {
var attr = { }
attr . dev = FS . isChrdev ( node . mode ) ? node . id : 1
attr . ino = node . id
attr . mode = node . mode
attr . nlink = 1
attr . uid = 0
attr . gid = 0
attr . rdev = node . rdev
if ( FS . isDir ( node . mode ) ) {
attr . size = 4096
} else if ( FS . isFile ( node . mode ) ) {
attr . size = node . usedBytes
} else if ( FS . isLink ( node . mode ) ) {
attr . size = node . link . length
} else {
attr . size = 0
}
attr . atime = new Date ( node . timestamp )
attr . mtime = new Date ( node . timestamp )
attr . ctime = new Date ( node . timestamp )
attr . blksize = 4096
attr . blocks = Math . ceil ( attr . size / attr . blksize )
return attr
} ,
setattr : function ( node , attr ) {
if ( attr . mode !== undefined ) {
node . mode = attr . mode
}
if ( attr . timestamp !== undefined ) {
node . timestamp = attr . timestamp
}
if ( attr . size !== undefined ) {
MEMFS . resizeFileStorage ( node , attr . size )
}
} ,
lookup : function ( parent , name ) {
throw FS . genericErrors [ 2 ]
} ,
mknod : function ( parent , name , mode , dev ) {
return MEMFS . createNode ( parent , name , mode , dev )
} ,
rename : function ( old _node , new _dir , new _name ) {
if ( FS . isDir ( old _node . mode ) ) {
var new _node
try {
new _node = FS . lookupNode ( new _dir , new _name )
} catch ( e ) { }
if ( new _node ) {
for ( var i in new _node . contents ) {
throw new FS . ErrnoError ( 39 )
}
}
}
delete old _node . parent . contents [ old _node . name ]
old _node . name = new _name
new _dir . contents [ new _name ] = old _node
old _node . parent = new _dir
} ,
unlink : function ( parent , name ) {
delete parent . contents [ name ]
} ,
rmdir : function ( parent , name ) {
var node = FS . lookupNode ( parent , name )
for ( var i in node . contents ) {
throw new FS . ErrnoError ( 39 )
}
delete parent . contents [ name ]
} ,
readdir : function ( node ) {
var entries = [ '.' , '..' ]
for ( var key in node . contents ) {
if ( ! node . contents . hasOwnProperty ( key ) ) {
continue
}
entries . push ( key )
}
return entries
} ,
symlink : function ( parent , newname , oldpath ) {
var node = MEMFS . createNode ( parent , newname , 511 | 40960 , 0 )
node . link = oldpath
return node
} ,
readlink : function ( node ) {
if ( ! FS . isLink ( node . mode ) ) {
throw new FS . ErrnoError ( 22 )
}
return node . link
} ,
} ,
stream _ops : {
read : function ( stream , buffer , offset , length , position ) {
var contents = stream . node . contents
if ( position >= stream . node . usedBytes ) return 0
var size = Math . min ( stream . node . usedBytes - position , length )
if ( size > 8 && contents . subarray ) {
buffer . set ( contents . subarray ( position , position + size ) , offset )
} else {
for ( var i = 0 ; i < size ; i ++ ) buffer [ offset + i ] = contents [ position + i ]
}
return size
} ,
write : function ( stream , buffer , offset , length , position , canOwn ) {
canOwn = false
if ( ! length ) return 0
var node = stream . node
node . timestamp = Date . now ( )
if ( buffer . subarray && ( ! node . contents || node . contents . subarray ) ) {
if ( canOwn ) {
node . contents = buffer . subarray ( offset , offset + length )
node . usedBytes = length
return length
} else if ( node . usedBytes === 0 && position === 0 ) {
node . contents = new Uint8Array ( buffer . subarray ( offset , offset + length ) )
node . usedBytes = length
return length
} else if ( position + length <= node . usedBytes ) {
node . contents . set ( buffer . subarray ( offset , offset + length ) , position )
return length
}
}
MEMFS . expandFileStorage ( node , position + length )
if ( node . contents . subarray && buffer . subarray )
node . contents . set ( buffer . subarray ( offset , offset + length ) , position )
else {
for ( var i = 0 ; i < length ; i ++ ) {
node . contents [ position + i ] = buffer [ offset + i ]
}
}
node . usedBytes = Math . max ( node . usedBytes , position + length )
return length
} ,
llseek : function ( stream , offset , whence ) {
var position = offset
if ( whence === 1 ) {
position += stream . position
} else if ( whence === 2 ) {
if ( FS . isFile ( stream . node . mode ) ) {
position += stream . node . usedBytes
}
}
if ( position < 0 ) {
throw new FS . ErrnoError ( 22 )
}
return position
} ,
allocate : function ( stream , offset , length ) {
MEMFS . expandFileStorage ( stream . node , offset + length )
stream . node . usedBytes = Math . max ( stream . node . usedBytes , offset + length )
} ,
mmap : function ( stream , buffer , offset , length , position , prot , flags ) {
if ( ! FS . isFile ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 19 )
}
var ptr
var allocated
var contents = stream . node . contents
if (
! ( flags & 2 ) &&
( contents . buffer === buffer || contents . buffer === buffer . buffer )
) {
allocated = false
ptr = contents . byteOffset
} else {
if ( position > 0 || position + length < stream . node . usedBytes ) {
if ( contents . subarray ) {
contents = contents . subarray ( position , position + length )
} else {
contents = Array . prototype . slice . call (
contents ,
position ,
position + length
)
}
}
allocated = true
ptr = _malloc ( length )
if ( ! ptr ) {
throw new FS . ErrnoError ( 12 )
}
buffer . set ( contents , ptr )
}
return { ptr : ptr , allocated : allocated }
} ,
msync : function ( stream , buffer , offset , length , mmapFlags ) {
if ( ! FS . isFile ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 19 )
}
if ( mmapFlags & 2 ) {
return 0
}
var bytesWritten = MEMFS . stream _ops . write (
stream ,
buffer ,
0 ,
length ,
offset ,
false
)
return 0
} ,
} ,
}
var IDBFS = {
dbs : { } ,
indexedDB : function ( ) {
if ( typeof indexedDB !== 'undefined' ) return indexedDB
var ret = null
if ( typeof window === 'object' )
ret =
window . indexedDB ||
window . mozIndexedDB ||
window . webkitIndexedDB ||
window . msIndexedDB
assert ( ret , 'IDBFS used, but indexedDB not supported' )
return ret
} ,
DB _VERSION : 21 ,
DB _STORE _NAME : 'FILE_DATA' ,
mount : function ( mount ) {
return MEMFS . mount . apply ( null , arguments )
} ,
syncfs : function ( mount , populate , callback ) {
IDBFS . getLocalSet ( mount , function ( err , local ) {
if ( err ) return callback ( err )
IDBFS . getRemoteSet ( mount , function ( err , remote ) {
if ( err ) return callback ( err )
var src = populate ? remote : local
var dst = populate ? local : remote
IDBFS . reconcile ( src , dst , callback )
} )
} )
} ,
getDB : function ( name , callback ) {
var db = IDBFS . dbs [ name ]
if ( db ) {
return callback ( null , db )
}
var req
try {
req = IDBFS . indexedDB ( ) . open ( name , IDBFS . DB _VERSION )
} catch ( e ) {
return callback ( e )
}
if ( ! req ) {
return callback ( 'Unable to connect to IndexedDB' )
}
req . onupgradeneeded = function ( e ) {
var db = e . target . result
var transaction = e . target . transaction
var fileStore
if ( db . objectStoreNames . contains ( IDBFS . DB _STORE _NAME ) ) {
fileStore = transaction . objectStore ( IDBFS . DB _STORE _NAME )
} else {
fileStore = db . createObjectStore ( IDBFS . DB _STORE _NAME )
}
if ( ! fileStore . indexNames . contains ( 'timestamp' ) ) {
fileStore . createIndex ( 'timestamp' , 'timestamp' , { unique : false } )
}
}
req . onsuccess = function ( ) {
db = req . result
IDBFS . dbs [ name ] = db
callback ( null , db )
}
req . onerror = function ( e ) {
callback ( this . error )
e . preventDefault ( )
}
} ,
getLocalSet : function ( mount , callback ) {
var entries = { }
function isRealDir ( p ) {
return p !== '.' && p !== '..'
}
function toAbsolute ( root ) {
return function ( p ) {
return PATH . join2 ( root , p )
}
}
var check = FS . readdir ( mount . mountpoint )
. filter ( isRealDir )
. map ( toAbsolute ( mount . mountpoint ) )
while ( check . length ) {
var path = check . pop ( )
var stat
try {
stat = FS . stat ( path )
} catch ( e ) {
return callback ( e )
}
if ( FS . isDir ( stat . mode ) ) {
check . push . apply (
check ,
FS . readdir ( path )
. filter ( isRealDir )
. map ( toAbsolute ( path ) )
)
}
entries [ path ] = { timestamp : stat . mtime }
}
return callback ( null , { type : 'local' , entries : entries } )
} ,
getRemoteSet : function ( mount , callback ) {
var entries = { }
IDBFS . getDB ( mount . mountpoint , function ( err , db ) {
if ( err ) return callback ( err )
try {
var transaction = db . transaction ( [ IDBFS . DB _STORE _NAME ] , 'readonly' )
transaction . onerror = function ( e ) {
callback ( this . error )
e . preventDefault ( )
}
var store = transaction . objectStore ( IDBFS . DB _STORE _NAME )
var index = store . index ( 'timestamp' )
index . openKeyCursor ( ) . onsuccess = function ( event ) {
var cursor = event . target . result
if ( ! cursor ) {
return callback ( null , { type : 'remote' , db : db , entries : entries } )
}
entries [ cursor . primaryKey ] = { timestamp : cursor . key }
cursor . continue ( )
}
} catch ( e ) {
return callback ( e )
}
} )
} ,
loadLocalEntry : function ( path , callback ) {
var stat , node
try {
var lookup = FS . lookupPath ( path )
node = lookup . node
stat = FS . stat ( path )
} catch ( e ) {
return callback ( e )
}
if ( FS . isDir ( stat . mode ) ) {
return callback ( null , { timestamp : stat . mtime , mode : stat . mode } )
} else if ( FS . isFile ( stat . mode ) ) {
node . contents = MEMFS . getFileDataAsTypedArray ( node )
return callback ( null , {
timestamp : stat . mtime ,
mode : stat . mode ,
contents : node . contents ,
} )
} else {
return callback ( new Error ( 'node type not supported' ) )
}
} ,
storeLocalEntry : function ( path , entry , callback ) {
try {
if ( FS . isDir ( entry . mode ) ) {
FS . mkdir ( path , entry . mode )
} else if ( FS . isFile ( entry . mode ) ) {
FS . writeFile ( path , entry . contents , { canOwn : true } )
} else {
return callback ( new Error ( 'node type not supported' ) )
}
FS . chmod ( path , entry . mode )
FS . utime ( path , entry . timestamp , entry . timestamp )
} catch ( e ) {
return callback ( e )
}
callback ( null )
} ,
removeLocalEntry : function ( path , callback ) {
try {
var lookup = FS . lookupPath ( path )
var stat = FS . stat ( path )
if ( FS . isDir ( stat . mode ) ) {
FS . rmdir ( path )
} else if ( FS . isFile ( stat . mode ) ) {
FS . unlink ( path )
}
} catch ( e ) {
return callback ( e )
}
callback ( null )
} ,
loadRemoteEntry : function ( store , path , callback ) {
var req = store . get ( path )
req . onsuccess = function ( event ) {
callback ( null , event . target . result )
}
req . onerror = function ( e ) {
callback ( this . error )
e . preventDefault ( )
}
} ,
storeRemoteEntry : function ( store , path , entry , callback ) {
var req = store . put ( entry , path )
req . onsuccess = function ( ) {
callback ( null )
}
req . onerror = function ( e ) {
callback ( this . error )
e . preventDefault ( )
}
} ,
removeRemoteEntry : function ( store , path , callback ) {
var req = store . delete ( path )
req . onsuccess = function ( ) {
callback ( null )
}
req . onerror = function ( e ) {
callback ( this . error )
e . preventDefault ( )
}
} ,
reconcile : function ( src , dst , callback ) {
var total = 0
var create = [ ]
Object . keys ( src . entries ) . forEach ( function ( key ) {
var e = src . entries [ key ]
var e2 = dst . entries [ key ]
if ( ! e2 || e . timestamp > e2 . timestamp ) {
create . push ( key )
total ++
}
} )
var remove = [ ]
Object . keys ( dst . entries ) . forEach ( function ( key ) {
var e = dst . entries [ key ]
var e2 = src . entries [ key ]
if ( ! e2 ) {
remove . push ( key )
total ++
}
} )
if ( ! total ) {
return callback ( null )
}
var errored = false
var completed = 0
var db = src . type === 'remote' ? src . db : dst . db
var transaction = db . transaction ( [ IDBFS . DB _STORE _NAME ] , 'readwrite' )
var store = transaction . objectStore ( IDBFS . DB _STORE _NAME )
function done ( err ) {
if ( err ) {
if ( ! done . errored ) {
done . errored = true
return callback ( err )
}
return
}
if ( ++ completed >= total ) {
return callback ( null )
}
}
transaction . onerror = function ( e ) {
done ( this . error )
e . preventDefault ( )
}
create . sort ( ) . forEach ( function ( path ) {
if ( dst . type === 'local' ) {
IDBFS . loadRemoteEntry ( store , path , function ( err , entry ) {
if ( err ) return done ( err )
IDBFS . storeLocalEntry ( path , entry , done )
} )
} else {
IDBFS . loadLocalEntry ( path , function ( err , entry ) {
if ( err ) return done ( err )
IDBFS . storeRemoteEntry ( store , path , entry , done )
} )
}
} )
remove
. sort ( )
. reverse ( )
. forEach ( function ( path ) {
if ( dst . type === 'local' ) {
IDBFS . removeLocalEntry ( path , done )
} else {
IDBFS . removeRemoteEntry ( store , path , done )
}
} )
} ,
}
var NODEFS = {
isWindows : false ,
staticInit : function ( ) {
NODEFS . isWindows = ! ! process . platform . match ( /^win/ )
var flags = process [ 'binding' ] ( 'constants' )
if ( flags [ 'fs' ] ) {
flags = flags [ 'fs' ]
}
NODEFS . flagsForNodeMap = {
1024 : flags [ 'O_APPEND' ] ,
64 : flags [ 'O_CREAT' ] ,
128 : flags [ 'O_EXCL' ] ,
0 : flags [ 'O_RDONLY' ] ,
2 : flags [ 'O_RDWR' ] ,
4096 : flags [ 'O_SYNC' ] ,
512 : flags [ 'O_TRUNC' ] ,
1 : flags [ 'O_WRONLY' ] ,
}
} ,
bufferFrom : function ( arrayBuffer ) {
return Buffer . alloc ? Buffer . from ( arrayBuffer ) : new Buffer ( arrayBuffer )
} ,
mount : function ( mount ) {
assert ( ENVIRONMENT _IS _NODE )
return NODEFS . createNode ( null , '/' , NODEFS . getMode ( mount . opts . root ) , 0 )
} ,
createNode : function ( parent , name , mode , dev ) {
if ( ! FS . isDir ( mode ) && ! FS . isFile ( mode ) && ! FS . isLink ( mode ) ) {
throw new FS . ErrnoError ( 22 )
}
var node = FS . createNode ( parent , name , mode )
node . node _ops = NODEFS . node _ops
node . stream _ops = NODEFS . stream _ops
return node
} ,
getMode : function ( path ) {
var stat
try {
stat = fs . lstatSync ( path )
if ( NODEFS . isWindows ) {
stat . mode = stat . mode | ( ( stat . mode & 292 ) >> 2 )
}
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
return stat . mode
} ,
realPath : function ( node ) {
var parts = [ ]
while ( node . parent !== node ) {
parts . push ( node . name )
node = node . parent
}
parts . push ( node . mount . opts . root )
parts . reverse ( )
return PATH . join . apply ( null , parts )
} ,
flagsForNode : function ( flags ) {
flags &= ~ 2097152
flags &= ~ 2048
flags &= ~ 32768
flags &= ~ 524288
var newFlags = 0
for ( var k in NODEFS . flagsForNodeMap ) {
if ( flags & k ) {
newFlags |= NODEFS . flagsForNodeMap [ k ]
flags ^= k
}
}
if ( ! flags ) {
return newFlags
} else {
throw new FS . ErrnoError ( 22 )
}
} ,
node _ops : {
getattr : function ( node ) {
var path = NODEFS . realPath ( node )
var stat
try {
stat = fs . lstatSync ( path )
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
if ( NODEFS . isWindows && ! stat . blksize ) {
stat . blksize = 4096
}
if ( NODEFS . isWindows && ! stat . blocks ) {
stat . blocks = ( ( stat . size + stat . blksize - 1 ) / stat . blksize ) | 0
}
return {
dev : stat . dev ,
ino : stat . ino ,
mode : stat . mode ,
nlink : stat . nlink ,
uid : stat . uid ,
gid : stat . gid ,
rdev : stat . rdev ,
size : stat . size ,
atime : stat . atime ,
mtime : stat . mtime ,
ctime : stat . ctime ,
blksize : stat . blksize ,
blocks : stat . blocks ,
}
} ,
setattr : function ( node , attr ) {
var path = NODEFS . realPath ( node )
try {
if ( attr . mode !== undefined ) {
fs . chmodSync ( path , attr . mode )
node . mode = attr . mode
}
if ( attr . timestamp !== undefined ) {
var date = new Date ( attr . timestamp )
fs . utimesSync ( path , date , date )
}
if ( attr . size !== undefined ) {
fs . truncateSync ( path , attr . size )
}
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
lookup : function ( parent , name ) {
var path = PATH . join2 ( NODEFS . realPath ( parent ) , name )
var mode = NODEFS . getMode ( path )
return NODEFS . createNode ( parent , name , mode )
} ,
mknod : function ( parent , name , mode , dev ) {
var node = NODEFS . createNode ( parent , name , mode , dev )
var path = NODEFS . realPath ( node )
try {
if ( FS . isDir ( node . mode ) ) {
fs . mkdirSync ( path , node . mode )
} else {
fs . writeFileSync ( path , '' , { mode : node . mode } )
}
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
return node
} ,
rename : function ( oldNode , newDir , newName ) {
var oldPath = NODEFS . realPath ( oldNode )
var newPath = PATH . join2 ( NODEFS . realPath ( newDir ) , newName )
try {
fs . renameSync ( oldPath , newPath )
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
unlink : function ( parent , name ) {
var path = PATH . join2 ( NODEFS . realPath ( parent ) , name )
try {
fs . unlinkSync ( path )
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
rmdir : function ( parent , name ) {
var path = PATH . join2 ( NODEFS . realPath ( parent ) , name )
try {
fs . rmdirSync ( path )
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
readdir : function ( node ) {
var path = NODEFS . realPath ( node )
try {
return fs . readdirSync ( path )
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
symlink : function ( parent , newName , oldPath ) {
var newPath = PATH . join2 ( NODEFS . realPath ( parent ) , newName )
try {
fs . symlinkSync ( oldPath , newPath )
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
readlink : function ( node ) {
var path = NODEFS . realPath ( node )
try {
path = fs . readlinkSync ( path )
path = NODEJS _PATH . relative ( NODEJS _PATH . resolve ( node . mount . opts . root ) , path )
return path
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
} ,
stream _ops : {
open : function ( stream ) {
var path = NODEFS . realPath ( stream . node )
try {
if ( FS . isFile ( stream . node . mode ) ) {
stream . nfd = fs . openSync ( path , NODEFS . flagsForNode ( stream . flags ) )
}
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
close : function ( stream ) {
try {
if ( FS . isFile ( stream . node . mode ) && stream . nfd ) {
fs . closeSync ( stream . nfd )
}
} catch ( e ) {
if ( ! e . code ) throw e
throw new FS . ErrnoError ( - e . errno )
}
} ,
read : function ( stream , buffer , offset , length , position ) {
if ( length === 0 ) return 0
try {
return fs . readSync (
stream . nfd ,
NODEFS . bufferFrom ( buffer . buffer ) ,
offset ,
length ,
position
)
} catch ( e ) {
throw new FS . ErrnoError ( - e . errno )
}
} ,
write : function ( stream , buffer , offset , length , position ) {
try {
return fs . writeSync (
stream . nfd ,
NODEFS . bufferFrom ( buffer . buffer ) ,
offset ,
length ,
position
)
} catch ( e ) {
throw new FS . ErrnoError ( - e . errno )
}
} ,
llseek : function ( stream , offset , whence ) {
var position = offset
if ( whence === 1 ) {
position += stream . position
} else if ( whence === 2 ) {
if ( FS . isFile ( stream . node . mode ) ) {
try {
var stat = fs . fstatSync ( stream . nfd )
position += stat . size
} catch ( e ) {
throw new FS . ErrnoError ( - e . errno )
}
}
}
if ( position < 0 ) {
throw new FS . ErrnoError ( 22 )
}
return position
} ,
} ,
}
var WORKERFS = {
DIR _MODE : 16895 ,
FILE _MODE : 33279 ,
reader : null ,
mount : function ( mount ) {
assert ( ENVIRONMENT _IS _WORKER )
if ( ! WORKERFS . reader ) WORKERFS . reader = new FileReaderSync ( )
var root = WORKERFS . createNode ( null , '/' , WORKERFS . DIR _MODE , 0 )
var createdParents = { }
function ensureParent ( path ) {
var parts = path . split ( '/' )
var parent = root
for ( var i = 0 ; i < parts . length - 1 ; i ++ ) {
var curr = parts . slice ( 0 , i + 1 ) . join ( '/' )
if ( ! createdParents [ curr ] ) {
createdParents [ curr ] = WORKERFS . createNode (
parent ,
parts [ i ] ,
WORKERFS . DIR _MODE ,
0
)
}
parent = createdParents [ curr ]
}
return parent
}
function base ( path ) {
var parts = path . split ( '/' )
return parts [ parts . length - 1 ]
}
Array . prototype . forEach . call ( mount . opts [ 'files' ] || [ ] , function ( file ) {
WORKERFS . createNode (
ensureParent ( file . name ) ,
base ( file . name ) ,
WORKERFS . FILE _MODE ,
0 ,
file ,
file . lastModifiedDate
)
} )
; ( mount . opts [ 'blobs' ] || [ ] ) . forEach ( function ( obj ) {
WORKERFS . createNode (
ensureParent ( obj [ 'name' ] ) ,
base ( obj [ 'name' ] ) ,
WORKERFS . FILE _MODE ,
0 ,
obj [ 'data' ]
)
} )
; ( mount . opts [ 'packages' ] || [ ] ) . forEach ( function ( pack ) {
pack [ 'metadata' ] . files . forEach ( function ( file ) {
var name = file . filename . substr ( 1 )
WORKERFS . createNode (
ensureParent ( name ) ,
base ( name ) ,
WORKERFS . FILE _MODE ,
0 ,
pack [ 'blob' ] . slice ( file . start , file . end )
)
} )
} )
return root
} ,
createNode : function ( parent , name , mode , dev , contents , mtime ) {
var node = FS . createNode ( parent , name , mode )
node . mode = mode
node . node _ops = WORKERFS . node _ops
node . stream _ops = WORKERFS . stream _ops
node . timestamp = ( mtime || new Date ( ) ) . getTime ( )
assert ( WORKERFS . FILE _MODE !== WORKERFS . DIR _MODE )
if ( mode === WORKERFS . FILE _MODE ) {
node . size = contents . size
node . contents = contents
} else {
node . size = 4096
node . contents = { }
}
if ( parent ) {
parent . contents [ name ] = node
}
return node
} ,
node _ops : {
getattr : function ( node ) {
return {
dev : 1 ,
ino : undefined ,
mode : node . mode ,
nlink : 1 ,
uid : 0 ,
gid : 0 ,
rdev : undefined ,
size : node . size ,
atime : new Date ( node . timestamp ) ,
mtime : new Date ( node . timestamp ) ,
ctime : new Date ( node . timestamp ) ,
blksize : 4096 ,
blocks : Math . ceil ( node . size / 4096 ) ,
}
} ,
setattr : function ( node , attr ) {
if ( attr . mode !== undefined ) {
node . mode = attr . mode
}
if ( attr . timestamp !== undefined ) {
node . timestamp = attr . timestamp
}
} ,
lookup : function ( parent , name ) {
throw new FS . ErrnoError ( 2 )
} ,
mknod : function ( parent , name , mode , dev ) {
throw new FS . ErrnoError ( 1 )
} ,
rename : function ( oldNode , newDir , newName ) {
throw new FS . ErrnoError ( 1 )
} ,
unlink : function ( parent , name ) {
throw new FS . ErrnoError ( 1 )
} ,
rmdir : function ( parent , name ) {
throw new FS . ErrnoError ( 1 )
} ,
readdir : function ( node ) {
var entries = [ '.' , '..' ]
for ( var key in node . contents ) {
if ( ! node . contents . hasOwnProperty ( key ) ) {
continue
}
entries . push ( key )
}
return entries
} ,
symlink : function ( parent , newName , oldPath ) {
throw new FS . ErrnoError ( 1 )
} ,
readlink : function ( node ) {
throw new FS . ErrnoError ( 1 )
} ,
} ,
stream _ops : {
read : function ( stream , buffer , offset , length , position ) {
if ( position >= stream . node . size ) return 0
var chunk = stream . node . contents . slice ( position , position + length )
var ab = WORKERFS . reader . readAsArrayBuffer ( chunk )
buffer . set ( new Uint8Array ( ab ) , offset )
return chunk . size
} ,
write : function ( stream , buffer , offset , length , position ) {
throw new FS . ErrnoError ( 5 )
} ,
llseek : function ( stream , offset , whence ) {
var position = offset
if ( whence === 1 ) {
position += stream . position
} else if ( whence === 2 ) {
if ( FS . isFile ( stream . node . mode ) ) {
position += stream . node . size
}
}
if ( position < 0 ) {
throw new FS . ErrnoError ( 22 )
}
return position
} ,
} ,
}
var FS = {
root : null ,
mounts : [ ] ,
devices : { } ,
streams : [ ] ,
nextInode : 1 ,
nameTable : null ,
currentPath : '/' ,
initialized : false ,
ignorePermissions : true ,
trackingDelegate : { } ,
tracking : { openFlags : { READ : 1 , WRITE : 2 } } ,
ErrnoError : null ,
genericErrors : { } ,
filesystems : null ,
syncFSRequests : 0 ,
handleFSError : function ( e ) {
if ( ! ( e instanceof FS . ErrnoError ) ) throw e + ' : ' + stackTrace ( )
return _ _ _setErrNo ( e . errno )
} ,
lookupPath : function ( path , opts ) {
path = PATH _FS . resolve ( FS . cwd ( ) , path )
opts = opts || { }
if ( ! path ) return { path : '' , node : null }
var defaults = { follow _mount : true , recurse _count : 0 }
for ( var key in defaults ) {
if ( opts [ key ] === undefined ) {
opts [ key ] = defaults [ key ]
}
}
if ( opts . recurse _count > 8 ) {
throw new FS . ErrnoError ( 40 )
}
var parts = PATH . normalizeArray (
path . split ( '/' ) . filter ( function ( p ) {
return ! ! p
} ) ,
false
)
var current = FS . root
var current _path = '/'
for ( var i = 0 ; i < parts . length ; i ++ ) {
var islast = i === parts . length - 1
if ( islast && opts . parent ) {
break
}
current = FS . lookupNode ( current , parts [ i ] )
current _path = PATH . join2 ( current _path , parts [ i ] )
if ( FS . isMountpoint ( current ) ) {
if ( ! islast || ( islast && opts . follow _mount ) ) {
current = current . mounted . root
}
}
if ( ! islast || opts . follow ) {
var count = 0
while ( FS . isLink ( current . mode ) ) {
var link = FS . readlink ( current _path )
current _path = PATH _FS . resolve ( PATH . dirname ( current _path ) , link )
var lookup = FS . lookupPath ( current _path , {
recurse _count : opts . recurse _count ,
} )
current = lookup . node
if ( count ++ > 40 ) {
throw new FS . ErrnoError ( 40 )
}
}
}
}
return { path : current _path , node : current }
} ,
getPath : function ( node ) {
var path
while ( true ) {
if ( FS . isRoot ( node ) ) {
var mount = node . mount . mountpoint
if ( ! path ) return mount
return mount [ mount . length - 1 ] !== '/' ? mount + '/' + path : mount + path
}
path = path ? node . name + '/' + path : node . name
node = node . parent
}
} ,
hashName : function ( parentid , name ) {
var hash = 0
for ( var i = 0 ; i < name . length ; i ++ ) {
hash = ( ( hash << 5 ) - hash + name . charCodeAt ( i ) ) | 0
}
return ( ( parentid + hash ) >>> 0 ) % FS . nameTable . length
} ,
hashAddNode : function ( node ) {
var hash = FS . hashName ( node . parent . id , node . name )
node . name _next = FS . nameTable [ hash ]
FS . nameTable [ hash ] = node
} ,
hashRemoveNode : function ( node ) {
var hash = FS . hashName ( node . parent . id , node . name )
if ( FS . nameTable [ hash ] === node ) {
FS . nameTable [ hash ] = node . name _next
} else {
var current = FS . nameTable [ hash ]
while ( current ) {
if ( current . name _next === node ) {
current . name _next = node . name _next
break
}
current = current . name _next
}
}
} ,
lookupNode : function ( parent , name ) {
var err = FS . mayLookup ( parent )
if ( err ) {
throw new FS . ErrnoError ( err , parent )
}
var hash = FS . hashName ( parent . id , name )
for ( var node = FS . nameTable [ hash ] ; node ; node = node . name _next ) {
var nodeName = node . name
if ( node . parent . id === parent . id && nodeName === name ) {
return node
}
}
return FS . lookup ( parent , name )
} ,
createNode : function ( parent , name , mode , rdev ) {
if ( ! FS . FSNode ) {
FS . FSNode = function ( parent , name , mode , rdev ) {
if ( ! parent ) {
parent = this
}
this . parent = parent
this . mount = parent . mount
this . mounted = null
this . id = FS . nextInode ++
this . name = name
this . mode = mode
this . node _ops = { }
this . stream _ops = { }
this . rdev = rdev
}
FS . FSNode . prototype = { }
var readMode = 292 | 73
var writeMode = 146
Object . defineProperties ( FS . FSNode . prototype , {
read : {
get : function ( ) {
return ( this . mode & readMode ) === readMode
} ,
set : function ( val ) {
val ? ( this . mode |= readMode ) : ( this . mode &= ~ readMode )
} ,
} ,
write : {
get : function ( ) {
return ( this . mode & writeMode ) === writeMode
} ,
set : function ( val ) {
val ? ( this . mode |= writeMode ) : ( this . mode &= ~ writeMode )
} ,
} ,
isFolder : {
get : function ( ) {
return FS . isDir ( this . mode )
} ,
} ,
isDevice : {
get : function ( ) {
return FS . isChrdev ( this . mode )
} ,
} ,
} )
}
var node = new FS . FSNode ( parent , name , mode , rdev )
FS . hashAddNode ( node )
return node
} ,
destroyNode : function ( node ) {
FS . hashRemoveNode ( node )
} ,
isRoot : function ( node ) {
return node === node . parent
} ,
isMountpoint : function ( node ) {
return ! ! node . mounted
} ,
isFile : function ( mode ) {
return ( mode & 61440 ) === 32768
} ,
isDir : function ( mode ) {
return ( mode & 61440 ) === 16384
} ,
isLink : function ( mode ) {
return ( mode & 61440 ) === 40960
} ,
isChrdev : function ( mode ) {
return ( mode & 61440 ) === 8192
} ,
isBlkdev : function ( mode ) {
return ( mode & 61440 ) === 24576
} ,
isFIFO : function ( mode ) {
return ( mode & 61440 ) === 4096
} ,
isSocket : function ( mode ) {
return ( mode & 49152 ) === 49152
} ,
flagModes : {
r : 0 ,
rs : 1052672 ,
'r+' : 2 ,
w : 577 ,
wx : 705 ,
xw : 705 ,
'w+' : 578 ,
'wx+' : 706 ,
'xw+' : 706 ,
a : 1089 ,
ax : 1217 ,
xa : 1217 ,
'a+' : 1090 ,
'ax+' : 1218 ,
'xa+' : 1218 ,
} ,
modeStringToFlags : function ( str ) {
var flags = FS . flagModes [ str ]
if ( typeof flags === 'undefined' ) {
throw new Error ( 'Unknown file open mode: ' + str )
}
return flags
} ,
flagsToPermissionString : function ( flag ) {
var perms = [ 'r' , 'w' , 'rw' ] [ flag & 3 ]
if ( flag & 512 ) {
perms += 'w'
}
return perms
} ,
nodePermissions : function ( node , perms ) {
if ( FS . ignorePermissions ) {
return 0
}
if ( perms . indexOf ( 'r' ) !== - 1 && ! ( node . mode & 292 ) ) {
return 13
} else if ( perms . indexOf ( 'w' ) !== - 1 && ! ( node . mode & 146 ) ) {
return 13
} else if ( perms . indexOf ( 'x' ) !== - 1 && ! ( node . mode & 73 ) ) {
return 13
}
return 0
} ,
mayLookup : function ( dir ) {
var err = FS . nodePermissions ( dir , 'x' )
if ( err ) return err
if ( ! dir . node _ops . lookup ) return 13
return 0
} ,
mayCreate : function ( dir , name ) {
try {
var node = FS . lookupNode ( dir , name )
return 17
} catch ( e ) { }
return FS . nodePermissions ( dir , 'wx' )
} ,
mayDelete : function ( dir , name , isdir ) {
var node
try {
node = FS . lookupNode ( dir , name )
} catch ( e ) {
return e . errno
}
var err = FS . nodePermissions ( dir , 'wx' )
if ( err ) {
return err
}
if ( isdir ) {
if ( ! FS . isDir ( node . mode ) ) {
return 20
}
if ( FS . isRoot ( node ) || FS . getPath ( node ) === FS . cwd ( ) ) {
return 16
}
} else {
if ( FS . isDir ( node . mode ) ) {
return 21
}
}
return 0
} ,
mayOpen : function ( node , flags ) {
if ( ! node ) {
return 2
}
if ( FS . isLink ( node . mode ) ) {
return 40
} else if ( FS . isDir ( node . mode ) ) {
if ( FS . flagsToPermissionString ( flags ) !== 'r' || flags & 512 ) {
return 21
}
}
return FS . nodePermissions ( node , FS . flagsToPermissionString ( flags ) )
} ,
MAX _OPEN _FDS : 4096 ,
nextfd : function ( fd _start , fd _end ) {
fd _start = fd _start || 0
fd _end = fd _end || FS . MAX _OPEN _FDS
for ( var fd = fd _start ; fd <= fd _end ; fd ++ ) {
if ( ! FS . streams [ fd ] ) {
return fd
}
}
throw new FS . ErrnoError ( 24 )
} ,
getStream : function ( fd ) {
return FS . streams [ fd ]
} ,
createStream : function ( stream , fd _start , fd _end ) {
if ( ! FS . FSStream ) {
FS . FSStream = function ( ) { }
FS . FSStream . prototype = { }
Object . defineProperties ( FS . FSStream . prototype , {
object : {
get : function ( ) {
return this . node
} ,
set : function ( val ) {
this . node = val
} ,
} ,
isRead : {
get : function ( ) {
return ( this . flags & 2097155 ) !== 1
} ,
} ,
isWrite : {
get : function ( ) {
return ( this . flags & 2097155 ) !== 0
} ,
} ,
isAppend : {
get : function ( ) {
return this . flags & 1024
} ,
} ,
} )
}
var newStream = new FS . FSStream ( )
for ( var p in stream ) {
newStream [ p ] = stream [ p ]
}
stream = newStream
var fd = FS . nextfd ( fd _start , fd _end )
stream . fd = fd
FS . streams [ fd ] = stream
return stream
} ,
closeStream : function ( fd ) {
FS . streams [ fd ] = null
} ,
chrdev _stream _ops : {
open : function ( stream ) {
var device = FS . getDevice ( stream . node . rdev )
stream . stream _ops = device . stream _ops
if ( stream . stream _ops . open ) {
stream . stream _ops . open ( stream )
}
} ,
llseek : function ( ) {
throw new FS . ErrnoError ( 29 )
} ,
} ,
major : function ( dev ) {
return dev >> 8
} ,
minor : function ( dev ) {
return dev & 255
} ,
makedev : function ( ma , mi ) {
return ( ma << 8 ) | mi
} ,
registerDevice : function ( dev , ops ) {
FS . devices [ dev ] = { stream _ops : ops }
} ,
getDevice : function ( dev ) {
return FS . devices [ dev ]
} ,
getMounts : function ( mount ) {
var mounts = [ ]
var check = [ mount ]
while ( check . length ) {
var m = check . pop ( )
mounts . push ( m )
check . push . apply ( check , m . mounts )
}
return mounts
} ,
syncfs : function ( populate , callback ) {
if ( typeof populate === 'function' ) {
callback = populate
populate = false
}
FS . syncFSRequests ++
if ( FS . syncFSRequests > 1 ) {
console . log (
'warning: ' +
FS . syncFSRequests +
' FS.syncfs operations in flight at once, probably just doing extra work'
)
}
var mounts = FS . getMounts ( FS . root . mount )
var completed = 0
function doCallback ( err ) {
FS . syncFSRequests --
return callback ( err )
}
function done ( err ) {
if ( err ) {
if ( ! done . errored ) {
done . errored = true
return doCallback ( err )
}
return
}
if ( ++ completed >= mounts . length ) {
doCallback ( null )
}
}
mounts . forEach ( function ( mount ) {
if ( ! mount . type . syncfs ) {
return done ( null )
}
mount . type . syncfs ( mount , populate , done )
} )
} ,
mount : function ( type , opts , mountpoint ) {
var root = mountpoint === '/'
var pseudo = ! mountpoint
var node
if ( root && FS . root ) {
throw new FS . ErrnoError ( 16 )
} else if ( ! root && ! pseudo ) {
var lookup = FS . lookupPath ( mountpoint , { follow _mount : false } )
mountpoint = lookup . path
node = lookup . node
if ( FS . isMountpoint ( node ) ) {
throw new FS . ErrnoError ( 16 )
}
if ( ! FS . isDir ( node . mode ) ) {
throw new FS . ErrnoError ( 20 )
}
}
var mount = { type : type , opts : opts , mountpoint : mountpoint , mounts : [ ] }
var mountRoot = type . mount ( mount )
mountRoot . mount = mount
mount . root = mountRoot
if ( root ) {
FS . root = mountRoot
} else if ( node ) {
node . mounted = mount
if ( node . mount ) {
node . mount . mounts . push ( mount )
}
}
return mountRoot
} ,
unmount : function ( mountpoint ) {
var lookup = FS . lookupPath ( mountpoint , { follow _mount : false } )
if ( ! FS . isMountpoint ( lookup . node ) ) {
throw new FS . ErrnoError ( 22 )
}
var node = lookup . node
var mount = node . mounted
var mounts = FS . getMounts ( mount )
Object . keys ( FS . nameTable ) . forEach ( function ( hash ) {
var current = FS . nameTable [ hash ]
while ( current ) {
var next = current . name _next
if ( mounts . indexOf ( current . mount ) !== - 1 ) {
FS . destroyNode ( current )
}
current = next
}
} )
node . mounted = null
var idx = node . mount . mounts . indexOf ( mount )
node . mount . mounts . splice ( idx , 1 )
} ,
lookup : function ( parent , name ) {
return parent . node _ops . lookup ( parent , name )
} ,
mknod : function ( path , mode , dev ) {
var lookup = FS . lookupPath ( path , { parent : true } )
var parent = lookup . node
var name = PATH . basename ( path )
if ( ! name || name === '.' || name === '..' ) {
throw new FS . ErrnoError ( 22 )
}
var err = FS . mayCreate ( parent , name )
if ( err ) {
throw new FS . ErrnoError ( err )
}
if ( ! parent . node _ops . mknod ) {
throw new FS . ErrnoError ( 1 )
}
return parent . node _ops . mknod ( parent , name , mode , dev )
} ,
create : function ( path , mode ) {
mode = mode !== undefined ? mode : 438
mode &= 4095
mode |= 32768
return FS . mknod ( path , mode , 0 )
} ,
mkdir : function ( path , mode ) {
mode = mode !== undefined ? mode : 511
mode &= 511 | 512
mode |= 16384
return FS . mknod ( path , mode , 0 )
} ,
mkdirTree : function ( path , mode ) {
var dirs = path . split ( '/' )
var d = ''
for ( var i = 0 ; i < dirs . length ; ++ i ) {
if ( ! dirs [ i ] ) continue
d += '/' + dirs [ i ]
try {
FS . mkdir ( d , mode )
} catch ( e ) {
if ( e . errno != 17 ) throw e
}
}
} ,
mkdev : function ( path , mode , dev ) {
if ( typeof dev === 'undefined' ) {
dev = mode
mode = 438
}
mode |= 8192
return FS . mknod ( path , mode , dev )
} ,
symlink : function ( oldpath , newpath ) {
if ( ! PATH _FS . resolve ( oldpath ) ) {
throw new FS . ErrnoError ( 2 )
}
var lookup = FS . lookupPath ( newpath , { parent : true } )
var parent = lookup . node
if ( ! parent ) {
throw new FS . ErrnoError ( 2 )
}
var newname = PATH . basename ( newpath )
var err = FS . mayCreate ( parent , newname )
if ( err ) {
throw new FS . ErrnoError ( err )
}
if ( ! parent . node _ops . symlink ) {
throw new FS . ErrnoError ( 1 )
}
return parent . node _ops . symlink ( parent , newname , oldpath )
} ,
rename : function ( old _path , new _path ) {
var old _dirname = PATH . dirname ( old _path )
var new _dirname = PATH . dirname ( new _path )
var old _name = PATH . basename ( old _path )
var new _name = PATH . basename ( new _path )
var lookup , old _dir , new _dir
try {
lookup = FS . lookupPath ( old _path , { parent : true } )
old _dir = lookup . node
lookup = FS . lookupPath ( new _path , { parent : true } )
new _dir = lookup . node
} catch ( e ) {
throw new FS . ErrnoError ( 16 )
}
if ( ! old _dir || ! new _dir ) throw new FS . ErrnoError ( 2 )
if ( old _dir . mount !== new _dir . mount ) {
throw new FS . ErrnoError ( 18 )
}
var old _node = FS . lookupNode ( old _dir , old _name )
var relative = PATH _FS . relative ( old _path , new _dirname )
if ( relative . charAt ( 0 ) !== '.' ) {
throw new FS . ErrnoError ( 22 )
}
relative = PATH _FS . relative ( new _path , old _dirname )
if ( relative . charAt ( 0 ) !== '.' ) {
throw new FS . ErrnoError ( 39 )
}
var new _node
try {
new _node = FS . lookupNode ( new _dir , new _name )
} catch ( e ) { }
if ( old _node === new _node ) {
return
}
var isdir = FS . isDir ( old _node . mode )
var err = FS . mayDelete ( old _dir , old _name , isdir )
if ( err ) {
throw new FS . ErrnoError ( err )
}
err = new _node
? FS . mayDelete ( new _dir , new _name , isdir )
: FS . mayCreate ( new _dir , new _name )
if ( err ) {
throw new FS . ErrnoError ( err )
}
if ( ! old _dir . node _ops . rename ) {
throw new FS . ErrnoError ( 1 )
}
if ( FS . isMountpoint ( old _node ) || ( new _node && FS . isMountpoint ( new _node ) ) ) {
throw new FS . ErrnoError ( 16 )
}
if ( new _dir !== old _dir ) {
err = FS . nodePermissions ( old _dir , 'w' )
if ( err ) {
throw new FS . ErrnoError ( err )
}
}
try {
if ( FS . trackingDelegate [ 'willMovePath' ] ) {
FS . trackingDelegate [ 'willMovePath' ] ( old _path , new _path )
}
} catch ( e ) {
console . log (
"FS.trackingDelegate['willMovePath']('" +
old _path +
"', '" +
new _path +
"') threw an exception: " +
e . message
)
}
FS . hashRemoveNode ( old _node )
try {
old _dir . node _ops . rename ( old _node , new _dir , new _name )
} catch ( e ) {
throw e
} finally {
FS . hashAddNode ( old _node )
}
try {
if ( FS . trackingDelegate [ 'onMovePath' ] )
FS . trackingDelegate [ 'onMovePath' ] ( old _path , new _path )
} catch ( e ) {
console . log (
"FS.trackingDelegate['onMovePath']('" +
old _path +
"', '" +
new _path +
"') threw an exception: " +
e . message
)
}
} ,
rmdir : function ( path ) {
var lookup = FS . lookupPath ( path , { parent : true } )
var parent = lookup . node
var name = PATH . basename ( path )
var node = FS . lookupNode ( parent , name )
var err = FS . mayDelete ( parent , name , true )
if ( err ) {
throw new FS . ErrnoError ( err )
}
if ( ! parent . node _ops . rmdir ) {
throw new FS . ErrnoError ( 1 )
}
if ( FS . isMountpoint ( node ) ) {
throw new FS . ErrnoError ( 16 )
}
try {
if ( FS . trackingDelegate [ 'willDeletePath' ] ) {
FS . trackingDelegate [ 'willDeletePath' ] ( path )
}
} catch ( e ) {
console . log (
"FS.trackingDelegate['willDeletePath']('" +
path +
"') threw an exception: " +
e . message
)
}
parent . node _ops . rmdir ( parent , name )
FS . destroyNode ( node )
try {
if ( FS . trackingDelegate [ 'onDeletePath' ] )
FS . trackingDelegate [ 'onDeletePath' ] ( path )
} catch ( e ) {
console . log (
"FS.trackingDelegate['onDeletePath']('" +
path +
"') threw an exception: " +
e . message
)
}
} ,
readdir : function ( path ) {
var lookup = FS . lookupPath ( path , { follow : true } )
var node = lookup . node
if ( ! node . node _ops . readdir ) {
throw new FS . ErrnoError ( 20 )
}
return node . node _ops . readdir ( node )
} ,
unlink : function ( path ) {
var lookup = FS . lookupPath ( path , { parent : true } )
var parent = lookup . node
var name = PATH . basename ( path )
var node = FS . lookupNode ( parent , name )
var err = FS . mayDelete ( parent , name , false )
if ( err ) {
throw new FS . ErrnoError ( err )
}
if ( ! parent . node _ops . unlink ) {
throw new FS . ErrnoError ( 1 )
}
if ( FS . isMountpoint ( node ) ) {
throw new FS . ErrnoError ( 16 )
}
try {
if ( FS . trackingDelegate [ 'willDeletePath' ] ) {
FS . trackingDelegate [ 'willDeletePath' ] ( path )
}
} catch ( e ) {
console . log (
"FS.trackingDelegate['willDeletePath']('" +
path +
"') threw an exception: " +
e . message
)
}
parent . node _ops . unlink ( parent , name )
FS . destroyNode ( node )
try {
if ( FS . trackingDelegate [ 'onDeletePath' ] )
FS . trackingDelegate [ 'onDeletePath' ] ( path )
} catch ( e ) {
console . log (
"FS.trackingDelegate['onDeletePath']('" +
path +
"') threw an exception: " +
e . message
)
}
} ,
readlink : function ( path ) {
var lookup = FS . lookupPath ( path )
var link = lookup . node
if ( ! link ) {
throw new FS . ErrnoError ( 2 )
}
if ( ! link . node _ops . readlink ) {
throw new FS . ErrnoError ( 22 )
}
return PATH _FS . resolve ( FS . getPath ( link . parent ) , link . node _ops . readlink ( link ) )
} ,
stat : function ( path , dontFollow ) {
var lookup = FS . lookupPath ( path , { follow : ! dontFollow } )
var node = lookup . node
if ( ! node ) {
throw new FS . ErrnoError ( 2 )
}
if ( ! node . node _ops . getattr ) {
throw new FS . ErrnoError ( 1 )
}
return node . node _ops . getattr ( node )
} ,
lstat : function ( path ) {
return FS . stat ( path , true )
} ,
chmod : function ( path , mode , dontFollow ) {
var node
if ( typeof path === 'string' ) {
var lookup = FS . lookupPath ( path , { follow : ! dontFollow } )
node = lookup . node
} else {
node = path
}
if ( ! node . node _ops . setattr ) {
throw new FS . ErrnoError ( 1 )
}
node . node _ops . setattr ( node , {
mode : ( mode & 4095 ) | ( node . mode & ~ 4095 ) ,
timestamp : Date . now ( ) ,
} )
} ,
lchmod : function ( path , mode ) {
FS . chmod ( path , mode , true )
} ,
fchmod : function ( fd , mode ) {
var stream = FS . getStream ( fd )
if ( ! stream ) {
throw new FS . ErrnoError ( 9 )
}
FS . chmod ( stream . node , mode )
} ,
chown : function ( path , uid , gid , dontFollow ) {
var node
if ( typeof path === 'string' ) {
var lookup = FS . lookupPath ( path , { follow : ! dontFollow } )
node = lookup . node
} else {
node = path
}
if ( ! node . node _ops . setattr ) {
throw new FS . ErrnoError ( 1 )
}
node . node _ops . setattr ( node , { timestamp : Date . now ( ) } )
} ,
lchown : function ( path , uid , gid ) {
FS . chown ( path , uid , gid , true )
} ,
fchown : function ( fd , uid , gid ) {
var stream = FS . getStream ( fd )
if ( ! stream ) {
throw new FS . ErrnoError ( 9 )
}
FS . chown ( stream . node , uid , gid )
} ,
truncate : function ( path , len ) {
if ( len < 0 ) {
throw new FS . ErrnoError ( 22 )
}
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 ( 1 )
}
if ( FS . isDir ( node . mode ) ) {
throw new FS . ErrnoError ( 21 )
}
if ( ! FS . isFile ( node . mode ) ) {
throw new FS . ErrnoError ( 22 )
}
var err = FS . nodePermissions ( node , 'w' )
if ( err ) {
throw new FS . ErrnoError ( err )
}
node . node _ops . setattr ( node , { size : len , timestamp : Date . now ( ) } )
} ,
ftruncate : function ( fd , len ) {
var stream = FS . getStream ( fd )
if ( ! stream ) {
throw new FS . ErrnoError ( 9 )
}
if ( ( stream . flags & 2097155 ) === 0 ) {
throw new FS . ErrnoError ( 22 )
}
FS . truncate ( stream . node , len )
} ,
utime : function ( path , atime , mtime ) {
var lookup = FS . lookupPath ( path , { follow : true } )
var node = lookup . node
node . node _ops . setattr ( node , { timestamp : Math . max ( atime , mtime ) } )
} ,
open : function ( path , flags , mode , fd _start , fd _end ) {
if ( path === '' ) {
throw new FS . ErrnoError ( 2 )
}
flags = typeof flags === 'string' ? FS . modeStringToFlags ( flags ) : flags
mode = typeof mode === 'undefined' ? 438 : mode
if ( flags & 64 ) {
mode = ( mode & 4095 ) | 32768
} else {
mode = 0
}
var node
if ( typeof path === 'object' ) {
node = path
} else {
path = PATH . normalize ( path )
try {
var lookup = FS . lookupPath ( path , { follow : ! ( flags & 131072 ) } )
node = lookup . node
} catch ( e ) { }
}
var created = false
if ( flags & 64 ) {
if ( node ) {
if ( flags & 128 ) {
throw new FS . ErrnoError ( 17 )
}
} else {
node = FS . mknod ( path , mode , 0 )
created = true
}
}
if ( ! node ) {
throw new FS . ErrnoError ( 2 )
}
if ( FS . isChrdev ( node . mode ) ) {
flags &= ~ 512
}
if ( flags & 65536 && ! FS . isDir ( node . mode ) ) {
throw new FS . ErrnoError ( 20 )
}
if ( ! created ) {
var err = FS . mayOpen ( node , flags )
if ( err ) {
throw new FS . ErrnoError ( err )
}
}
if ( flags & 512 ) {
FS . truncate ( node , 0 )
}
flags &= ~ ( 128 | 512 )
var stream = FS . createStream (
{
node : node ,
path : FS . getPath ( node ) ,
flags : flags ,
seekable : true ,
position : 0 ,
stream _ops : node . stream _ops ,
ungotten : [ ] ,
error : false ,
} ,
fd _start ,
fd _end
)
if ( stream . stream _ops . open ) {
stream . stream _ops . open ( stream )
}
if ( Module [ 'logReadFiles' ] && ! ( flags & 1 ) ) {
if ( ! FS . readFiles ) FS . readFiles = { }
if ( ! ( path in FS . readFiles ) ) {
FS . readFiles [ path ] = 1
console . log ( 'FS.trackingDelegate error on read file: ' + path )
}
}
try {
if ( FS . trackingDelegate [ 'onOpenFile' ] ) {
var trackingFlags = 0
if ( ( flags & 2097155 ) !== 1 ) {
trackingFlags |= FS . tracking . openFlags . READ
}
if ( ( flags & 2097155 ) !== 0 ) {
trackingFlags |= FS . tracking . openFlags . WRITE
}
FS . trackingDelegate [ 'onOpenFile' ] ( path , trackingFlags )
}
} catch ( e ) {
console . log (
"FS.trackingDelegate['onOpenFile']('" +
path +
"', flags) threw an exception: " +
e . message
)
}
return stream
} ,
close : function ( stream ) {
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 9 )
}
if ( stream . getdents ) stream . getdents = null
try {
if ( stream . stream _ops . close ) {
stream . stream _ops . close ( stream )
}
} catch ( e ) {
throw e
} finally {
FS . closeStream ( stream . fd )
}
stream . fd = null
} ,
isClosed : function ( stream ) {
return stream . fd === null
} ,
llseek : function ( stream , offset , whence ) {
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 9 )
}
if ( ! stream . seekable || ! stream . stream _ops . llseek ) {
throw new FS . ErrnoError ( 29 )
}
if ( whence != 0 && whence != 1 && whence != 2 ) {
throw new FS . ErrnoError ( 22 )
}
stream . position = stream . stream _ops . llseek ( stream , offset , whence )
stream . ungotten = [ ]
return stream . position
} ,
read : function ( stream , buffer , offset , length , position ) {
if ( length < 0 || position < 0 ) {
throw new FS . ErrnoError ( 22 )
}
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 9 )
}
if ( ( stream . flags & 2097155 ) === 1 ) {
throw new FS . ErrnoError ( 9 )
}
if ( FS . isDir ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 21 )
}
if ( ! stream . stream _ops . read ) {
throw new FS . ErrnoError ( 22 )
}
var seeking = typeof position !== 'undefined'
if ( ! seeking ) {
position = stream . position
} else if ( ! stream . seekable ) {
throw new FS . ErrnoError ( 29 )
}
var bytesRead = stream . stream _ops . read ( stream , buffer , offset , length , position )
if ( ! seeking ) stream . position += bytesRead
return bytesRead
} ,
write : function ( stream , buffer , offset , length , position , canOwn ) {
if ( length < 0 || position < 0 ) {
throw new FS . ErrnoError ( 22 )
}
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 9 )
}
if ( ( stream . flags & 2097155 ) === 0 ) {
throw new FS . ErrnoError ( 9 )
}
if ( FS . isDir ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 21 )
}
if ( ! stream . stream _ops . write ) {
throw new FS . ErrnoError ( 22 )
}
if ( stream . flags & 1024 ) {
FS . llseek ( stream , 0 , 2 )
}
var seeking = typeof position !== 'undefined'
if ( ! seeking ) {
position = stream . position
} else if ( ! stream . seekable ) {
throw new FS . ErrnoError ( 29 )
}
var bytesWritten = stream . stream _ops . write (
stream ,
buffer ,
offset ,
length ,
position ,
canOwn
)
if ( ! seeking ) stream . position += bytesWritten
try {
if ( stream . path && FS . trackingDelegate [ 'onWriteToFile' ] )
FS . trackingDelegate [ 'onWriteToFile' ] ( stream . path )
} catch ( e ) {
console . log (
"FS.trackingDelegate['onWriteToFile']('" +
stream . path +
"') threw an exception: " +
e . message
)
}
return bytesWritten
} ,
allocate : function ( stream , offset , length ) {
if ( FS . isClosed ( stream ) ) {
throw new FS . ErrnoError ( 9 )
}
if ( offset < 0 || length <= 0 ) {
throw new FS . ErrnoError ( 22 )
}
if ( ( stream . flags & 2097155 ) === 0 ) {
throw new FS . ErrnoError ( 9 )
}
if ( ! FS . isFile ( stream . node . mode ) && ! FS . isDir ( stream . node . mode ) ) {
throw new FS . ErrnoError ( 19 )
}
if ( ! stream . stream _ops . allocate ) {
throw new FS . ErrnoError ( 95 )
}
stream . stream _ops . allocate ( stream , offset , length )
} ,
mmap : function ( stream , buffer , offset , length , position , prot , flags ) {
if ( ( stream . flags & 2097155 ) === 1 ) {
throw new FS . ErrnoError ( 13 )
}
if ( ! stream . stream _ops . mmap ) {
throw new FS . ErrnoError ( 19 )
}
return stream . stream _ops . mmap (
stream ,
buffer ,
offset ,
length ,
position ,
prot ,
flags
)
} ,
msync : function ( stream , buffer , offset , length , mmapFlags ) {
if ( ! stream || ! stream . stream _ops . msync ) {
return 0
}
return stream . stream _ops . msync ( stream , buffer , offset , length , mmapFlags )
} ,
munmap : function ( stream ) {
return 0
} ,
ioctl : function ( stream , cmd , arg ) {
if ( ! stream . stream _ops . ioctl ) {
throw new FS . ErrnoError ( 25 )
}
return stream . stream _ops . ioctl ( stream , cmd , arg )
} ,
readFile : function ( path , opts ) {
opts = opts || { }
opts . flags = opts . flags || 'r'
opts . encoding = opts . encoding || 'binary'
if ( opts . encoding !== 'utf8' && opts . encoding !== 'binary' ) {
throw new Error ( 'Invalid encoding type "' + opts . encoding + '"' )
}
var ret
var stream = FS . open ( path , opts . flags )
var stat = FS . stat ( path )
var length = stat . size
var buf = new Uint8Array ( length )
FS . read ( stream , buf , 0 , length , 0 )
if ( opts . encoding === 'utf8' ) {
ret = UTF8ArrayToString ( buf , 0 )
} else if ( opts . encoding === 'binary' ) {
ret = buf
}
FS . close ( stream )
return ret
} ,
writeFile : function ( path , data , opts ) {
opts = opts || { }
opts . flags = opts . flags || 'w'
var stream = FS . open ( path , opts . flags , opts . mode )
if ( typeof data === 'string' ) {
var buf = new Uint8Array ( lengthBytesUTF8 ( data ) + 1 )
var actualNumBytes = stringToUTF8Array ( data , buf , 0 , buf . length )
FS . write ( stream , buf , 0 , actualNumBytes , undefined , opts . canOwn )
} else if ( ArrayBuffer . isView ( data ) ) {
FS . write ( stream , data , 0 , data . byteLength , undefined , opts . canOwn )
} else {
throw new Error ( 'Unsupported data type' )
}
FS . close ( stream )
} ,
cwd : function ( ) {
return FS . currentPath
} ,
chdir : function ( path ) {
var lookup = FS . lookupPath ( path , { follow : true } )
if ( lookup . node === null ) {
throw new FS . ErrnoError ( 2 )
}
if ( ! FS . isDir ( lookup . node . mode ) ) {
throw new FS . ErrnoError ( 20 )
}
var err = FS . nodePermissions ( lookup . node , 'x' )
if ( err ) {
throw new FS . ErrnoError ( err )
}
FS . currentPath = lookup . path
} ,
createDefaultDirectories : function ( ) {
FS . mkdir ( '/tmp' )
FS . mkdir ( '/home' )
FS . mkdir ( '/home/web_user' )
} ,
createDefaultDevices : function ( ) {
FS . mkdir ( '/dev' )
FS . registerDevice ( FS . makedev ( 1 , 3 ) , {
read : function ( ) {
return 0
} ,
write : function ( stream , buffer , offset , length , pos ) {
return length
} ,
} )
FS . mkdev ( '/dev/null' , FS . makedev ( 1 , 3 ) )
TTY . register ( FS . makedev ( 5 , 0 ) , TTY . default _tty _ops )
TTY . register ( FS . makedev ( 6 , 0 ) , TTY . default _tty1 _ops )
FS . mkdev ( '/dev/tty' , FS . makedev ( 5 , 0 ) )
FS . mkdev ( '/dev/tty1' , FS . makedev ( 6 , 0 ) )
var random _device
if (
typeof crypto === 'object' &&
typeof crypto [ 'getRandomValues' ] === 'function'
) {
var randomBuffer = new Uint8Array ( 1 )
random _device = function ( ) {
crypto . getRandomValues ( randomBuffer )
return randomBuffer [ 0 ]
}
} else if ( ENVIRONMENT _IS _NODE ) {
try {
var crypto _module = require ( 'crypto' )
random _device = function ( ) {
return crypto _module [ 'randomBytes' ] ( 1 ) [ 0 ]
}
} catch ( e ) { }
} else {
}
if ( ! random _device ) {
random _device = function ( ) {
abort ( 'random_device' )
}
}
FS . createDevice ( '/dev' , 'random' , random _device )
FS . createDevice ( '/dev' , 'urandom' , random _device )
FS . mkdir ( '/dev/shm' )
FS . mkdir ( '/dev/shm/tmp' )
} ,
createSpecialDirectories : function ( ) {
FS . mkdir ( '/proc' )
FS . mkdir ( '/proc/self' )
FS . mkdir ( '/proc/self/fd' )
FS . mount (
{
mount : function ( ) {
var node = FS . createNode ( '/proc/self' , 'fd' , 16384 | 511 , 73 )
node . node _ops = {
lookup : function ( parent , name ) {
var fd = + name
var stream = FS . getStream ( fd )
if ( ! stream ) throw new FS . ErrnoError ( 9 )
var ret = {
parent : null ,
mount : { mountpoint : 'fake' } ,
node _ops : {
readlink : function ( ) {
return stream . path
} ,
} ,
}
ret . parent = ret
return ret
} ,
}
return node
} ,
} ,
{ } ,
'/proc/self/fd'
)
} ,
createStandardStreams : function ( ) {
if ( Module [ 'stdin' ] ) {
FS . createDevice ( '/dev' , 'stdin' , Module [ 'stdin' ] )
} else {
FS . symlink ( '/dev/tty' , '/dev/stdin' )
}
if ( Module [ 'stdout' ] ) {
FS . createDevice ( '/dev' , 'stdout' , null , Module [ 'stdout' ] )
} else {
FS . symlink ( '/dev/tty' , '/dev/stdout' )
}
if ( Module [ 'stderr' ] ) {
FS . createDevice ( '/dev' , 'stderr' , null , Module [ 'stderr' ] )
} else {
FS . symlink ( '/dev/tty1' , '/dev/stderr' )
}
var stdin = FS . open ( '/dev/stdin' , 'r' )
var stdout = FS . open ( '/dev/stdout' , 'w' )
var stderr = FS . open ( '/dev/stderr' , 'w' )
} ,
ensureErrnoError : function ( ) {
if ( FS . ErrnoError ) return
FS . ErrnoError = function ErrnoError ( errno , node ) {
this . node = node
this . setErrno = function ( errno ) {
this . errno = errno
}
this . setErrno ( errno )
this . message = 'FS error'
if ( this . stack )
Object . defineProperty ( this , 'stack' , {
value : new Error ( ) . stack ,
writable : true ,
} )
}
FS . ErrnoError . prototype = new Error ( )
FS . ErrnoError . prototype . constructor = FS . ErrnoError
; [ 2 ] . forEach ( function ( code ) {
FS . genericErrors [ code ] = new FS . ErrnoError ( code )
FS . genericErrors [ code ] . stack = '<generic error, no stack>'
} )
} ,
staticInit : function ( ) {
FS . ensureErrnoError ( )
FS . nameTable = new Array ( 4096 )
FS . mount ( MEMFS , { } , '/' )
FS . createDefaultDirectories ( )
FS . createDefaultDevices ( )
FS . createSpecialDirectories ( )
FS . filesystems = {
MEMFS : MEMFS ,
IDBFS : IDBFS ,
NODEFS : NODEFS ,
WORKERFS : WORKERFS ,
}
} ,
init : function ( input , output , error ) {
FS . init . initialized = true
FS . ensureErrnoError ( )
Module [ 'stdin' ] = input || Module [ 'stdin' ]
Module [ 'stdout' ] = output || Module [ 'stdout' ]
Module [ 'stderr' ] = error || Module [ 'stderr' ]
FS . createStandardStreams ( )
} ,
quit : function ( ) {
FS . init . initialized = false
var fflush = Module [ '_fflush' ]
if ( fflush ) fflush ( 0 )
for ( var i = 0 ; i < FS . streams . length ; i ++ ) {
var stream = FS . streams [ i ]
if ( ! stream ) {
continue
}
FS . close ( stream )
}
} ,
getMode : function ( canRead , canWrite ) {
var mode = 0
if ( canRead ) mode |= 292 | 73
if ( canWrite ) mode |= 146
return mode
} ,
joinPath : function ( parts , forceRelative ) {
var path = PATH . join . apply ( null , parts )
if ( forceRelative && path [ 0 ] == '/' ) path = path . substr ( 1 )
return path
} ,
absolutePath : function ( relative , base ) {
return PATH _FS . resolve ( base , relative )
} ,
standardizePath : function ( path ) {
return PATH . normalize ( path )
} ,
findObject : function ( path , dontResolveLastLink ) {
var ret = FS . analyzePath ( path , dontResolveLastLink )
if ( ret . exists ) {
return ret . object
} else {
_ _ _setErrNo ( ret . error )
return null
}
} ,
analyzePath : function ( path , dontResolveLastLink ) {
try {
var lookup = FS . lookupPath ( path , { follow : ! dontResolveLastLink } )
path = lookup . path
} catch ( e ) { }
var ret = {
isRoot : false ,
exists : false ,
error : 0 ,
name : null ,
path : null ,
object : null ,
parentExists : false ,
parentPath : null ,
parentObject : null ,
}
try {
var lookup = FS . lookupPath ( path , { parent : true } )
ret . parentExists = true
ret . parentPath = lookup . path
ret . parentObject = lookup . node
ret . name = PATH . basename ( path )
lookup = FS . lookupPath ( path , { follow : ! dontResolveLastLink } )
ret . exists = true
ret . path = lookup . path
ret . object = lookup . node
ret . name = lookup . node . name
ret . isRoot = lookup . path === '/'
} catch ( e ) {
ret . error = e . errno
}
return ret
} ,
createFolder : function ( parent , name , canRead , canWrite ) {
var path = PATH . join2 (
typeof parent === 'string' ? parent : FS . getPath ( parent ) ,
name
)
var mode = FS . getMode ( canRead , canWrite )
return FS . mkdir ( path , mode )
} ,
createPath : function ( parent , path , canRead , canWrite ) {
parent = typeof parent === 'string' ? parent : FS . getPath ( parent )
var parts = path . split ( '/' ) . reverse ( )
while ( parts . length ) {
var part = parts . pop ( )
if ( ! part ) continue
var current = PATH . join2 ( parent , part )
try {
FS . mkdir ( current )
} catch ( e ) { }
parent = current
}
return current
} ,
createFile : function ( parent , name , properties , canRead , canWrite ) {
var path = PATH . join2 (
typeof parent === 'string' ? parent : FS . getPath ( parent ) ,
name
)
var mode = FS . getMode ( canRead , canWrite )
return FS . create ( path , mode )
} ,
createDataFile : function ( parent , name , data , canRead , canWrite , canOwn ) {
var path = name
? PATH . join2 ( typeof parent === 'string' ? parent : FS . getPath ( parent ) , name )
: parent
var mode = FS . getMode ( canRead , canWrite )
var node = FS . create ( path , mode )
if ( data ) {
if ( typeof data === 'string' ) {
var arr = new Array ( data . length )
for ( var i = 0 , len = data . length ; i < len ; ++ i ) arr [ i ] = data . charCodeAt ( i )
data = arr
}
FS . chmod ( node , mode | 146 )
var stream = FS . open ( node , 'w' )
FS . write ( stream , data , 0 , data . length , 0 , canOwn )
FS . close ( stream )
FS . chmod ( node , mode )
}
return node
} ,
createDevice : function ( parent , name , input , output ) {
var path = PATH . join2 (
typeof parent === 'string' ? parent : FS . getPath ( parent ) ,
name
)
var mode = FS . getMode ( ! ! input , ! ! output )
if ( ! FS . createDevice . major ) FS . createDevice . major = 64
var dev = FS . makedev ( FS . createDevice . major ++ , 0 )
FS . registerDevice ( dev , {
open : function ( stream ) {
stream . seekable = false
} ,
close : function ( stream ) {
if ( output && output . buffer && output . buffer . length ) {
output ( 10 )
}
} ,
read : function ( stream , buffer , offset , length , pos ) {
var bytesRead = 0
for ( var i = 0 ; i < length ; i ++ ) {
var result
try {
result = input ( )
} catch ( e ) {
throw new FS . ErrnoError ( 5 )
}
if ( result === undefined && bytesRead === 0 ) {
throw new FS . ErrnoError ( 11 )
}
if ( result === null || result === undefined ) break
bytesRead ++
buffer [ offset + i ] = result
}
if ( bytesRead ) {
stream . node . timestamp = Date . now ( )
}
return bytesRead
} ,
write : function ( stream , buffer , offset , length , pos ) {
for ( var i = 0 ; i < length ; i ++ ) {
try {
output ( buffer [ offset + i ] )
} catch ( e ) {
throw new FS . ErrnoError ( 5 )
}
}
if ( length ) {
stream . node . timestamp = Date . now ( )
}
return i
} ,
} )
return FS . mkdev ( path , mode , dev )
} ,
createLink : function ( parent , name , target , canRead , canWrite ) {
var path = PATH . join2 (
typeof parent === 'string' ? parent : FS . getPath ( parent ) ,
name
)
return FS . symlink ( target , path )
} ,
forceLoadFile : function ( obj ) {
if ( obj . isDevice || obj . isFolder || obj . link || obj . contents ) return true
var success = true
if ( typeof XMLHttpRequest !== 'undefined' ) {
throw new Error (
'Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.'
)
} else if ( Module [ 'read' ] ) {
try {
obj . contents = intArrayFromString ( Module [ 'read' ] ( obj . url ) , true )
obj . usedBytes = obj . contents . length
} catch ( e ) {
success = false
}
} else {
throw new Error ( 'Cannot load without read() or XMLHttpRequest.' )
}
if ( ! success ) _ _ _setErrNo ( 5 )
return success
} ,
createLazyFile : function ( parent , name , url , canRead , canWrite ) {
function LazyUint8Array ( ) {
this . lengthKnown = false
this . chunks = [ ]
}
LazyUint8Array . prototype . get = function LazyUint8Array _get ( idx ) {
if ( idx > this . length - 1 || idx < 0 ) {
return undefined
}
var chunkOffset = idx % this . chunkSize
var chunkNum = ( idx / this . chunkSize ) | 0
return this . getter ( chunkNum ) [ chunkOffset ]
}
LazyUint8Array . prototype . setDataGetter = function LazyUint8Array _setDataGetter (
getter
) {
this . getter = getter
}
LazyUint8Array . prototype . cacheLength = function LazyUint8Array _cacheLength ( ) {
var xhr = new XMLHttpRequest ( )
xhr . open ( 'HEAD' , url , false )
xhr . send ( null )
if ( ! ( ( xhr . status >= 200 && xhr . status < 300 ) || xhr . status === 304 ) )
throw new Error ( "Couldn't load " + url + '. Status: ' + xhr . status )
var datalength = Number ( xhr . getResponseHeader ( 'Content-length' ) )
var header
var hasByteServing =
( header = xhr . getResponseHeader ( 'Accept-Ranges' ) ) && header === 'bytes'
var usesGzip =
( header = xhr . getResponseHeader ( 'Content-Encoding' ) ) && header === 'gzip'
var chunkSize = 1024 * 1024
if ( ! hasByteServing ) chunkSize = datalength
var doXHR = function ( from , to ) {
if ( from > to )
throw new Error (
'invalid range (' + from + ', ' + to + ') or no bytes requested!'
)
if ( to > datalength - 1 )
throw new Error (
'only ' + datalength + ' bytes available! programmer error!'
)
var xhr = new XMLHttpRequest ( )
xhr . open ( 'GET' , url , false )
if ( datalength !== chunkSize )
xhr . setRequestHeader ( 'Range' , 'bytes=' + from + '-' + to )
if ( typeof Uint8Array != 'undefined' ) xhr . responseType = 'arraybuffer'
if ( xhr . overrideMimeType ) {
xhr . overrideMimeType ( 'text/plain; charset=x-user-defined' )
}
xhr . send ( null )
if ( ! ( ( xhr . status >= 200 && xhr . status < 300 ) || xhr . status === 304 ) )
throw new Error ( "Couldn't load " + url + '. Status: ' + xhr . status )
if ( xhr . response !== undefined ) {
return new Uint8Array ( xhr . response || [ ] )
} else {
return intArrayFromString ( xhr . responseText || '' , true )
}
}
var lazyArray = this
lazyArray . setDataGetter ( function ( chunkNum ) {
var start = chunkNum * chunkSize
var end = ( chunkNum + 1 ) * chunkSize - 1
end = Math . min ( end , datalength - 1 )
if ( typeof lazyArray . chunks [ chunkNum ] === 'undefined' ) {
lazyArray . chunks [ chunkNum ] = doXHR ( start , end )
}
if ( typeof lazyArray . chunks [ chunkNum ] === 'undefined' )
throw new Error ( 'doXHR failed!' )
return lazyArray . chunks [ chunkNum ]
} )
if ( usesGzip || ! datalength ) {
chunkSize = datalength = 1
datalength = this . getter ( 0 ) . length
chunkSize = datalength
console . log (
'LazyFiles on gzip forces download of the whole file when length is accessed'
)
}
this . _length = datalength
this . _chunkSize = chunkSize
this . lengthKnown = true
}
if ( typeof XMLHttpRequest !== 'undefined' ) {
if ( ! ENVIRONMENT _IS _WORKER )
throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'
var lazyArray = new LazyUint8Array ( )
Object . defineProperties ( lazyArray , {
length : {
get : function ( ) {
if ( ! this . lengthKnown ) {
this . cacheLength ( )
}
return this . _length
} ,
} ,
chunkSize : {
get : function ( ) {
if ( ! this . lengthKnown ) {
this . cacheLength ( )
}
return this . _chunkSize
} ,
} ,
} )
var properties = { isDevice : false , contents : lazyArray }
} else {
var properties = { isDevice : false , url : url }
}
var node = FS . createFile ( parent , name , properties , canRead , canWrite )
if ( properties . contents ) {
node . contents = properties . contents
} else if ( properties . url ) {
node . contents = null
node . url = properties . url
}
Object . defineProperties ( node , {
usedBytes : {
get : function ( ) {
return this . contents . length
} ,
} ,
} )
var stream _ops = { }
var keys = Object . keys ( node . stream _ops )
keys . forEach ( function ( key ) {
var fn = node . stream _ops [ key ]
stream _ops [ key ] = function forceLoadLazyFile ( ) {
if ( ! FS . forceLoadFile ( node ) ) {
throw new FS . ErrnoError ( 5 )
}
return fn . apply ( null , arguments )
}
} )
stream _ops . read = function stream _ops _read (
stream ,
buffer ,
offset ,
length ,
position
) {
if ( ! FS . forceLoadFile ( node ) ) {
throw new FS . ErrnoError ( 5 )
}
var contents = stream . node . contents
if ( position >= contents . length ) return 0
var size = Math . min ( contents . length - position , length )
if ( contents . slice ) {
for ( var i = 0 ; i < size ; i ++ ) {
buffer [ offset + i ] = contents [ position + i ]
}
} else {
for ( var i = 0 ; i < size ; i ++ ) {
buffer [ offset + i ] = contents . get ( position + i )
}
}
return size
}
node . stream _ops = stream _ops
return node
} ,
createPreloadedFile : function (
parent ,
name ,
url ,
canRead ,
canWrite ,
onload ,
onerror ,
dontCreateFile ,
canOwn ,
preFinish
) {
Browser . init ( )
var fullname = name ? PATH _FS . resolve ( PATH . join2 ( parent , name ) ) : parent
var dep = getUniqueRunDependency ( 'cp ' + fullname )
function processData ( byteArray ) {
function finish ( byteArray ) {
if ( preFinish ) preFinish ( )
if ( ! dontCreateFile ) {
FS . createDataFile ( parent , name , byteArray , canRead , canWrite , canOwn )
}
if ( onload ) onload ( )
removeRunDependency ( dep )
}
var handled = false
Module [ 'preloadPlugins' ] . forEach ( function ( plugin ) {
if ( handled ) return
if ( plugin [ 'canHandle' ] ( fullname ) ) {
plugin [ 'handle' ] ( byteArray , fullname , finish , function ( ) {
if ( onerror ) onerror ( )
removeRunDependency ( dep )
} )
handled = true
}
} )
if ( ! handled ) finish ( byteArray )
}
addRunDependency ( dep )
if ( typeof url == 'string' ) {
Browser . asyncLoad (
url ,
function ( byteArray ) {
processData ( byteArray )
} ,
onerror
)
} else {
processData ( url )
}
} ,
indexedDB : function ( ) {
return (
window . indexedDB ||
window . mozIndexedDB ||
window . webkitIndexedDB ||
window . msIndexedDB
)
} ,
DB _NAME : function ( ) {
return 'EM_FS_' + window . location . pathname
} ,
DB _VERSION : 20 ,
DB _STORE _NAME : 'FILE_DATA' ,
saveFilesToDB : function ( paths , onload , onerror ) {
onload = onload || function ( ) { }
onerror = onerror || function ( ) { }
var indexedDB = FS . indexedDB ( )
try {
var openRequest = indexedDB . open ( FS . DB _NAME ( ) , FS . DB _VERSION )
} catch ( e ) {
return onerror ( e )
}
openRequest . onupgradeneeded = function openRequest _onupgradeneeded ( ) {
console . log ( 'creating db' )
var db = openRequest . result
db . createObjectStore ( FS . DB _STORE _NAME )
}
openRequest . onsuccess = function openRequest _onsuccess ( ) {
var db = openRequest . result
var transaction = db . transaction ( [ FS . DB _STORE _NAME ] , 'readwrite' )
var files = transaction . objectStore ( FS . DB _STORE _NAME )
var ok = 0 ,
fail = 0 ,
total = paths . length
function finish ( ) {
if ( fail == 0 ) onload ( )
else onerror ( )
}
paths . forEach ( function ( path ) {
var putRequest = files . put ( FS . analyzePath ( path ) . object . contents , path )
putRequest . onsuccess = function putRequest _onsuccess ( ) {
ok ++
if ( ok + fail == total ) finish ( )
}
putRequest . onerror = function putRequest _onerror ( ) {
fail ++
if ( ok + fail == total ) finish ( )
}
} )
transaction . onerror = onerror
}
openRequest . onerror = onerror
} ,
loadFilesFromDB : function ( paths , onload , onerror ) {
onload = onload || function ( ) { }
onerror = onerror || function ( ) { }
var indexedDB = FS . indexedDB ( )
try {
var openRequest = indexedDB . open ( FS . DB _NAME ( ) , FS . DB _VERSION )
} catch ( e ) {
return onerror ( e )
}
openRequest . onupgradeneeded = onerror
openRequest . onsuccess = function openRequest _onsuccess ( ) {
var db = openRequest . result
try {
var transaction = db . transaction ( [ FS . DB _STORE _NAME ] , 'readonly' )
} catch ( e ) {
onerror ( e )
return
}
var files = transaction . objectStore ( FS . DB _STORE _NAME )
var ok = 0 ,
fail = 0 ,
total = paths . length
function finish ( ) {
if ( fail == 0 ) onload ( )
else onerror ( )
}
paths . forEach ( function ( path ) {
var getRequest = files . get ( path )
getRequest . onsuccess = function getRequest _onsuccess ( ) {
if ( FS . analyzePath ( path ) . exists ) {
FS . unlink ( path )
}
FS . createDataFile (
PATH . dirname ( path ) ,
PATH . basename ( path ) ,
getRequest . result ,
true ,
true ,
true
)
ok ++
if ( ok + fail == total ) finish ( )
}
getRequest . onerror = function getRequest _onerror ( ) {
fail ++
if ( ok + fail == total ) finish ( )
}
} )
transaction . onerror = onerror
}
openRequest . onerror = onerror
} ,
}
var SYSCALLS = {
DEFAULT _POLLMASK : 5 ,
mappings : { } ,
umask : 511 ,
calculateAt : function ( dirfd , path ) {
if ( path [ 0 ] !== '/' ) {
var dir
if ( dirfd === - 100 ) {
dir = FS . cwd ( )
} else {
var dirstream = FS . getStream ( dirfd )
if ( ! dirstream ) throw new FS . ErrnoError ( 9 )
dir = dirstream . path
}
path = PATH . join2 ( dir , path )
}
return path
} ,
doStat : function ( func , path , buf ) {
try {
var stat = func ( path )
} catch ( e ) {
if (
e &&
e . node &&
PATH . normalize ( path ) !== PATH . normalize ( FS . getPath ( e . node ) )
) {
return - 20
}
throw e
}
HEAP32 [ buf >> 2 ] = stat . dev
HEAP32 [ ( buf + 4 ) >> 2 ] = 0
HEAP32 [ ( buf + 8 ) >> 2 ] = stat . ino
HEAP32 [ ( buf + 12 ) >> 2 ] = stat . mode
HEAP32 [ ( buf + 16 ) >> 2 ] = stat . nlink
HEAP32 [ ( buf + 20 ) >> 2 ] = stat . uid
HEAP32 [ ( buf + 24 ) >> 2 ] = stat . gid
HEAP32 [ ( buf + 28 ) >> 2 ] = stat . rdev
HEAP32 [ ( buf + 32 ) >> 2 ] = 0
; ( tempI64 = [
stat . size >>> 0 ,
( ( tempDouble = stat . size ) ,
+ Math _abs ( tempDouble ) >= 1
? tempDouble > 0
? ( Math _min ( + Math _floor ( tempDouble / 4294967296 ) , 4294967295 ) | 0 ) >>> 0
: ~ ~ + Math _ceil ( ( tempDouble - + ( ~ ~ tempDouble >>> 0 ) ) / 4294967296 ) >>> 0
: 0 ) ,
] ) ,
( HEAP32 [ ( buf + 40 ) >> 2 ] = tempI64 [ 0 ] ) ,
( HEAP32 [ ( buf + 44 ) >> 2 ] = tempI64 [ 1 ] )
HEAP32 [ ( buf + 48 ) >> 2 ] = 4096
HEAP32 [ ( buf + 52 ) >> 2 ] = stat . blocks
HEAP32 [ ( buf + 56 ) >> 2 ] = ( stat . atime . getTime ( ) / 1e3 ) | 0
HEAP32 [ ( buf + 60 ) >> 2 ] = 0
HEAP32 [ ( buf + 64 ) >> 2 ] = ( stat . mtime . getTime ( ) / 1e3 ) | 0
HEAP32 [ ( buf + 68 ) >> 2 ] = 0
HEAP32 [ ( buf + 72 ) >> 2 ] = ( stat . ctime . getTime ( ) / 1e3 ) | 0
HEAP32 [ ( buf + 76 ) >> 2 ] = 0
; ( tempI64 = [
stat . ino >>> 0 ,
( ( tempDouble = stat . ino ) ,
+ Math _abs ( tempDouble ) >= 1
? tempDouble > 0
? ( Math _min ( + Math _floor ( tempDouble / 4294967296 ) , 4294967295 ) | 0 ) >>> 0
: ~ ~ + Math _ceil ( ( tempDouble - + ( ~ ~ tempDouble >>> 0 ) ) / 4294967296 ) >>> 0
: 0 ) ,
] ) ,
( HEAP32 [ ( buf + 80 ) >> 2 ] = tempI64 [ 0 ] ) ,
( HEAP32 [ ( buf + 84 ) >> 2 ] = tempI64 [ 1 ] )
return 0
} ,
doMsync : function ( addr , stream , len , flags ) {
var buffer = new Uint8Array ( HEAPU8 . subarray ( addr , addr + len ) )
FS . msync ( stream , buffer , 0 , len , flags )
} ,
doMkdir : function ( path , mode ) {
path = PATH . normalize ( path )
if ( path [ path . length - 1 ] === '/' ) path = path . substr ( 0 , path . length - 1 )
FS . mkdir ( path , mode , 0 )
return 0
} ,
doMknod : function ( path , mode , dev ) {
switch ( mode & 61440 ) {
case 32768 :
case 8192 :
case 24576 :
case 4096 :
case 49152 :
break
default :
return - 22
}
FS . mknod ( path , mode , dev )
return 0
} ,
doReadlink : function ( path , buf , bufsize ) {
if ( bufsize <= 0 ) return - 22
var ret = FS . readlink ( path )
var len = Math . min ( bufsize , lengthBytesUTF8 ( ret ) )
var endChar = HEAP8 [ buf + len ]
stringToUTF8 ( ret , buf , bufsize + 1 )
HEAP8 [ buf + len ] = endChar
return len
} ,
doAccess : function ( path , amode ) {
if ( amode & ~ 7 ) {
return - 22
}
var node
var lookup = FS . lookupPath ( path , { follow : true } )
node = lookup . node
var perms = ''
if ( amode & 4 ) perms += 'r'
if ( amode & 2 ) perms += 'w'
if ( amode & 1 ) perms += 'x'
if ( perms && FS . nodePermissions ( node , perms ) ) {
return - 13
}
return 0
} ,
doDup : function ( path , flags , suggestFD ) {
var suggest = FS . getStream ( suggestFD )
if ( suggest ) FS . close ( suggest )
return FS . open ( path , flags , 0 , suggestFD , suggestFD ) . fd
} ,
doReadv : function ( stream , iov , iovcnt , offset ) {
var ret = 0
for ( var i = 0 ; i < iovcnt ; i ++ ) {
var ptr = HEAP32 [ ( iov + i * 8 ) >> 2 ]
var len = HEAP32 [ ( iov + ( i * 8 + 4 ) ) >> 2 ]
var curr = FS . read ( stream , HEAP8 , ptr , len , offset )
if ( curr < 0 ) return - 1
ret += curr
if ( curr < len ) break
}
return ret
} ,
doWritev : function ( stream , iov , iovcnt , offset ) {
var ret = 0
for ( var i = 0 ; i < iovcnt ; i ++ ) {
var ptr = HEAP32 [ ( iov + i * 8 ) >> 2 ]
var len = HEAP32 [ ( iov + ( i * 8 + 4 ) ) >> 2 ]
var curr = FS . write ( stream , HEAP8 , ptr , len , offset )
if ( curr < 0 ) return - 1
ret += curr
}
return ret
} ,
varargs : 0 ,
get : function ( varargs ) {
SYSCALLS . varargs += 4
var ret = HEAP32 [ ( SYSCALLS . varargs - 4 ) >> 2 ]
return ret
} ,
getStr : function ( ) {
var ret = UTF8ToString ( SYSCALLS . get ( ) )
return ret
} ,
getStreamFromFD : function ( ) {
var stream = FS . getStream ( SYSCALLS . get ( ) )
if ( ! stream ) throw new FS . ErrnoError ( 9 )
return stream
} ,
get64 : function ( ) {
var low = SYSCALLS . get ( ) ,
high = SYSCALLS . get ( )
return low
} ,
getZero : function ( ) {
SYSCALLS . get ( )
} ,
}
function _ _ _syscall140 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( ) ,
offset _high = SYSCALLS . get ( ) ,
offset _low = SYSCALLS . get ( ) ,
result = SYSCALLS . get ( ) ,
whence = SYSCALLS . get ( )
if (
! ( offset _high == - 1 && offset _low < 0 ) &&
! ( offset _high == 0 && offset _low >= 0 )
) {
return - 75
}
var offset = offset _low
FS . llseek ( stream , offset , whence )
; ( tempI64 = [
stream . position >>> 0 ,
( ( tempDouble = stream . position ) ,
+ Math _abs ( tempDouble ) >= 1
? tempDouble > 0
? ( Math _min ( + Math _floor ( tempDouble / 4294967296 ) , 4294967295 ) | 0 ) >>> 0
: ~ ~ + Math _ceil ( ( tempDouble - + ( ~ ~ tempDouble >>> 0 ) ) / 4294967296 ) >>> 0
: 0 ) ,
] ) ,
( HEAP32 [ result >> 2 ] = tempI64 [ 0 ] ) ,
( HEAP32 [ ( result + 4 ) >> 2 ] = tempI64 [ 1 ] )
if ( stream . getdents && offset === 0 && whence === 0 ) stream . getdents = null
return 0
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall146 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( ) ,
iov = SYSCALLS . get ( ) ,
iovcnt = SYSCALLS . get ( )
return SYSCALLS . doWritev ( stream , iov , iovcnt )
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall168 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var fds = SYSCALLS . get ( ) ,
nfds = SYSCALLS . get ( ) ,
timeout = SYSCALLS . get ( )
var nonzero = 0
for ( var i = 0 ; i < nfds ; i ++ ) {
var pollfd = fds + 8 * i
var fd = HEAP32 [ pollfd >> 2 ]
var events = HEAP16 [ ( pollfd + 4 ) >> 1 ]
var mask = 32
var stream = FS . getStream ( fd )
if ( stream ) {
mask = SYSCALLS . DEFAULT _POLLMASK
if ( stream . stream _ops . poll ) {
mask = stream . stream _ops . poll ( stream )
}
}
mask &= events | 8 | 16
if ( mask ) nonzero ++
HEAP16 [ ( pollfd + 6 ) >> 1 ] = mask
}
return nonzero
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall195 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var path = SYSCALLS . getStr ( ) ,
buf = SYSCALLS . get ( )
return SYSCALLS . doStat ( FS . stat , path , buf )
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall196 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var path = SYSCALLS . getStr ( ) ,
buf = SYSCALLS . get ( )
return SYSCALLS . doStat ( FS . lstat , path , buf )
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall197 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( ) ,
buf = SYSCALLS . get ( )
return SYSCALLS . doStat ( FS . stat , stream . path , buf )
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall221 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( ) ,
cmd = SYSCALLS . get ( )
switch ( cmd ) {
case 0 : {
var arg = SYSCALLS . get ( )
if ( arg < 0 ) {
return - 22
}
var newStream
newStream = FS . open ( stream . path , stream . flags , 0 , arg )
return newStream . fd
}
case 1 :
case 2 :
return 0
case 3 :
return stream . flags
case 4 : {
var arg = SYSCALLS . get ( )
stream . flags |= arg
return 0
}
case 12 : {
var arg = SYSCALLS . get ( )
var offset = 0
HEAP16 [ ( arg + offset ) >> 1 ] = 2
return 0
}
case 13 :
case 14 :
return 0
case 16 :
case 8 :
return - 22
case 9 :
_ _ _setErrNo ( 22 )
return - 1
default : {
return - 22
}
}
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall3 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( ) ,
buf = SYSCALLS . get ( ) ,
count = SYSCALLS . get ( )
return FS . read ( stream , HEAP8 , buf , count )
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall4 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( ) ,
buf = SYSCALLS . get ( ) ,
count = SYSCALLS . get ( )
return FS . write ( stream , HEAP8 , buf , count )
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall41 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var old = SYSCALLS . getStreamFromFD ( )
return FS . open ( old . path , old . flags , 0 ) . fd
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
var ERRNO _CODES = {
EPERM : 1 ,
ENOENT : 2 ,
ESRCH : 3 ,
EINTR : 4 ,
EIO : 5 ,
ENXIO : 6 ,
E2BIG : 7 ,
ENOEXEC : 8 ,
EBADF : 9 ,
ECHILD : 10 ,
EAGAIN : 11 ,
EWOULDBLOCK : 11 ,
ENOMEM : 12 ,
EACCES : 13 ,
EFAULT : 14 ,
ENOTBLK : 15 ,
EBUSY : 16 ,
EEXIST : 17 ,
EXDEV : 18 ,
ENODEV : 19 ,
ENOTDIR : 20 ,
EISDIR : 21 ,
EINVAL : 22 ,
ENFILE : 23 ,
EMFILE : 24 ,
ENOTTY : 25 ,
ETXTBSY : 26 ,
EFBIG : 27 ,
ENOSPC : 28 ,
ESPIPE : 29 ,
EROFS : 30 ,
EMLINK : 31 ,
EPIPE : 32 ,
EDOM : 33 ,
ERANGE : 34 ,
ENOMSG : 42 ,
EIDRM : 43 ,
ECHRNG : 44 ,
EL2NSYNC : 45 ,
EL3HLT : 46 ,
EL3RST : 47 ,
ELNRNG : 48 ,
EUNATCH : 49 ,
ENOCSI : 50 ,
EL2HLT : 51 ,
EDEADLK : 35 ,
ENOLCK : 37 ,
EBADE : 52 ,
EBADR : 53 ,
EXFULL : 54 ,
ENOANO : 55 ,
EBADRQC : 56 ,
EBADSLT : 57 ,
EDEADLOCK : 35 ,
EBFONT : 59 ,
ENOSTR : 60 ,
ENODATA : 61 ,
ETIME : 62 ,
ENOSR : 63 ,
ENONET : 64 ,
ENOPKG : 65 ,
EREMOTE : 66 ,
ENOLINK : 67 ,
EADV : 68 ,
ESRMNT : 69 ,
ECOMM : 70 ,
EPROTO : 71 ,
EMULTIHOP : 72 ,
EDOTDOT : 73 ,
EBADMSG : 74 ,
ENOTUNIQ : 76 ,
EBADFD : 77 ,
EREMCHG : 78 ,
ELIBACC : 79 ,
ELIBBAD : 80 ,
ELIBSCN : 81 ,
ELIBMAX : 82 ,
ELIBEXEC : 83 ,
ENOSYS : 38 ,
ENOTEMPTY : 39 ,
ENAMETOOLONG : 36 ,
ELOOP : 40 ,
EOPNOTSUPP : 95 ,
EPFNOSUPPORT : 96 ,
ECONNRESET : 104 ,
ENOBUFS : 105 ,
EAFNOSUPPORT : 97 ,
EPROTOTYPE : 91 ,
ENOTSOCK : 88 ,
ENOPROTOOPT : 92 ,
ESHUTDOWN : 108 ,
ECONNREFUSED : 111 ,
EADDRINUSE : 98 ,
ECONNABORTED : 103 ,
ENETUNREACH : 101 ,
ENETDOWN : 100 ,
ETIMEDOUT : 110 ,
EHOSTDOWN : 112 ,
EHOSTUNREACH : 113 ,
EINPROGRESS : 115 ,
EALREADY : 114 ,
EDESTADDRREQ : 89 ,
EMSGSIZE : 90 ,
EPROTONOSUPPORT : 93 ,
ESOCKTNOSUPPORT : 94 ,
EADDRNOTAVAIL : 99 ,
ENETRESET : 102 ,
EISCONN : 106 ,
ENOTCONN : 107 ,
ETOOMANYREFS : 109 ,
EUSERS : 87 ,
EDQUOT : 122 ,
ESTALE : 116 ,
ENOTSUP : 95 ,
ENOMEDIUM : 123 ,
EILSEQ : 84 ,
EOVERFLOW : 75 ,
ECANCELED : 125 ,
ENOTRECOVERABLE : 131 ,
EOWNERDEAD : 130 ,
ESTRPIPE : 86 ,
}
var PIPEFS = {
BUCKET _BUFFER _SIZE : 8192 ,
mount : function ( mount ) {
return FS . createNode ( null , '/' , 16384 | 511 , 0 )
} ,
createPipe : function ( ) {
var pipe = { buckets : [ ] }
pipe . buckets . push ( {
buffer : new Uint8Array ( PIPEFS . BUCKET _BUFFER _SIZE ) ,
offset : 0 ,
roffset : 0 ,
} )
var rName = PIPEFS . nextname ( )
var wName = PIPEFS . nextname ( )
var rNode = FS . createNode ( PIPEFS . root , rName , 4096 , 0 )
var wNode = FS . createNode ( PIPEFS . root , wName , 4096 , 0 )
rNode . pipe = pipe
wNode . pipe = pipe
var readableStream = FS . createStream ( {
path : rName ,
node : rNode ,
flags : FS . modeStringToFlags ( 'r' ) ,
seekable : false ,
stream _ops : PIPEFS . stream _ops ,
} )
rNode . stream = readableStream
var writableStream = FS . createStream ( {
path : wName ,
node : wNode ,
flags : FS . modeStringToFlags ( 'w' ) ,
seekable : false ,
stream _ops : PIPEFS . stream _ops ,
} )
wNode . stream = writableStream
return { readable _fd : readableStream . fd , writable _fd : writableStream . fd }
} ,
stream _ops : {
poll : function ( stream ) {
var pipe = stream . node . pipe
if ( ( stream . flags & 2097155 ) === 1 ) {
return 256 | 4
} else {
if ( pipe . buckets . length > 0 ) {
for ( var i = 0 ; i < pipe . buckets . length ; i ++ ) {
var bucket = pipe . buckets [ i ]
if ( bucket . offset - bucket . roffset > 0 ) {
return 64 | 1
}
}
}
}
return 0
} ,
ioctl : function ( stream , request , varargs ) {
return ERRNO _CODES . EINVAL
} ,
read : function ( stream , buffer , offset , length , position ) {
var pipe = stream . node . pipe
var currentLength = 0
for ( var i = 0 ; i < pipe . buckets . length ; i ++ ) {
var bucket = pipe . buckets [ i ]
currentLength += bucket . offset - bucket . roffset
}
assert ( buffer instanceof ArrayBuffer || ArrayBuffer . isView ( buffer ) )
var data = buffer . subarray ( offset , offset + length )
if ( length <= 0 ) {
return 0
}
if ( currentLength == 0 ) {
throw new FS . ErrnoError ( ERRNO _CODES . EAGAIN )
}
var toRead = Math . min ( currentLength , length )
var totalRead = toRead
var toRemove = 0
for ( var i = 0 ; i < pipe . buckets . length ; i ++ ) {
var currBucket = pipe . buckets [ i ]
var bucketSize = currBucket . offset - currBucket . roffset
if ( toRead <= bucketSize ) {
var tmpSlice = currBucket . buffer . subarray (
currBucket . roffset ,
currBucket . offset
)
if ( toRead < bucketSize ) {
tmpSlice = tmpSlice . subarray ( 0 , toRead )
currBucket . roffset += toRead
} else {
toRemove ++
}
data . set ( tmpSlice )
break
} else {
var tmpSlice = currBucket . buffer . subarray (
currBucket . roffset ,
currBucket . offset
)
data . set ( tmpSlice )
data = data . subarray ( tmpSlice . byteLength )
toRead -= tmpSlice . byteLength
toRemove ++
}
}
if ( toRemove && toRemove == pipe . buckets . length ) {
toRemove --
pipe . buckets [ toRemove ] . offset = 0
pipe . buckets [ toRemove ] . roffset = 0
}
pipe . buckets . splice ( 0 , toRemove )
return totalRead
} ,
write : function ( stream , buffer , offset , length , position ) {
var pipe = stream . node . pipe
assert ( buffer instanceof ArrayBuffer || ArrayBuffer . isView ( buffer ) )
var data = buffer . subarray ( offset , offset + length )
var dataLen = data . byteLength
if ( dataLen <= 0 ) {
return 0
}
var currBucket = null
if ( pipe . buckets . length == 0 ) {
currBucket = {
buffer : new Uint8Array ( PIPEFS . BUCKET _BUFFER _SIZE ) ,
offset : 0 ,
roffset : 0 ,
}
pipe . buckets . push ( currBucket )
} else {
currBucket = pipe . buckets [ pipe . buckets . length - 1 ]
}
assert ( currBucket . offset <= PIPEFS . BUCKET _BUFFER _SIZE )
var freeBytesInCurrBuffer = PIPEFS . BUCKET _BUFFER _SIZE - currBucket . offset
if ( freeBytesInCurrBuffer >= dataLen ) {
currBucket . buffer . set ( data , currBucket . offset )
currBucket . offset += dataLen
return dataLen
} else if ( freeBytesInCurrBuffer > 0 ) {
currBucket . buffer . set (
data . subarray ( 0 , freeBytesInCurrBuffer ) ,
currBucket . offset
)
currBucket . offset += freeBytesInCurrBuffer
data = data . subarray ( freeBytesInCurrBuffer , data . byteLength )
}
var numBuckets = ( data . byteLength / PIPEFS . BUCKET _BUFFER _SIZE ) | 0
var remElements = data . byteLength % PIPEFS . BUCKET _BUFFER _SIZE
for ( var i = 0 ; i < numBuckets ; i ++ ) {
var newBucket = {
buffer : new Uint8Array ( PIPEFS . BUCKET _BUFFER _SIZE ) ,
offset : PIPEFS . BUCKET _BUFFER _SIZE ,
roffset : 0 ,
}
pipe . buckets . push ( newBucket )
newBucket . buffer . set ( data . subarray ( 0 , PIPEFS . BUCKET _BUFFER _SIZE ) )
data = data . subarray ( PIPEFS . BUCKET _BUFFER _SIZE , data . byteLength )
}
if ( remElements > 0 ) {
var newBucket = {
buffer : new Uint8Array ( PIPEFS . BUCKET _BUFFER _SIZE ) ,
offset : data . byteLength ,
roffset : 0 ,
}
pipe . buckets . push ( newBucket )
newBucket . buffer . set ( data )
}
return dataLen
} ,
close : function ( stream ) {
var pipe = stream . node . pipe
pipe . buckets = null
} ,
} ,
nextname : function ( ) {
if ( ! PIPEFS . nextname . current ) {
PIPEFS . nextname . current = 0
}
return 'pipe[' + PIPEFS . nextname . current ++ + ']'
} ,
}
function _ _ _syscall42 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var fdPtr = SYSCALLS . get ( )
if ( fdPtr == 0 ) {
throw new FS . ErrnoError ( 14 )
}
var res = PIPEFS . createPipe ( )
HEAP32 [ fdPtr >> 2 ] = res . readable _fd
HEAP32 [ ( fdPtr + 4 ) >> 2 ] = res . writable _fd
return 0
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall5 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var pathname = SYSCALLS . getStr ( ) ,
flags = SYSCALLS . get ( ) ,
mode = SYSCALLS . get ( )
var stream = FS . open ( pathname , flags , mode )
return stream . fd
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _ _ _syscall6 ( which , varargs ) {
SYSCALLS . varargs = varargs
try {
var stream = SYSCALLS . getStreamFromFD ( )
FS . close ( stream )
return 0
} catch ( e ) {
if ( typeof FS === 'undefined' || ! ( e instanceof FS . ErrnoError ) ) abort ( e )
return - e . errno
}
}
function _abort ( ) {
Module [ 'abort' ] ( )
}
function _emscripten _get _heap _size ( ) {
return HEAP8 . length
}
function abortOnCannotGrowMemory ( requestedSize ) {
abort ( 'OOM' )
}
function emscripten _realloc _buffer ( size ) {
var PAGE _MULTIPLE = 65536
size = alignUp ( size , PAGE _MULTIPLE )
var oldSize = buffer . byteLength
try {
var result = wasmMemory . grow ( ( size - oldSize ) / 65536 )
if ( result !== ( - 1 | 0 ) ) {
buffer = wasmMemory . buffer
return true
} else {
return false
}
} catch ( e ) {
return false
}
}
function _emscripten _resize _heap ( requestedSize ) {
var oldSize = _emscripten _get _heap _size ( )
var PAGE _MULTIPLE = 65536
var LIMIT = 2147483648 - PAGE _MULTIPLE
if ( requestedSize > LIMIT ) {
return false
}
var MIN _TOTAL _MEMORY = 16777216
var newSize = Math . max ( oldSize , MIN _TOTAL _MEMORY )
while ( newSize < requestedSize ) {
if ( newSize <= 536870912 ) {
newSize = alignUp ( 2 * newSize , PAGE _MULTIPLE )
} else {
newSize = Math . min (
alignUp ( ( 3 * newSize + 2147483648 ) / 4 , PAGE _MULTIPLE ) ,
LIMIT
)
}
}
if ( ! emscripten _realloc _buffer ( newSize ) ) {
return false
}
updateGlobalBufferViews ( )
return true
}
function _exit ( status ) {
exit ( status )
}
var _ _ _tm _current = 277408
var _ _ _tm _timezone = ( stringToUTF8 ( 'GMT' , 277456 , 4 ) , 277456 )
function _tzset ( ) {
if ( _tzset . called ) return
_tzset . called = true
HEAP32 [ _ _get _timezone ( ) >> 2 ] = new Date ( ) . getTimezoneOffset ( ) * 60
var winter = new Date ( 2e3 , 0 , 1 )
var summer = new Date ( 2e3 , 6 , 1 )
HEAP32 [ _ _get _daylight ( ) >> 2 ] = Number (
winter . getTimezoneOffset ( ) != summer . getTimezoneOffset ( )
)
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 = allocate ( intArrayFromString ( winterName ) , 'i8' , ALLOC _NORMAL )
var summerNamePtr = allocate ( intArrayFromString ( summerName ) , 'i8' , ALLOC _NORMAL )
if ( summer . getTimezoneOffset ( ) < winter . getTimezoneOffset ( ) ) {
HEAP32 [ _ _get _tzname ( ) >> 2 ] = winterNamePtr
HEAP32 [ ( _ _get _tzname ( ) + 4 ) >> 2 ] = summerNamePtr
} else {
HEAP32 [ _ _get _tzname ( ) >> 2 ] = summerNamePtr
HEAP32 [ ( _ _get _tzname ( ) + 4 ) >> 2 ] = winterNamePtr
}
}
function _localtime _r ( time , tmPtr ) {
_tzset ( )
var date = new Date ( HEAP32 [ time >> 2 ] * 1e3 )
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 ( ) ) / ( 1e3 * 60 * 60 * 24 ) ) | 0
HEAP32 [ ( tmPtr + 28 ) >> 2 ] = yday
HEAP32 [ ( tmPtr + 36 ) >> 2 ] = - ( date . getTimezoneOffset ( ) * 60 )
var summerOffset = new Date ( 2e3 , 6 , 1 ) . getTimezoneOffset ( )
var winterOffset = start . getTimezoneOffset ( )
var dst =
( summerOffset != winterOffset &&
date . getTimezoneOffset ( ) == Math . min ( winterOffset , summerOffset ) ) | 0
HEAP32 [ ( tmPtr + 32 ) >> 2 ] = dst
var zonePtr = HEAP32 [ ( _ _get _tzname ( ) + ( dst ? 4 : 0 ) ) >> 2 ]
HEAP32 [ ( tmPtr + 40 ) >> 2 ] = zonePtr
return tmPtr
}
function _localtime ( time ) {
return _localtime _r ( time , _ _ _tm _current )
}
function _emscripten _memcpy _big ( dest , src , num ) {
HEAPU8 . set ( HEAPU8 . subarray ( src , src + num ) , dest )
}
function _mktime ( tmPtr ) {
_tzset ( )
var date = new Date (
HEAP32 [ ( tmPtr + 20 ) >> 2 ] + 1900 ,
HEAP32 [ ( tmPtr + 16 ) >> 2 ] ,
HEAP32 [ ( tmPtr + 12 ) >> 2 ] ,
HEAP32 [ ( tmPtr + 8 ) >> 2 ] ,
HEAP32 [ ( tmPtr + 4 ) >> 2 ] ,
HEAP32 [ tmPtr >> 2 ] ,
0
)
var dst = HEAP32 [ ( tmPtr + 32 ) >> 2 ]
var guessedOffset = date . getTimezoneOffset ( )
var start = new Date ( date . getFullYear ( ) , 0 , 1 )
var summerOffset = new Date ( 2e3 , 6 , 1 ) . getTimezoneOffset ( )
var winterOffset = start . getTimezoneOffset ( )
var dstOffset = Math . min ( winterOffset , summerOffset )
if ( dst < 0 ) {
HEAP32 [ ( tmPtr + 32 ) >> 2 ] = Number (
summerOffset != winterOffset && dstOffset == guessedOffset
)
} else if ( dst > 0 != ( dstOffset == guessedOffset ) ) {
var nonDstOffset = Math . max ( winterOffset , summerOffset )
var trueOffset = dst > 0 ? dstOffset : nonDstOffset
date . setTime ( date . getTime ( ) + ( trueOffset - guessedOffset ) * 6e4 )
}
HEAP32 [ ( tmPtr + 24 ) >> 2 ] = date . getDay ( )
var yday = ( ( date . getTime ( ) - start . getTime ( ) ) / ( 1e3 * 60 * 60 * 24 ) ) | 0
HEAP32 [ ( tmPtr + 28 ) >> 2 ] = yday
return ( date . getTime ( ) / 1e3 ) | 0
}
function _posix _spawn _file _actions _addclose ( ) {
err ( 'missing function: posix_spawn_file_actions_addclose' )
abort ( - 1 )
}
function _posix _spawn _file _actions _adddup2 ( ) {
err ( 'missing function: posix_spawn_file_actions_adddup2' )
abort ( - 1 )
}
function _posix _spawn _file _actions _destroy ( ) {
err ( 'missing function: posix_spawn_file_actions_destroy' )
abort ( - 1 )
}
function _posix _spawn _file _actions _init ( ) {
err ( 'missing function: posix_spawn_file_actions_init' )
abort ( - 1 )
}
function _fork ( ) {
_ _ _setErrNo ( 11 )
return - 1
}
function _posix _spawnp ( ) {
return _fork . apply ( null , arguments )
}
function _timegm ( tmPtr ) {
_tzset ( )
var time = Date . UTC (
HEAP32 [ ( tmPtr + 20 ) >> 2 ] + 1900 ,
HEAP32 [ ( tmPtr + 16 ) >> 2 ] ,
HEAP32 [ ( tmPtr + 12 ) >> 2 ] ,
HEAP32 [ ( tmPtr + 8 ) >> 2 ] ,
HEAP32 [ ( tmPtr + 4 ) >> 2 ] ,
HEAP32 [ tmPtr >> 2 ] ,
0
)
var date = new Date ( time )
HEAP32 [ ( tmPtr + 24 ) >> 2 ] = date . getUTCDay ( )
var start = Date . UTC ( date . getUTCFullYear ( ) , 0 , 1 , 0 , 0 , 0 , 0 )
var yday = ( ( date . getTime ( ) - start ) / ( 1e3 * 60 * 60 * 24 ) ) | 0
HEAP32 [ ( tmPtr + 28 ) >> 2 ] = yday
return ( date . getTime ( ) / 1e3 ) | 0
}
function _wait ( stat _loc ) {
_ _ _setErrNo ( 10 )
return - 1
}
function _waitpid ( ) {
return _wait . apply ( null , arguments )
}
FS . staticInit ( )
if ( ENVIRONMENT _IS _NODE ) {
var fs = require ( 'fs' )
var NODEJS _PATH = require ( 'path' )
NODEFS . staticInit ( )
}
function intArrayFromString ( stringy , dontAddNull , length ) {
var len = length > 0 ? length : lengthBytesUTF8 ( stringy ) + 1
var u8array = new Array ( len )
var numBytesWritten = stringToUTF8Array ( stringy , u8array , 0 , u8array . length )
if ( dontAddNull ) u8array . length = numBytesWritten
return u8array
}
var asmGlobalArg = { }
var asmLibraryArg = {
b : abort ,
q : setTempRet0 ,
G : _ _ _buildEnvironment ,
l : _ _ _setErrNo ,
s : _ _ _syscall140 ,
i : _ _ _syscall146 ,
p : _ _ _syscall168 ,
o : _ _ _syscall195 ,
n : _ _ _syscall196 ,
m : _ _ _syscall197 ,
c : _ _ _syscall221 ,
F : _ _ _syscall3 ,
E : _ _ _syscall4 ,
D : _ _ _syscall41 ,
C : _ _ _syscall42 ,
B : _ _ _syscall5 ,
h : _ _ _syscall6 ,
g : _abort ,
A : _emscripten _get _heap _size ,
z : _emscripten _memcpy _big ,
y : _emscripten _resize _heap ,
f : _exit ,
x : _localtime ,
d : _mktime ,
e : _posix _spawn _file _actions _addclose ,
k : _posix _spawn _file _actions _adddup2 ,
j : _posix _spawn _file _actions _destroy ,
w : _posix _spawn _file _actions _init ,
v : _posix _spawnp ,
u : _timegm ,
t : _waitpid ,
r : abortOnCannotGrowMemory ,
a : DYNAMICTOP _PTR ,
}
var asm = Module [ 'asm' ] ( asmGlobalArg , asmLibraryArg , buffer )
Module [ 'asm' ] = asm
var _ _ _emscripten _environ _constructor = ( Module [
'___emscripten_environ_constructor'
] = function ( ) {
return Module [ 'asm' ] [ 'H' ] . apply ( null , arguments )
} )
var _ _ _errno _location = ( Module [ '___errno_location' ] = function ( ) {
return Module [ 'asm' ] [ 'I' ] . apply ( null , arguments )
} )
var _ _get _daylight = ( Module [ '__get_daylight' ] = function ( ) {
return Module [ 'asm' ] [ 'J' ] . apply ( null , arguments )
} )
var _ _get _timezone = ( Module [ '__get_timezone' ] = function ( ) {
return Module [ 'asm' ] [ 'K' ] . apply ( null , arguments )
} )
var _ _get _tzname = ( Module [ '__get_tzname' ] = function ( ) {
return Module [ 'asm' ] [ 'L' ] . apply ( null , arguments )
} )
var _archive _close = ( Module [ '_archive_close' ] = function ( ) {
return Module [ 'asm' ] [ 'M' ] . apply ( null , arguments )
} )
var _archive _entry _filetype = ( Module [ '_archive_entry_filetype' ] = function ( ) {
return Module [ 'asm' ] [ 'N' ] . apply ( null , arguments )
} )
var _archive _entry _is _encrypted = ( Module [
'_archive_entry_is_encrypted'
] = function ( ) {
return Module [ 'asm' ] [ 'O' ] . apply ( null , arguments )
} )
var _archive _entry _pathname = ( Module [ '_archive_entry_pathname' ] = function ( ) {
return Module [ 'asm' ] [ 'P' ] . apply ( null , arguments )
} )
var _archive _entry _pathname _utf8 = ( Module [
'_archive_entry_pathname_utf8'
] = function ( ) {
return Module [ 'asm' ] [ 'Q' ] . apply ( null , arguments )
} )
var _archive _entry _size = ( Module [ '_archive_entry_size' ] = function ( ) {
return Module [ 'asm' ] [ 'R' ] . apply ( null , arguments )
} )
var _archive _error _string = ( Module [ '_archive_error_string' ] = function ( ) {
return Module [ 'asm' ] [ 'S' ] . apply ( null , arguments )
} )
var _archive _open = ( Module [ '_archive_open' ] = function ( ) {
return Module [ 'asm' ] [ 'T' ] . apply ( null , arguments )
} )
var _archive _read _add _passphrase = ( Module [
'_archive_read_add_passphrase'
] = function ( ) {
return Module [ 'asm' ] [ 'U' ] . apply ( null , arguments )
} )
var _archive _read _data _skip = ( Module [ '_archive_read_data_skip' ] = function ( ) {
return Module [ 'asm' ] [ 'V' ] . apply ( null , arguments )
} )
var _archive _read _has _encrypted _entries = ( Module [
'_archive_read_has_encrypted_entries'
] = function ( ) {
return Module [ 'asm' ] [ 'W' ] . apply ( null , arguments )
} )
var _free = ( Module [ '_free' ] = function ( ) {
return Module [ 'asm' ] [ 'X' ] . apply ( null , arguments )
} )
var _get _filedata = ( Module [ '_get_filedata' ] = function ( ) {
return Module [ 'asm' ] [ 'Y' ] . apply ( null , arguments )
} )
var _get _next _entry = ( Module [ '_get_next_entry' ] = function ( ) {
return Module [ 'asm' ] [ 'Z' ] . apply ( null , arguments )
} )
var _get _version = ( Module [ '_get_version' ] = function ( ) {
return Module [ 'asm' ] [ '_' ] . apply ( null , arguments )
} )
var _malloc = ( Module [ '_malloc' ] = function ( ) {
return Module [ 'asm' ] [ '$' ] . apply ( null , arguments )
} )
var stackAlloc = ( Module [ 'stackAlloc' ] = function ( ) {
return Module [ 'asm' ] [ 'ca' ] . apply ( null , arguments )
} )
var stackRestore = ( Module [ 'stackRestore' ] = function ( ) {
return Module [ 'asm' ] [ 'da' ] . apply ( null , arguments )
} )
var stackSave = ( Module [ 'stackSave' ] = function ( ) {
return Module [ 'asm' ] [ 'ea' ] . apply ( null , arguments )
} )
var dynCall _v = ( Module [ 'dynCall_v' ] = function ( ) {
return Module [ 'asm' ] [ 'aa' ] . apply ( null , arguments )
} )
var dynCall _vi = ( Module [ 'dynCall_vi' ] = function ( ) {
return Module [ 'asm' ] [ 'ba' ] . apply ( null , arguments )
} )
Module [ 'asm' ] = asm
Module [ 'intArrayFromString' ] = intArrayFromString
Module [ 'cwrap' ] = cwrap
Module [ 'allocate' ] = allocate
Module [ 'then' ] = function ( func ) {
if ( Module [ 'calledRun' ] ) {
func ( Module )
} else {
var old = Module [ 'onRuntimeInitialized' ]
Module [ 'onRuntimeInitialized' ] = function ( ) {
if ( old ) old ( )
func ( Module )
}
}
return Module
}
function ExitStatus ( status ) {
this . name = 'ExitStatus'
this . message = 'Program terminated with exit(' + status + ')'
this . status = status
}
ExitStatus . prototype = new Error ( )
ExitStatus . prototype . constructor = ExitStatus
dependenciesFulfilled = function runCaller ( ) {
if ( ! Module [ 'calledRun' ] ) run ( )
if ( ! Module [ 'calledRun' ] ) dependenciesFulfilled = runCaller
}
function run ( args ) {
args = args || Module [ 'arguments' ]
if ( runDependencies > 0 ) {
return
}
preRun ( )
if ( runDependencies > 0 ) return
if ( Module [ 'calledRun' ] ) return
function doRun ( ) {
if ( Module [ 'calledRun' ] ) return
Module [ 'calledRun' ] = true
if ( ABORT ) return
ensureInitRuntime ( )
preMain ( )
if ( Module [ 'onRuntimeInitialized' ] ) Module [ 'onRuntimeInitialized' ] ( )
postRun ( )
}
if ( Module [ 'setStatus' ] ) {
Module [ 'setStatus' ] ( 'Running...' )
setTimeout ( function ( ) {
setTimeout ( function ( ) {
Module [ 'setStatus' ] ( '' )
} , 1 )
doRun ( )
} , 1 )
} else {
doRun ( )
}
}
Module [ 'run' ] = run
function exit ( status , implicit ) {
if ( implicit && Module [ 'noExitRuntime' ] && status === 0 ) {
return
}
if ( Module [ 'noExitRuntime' ] ) {
} else {
ABORT = true
EXITSTATUS = status
exitRuntime ( )
if ( Module [ 'onExit' ] ) Module [ 'onExit' ] ( status )
}
Module [ 'quit' ] ( status , new ExitStatus ( status ) )
}
function abort ( what ) {
if ( Module [ 'onAbort' ] ) {
Module [ 'onAbort' ] ( what )
}
if ( what !== undefined ) {
out ( what )
err ( what )
what = JSON . stringify ( what )
} else {
what = ''
}
ABORT = true
EXITSTATUS = 1
throw 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'
}
Module [ 'abort' ] = abort
if ( Module [ 'preInit' ] ) {
if ( typeof Module [ 'preInit' ] == 'function' ) Module [ 'preInit' ] = [ Module [ 'preInit' ] ]
while ( Module [ 'preInit' ] . length > 0 ) {
Module [ 'preInit' ] . pop ( ) ( )
}
}
Module [ 'noExitRuntime' ] = true
run ( )
2019-05-16 08:32:53 +02:00
2019-11-24 02:56:08 +01:00
return libarchive
}
} ) ( )
export default libarchive