( function e ( t , n , r ) { function s ( o , u ) { if ( ! n [ o ] ) { if ( ! t [ o ] ) { var a = typeof require == "function" && require ; if ( ! u && a ) return a ( o , ! 0 ) ; if ( i ) return i ( o , ! 0 ) ; var f = new Error ( "Cannot find module '" + o + "'" ) ; throw f . code = "MODULE_NOT_FOUND" , f } var l = n [ o ] = { exports : { } } ; t [ o ] [ 0 ] . call ( l . exports , function ( e ) { var n = t [ o ] [ 1 ] [ e ] ; return s ( n ? n : e ) } , l , l . exports , e , t , n , r ) } return n [ o ] . exports } var i = typeof require == "function" && require ; for ( var o = 0 ; o < r . length ; o ++ ) s ( r [ o ] ) ; return s } ) ( { 1 : [ function ( require , module , exports ) {
'use strict' ;
var zlib _inflate = require ( './zlib/inflate' ) ;
var utils = require ( './utils/common' ) ;
var strings = require ( './utils/strings' ) ;
var c = require ( './zlib/constants' ) ;
var msg = require ( './zlib/messages' ) ;
var ZStream = require ( './zlib/zstream' ) ;
var GZheader = require ( './zlib/gzheader' ) ;
var toString = Object . prototype . toString ;
/ * *
* class Inflate
*
* Generic JS - style wrapper for zlib calls . If you don ' t need
* streaming behaviour - use more simple functions : [ [ inflate ] ]
* and [ [ inflateRaw ] ] .
* * /
/ * i n t e r n a l
* inflate . chunks - > Array
*
* Chunks of output data , if [ [ Inflate # onData ] ] not overriden .
* * /
/ * *
* Inflate . result - > Uint8Array | Array | String
*
* Uncompressed result , generated by default [ [ Inflate # onData ] ]
* and [ [ Inflate # onEnd ] ] handlers . Filled after you push last chunk
* ( call [ [ Inflate # push ] ] with ` Z_FINISH ` / ` true ` param ) or if you
* push a chunk with explicit flush ( call [ [ Inflate # push ] ] with
* ` Z_SYNC_FLUSH ` param ) .
* * /
/ * *
* Inflate . err - > Number
*
* Error code after inflate finished . 0 ( Z _OK ) on success .
* Should be checked if broken data possible .
* * /
/ * *
* Inflate . msg - > String
*
* Error message , if [ [ Inflate . err ] ] != 0
* * /
/ * *
* new Inflate ( options )
* - options ( Object ) : zlib inflate options .
*
* Creates new inflator instance with specified params . Throws exception
* on bad params . Supported options :
*
* - ` windowBits `
* - ` dictionary `
*
* [ http : //zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
* for more information on these .
*
* Additional options , for internal needs :
*
* - ` chunkSize ` - size of generated data chunks ( 16 K by default )
* - ` raw ` ( Boolean ) - do raw inflate
* - ` to ` ( String ) - if equal to 'string' , then result will be converted
* from utf8 to utf16 ( javascript ) string . When string output requested ,
* chunk length can differ from ` chunkSize ` , depending on content .
*
* By default , when no options set , autodetect deflate / gzip data format via
* wrapper header .
*
* # # # # # Example :
*
* ` ` ` javascript
* var pako = require ( 'pako' )
* , chunk1 = Uint8Array ( [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] )
* , chunk2 = Uint8Array ( [ 10 , 11 , 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 ] ) ;
*
* var inflate = new pako . Inflate ( { level : 3 } ) ;
*
* inflate . push ( chunk1 , false ) ;
* inflate . push ( chunk2 , true ) ; // true -> last chunk
*
* if ( inflate . err ) { throw new Error ( inflate . err ) ; }
*
* console . log ( inflate . result ) ;
* ` ` `
* * /
function Inflate ( options ) {
if ( ! ( this instanceof Inflate ) ) return new Inflate ( options ) ;
this . options = utils . assign ( {
chunkSize : 16384 ,
windowBits : 0 ,
to : ''
} , options || { } ) ;
var opt = this . options ;
// Force window size for `raw` data, if not set directly,
// because we have no header for autodetect.
if ( opt . raw && ( opt . windowBits >= 0 ) && ( opt . windowBits < 16 ) ) {
opt . windowBits = - opt . windowBits ;
if ( opt . windowBits === 0 ) { opt . windowBits = - 15 ; }
}
// If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
if ( ( opt . windowBits >= 0 ) && ( opt . windowBits < 16 ) &&
! ( options && options . windowBits ) ) {
opt . windowBits += 32 ;
}
// Gzip header has no info about windows size, we can do autodetect only
// for deflate. So, if window size not set, force it to max when gzip possible
if ( ( opt . windowBits > 15 ) && ( opt . windowBits < 48 ) ) {
// bit 3 (16) -> gzipped data
// bit 4 (32) -> autodetect gzip/deflate
if ( ( opt . windowBits & 15 ) === 0 ) {
opt . windowBits |= 15 ;
}
}
this . err = 0 ; // error code, if happens (0 = Z_OK)
this . msg = '' ; // error message
this . ended = false ; // used to avoid multiple onEnd() calls
this . chunks = [ ] ; // chunks of compressed data
this . strm = new ZStream ( ) ;
this . strm . avail _out = 0 ;
var status = zlib _inflate . inflateInit2 (
this . strm ,
opt . windowBits
) ;
if ( status !== c . Z _OK ) {
throw new Error ( msg [ status ] ) ;
}
this . header = new GZheader ( ) ;
zlib _inflate . inflateGetHeader ( this . strm , this . header ) ;
}
/ * *
* Inflate # push ( data [ , mode ] ) - > Boolean
* - data ( Uint8Array | Array | ArrayBuffer | String ) : input data
* - mode ( Number | Boolean ) : 0. . 6 for corresponding Z _NO _FLUSH . . Z _TREE modes .
* See constants . Skipped or ` false ` means Z _NO _FLUSH , ` true ` meansh Z _FINISH .
*
* Sends input data to inflate pipe , generating [ [ Inflate # onData ] ] calls with
* new output chunks . Returns ` true ` on success . The last data block must have
* mode Z _FINISH ( or ` true ` ) . That will flush internal pending buffers and call
* [ [ Inflate # onEnd ] ] . For interim explicit flushes ( without ending the stream ) you
* can use mode Z _SYNC _FLUSH , keeping the decompression context .
*
* On fail call [ [ Inflate # onEnd ] ] with error code and return false .
*
* We strongly recommend to use ` Uint8Array ` on input for best speed ( output
* format is detected automatically ) . Also , don ' t skip last param and always
* use the same type in your code ( boolean or number ) . That will improve JS speed .
*
* For regular ` Array ` - s make sure all elements are [ 0. . 255 ] .
*
* # # # # # Example
*
* ` ` ` javascript
* push ( chunk , false ) ; // push one of data chunks
* ...
* push ( chunk , true ) ; // push last chunk
* ` ` `
* * /
Inflate . prototype . push = function ( data , mode ) {
var strm = this . strm ;
var chunkSize = this . options . chunkSize ;
var dictionary = this . options . dictionary ;
var status , _mode ;
var next _out _utf8 , tail , utf8str ;
var dict ;
// Flag to properly process Z_BUF_ERROR on testing inflate call
// when we check that all output data was flushed.
var allowBufError = false ;
if ( this . ended ) { return false ; }
_mode = ( mode === ~ ~ mode ) ? mode : ( ( mode === true ) ? c . Z _FINISH : c . Z _NO _FLUSH ) ;
// Convert data if needed
if ( typeof data === 'string' ) {
// Only binary strings can be decompressed on practice
strm . input = strings . binstring2buf ( data ) ;
} else if ( toString . call ( data ) === '[object ArrayBuffer]' ) {
strm . input = new Uint8Array ( data ) ;
} else {
strm . input = data ;
}
strm . next _in = 0 ;
strm . avail _in = strm . input . length ;
do {
if ( strm . avail _out === 0 ) {
strm . output = new utils . Buf8 ( chunkSize ) ;
strm . next _out = 0 ;
strm . avail _out = chunkSize ;
}
status = zlib _inflate . inflate ( strm , c . Z _NO _FLUSH ) ; /* no bad return value */
if ( status === c . Z _NEED _DICT && dictionary ) {
// Convert data if needed
if ( typeof dictionary === 'string' ) {
dict = strings . string2buf ( dictionary ) ;
} else if ( toString . call ( dictionary ) === '[object ArrayBuffer]' ) {
dict = new Uint8Array ( dictionary ) ;
} else {
dict = dictionary ;
}
status = zlib _inflate . inflateSetDictionary ( this . strm , dict ) ;
}
if ( status === c . Z _BUF _ERROR && allowBufError === true ) {
status = c . Z _OK ;
allowBufError = false ;
}
if ( status !== c . Z _STREAM _END && status !== c . Z _OK ) {
this . onEnd ( status ) ;
this . ended = true ;
return false ;
}
if ( strm . next _out ) {
if ( strm . avail _out === 0 || status === c . Z _STREAM _END || ( strm . avail _in === 0 && ( _mode === c . Z _FINISH || _mode === c . Z _SYNC _FLUSH ) ) ) {
if ( this . options . to === 'string' ) {
next _out _utf8 = strings . utf8border ( strm . output , strm . next _out ) ;
tail = strm . next _out - next _out _utf8 ;
utf8str = strings . buf2string ( strm . output , next _out _utf8 ) ;
// move tail
strm . next _out = tail ;
strm . avail _out = chunkSize - tail ;
if ( tail ) { utils . arraySet ( strm . output , strm . output , next _out _utf8 , tail , 0 ) ; }
this . onData ( utf8str ) ;
} else {
this . onData ( utils . shrinkBuf ( strm . output , strm . next _out ) ) ;
}
}
}
// When no more input data, we should check that internal inflate buffers
// are flushed. The only way to do it when avail_out = 0 - run one more
// inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
// Here we set flag to process this error properly.
//
// NOTE. Deflate does not return error in this case and does not needs such
// logic.
if ( strm . avail _in === 0 && strm . avail _out === 0 ) {
allowBufError = true ;
}
} while ( ( strm . avail _in > 0 || strm . avail _out === 0 ) && status !== c . Z _STREAM _END ) ;
if ( status === c . Z _STREAM _END ) {
_mode = c . Z _FINISH ;
}
// Finalize on the last chunk.
if ( _mode === c . Z _FINISH ) {
status = zlib _inflate . inflateEnd ( this . strm ) ;
this . onEnd ( status ) ;
this . ended = true ;
return status === c . Z _OK ;
}
// callback interim results if Z_SYNC_FLUSH.
if ( _mode === c . Z _SYNC _FLUSH ) {
this . onEnd ( c . Z _OK ) ;
strm . avail _out = 0 ;
return true ;
}
return true ;
} ;
/ * *
* Inflate # onData ( chunk ) - > Void
* - chunk ( Uint8Array | Array | String ) : ouput data . Type of array depends
* on js engine support . When string output requested , each chunk
* will be string .
*
* By default , stores data blocks in ` chunks[] ` property and glue
* those in ` onEnd ` . Override this handler , if you need another behaviour .
* * /
Inflate . prototype . onData = function ( chunk ) {
this . chunks . push ( chunk ) ;
} ;
/ * *
* Inflate # onEnd ( status ) - > Void
* - status ( Number ) : inflate status . 0 ( Z _OK ) on success ,
* other if not .
*
* Called either after you tell inflate that the input stream is
* complete ( Z _FINISH ) or should be flushed ( Z _SYNC _FLUSH )
* or if an error happened . By default - join collected chunks ,
* free memory and fill ` results ` / ` err ` properties .
* * /
Inflate . prototype . onEnd = function ( status ) {
// On success - join
if ( status === c . Z _OK ) {
if ( this . options . to === 'string' ) {
// Glue & convert here, until we teach pako to send
// utf8 alligned strings to onData
this . result = this . chunks . join ( '' ) ;
} else {
this . result = utils . flattenChunks ( this . chunks ) ;
}
}
this . chunks = [ ] ;
this . err = status ;
this . msg = this . strm . msg ;
} ;
/ * *
* inflate ( data [ , options ] ) - > Uint8Array | Array | String
* - data ( Uint8Array | Array | String ) : input data to decompress .
* - options ( Object ) : zlib inflate options .
*
* Decompress ` data ` with inflate / ungzip and ` options ` . Autodetect
* format via wrapper header by default . That 's why we don' t provide
* separate ` ungzip ` method .
*
* Supported options are :
*
* - windowBits
*
* [ http : //zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
* for more information .
*
* Sugar ( options ) :
*
* - ` raw ` ( Boolean ) - say that we work with raw stream , if you don ' t wish to specify
* negative windowBits implicitly .
* - ` to ` ( String ) - if equal to 'string' , then result will be converted
* from utf8 to utf16 ( javascript ) string . When string output requested ,
* chunk length can differ from ` chunkSize ` , depending on content .
*
*
* # # # # # Example :
*
* ` ` ` javascript
* var pako = require ( 'pako' )
* , input = pako . deflate ( [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] )
* , output ;
*
* try {
* output = pako . inflate ( input ) ;
* } catch ( err )
* console . log ( err ) ;
* }
* ` ` `
* * /
function inflate ( input , options ) {
var inflator = new Inflate ( options ) ;
inflator . push ( input , true ) ;
// That will never happens, if you don't cheat with options :)
if ( inflator . err ) { throw inflator . msg ; }
return inflator . result ;
}
/ * *
* inflateRaw ( data [ , options ] ) - > Uint8Array | Array | String
* - data ( Uint8Array | Array | String ) : input data to decompress .
* - options ( Object ) : zlib inflate options .
*
* The same as [ [ inflate ] ] , but creates raw data , without wrapper
* ( header and adler32 crc ) .
* * /
function inflateRaw ( input , options ) {
options = options || { } ;
options . raw = true ;
return inflate ( input , options ) ;
}
/ * *
* ungzip ( data [ , options ] ) - > Uint8Array | Array | String
* - data ( Uint8Array | Array | String ) : input data to decompress .
* - options ( Object ) : zlib inflate options .
*
* Just shortcut to [ [ inflate ] ] , because it autodetects format
* by header . content . Done for convenience .
* * /
exports . Inflate = Inflate ;
exports . inflate = inflate ;
exports . inflateRaw = inflateRaw ;
exports . ungzip = inflate ;
} , { "./utils/common" : 2 , "./utils/strings" : 3 , "./zlib/constants" : 5 , "./zlib/gzheader" : 7 , "./zlib/inflate" : 9 , "./zlib/messages" : 11 , "./zlib/zstream" : 12 } ] , 2 : [ function ( require , module , exports ) {
'use strict' ;
var TYPED _OK = ( typeof Uint8Array !== 'undefined' ) &&
( typeof Uint16Array !== 'undefined' ) &&
( typeof Int32Array !== 'undefined' ) ;
exports . assign = function ( obj /*from1, from2, from3, ...*/ ) {
var sources = Array . prototype . slice . call ( arguments , 1 ) ;
while ( sources . length ) {
var source = sources . shift ( ) ;
if ( ! source ) { continue ; }
if ( typeof source !== 'object' ) {
throw new TypeError ( source + 'must be non-object' ) ;
}
for ( var p in source ) {
if ( source . hasOwnProperty ( p ) ) {
obj [ p ] = source [ p ] ;
}
}
}
return obj ;
} ;
// reduce buffer size, avoiding mem copy
exports . shrinkBuf = function ( buf , size ) {
if ( buf . length === size ) { return buf ; }
if ( buf . subarray ) { return buf . subarray ( 0 , size ) ; }
buf . length = size ;
return buf ;
} ;
var fnTyped = {
arraySet : function ( dest , src , src _offs , len , dest _offs ) {
if ( src . subarray && dest . subarray ) {
dest . set ( src . subarray ( src _offs , src _offs + len ) , dest _offs ) ;
return ;
}
// Fallback to ordinary array
for ( var i = 0 ; i < len ; i ++ ) {
dest [ dest _offs + i ] = src [ src _offs + i ] ;
}
} ,
// Join array of chunks to single array.
flattenChunks : function ( chunks ) {
var i , l , len , pos , chunk , result ;
// calculate data length
len = 0 ;
for ( i = 0 , l = chunks . length ; i < l ; i ++ ) {
len += chunks [ i ] . length ;
}
// join chunks
result = new Uint8Array ( len ) ;
pos = 0 ;
for ( i = 0 , l = chunks . length ; i < l ; i ++ ) {
chunk = chunks [ i ] ;
result . set ( chunk , pos ) ;
pos += chunk . length ;
}
return result ;
}
} ;
var fnUntyped = {
arraySet : function ( dest , src , src _offs , len , dest _offs ) {
for ( var i = 0 ; i < len ; i ++ ) {
dest [ dest _offs + i ] = src [ src _offs + i ] ;
}
} ,
// Join array of chunks to single array.
flattenChunks : function ( chunks ) {
return [ ] . concat . apply ( [ ] , chunks ) ;
}
} ;
// Enable/Disable typed arrays use, for testing
//
exports . setTyped = function ( on ) {
if ( on ) {
exports . Buf8 = Uint8Array ;
exports . Buf16 = Uint16Array ;
exports . Buf32 = Int32Array ;
exports . assign ( exports , fnTyped ) ;
} else {
exports . Buf8 = Array ;
exports . Buf16 = Array ;
exports . Buf32 = Array ;
exports . assign ( exports , fnUntyped ) ;
}
} ;
exports . setTyped ( TYPED _OK ) ;
} , { } ] , 3 : [ function ( require , module , exports ) {
// String encode/decode helpers
'use strict' ;
var utils = require ( './common' ) ;
// Quick check if we can use fast array to bin string conversion
//
// - apply(Array) can fail on Android 2.2
// - apply(Uint8Array) can fail on iOS 5.1 Safary
//
var STR _APPLY _OK = true ;
var STR _APPLY _UIA _OK = true ;
try { String . fromCharCode . apply ( null , [ 0 ] ) ; } catch ( _ _ ) { STR _APPLY _OK = false ; }
try { String . fromCharCode . apply ( null , new Uint8Array ( 1 ) ) ; } catch ( _ _ ) { STR _APPLY _UIA _OK = false ; }
// Table with utf8 lengths (calculated by first byte of sequence)
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
// because max possible codepoint is 0x10ffff
var _utf8len = new utils . Buf8 ( 256 ) ;
for ( var q = 0 ; q < 256 ; q ++ ) {
_utf8len [ q ] = ( q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1 ) ;
}
_utf8len [ 254 ] = _utf8len [ 254 ] = 1 ; // Invalid sequence start
// convert string to array (typed, when possible)
exports . string2buf = function ( str ) {
var buf , c , c2 , m _pos , i , str _len = str . length , buf _len = 0 ;
// count binary size
for ( m _pos = 0 ; m _pos < str _len ; m _pos ++ ) {
c = str . charCodeAt ( m _pos ) ;
if ( ( c & 0xfc00 ) === 0xd800 && ( m _pos + 1 < str _len ) ) {
c2 = str . charCodeAt ( m _pos + 1 ) ;
if ( ( c2 & 0xfc00 ) === 0xdc00 ) {
c = 0x10000 + ( ( c - 0xd800 ) << 10 ) + ( c2 - 0xdc00 ) ;
m _pos ++ ;
}
}
buf _len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4 ;
}
// allocate buffer
buf = new utils . Buf8 ( buf _len ) ;
// convert
for ( i = 0 , m _pos = 0 ; i < buf _len ; m _pos ++ ) {
c = str . charCodeAt ( m _pos ) ;
if ( ( c & 0xfc00 ) === 0xd800 && ( m _pos + 1 < str _len ) ) {
c2 = str . charCodeAt ( m _pos + 1 ) ;
if ( ( c2 & 0xfc00 ) === 0xdc00 ) {
c = 0x10000 + ( ( c - 0xd800 ) << 10 ) + ( c2 - 0xdc00 ) ;
m _pos ++ ;
}
}
if ( c < 0x80 ) {
/* one byte */
buf [ i ++ ] = c ;
} else if ( c < 0x800 ) {
/* two bytes */
buf [ i ++ ] = 0xC0 | ( c >>> 6 ) ;
buf [ i ++ ] = 0x80 | ( c & 0x3f ) ;
} else if ( c < 0x10000 ) {
/* three bytes */
buf [ i ++ ] = 0xE0 | ( c >>> 12 ) ;
buf [ i ++ ] = 0x80 | ( c >>> 6 & 0x3f ) ;
buf [ i ++ ] = 0x80 | ( c & 0x3f ) ;
} else {
/* four bytes */
buf [ i ++ ] = 0xf0 | ( c >>> 18 ) ;
buf [ i ++ ] = 0x80 | ( c >>> 12 & 0x3f ) ;
buf [ i ++ ] = 0x80 | ( c >>> 6 & 0x3f ) ;
buf [ i ++ ] = 0x80 | ( c & 0x3f ) ;
}
}
return buf ;
} ;
// Helper (used in 2 places)
function buf2binstring ( buf , len ) {
// use fallback for big arrays to avoid stack overflow
if ( len < 65537 ) {
if ( ( buf . subarray && STR _APPLY _UIA _OK ) || ( ! buf . subarray && STR _APPLY _OK ) ) {
return String . fromCharCode . apply ( null , utils . shrinkBuf ( buf , len ) ) ;
}
}
var result = '' ;
for ( var i = 0 ; i < len ; i ++ ) {
result += String . fromCharCode ( buf [ i ] ) ;
}
return result ;
}
// Convert byte array to binary string
exports . buf2binstring = function ( buf ) {
return buf2binstring ( buf , buf . length ) ;
} ;
// Convert binary string (typed, when possible)
exports . binstring2buf = function ( str ) {
var buf = new utils . Buf8 ( str . length ) ;
for ( var i = 0 , len = buf . length ; i < len ; i ++ ) {
buf [ i ] = str . charCodeAt ( i ) ;
}
return buf ;
} ;
// convert array to string
exports . buf2string = function ( buf , max ) {
var i , out , c , c _len ;
var len = max || buf . length ;
// Reserve max possible length (2 words per char)
// NB: by unknown reasons, Array is significantly faster for
// String.fromCharCode.apply than Uint16Array.
var utf16buf = new Array ( len * 2 ) ;
for ( out = 0 , i = 0 ; i < len ; ) {
c = buf [ i ++ ] ;
// quick process ascii
if ( c < 0x80 ) { utf16buf [ out ++ ] = c ; continue ; }
c _len = _utf8len [ c ] ;
// skip 5 & 6 byte codes
if ( c _len > 4 ) { utf16buf [ out ++ ] = 0xfffd ; i += c _len - 1 ; continue ; }
// apply mask on first byte
c &= c _len === 2 ? 0x1f : c _len === 3 ? 0x0f : 0x07 ;
// join the rest
while ( c _len > 1 && i < len ) {
c = ( c << 6 ) | ( buf [ i ++ ] & 0x3f ) ;
c _len -- ;
}
// terminated by end of string?
if ( c _len > 1 ) { utf16buf [ out ++ ] = 0xfffd ; continue ; }
if ( c < 0x10000 ) {
utf16buf [ out ++ ] = c ;
} else {
c -= 0x10000 ;
utf16buf [ out ++ ] = 0xd800 | ( ( c >> 10 ) & 0x3ff ) ;
utf16buf [ out ++ ] = 0xdc00 | ( c & 0x3ff ) ;
}
}
return buf2binstring ( utf16buf , out ) ;
} ;
// Calculate max possible position in utf8 buffer,
// that will not break sequence. If that's not possible
// - (very small limits) return max size as is.
//
// buf[] - utf8 bytes array
// max - length limit (mandatory);
exports . utf8border = function ( buf , max ) {
var pos ;
max = max || buf . length ;
if ( max > buf . length ) { max = buf . length ; }
// go back from last position, until start of sequence found
pos = max - 1 ;
while ( pos >= 0 && ( buf [ pos ] & 0xC0 ) === 0x80 ) { pos -- ; }
// Fuckup - very small and broken sequence,
// return max, because we should return something anyway.
if ( pos < 0 ) { return max ; }
// If we came to start of buffer - that means vuffer is too small,
// return max too.
if ( pos === 0 ) { return max ; }
return ( pos + _utf8len [ buf [ pos ] ] > max ) ? pos : max ;
} ;
} , { "./common" : 2 } ] , 4 : [ function ( require , module , exports ) {
'use strict' ;
// Note: adler32 takes 12% for level 0 and 2% for level 6.
// It doesn't worth to make additional optimizationa as in original.
// Small size is preferable.
function adler32 ( adler , buf , len , pos ) {
var s1 = ( adler & 0xffff ) | 0 ,
s2 = ( ( adler >>> 16 ) & 0xffff ) | 0 ,
n = 0 ;
while ( len !== 0 ) {
// Set limit ~ twice less than 5552, to keep
// s2 in 31-bits, because we force signed ints.
// in other case %= will fail.
n = len > 2000 ? 2000 : len ;
len -= n ;
do {
s1 = ( s1 + buf [ pos ++ ] ) | 0 ;
s2 = ( s2 + s1 ) | 0 ;
} while ( -- n ) ;
s1 %= 65521 ;
s2 %= 65521 ;
}
return ( s1 | ( s2 << 16 ) ) | 0 ;
}
module . exports = adler32 ;
} , { } ] , 5 : [ function ( require , module , exports ) {
'use strict' ;
module . exports = {
/* Allowed flush values; see deflate() and inflate() below for details */
Z _NO _FLUSH : 0 ,
Z _PARTIAL _FLUSH : 1 ,
Z _SYNC _FLUSH : 2 ,
Z _FULL _FLUSH : 3 ,
Z _FINISH : 4 ,
Z _BLOCK : 5 ,
Z _TREES : 6 ,
/ * R e t u r n c o d e s f o r t h e c o m p r e s s i o n / d e c o m p r e s s i o n f u n c t i o n s . N e g a t i v e v a l u e s
* are errors , positive values are used for special but normal events .
* /
Z _OK : 0 ,
Z _STREAM _END : 1 ,
Z _NEED _DICT : 2 ,
Z _ERRNO : - 1 ,
Z _STREAM _ERROR : - 2 ,
Z _DATA _ERROR : - 3 ,
//Z_MEM_ERROR: -4,
Z _BUF _ERROR : - 5 ,
//Z_VERSION_ERROR: -6,
/* compression levels */
Z _NO _COMPRESSION : 0 ,
Z _BEST _SPEED : 1 ,
Z _BEST _COMPRESSION : 9 ,
Z _DEFAULT _COMPRESSION : - 1 ,
Z _FILTERED : 1 ,
Z _HUFFMAN _ONLY : 2 ,
Z _RLE : 3 ,
Z _FIXED : 4 ,
Z _DEFAULT _STRATEGY : 0 ,
/* Possible values of the data_type field (though see inflate()) */
Z _BINARY : 0 ,
Z _TEXT : 1 ,
//Z_ASCII: 1, // = Z_TEXT (deprecated)
Z _UNKNOWN : 2 ,
/* The deflate compression method */
Z _DEFLATED : 8
//Z_NULL: null // Use -1 or null inline, depending on var type
} ;
} , { } ] , 6 : [ function ( require , module , exports ) {
'use strict' ;
// Note: we can't get significant speed boost here.
// So write code to minimize size - no pregenerated tables
// and array tools dependencies.
// Use ordinary array, since untyped makes no boost here
function makeTable ( ) {
var c , table = [ ] ;
for ( var n = 0 ; n < 256 ; n ++ ) {
c = n ;
for ( var k = 0 ; k < 8 ; k ++ ) {
c = ( ( c & 1 ) ? ( 0xEDB88320 ^ ( c >>> 1 ) ) : ( c >>> 1 ) ) ;
}
table [ n ] = c ;
}
return table ;
}
// Create table on load. Just 255 signed longs. Not a problem.
var crcTable = makeTable ( ) ;
function crc32 ( crc , buf , len , pos ) {
var t = crcTable ,
end = pos + len ;
crc ^= - 1 ;
for ( var i = pos ; i < end ; i ++ ) {
crc = ( crc >>> 8 ) ^ t [ ( crc ^ buf [ i ] ) & 0xFF ] ;
}
return ( crc ^ ( - 1 ) ) ; // >>> 0;
}
module . exports = crc32 ;
} , { } ] , 7 : [ function ( require , module , exports ) {
'use strict' ;
function GZheader ( ) {
/* true if compressed data believed to be text */
this . text = 0 ;
/* modification time */
this . time = 0 ;
/* extra flags (not used when writing a gzip file) */
this . xflags = 0 ;
/* operating system */
this . os = 0 ;
/* pointer to extra field or Z_NULL if none */
this . extra = null ;
/* extra field length (valid if extra != Z_NULL) */
this . extra _len = 0 ; // Actually, we don't need it in JS,
// but leave for few code modifications
//
// Setup limits is not necessary because in js we should not preallocate memory
// for inflate use constant limit in 65536 bytes
//
/* space at extra (only when reading header) */
// this.extra_max = 0;
/* pointer to zero-terminated file name or Z_NULL */
this . name = '' ;
/* space at name (only when reading header) */
// this.name_max = 0;
/* pointer to zero-terminated comment or Z_NULL */
this . comment = '' ;
/* space at comment (only when reading header) */
// this.comm_max = 0;
/* true if there was or will be a header crc */
this . hcrc = 0 ;
/* true when done reading gzip header (not used when writing a gzip file) */
this . done = false ;
}
module . exports = GZheader ;
} , { } ] , 8 : [ function ( require , module , exports ) {
'use strict' ;
// See state defs from inflate.js
var BAD = 30 ; /* got a data error -- remain here until reset */
var TYPE = 12 ; /* i: waiting for type bits, including last-flag bit */
/ *
Decode literal , length , and distance codes and write out the resulting
literal and match bytes until either not enough input or output is
available , an end - of - block is encountered , or a data error is encountered .
When large enough input and output buffers are supplied to inflate ( ) , for
example , a 16 K input buffer and a 64 K output buffer , more than 95 % of the
inflate execution time is spent in this routine .
Entry assumptions :
state . mode === LEN
strm . avail _in >= 6
strm . avail _out >= 258
start >= strm . avail _out
state . bits < 8
On return , state . mode is one of :
LEN -- ran out of enough output space or enough available input
TYPE -- reached end of block code , inflate ( ) to interpret next block
BAD -- error in block data
Notes :
- The maximum input bits used by a length / distance pair is 15 bits for the
length code , 5 bits for the length extra , 15 bits for the distance code ,
and 13 bits for the distance extra . This totals 48 bits , or six bytes .
Therefore if strm . avail _in >= 6 , then there is enough input to avoid
checking for available input while decoding .
- The maximum bytes that a single length / distance pair can output is 258
bytes , which is the maximum length that can be coded . inflate _fast ( )
requires strm . avail _out >= 258 for each loop to avoid checking for
output space .
* /
module . exports = function inflate _fast ( strm , start ) {
var state ;
var _in ; /* local strm.input */
var last ; /* have enough input while in < last */
var _out ; /* local strm.output */
var beg ; /* inflate()'s initial strm.output */
var end ; /* while out < end, enough space available */
//#ifdef INFLATE_STRICT
var dmax ; /* maximum distance from zlib header */
//#endif
var wsize ; /* window size or zero if not using window */
var whave ; /* valid bytes in the window */
var wnext ; /* window write index */
// Use `s_window` instead `window`, avoid conflict with instrumentation tools
var s _window ; /* allocated sliding window, if wsize != 0 */
var hold ; /* local strm.hold */
var bits ; /* local strm.bits */
var lcode ; /* local strm.lencode */
var dcode ; /* local strm.distcode */
var lmask ; /* mask for first level of length codes */
var dmask ; /* mask for first level of distance codes */
var here ; /* retrieved table entry */
var op ; /* code bits, operation, extra bits, or */
/* window position, window bytes to copy */
var len ; /* match length, unused bytes */
var dist ; /* match distance */
var from ; /* where to copy match from */
var from _source ;
var input , output ; // JS specific, because we have no pointers
/* copy state to local variables */
state = strm . state ;
//here = state.here;
_in = strm . next _in ;
input = strm . input ;
last = _in + ( strm . avail _in - 5 ) ;
_out = strm . next _out ;
output = strm . output ;
beg = _out - ( start - strm . avail _out ) ;
end = _out + ( strm . avail _out - 257 ) ;
//#ifdef INFLATE_STRICT
dmax = state . dmax ;
//#endif
wsize = state . wsize ;
whave = state . whave ;
wnext = state . wnext ;
s _window = state . window ;
hold = state . hold ;
bits = state . bits ;
lcode = state . lencode ;
dcode = state . distcode ;
lmask = ( 1 << state . lenbits ) - 1 ;
dmask = ( 1 << state . distbits ) - 1 ;
/ * d e c o d e l i t e r a l s a n d l e n g t h / d i s t a n c e s u n t i l e n d - o f - b l o c k o r n o t e n o u g h
input data or output space * /
top :
do {
if ( bits < 15 ) {
hold += input [ _in ++ ] << bits ;
bits += 8 ;
hold += input [ _in ++ ] << bits ;
bits += 8 ;
}
here = lcode [ hold & lmask ] ;
dolen :
for ( ; ; ) { // Goto emulation
op = here >>> 24 /*here.bits*/ ;
hold >>>= op ;
bits -= op ;
op = ( here >>> 16 ) & 0xff /*here.op*/ ;
if ( op === 0 ) { /* literal */
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
// "inflate: literal '%c'\n" :
// "inflate: literal 0x%02x\n", here.val));
output [ _out ++ ] = here & 0xffff /*here.val*/ ;
}
else if ( op & 16 ) { /* length base */
len = here & 0xffff /*here.val*/ ;
op &= 15 ; /* number of extra bits */
if ( op ) {
if ( bits < op ) {
hold += input [ _in ++ ] << bits ;
bits += 8 ;
}
len += hold & ( ( 1 << op ) - 1 ) ;
hold >>>= op ;
bits -= op ;
}
//Tracevv((stderr, "inflate: length %u\n", len));
if ( bits < 15 ) {
hold += input [ _in ++ ] << bits ;
bits += 8 ;
hold += input [ _in ++ ] << bits ;
bits += 8 ;
}
here = dcode [ hold & dmask ] ;
dodist :
for ( ; ; ) { // goto emulation
op = here >>> 24 /*here.bits*/ ;
hold >>>= op ;
bits -= op ;
op = ( here >>> 16 ) & 0xff /*here.op*/ ;
if ( op & 16 ) { /* distance base */
dist = here & 0xffff /*here.val*/ ;
op &= 15 ; /* number of extra bits */
if ( bits < op ) {
hold += input [ _in ++ ] << bits ;
bits += 8 ;
if ( bits < op ) {
hold += input [ _in ++ ] << bits ;
bits += 8 ;
}
}
dist += hold & ( ( 1 << op ) - 1 ) ;
//#ifdef INFLATE_STRICT
if ( dist > dmax ) {
strm . msg = 'invalid distance too far back' ;
state . mode = BAD ;
break top ;
}
//#endif
hold >>>= op ;
bits -= op ;
//Tracevv((stderr, "inflate: distance %u\n", dist));
op = _out - beg ; /* max distance in output */
if ( dist > op ) { /* see if copy from window */
op = dist - op ; /* distance back in window */
if ( op > whave ) {
if ( state . sane ) {
strm . msg = 'invalid distance too far back' ;
state . mode = BAD ;
break top ;
}
// (!) This block is disabled in zlib defailts,
// don't enable it for binary compatibility
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
// if (len <= op - whave) {
// do {
// output[_out++] = 0;
// } while (--len);
// continue top;
// }
// len -= op - whave;
// do {
// output[_out++] = 0;
// } while (--op > whave);
// if (op === 0) {
// from = _out - dist;
// do {
// output[_out++] = output[from++];
// } while (--len);
// continue top;
// }
//#endif
}
from = 0 ; // window index
from _source = s _window ;
if ( wnext === 0 ) { /* very common case */
from += wsize - op ;
if ( op < len ) { /* some from window */
len -= op ;
do {
output [ _out ++ ] = s _window [ from ++ ] ;
} while ( -- op ) ;
from = _out - dist ; /* rest from output */
from _source = output ;
}
}
else if ( wnext < op ) { /* wrap around window */
from += wsize + wnext - op ;
op -= wnext ;
if ( op < len ) { /* some from end of window */
len -= op ;
do {
output [ _out ++ ] = s _window [ from ++ ] ;
} while ( -- op ) ;
from = 0 ;
if ( wnext < len ) { /* some from start of window */
op = wnext ;
len -= op ;
do {
output [ _out ++ ] = s _window [ from ++ ] ;
} while ( -- op ) ;
from = _out - dist ; /* rest from output */
from _source = output ;
}
}
}
else { /* contiguous in window */
from += wnext - op ;
if ( op < len ) { /* some from window */
len -= op ;
do {
output [ _out ++ ] = s _window [ from ++ ] ;
} while ( -- op ) ;
from = _out - dist ; /* rest from output */
from _source = output ;
}
}
while ( len > 2 ) {
output [ _out ++ ] = from _source [ from ++ ] ;
output [ _out ++ ] = from _source [ from ++ ] ;
output [ _out ++ ] = from _source [ from ++ ] ;
len -= 3 ;
}
if ( len ) {
output [ _out ++ ] = from _source [ from ++ ] ;
if ( len > 1 ) {
output [ _out ++ ] = from _source [ from ++ ] ;
}
}
}
else {
from = _out - dist ; /* copy direct from output */
do { /* minimum length is three */
output [ _out ++ ] = output [ from ++ ] ;
output [ _out ++ ] = output [ from ++ ] ;
output [ _out ++ ] = output [ from ++ ] ;
len -= 3 ;
} while ( len > 2 ) ;
if ( len ) {
output [ _out ++ ] = output [ from ++ ] ;
if ( len > 1 ) {
output [ _out ++ ] = output [ from ++ ] ;
}
}
}
}
else if ( ( op & 64 ) === 0 ) { /* 2nd level distance code */
here = dcode [ ( here & 0xffff ) /*here.val*/ + ( hold & ( ( 1 << op ) - 1 ) ) ] ;
continue dodist ;
}
else {
strm . msg = 'invalid distance code' ;
state . mode = BAD ;
break top ;
}
break ; // need to emulate goto via "continue"
}
}
else if ( ( op & 64 ) === 0 ) { /* 2nd level length code */
here = lcode [ ( here & 0xffff ) /*here.val*/ + ( hold & ( ( 1 << op ) - 1 ) ) ] ;
continue dolen ;
}
else if ( op & 32 ) { /* end-of-block */
//Tracevv((stderr, "inflate: end of block\n"));
state . mode = TYPE ;
break top ;
}
else {
strm . msg = 'invalid literal/length code' ;
state . mode = BAD ;
break top ;
}
break ; // need to emulate goto via "continue"
}
} while ( _in < last && _out < end ) ;
/* return unused bytes (on entry, bits < 8, so in won't go too far back) */
len = bits >> 3 ;
_in -= len ;
bits -= len << 3 ;
hold &= ( 1 << bits ) - 1 ;
/* update state and return */
strm . next _in = _in ;
strm . next _out = _out ;
strm . avail _in = ( _in < last ? 5 + ( last - _in ) : 5 - ( _in - last ) ) ;
strm . avail _out = ( _out < end ? 257 + ( end - _out ) : 257 - ( _out - end ) ) ;
state . hold = hold ;
state . bits = bits ;
return ;
} ;
} , { } ] , 9 : [ function ( require , module , exports ) {
'use strict' ;
var utils = require ( '../utils/common' ) ;
var adler32 = require ( './adler32' ) ;
var crc32 = require ( './crc32' ) ;
var inflate _fast = require ( './inffast' ) ;
var inflate _table = require ( './inftrees' ) ;
var CODES = 0 ;
var LENS = 1 ;
var DISTS = 2 ;
/* Public constants ==========================================================*/
/* ===========================================================================*/
/* Allowed flush values; see deflate() and inflate() below for details */
//var Z_NO_FLUSH = 0;
//var Z_PARTIAL_FLUSH = 1;
//var Z_SYNC_FLUSH = 2;
//var Z_FULL_FLUSH = 3;
var Z _FINISH = 4 ;
var Z _BLOCK = 5 ;
var Z _TREES = 6 ;
/ * R e t u r n c o d e s f o r t h e c o m p r e s s i o n / d e c o m p r e s s i o n f u n c t i o n s . N e g a t i v e v a l u e s
* are errors , positive values are used for special but normal events .
* /
var Z _OK = 0 ;
var Z _STREAM _END = 1 ;
var Z _NEED _DICT = 2 ;
//var Z_ERRNO = -1;
var Z _STREAM _ERROR = - 2 ;
var Z _DATA _ERROR = - 3 ;
var Z _MEM _ERROR = - 4 ;
var Z _BUF _ERROR = - 5 ;
//var Z_VERSION_ERROR = -6;
/* The deflate compression method */
var Z _DEFLATED = 8 ;
/* STATES ====================================================================*/
/* ===========================================================================*/
var HEAD = 1 ; /* i: waiting for magic header */
var FLAGS = 2 ; /* i: waiting for method and flags (gzip) */
var TIME = 3 ; /* i: waiting for modification time (gzip) */
var OS = 4 ; /* i: waiting for extra flags and operating system (gzip) */
var EXLEN = 5 ; /* i: waiting for extra length (gzip) */
var EXTRA = 6 ; /* i: waiting for extra bytes (gzip) */
var NAME = 7 ; /* i: waiting for end of file name (gzip) */
var COMMENT = 8 ; /* i: waiting for end of comment (gzip) */
var HCRC = 9 ; /* i: waiting for header crc (gzip) */
var DICTID = 10 ; /* i: waiting for dictionary check value */
var DICT = 11 ; /* waiting for inflateSetDictionary() call */
var TYPE = 12 ; /* i: waiting for type bits, including last-flag bit */
var TYPEDO = 13 ; /* i: same, but skip check to exit inflate on new block */
var STORED = 14 ; /* i: waiting for stored size (length and complement) */
var COPY _ = 15 ; /* i/o: same as COPY below, but only first time in */
var COPY = 16 ; /* i/o: waiting for input or output to copy stored block */
var TABLE = 17 ; /* i: waiting for dynamic block table lengths */
var LENLENS = 18 ; /* i: waiting for code length code lengths */
var CODELENS = 19 ; /* i: waiting for length/lit and distance code lengths */
var LEN _ = 20 ; /* i: same as LEN below, but only first time in */
var LEN = 21 ; /* i: waiting for length/lit/eob code */
var LENEXT = 22 ; /* i: waiting for length extra bits */
var DIST = 23 ; /* i: waiting for distance code */
var DISTEXT = 24 ; /* i: waiting for distance extra bits */
var MATCH = 25 ; /* o: waiting for output space to copy string */
var LIT = 26 ; /* o: waiting for output space to write literal */
var CHECK = 27 ; /* i: waiting for 32-bit check value */
var LENGTH = 28 ; /* i: waiting for 32-bit length (gzip) */
var DONE = 29 ; /* finished check, done -- remain here until reset */
var BAD = 30 ; /* got a data error -- remain here until reset */
var MEM = 31 ; /* got an inflate() memory error -- remain here until reset */
var SYNC = 32 ; /* looking for synchronization bytes to restart inflate() */
/* ===========================================================================*/
var ENOUGH _LENS = 852 ;
var ENOUGH _DISTS = 592 ;
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
var MAX _WBITS = 15 ;
/* 32K LZ77 window */
var DEF _WBITS = MAX _WBITS ;
function zswap32 ( q ) {
return ( ( ( q >>> 24 ) & 0xff ) +
( ( q >>> 8 ) & 0xff00 ) +
( ( q & 0xff00 ) << 8 ) +
( ( q & 0xff ) << 24 ) ) ;
}
function InflateState ( ) {
this . mode = 0 ; /* current inflate mode */
this . last = false ; /* true if processing last block */
this . wrap = 0 ; /* bit 0 true for zlib, bit 1 true for gzip */
this . havedict = false ; /* true if dictionary provided */
this . flags = 0 ; /* gzip header method and flags (0 if zlib) */
this . dmax = 0 ; /* zlib header max distance (INFLATE_STRICT) */
this . check = 0 ; /* protected copy of check value */
this . total = 0 ; /* protected copy of output count */
// TODO: may be {}
this . head = null ; /* where to save gzip header information */
/* sliding window */
this . wbits = 0 ; /* log base 2 of requested window size */
this . wsize = 0 ; /* window size or zero if not using window */
this . whave = 0 ; /* valid bytes in the window */
this . wnext = 0 ; /* window write index */
this . window = null ; /* allocated sliding window, if needed */
/* bit accumulator */
this . hold = 0 ; /* input bit accumulator */
this . bits = 0 ; /* number of bits in "in" */
/* for string and stored block copying */
this . length = 0 ; /* literal or length of data to copy */
this . offset = 0 ; /* distance back to copy string from */
/* for table and code decoding */
this . extra = 0 ; /* extra bits needed */
/* fixed and dynamic code tables */
this . lencode = null ; /* starting table for length/literal codes */
this . distcode = null ; /* starting table for distance codes */
this . lenbits = 0 ; /* index bits for lencode */
this . distbits = 0 ; /* index bits for distcode */
/* dynamic table building */
this . ncode = 0 ; /* number of code length code lengths */
this . nlen = 0 ; /* number of length code lengths */
this . ndist = 0 ; /* number of distance code lengths */
this . have = 0 ; /* number of code lengths in lens[] */
this . next = null ; /* next available space in codes[] */
this . lens = new utils . Buf16 ( 320 ) ; /* temporary storage for code lengths */
this . work = new utils . Buf16 ( 288 ) ; /* work area for code table building */
/ *
because we don ' t have pointers in js , we use lencode and distcode directly
as buffers so we don ' t need codes
* /
//this.codes = new utils.Buf32(ENOUGH); /* space for code tables */
this . lendyn = null ; /* dynamic table for length/literal codes (JS specific) */
this . distdyn = null ; /* dynamic table for distance codes (JS specific) */
this . sane = 0 ; /* if false, allow invalid distance too far */
this . back = 0 ; /* bits back of last unprocessed length/lit */
this . was = 0 ; /* initial length of match */
}
function inflateResetKeep ( strm ) {
var state ;
if ( ! strm || ! strm . state ) { return Z _STREAM _ERROR ; }
state = strm . state ;
strm . total _in = strm . total _out = state . total = 0 ;
strm . msg = '' ; /*Z_NULL*/
if ( state . wrap ) { /* to support ill-conceived Java test suite */
strm . adler = state . wrap & 1 ;
}
state . mode = HEAD ;
state . last = 0 ;
state . havedict = 0 ;
state . dmax = 32768 ;
state . head = null /*Z_NULL*/ ;
state . hold = 0 ;
state . bits = 0 ;
//state.lencode = state.distcode = state.next = state.codes;
state . lencode = state . lendyn = new utils . Buf32 ( ENOUGH _LENS ) ;
state . distcode = state . distdyn = new utils . Buf32 ( ENOUGH _DISTS ) ;
state . sane = 1 ;
state . back = - 1 ;
//Tracev((stderr, "inflate: reset\n"));
return Z _OK ;
}
function inflateReset ( strm ) {
var state ;
if ( ! strm || ! strm . state ) { return Z _STREAM _ERROR ; }
state = strm . state ;
state . wsize = 0 ;
state . whave = 0 ;
state . wnext = 0 ;
return inflateResetKeep ( strm ) ;
}
function inflateReset2 ( strm , windowBits ) {
var wrap ;
var state ;
/* get the state */
if ( ! strm || ! strm . state ) { return Z _STREAM _ERROR ; }
state = strm . state ;
/* extract wrap request from windowBits parameter */
if ( windowBits < 0 ) {
wrap = 0 ;
windowBits = - windowBits ;
}
else {
wrap = ( windowBits >> 4 ) + 1 ;
if ( windowBits < 48 ) {
windowBits &= 15 ;
}
}
/* set number of window bits, free window if different */
if ( windowBits && ( windowBits < 8 || windowBits > 15 ) ) {
return Z _STREAM _ERROR ;
}
if ( state . window !== null && state . wbits !== windowBits ) {
state . window = null ;
}
/* update state and reset the rest of it */
state . wrap = wrap ;
state . wbits = windowBits ;
return inflateReset ( strm ) ;
}
function inflateInit2 ( strm , windowBits ) {
var ret ;
var state ;
if ( ! strm ) { return Z _STREAM _ERROR ; }
//strm.msg = Z_NULL; /* in case we return an error */
state = new InflateState ( ) ;
//if (state === Z_NULL) return Z_MEM_ERROR;
//Tracev((stderr, "inflate: allocated\n"));
strm . state = state ;
state . window = null /*Z_NULL*/ ;
ret = inflateReset2 ( strm , windowBits ) ;
if ( ret !== Z _OK ) {
strm . state = null /*Z_NULL*/ ;
}
return ret ;
}
function inflateInit ( strm ) {
return inflateInit2 ( strm , DEF _WBITS ) ;
}
/ *
Return state with length and distance decoding tables and index sizes set to
fixed code decoding . Normally this returns fixed tables from inffixed . h .
If BUILDFIXED is defined , then instead this routine builds the tables the
first time it ' s called , and returns those tables the first time and
thereafter . This reduces the size of the code by about 2 K bytes , in
exchange for a little execution time . However , BUILDFIXED should not be
used for threaded applications , since the rewriting of the tables and virgin
may not be thread - safe .
* /
var virgin = true ;
var lenfix , distfix ; // We have no pointers in JS, so keep tables separate
function fixedtables ( state ) {
/* build fixed huffman tables if first call (may not be thread safe) */
if ( virgin ) {
var sym ;
lenfix = new utils . Buf32 ( 512 ) ;
distfix = new utils . Buf32 ( 32 ) ;
/* literal/length table */
sym = 0 ;
while ( sym < 144 ) { state . lens [ sym ++ ] = 8 ; }
while ( sym < 256 ) { state . lens [ sym ++ ] = 9 ; }
while ( sym < 280 ) { state . lens [ sym ++ ] = 7 ; }
while ( sym < 288 ) { state . lens [ sym ++ ] = 8 ; }
inflate _table ( LENS , state . lens , 0 , 288 , lenfix , 0 , state . work , { bits : 9 } ) ;
/* distance table */
sym = 0 ;
while ( sym < 32 ) { state . lens [ sym ++ ] = 5 ; }
inflate _table ( DISTS , state . lens , 0 , 32 , distfix , 0 , state . work , { bits : 5 } ) ;
/* do this just once */
virgin = false ;
}
state . lencode = lenfix ;
state . lenbits = 9 ;
state . distcode = distfix ;
state . distbits = 5 ;
}
/ *
Update the window with the last wsize ( normally 32 K ) bytes written before
returning . If window does not exist yet , create it . This is only called
when a window is already in use , or when output has been written during this
inflate call , but the end of the deflate stream has not been reached yet .
It is also called to create a window for dictionary data when a dictionary
is loaded .
Providing output buffers larger than 32 K to inflate ( ) should provide a speed
advantage , since only the last 32 K of output is copied to the sliding window
upon return from inflate ( ) , and since all distances after the first 32 K of
output will fall in the output data , making match copies simpler and faster .
The advantage may be dependent on the size of the processor ' s data caches .
* /
function updatewindow ( strm , src , end , copy ) {
var dist ;
var state = strm . state ;
/* if it hasn't been done already, allocate space for the window */
if ( state . window === null ) {
state . wsize = 1 << state . wbits ;
state . wnext = 0 ;
state . whave = 0 ;
state . window = new utils . Buf8 ( state . wsize ) ;
}
/* copy state->wsize or less output bytes into the circular window */
if ( copy >= state . wsize ) {
utils . arraySet ( state . window , src , end - state . wsize , state . wsize , 0 ) ;
state . wnext = 0 ;
state . whave = state . wsize ;
}
else {
dist = state . wsize - state . wnext ;
if ( dist > copy ) {
dist = copy ;
}
//zmemcpy(state->window + state->wnext, end - copy, dist);
utils . arraySet ( state . window , src , end - copy , dist , state . wnext ) ;
copy -= dist ;
if ( copy ) {
//zmemcpy(state->window, end - copy, copy);
utils . arraySet ( state . window , src , end - copy , copy , 0 ) ;
state . wnext = copy ;
state . whave = state . wsize ;
}
else {
state . wnext += dist ;
if ( state . wnext === state . wsize ) { state . wnext = 0 ; }
if ( state . whave < state . wsize ) { state . whave += dist ; }
}
}
return 0 ;
}
function inflate ( strm , flush ) {
var state ;
var input , output ; // input/output buffers
var next ; /* next input INDEX */
var put ; /* next output INDEX */
var have , left ; /* available input and output */
var hold ; /* bit buffer */
var bits ; /* bits in bit buffer */
var _in , _out ; /* save starting available input and output */
var copy ; /* number of stored or match bytes to copy */
var from ; /* where to copy match bytes from */
var from _source ;
var here = 0 ; /* current decoding table entry */
var here _bits , here _op , here _val ; // paked "here" denormalized (JS specific)
//var last; /* parent table entry */
var last _bits , last _op , last _val ; // paked "last" denormalized (JS specific)
var len ; /* length to copy for repeats, bits to drop */
var ret ; /* return code */
var hbuf = new utils . Buf8 ( 4 ) ; /* buffer for gzip header crc calculation */
var opts ;
var n ; // temporary var for NEED_BITS
var order = /* permutation of code lengths */
[ 16 , 17 , 18 , 0 , 8 , 7 , 9 , 6 , 10 , 5 , 11 , 4 , 12 , 3 , 13 , 2 , 14 , 1 , 15 ] ;
if ( ! strm || ! strm . state || ! strm . output ||
( ! strm . input && strm . avail _in !== 0 ) ) {
return Z _STREAM _ERROR ;
}
state = strm . state ;
if ( state . mode === TYPE ) { state . mode = TYPEDO ; } /* skip check */
//--- LOAD() ---
put = strm . next _out ;
output = strm . output ;
left = strm . avail _out ;
next = strm . next _in ;
input = strm . input ;
have = strm . avail _in ;
hold = state . hold ;
bits = state . bits ;
//---
_in = have ;
_out = left ;
ret = Z _OK ;
inf _leave : // goto emulation
for ( ; ; ) {
switch ( state . mode ) {
case HEAD :
if ( state . wrap === 0 ) {
state . mode = TYPEDO ;
break ;
}
//=== NEEDBITS(16);
while ( bits < 16 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
if ( ( state . wrap & 2 ) && hold === 0x8b1f ) { /* gzip header */
state . check = 0 /*crc32(0L, Z_NULL, 0)*/ ;
//=== CRC2(state.check, hold);
hbuf [ 0 ] = hold & 0xff ;
hbuf [ 1 ] = ( hold >>> 8 ) & 0xff ;
state . check = crc32 ( state . check , hbuf , 2 , 0 ) ;
//===//
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
state . mode = FLAGS ;
break ;
}
state . flags = 0 ; /* expect zlib header */
if ( state . head ) {
state . head . done = false ;
}
if ( ! ( state . wrap & 1 ) || /* check if zlib header allowed */
( ( ( hold & 0xff ) /*BITS(8)*/ << 8 ) + ( hold >> 8 ) ) % 31 ) {
strm . msg = 'incorrect header check' ;
state . mode = BAD ;
break ;
}
if ( ( hold & 0x0f ) /*BITS(4)*/ !== Z _DEFLATED ) {
strm . msg = 'unknown compression method' ;
state . mode = BAD ;
break ;
}
//--- DROPBITS(4) ---//
hold >>>= 4 ;
bits -= 4 ;
//---//
len = ( hold & 0x0f ) /*BITS(4)*/ + 8 ;
if ( state . wbits === 0 ) {
state . wbits = len ;
}
else if ( len > state . wbits ) {
strm . msg = 'invalid window size' ;
state . mode = BAD ;
break ;
}
state . dmax = 1 << len ;
//Tracev((stderr, "inflate: zlib header ok\n"));
strm . adler = state . check = 1 /*adler32(0L, Z_NULL, 0)*/ ;
state . mode = hold & 0x200 ? DICTID : TYPE ;
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
break ;
case FLAGS :
//=== NEEDBITS(16); */
while ( bits < 16 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . flags = hold ;
if ( ( state . flags & 0xff ) !== Z _DEFLATED ) {
strm . msg = 'unknown compression method' ;
state . mode = BAD ;
break ;
}
if ( state . flags & 0xe000 ) {
strm . msg = 'unknown header flags set' ;
state . mode = BAD ;
break ;
}
if ( state . head ) {
state . head . text = ( ( hold >> 8 ) & 1 ) ;
}
if ( state . flags & 0x0200 ) {
//=== CRC2(state.check, hold);
hbuf [ 0 ] = hold & 0xff ;
hbuf [ 1 ] = ( hold >>> 8 ) & 0xff ;
state . check = crc32 ( state . check , hbuf , 2 , 0 ) ;
//===//
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
state . mode = TIME ;
/* falls through */
case TIME :
//=== NEEDBITS(32); */
while ( bits < 32 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
if ( state . head ) {
state . head . time = hold ;
}
if ( state . flags & 0x0200 ) {
//=== CRC4(state.check, hold)
hbuf [ 0 ] = hold & 0xff ;
hbuf [ 1 ] = ( hold >>> 8 ) & 0xff ;
hbuf [ 2 ] = ( hold >>> 16 ) & 0xff ;
hbuf [ 3 ] = ( hold >>> 24 ) & 0xff ;
state . check = crc32 ( state . check , hbuf , 4 , 0 ) ;
//===
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
state . mode = OS ;
/* falls through */
case OS :
//=== NEEDBITS(16); */
while ( bits < 16 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
if ( state . head ) {
state . head . xflags = ( hold & 0xff ) ;
state . head . os = ( hold >> 8 ) ;
}
if ( state . flags & 0x0200 ) {
//=== CRC2(state.check, hold);
hbuf [ 0 ] = hold & 0xff ;
hbuf [ 1 ] = ( hold >>> 8 ) & 0xff ;
state . check = crc32 ( state . check , hbuf , 2 , 0 ) ;
//===//
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
state . mode = EXLEN ;
/* falls through */
case EXLEN :
if ( state . flags & 0x0400 ) {
//=== NEEDBITS(16); */
while ( bits < 16 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . length = hold ;
if ( state . head ) {
state . head . extra _len = hold ;
}
if ( state . flags & 0x0200 ) {
//=== CRC2(state.check, hold);
hbuf [ 0 ] = hold & 0xff ;
hbuf [ 1 ] = ( hold >>> 8 ) & 0xff ;
state . check = crc32 ( state . check , hbuf , 2 , 0 ) ;
//===//
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
}
else if ( state . head ) {
state . head . extra = null /*Z_NULL*/ ;
}
state . mode = EXTRA ;
/* falls through */
case EXTRA :
if ( state . flags & 0x0400 ) {
copy = state . length ;
if ( copy > have ) { copy = have ; }
if ( copy ) {
if ( state . head ) {
len = state . head . extra _len - state . length ;
if ( ! state . head . extra ) {
// Use untyped array for more conveniend processing later
state . head . extra = new Array ( state . head . extra _len ) ;
}
utils . arraySet (
state . head . extra ,
input ,
next ,
// extra field is limited to 65536 bytes
// - no need for additional size check
copy ,
/*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
len
) ;
//zmemcpy(state.head.extra + len, next,
// len + copy > state.head.extra_max ?
// state.head.extra_max - len : copy);
}
if ( state . flags & 0x0200 ) {
state . check = crc32 ( state . check , input , copy , next ) ;
}
have -= copy ;
next += copy ;
state . length -= copy ;
}
if ( state . length ) { break inf _leave ; }
}
state . length = 0 ;
state . mode = NAME ;
/* falls through */
case NAME :
if ( state . flags & 0x0800 ) {
if ( have === 0 ) { break inf _leave ; }
copy = 0 ;
do {
// TODO: 2 or 1 bytes?
len = input [ next + copy ++ ] ;
/* use constant limit because in js we should not preallocate memory */
if ( state . head && len &&
( state . length < 65536 /*state.head.name_max*/ ) ) {
state . head . name += String . fromCharCode ( len ) ;
}
} while ( len && copy < have ) ;
if ( state . flags & 0x0200 ) {
state . check = crc32 ( state . check , input , copy , next ) ;
}
have -= copy ;
next += copy ;
if ( len ) { break inf _leave ; }
}
else if ( state . head ) {
state . head . name = null ;
}
state . length = 0 ;
state . mode = COMMENT ;
/* falls through */
case COMMENT :
if ( state . flags & 0x1000 ) {
if ( have === 0 ) { break inf _leave ; }
copy = 0 ;
do {
len = input [ next + copy ++ ] ;
/* use constant limit because in js we should not preallocate memory */
if ( state . head && len &&
( state . length < 65536 /*state.head.comm_max*/ ) ) {
state . head . comment += String . fromCharCode ( len ) ;
}
} while ( len && copy < have ) ;
if ( state . flags & 0x0200 ) {
state . check = crc32 ( state . check , input , copy , next ) ;
}
have -= copy ;
next += copy ;
if ( len ) { break inf _leave ; }
}
else if ( state . head ) {
state . head . comment = null ;
}
state . mode = HCRC ;
/* falls through */
case HCRC :
if ( state . flags & 0x0200 ) {
//=== NEEDBITS(16); */
while ( bits < 16 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
if ( hold !== ( state . check & 0xffff ) ) {
strm . msg = 'header crc mismatch' ;
state . mode = BAD ;
break ;
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
}
if ( state . head ) {
state . head . hcrc = ( ( state . flags >> 9 ) & 1 ) ;
state . head . done = true ;
}
strm . adler = state . check = 0 ;
state . mode = TYPE ;
break ;
case DICTID :
//=== NEEDBITS(32); */
while ( bits < 32 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
strm . adler = state . check = zswap32 ( hold ) ;
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
state . mode = DICT ;
/* falls through */
case DICT :
if ( state . havedict === 0 ) {
//--- RESTORE() ---
strm . next _out = put ;
strm . avail _out = left ;
strm . next _in = next ;
strm . avail _in = have ;
state . hold = hold ;
state . bits = bits ;
//---
return Z _NEED _DICT ;
}
strm . adler = state . check = 1 /*adler32(0L, Z_NULL, 0)*/ ;
state . mode = TYPE ;
/* falls through */
case TYPE :
if ( flush === Z _BLOCK || flush === Z _TREES ) { break inf _leave ; }
/* falls through */
case TYPEDO :
if ( state . last ) {
//--- BYTEBITS() ---//
hold >>>= bits & 7 ;
bits -= bits & 7 ;
//---//
state . mode = CHECK ;
break ;
}
//=== NEEDBITS(3); */
while ( bits < 3 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . last = ( hold & 0x01 ) /*BITS(1)*/ ;
//--- DROPBITS(1) ---//
hold >>>= 1 ;
bits -= 1 ;
//---//
switch ( ( hold & 0x03 ) /*BITS(2)*/ ) {
case 0 : /* stored block */
//Tracev((stderr, "inflate: stored block%s\n",
// state.last ? " (last)" : ""));
state . mode = STORED ;
break ;
case 1 : /* fixed block */
fixedtables ( state ) ;
//Tracev((stderr, "inflate: fixed codes block%s\n",
// state.last ? " (last)" : ""));
state . mode = LEN _ ; /* decode codes */
if ( flush === Z _TREES ) {
//--- DROPBITS(2) ---//
hold >>>= 2 ;
bits -= 2 ;
//---//
break inf _leave ;
}
break ;
case 2 : /* dynamic block */
//Tracev((stderr, "inflate: dynamic codes block%s\n",
// state.last ? " (last)" : ""));
state . mode = TABLE ;
break ;
case 3 :
strm . msg = 'invalid block type' ;
state . mode = BAD ;
}
//--- DROPBITS(2) ---//
hold >>>= 2 ;
bits -= 2 ;
//---//
break ;
case STORED :
//--- BYTEBITS() ---// /* go to byte boundary */
hold >>>= bits & 7 ;
bits -= bits & 7 ;
//---//
//=== NEEDBITS(32); */
while ( bits < 32 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
if ( ( hold & 0xffff ) !== ( ( hold >>> 16 ) ^ 0xffff ) ) {
strm . msg = 'invalid stored block lengths' ;
state . mode = BAD ;
break ;
}
state . length = hold & 0xffff ;
//Tracev((stderr, "inflate: stored length %u\n",
// state.length));
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
state . mode = COPY _ ;
if ( flush === Z _TREES ) { break inf _leave ; }
/* falls through */
case COPY _ :
state . mode = COPY ;
/* falls through */
case COPY :
copy = state . length ;
if ( copy ) {
if ( copy > have ) { copy = have ; }
if ( copy > left ) { copy = left ; }
if ( copy === 0 ) { break inf _leave ; }
//--- zmemcpy(put, next, copy); ---
utils . arraySet ( output , input , next , copy , put ) ;
//---//
have -= copy ;
next += copy ;
left -= copy ;
put += copy ;
state . length -= copy ;
break ;
}
//Tracev((stderr, "inflate: stored end\n"));
state . mode = TYPE ;
break ;
case TABLE :
//=== NEEDBITS(14); */
while ( bits < 14 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . nlen = ( hold & 0x1f ) /*BITS(5)*/ + 257 ;
//--- DROPBITS(5) ---//
hold >>>= 5 ;
bits -= 5 ;
//---//
state . ndist = ( hold & 0x1f ) /*BITS(5)*/ + 1 ;
//--- DROPBITS(5) ---//
hold >>>= 5 ;
bits -= 5 ;
//---//
state . ncode = ( hold & 0x0f ) /*BITS(4)*/ + 4 ;
//--- DROPBITS(4) ---//
hold >>>= 4 ;
bits -= 4 ;
//---//
//#ifndef PKZIP_BUG_WORKAROUND
if ( state . nlen > 286 || state . ndist > 30 ) {
strm . msg = 'too many length or distance symbols' ;
state . mode = BAD ;
break ;
}
//#endif
//Tracev((stderr, "inflate: table sizes ok\n"));
state . have = 0 ;
state . mode = LENLENS ;
/* falls through */
case LENLENS :
while ( state . have < state . ncode ) {
//=== NEEDBITS(3);
while ( bits < 3 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . lens [ order [ state . have ++ ] ] = ( hold & 0x07 ) ; //BITS(3);
//--- DROPBITS(3) ---//
hold >>>= 3 ;
bits -= 3 ;
//---//
}
while ( state . have < 19 ) {
state . lens [ order [ state . have ++ ] ] = 0 ;
}
// We have separate tables & no pointers. 2 commented lines below not needed.
//state.next = state.codes;
//state.lencode = state.next;
// Switch to use dynamic table
state . lencode = state . lendyn ;
state . lenbits = 7 ;
opts = { bits : state . lenbits } ;
ret = inflate _table ( CODES , state . lens , 0 , 19 , state . lencode , 0 , state . work , opts ) ;
state . lenbits = opts . bits ;
if ( ret ) {
strm . msg = 'invalid code lengths set' ;
state . mode = BAD ;
break ;
}
//Tracev((stderr, "inflate: code lengths ok\n"));
state . have = 0 ;
state . mode = CODELENS ;
/* falls through */
case CODELENS :
while ( state . have < state . nlen + state . ndist ) {
for ( ; ; ) {
here = state . lencode [ hold & ( ( 1 << state . lenbits ) - 1 ) ] ; /*BITS(state.lenbits)*/
here _bits = here >>> 24 ;
here _op = ( here >>> 16 ) & 0xff ;
here _val = here & 0xffff ;
if ( ( here _bits ) <= bits ) { break ; }
//--- PULLBYTE() ---//
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
//---//
}
if ( here _val < 16 ) {
//--- DROPBITS(here.bits) ---//
hold >>>= here _bits ;
bits -= here _bits ;
//---//
state . lens [ state . have ++ ] = here _val ;
}
else {
if ( here _val === 16 ) {
//=== NEEDBITS(here.bits + 2);
n = here _bits + 2 ;
while ( bits < n ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
//--- DROPBITS(here.bits) ---//
hold >>>= here _bits ;
bits -= here _bits ;
//---//
if ( state . have === 0 ) {
strm . msg = 'invalid bit length repeat' ;
state . mode = BAD ;
break ;
}
len = state . lens [ state . have - 1 ] ;
copy = 3 + ( hold & 0x03 ) ; //BITS(2);
//--- DROPBITS(2) ---//
hold >>>= 2 ;
bits -= 2 ;
//---//
}
else if ( here _val === 17 ) {
//=== NEEDBITS(here.bits + 3);
n = here _bits + 3 ;
while ( bits < n ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
//--- DROPBITS(here.bits) ---//
hold >>>= here _bits ;
bits -= here _bits ;
//---//
len = 0 ;
copy = 3 + ( hold & 0x07 ) ; //BITS(3);
//--- DROPBITS(3) ---//
hold >>>= 3 ;
bits -= 3 ;
//---//
}
else {
//=== NEEDBITS(here.bits + 7);
n = here _bits + 7 ;
while ( bits < n ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
//--- DROPBITS(here.bits) ---//
hold >>>= here _bits ;
bits -= here _bits ;
//---//
len = 0 ;
copy = 11 + ( hold & 0x7f ) ; //BITS(7);
//--- DROPBITS(7) ---//
hold >>>= 7 ;
bits -= 7 ;
//---//
}
if ( state . have + copy > state . nlen + state . ndist ) {
strm . msg = 'invalid bit length repeat' ;
state . mode = BAD ;
break ;
}
while ( copy -- ) {
state . lens [ state . have ++ ] = len ;
}
}
}
/* handle error breaks in while */
if ( state . mode === BAD ) { break ; }
/* check for end-of-block code (better have one) */
if ( state . lens [ 256 ] === 0 ) {
strm . msg = 'invalid code -- missing end-of-block' ;
state . mode = BAD ;
break ;
}
/ * b u i l d c o d e t a b l e s - - n o t e : d o n o t c h a n g e t h e l e n b i t s o r d i s t b i t s
values here ( 9 and 6 ) without reading the comments in inftrees . h
concerning the ENOUGH constants , which depend on those values * /
state . lenbits = 9 ;
opts = { bits : state . lenbits } ;
ret = inflate _table ( LENS , state . lens , 0 , state . nlen , state . lencode , 0 , state . work , opts ) ;
// We have separate tables & no pointers. 2 commented lines below not needed.
// state.next_index = opts.table_index;
state . lenbits = opts . bits ;
// state.lencode = state.next;
if ( ret ) {
strm . msg = 'invalid literal/lengths set' ;
state . mode = BAD ;
break ;
}
state . distbits = 6 ;
//state.distcode.copy(state.codes);
// Switch to use dynamic table
state . distcode = state . distdyn ;
opts = { bits : state . distbits } ;
ret = inflate _table ( DISTS , state . lens , state . nlen , state . ndist , state . distcode , 0 , state . work , opts ) ;
// We have separate tables & no pointers. 2 commented lines below not needed.
// state.next_index = opts.table_index;
state . distbits = opts . bits ;
// state.distcode = state.next;
if ( ret ) {
strm . msg = 'invalid distances set' ;
state . mode = BAD ;
break ;
}
//Tracev((stderr, 'inflate: codes ok\n'));
state . mode = LEN _ ;
if ( flush === Z _TREES ) { break inf _leave ; }
/* falls through */
case LEN _ :
state . mode = LEN ;
/* falls through */
case LEN :
if ( have >= 6 && left >= 258 ) {
//--- RESTORE() ---
strm . next _out = put ;
strm . avail _out = left ;
strm . next _in = next ;
strm . avail _in = have ;
state . hold = hold ;
state . bits = bits ;
//---
inflate _fast ( strm , _out ) ;
//--- LOAD() ---
put = strm . next _out ;
output = strm . output ;
left = strm . avail _out ;
next = strm . next _in ;
input = strm . input ;
have = strm . avail _in ;
hold = state . hold ;
bits = state . bits ;
//---
if ( state . mode === TYPE ) {
state . back = - 1 ;
}
break ;
}
state . back = 0 ;
for ( ; ; ) {
here = state . lencode [ hold & ( ( 1 << state . lenbits ) - 1 ) ] ; /*BITS(state.lenbits)*/
here _bits = here >>> 24 ;
here _op = ( here >>> 16 ) & 0xff ;
here _val = here & 0xffff ;
if ( here _bits <= bits ) { break ; }
//--- PULLBYTE() ---//
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
//---//
}
if ( here _op && ( here _op & 0xf0 ) === 0 ) {
last _bits = here _bits ;
last _op = here _op ;
last _val = here _val ;
for ( ; ; ) {
here = state . lencode [ last _val +
( ( hold & ( ( 1 << ( last _bits + last _op ) ) - 1 ) ) /*BITS(last.bits + last.op)*/ >> last _bits ) ] ;
here _bits = here >>> 24 ;
here _op = ( here >>> 16 ) & 0xff ;
here _val = here & 0xffff ;
if ( ( last _bits + here _bits ) <= bits ) { break ; }
//--- PULLBYTE() ---//
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
//---//
}
//--- DROPBITS(last.bits) ---//
hold >>>= last _bits ;
bits -= last _bits ;
//---//
state . back += last _bits ;
}
//--- DROPBITS(here.bits) ---//
hold >>>= here _bits ;
bits -= here _bits ;
//---//
state . back += here _bits ;
state . length = here _val ;
if ( here _op === 0 ) {
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
// "inflate: literal '%c'\n" :
// "inflate: literal 0x%02x\n", here.val));
state . mode = LIT ;
break ;
}
if ( here _op & 32 ) {
//Tracevv((stderr, "inflate: end of block\n"));
state . back = - 1 ;
state . mode = TYPE ;
break ;
}
if ( here _op & 64 ) {
strm . msg = 'invalid literal/length code' ;
state . mode = BAD ;
break ;
}
state . extra = here _op & 15 ;
state . mode = LENEXT ;
/* falls through */
case LENEXT :
if ( state . extra ) {
//=== NEEDBITS(state.extra);
n = state . extra ;
while ( bits < n ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . length += hold & ( ( 1 << state . extra ) - 1 ) /*BITS(state.extra)*/ ;
//--- DROPBITS(state.extra) ---//
hold >>>= state . extra ;
bits -= state . extra ;
//---//
state . back += state . extra ;
}
//Tracevv((stderr, "inflate: length %u\n", state.length));
state . was = state . length ;
state . mode = DIST ;
/* falls through */
case DIST :
for ( ; ; ) {
here = state . distcode [ hold & ( ( 1 << state . distbits ) - 1 ) ] ; /*BITS(state.distbits)*/
here _bits = here >>> 24 ;
here _op = ( here >>> 16 ) & 0xff ;
here _val = here & 0xffff ;
if ( ( here _bits ) <= bits ) { break ; }
//--- PULLBYTE() ---//
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
//---//
}
if ( ( here _op & 0xf0 ) === 0 ) {
last _bits = here _bits ;
last _op = here _op ;
last _val = here _val ;
for ( ; ; ) {
here = state . distcode [ last _val +
( ( hold & ( ( 1 << ( last _bits + last _op ) ) - 1 ) ) /*BITS(last.bits + last.op)*/ >> last _bits ) ] ;
here _bits = here >>> 24 ;
here _op = ( here >>> 16 ) & 0xff ;
here _val = here & 0xffff ;
if ( ( last _bits + here _bits ) <= bits ) { break ; }
//--- PULLBYTE() ---//
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
//---//
}
//--- DROPBITS(last.bits) ---//
hold >>>= last _bits ;
bits -= last _bits ;
//---//
state . back += last _bits ;
}
//--- DROPBITS(here.bits) ---//
hold >>>= here _bits ;
bits -= here _bits ;
//---//
state . back += here _bits ;
if ( here _op & 64 ) {
strm . msg = 'invalid distance code' ;
state . mode = BAD ;
break ;
}
state . offset = here _val ;
state . extra = ( here _op ) & 15 ;
state . mode = DISTEXT ;
/* falls through */
case DISTEXT :
if ( state . extra ) {
//=== NEEDBITS(state.extra);
n = state . extra ;
while ( bits < n ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
state . offset += hold & ( ( 1 << state . extra ) - 1 ) /*BITS(state.extra)*/ ;
//--- DROPBITS(state.extra) ---//
hold >>>= state . extra ;
bits -= state . extra ;
//---//
state . back += state . extra ;
}
//#ifdef INFLATE_STRICT
if ( state . offset > state . dmax ) {
strm . msg = 'invalid distance too far back' ;
state . mode = BAD ;
break ;
}
//#endif
//Tracevv((stderr, "inflate: distance %u\n", state.offset));
state . mode = MATCH ;
/* falls through */
case MATCH :
if ( left === 0 ) { break inf _leave ; }
copy = _out - left ;
if ( state . offset > copy ) { /* copy from window */
copy = state . offset - copy ;
if ( copy > state . whave ) {
if ( state . sane ) {
strm . msg = 'invalid distance too far back' ;
state . mode = BAD ;
break ;
}
// (!) This block is disabled in zlib defailts,
// don't enable it for binary compatibility
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
// Trace((stderr, "inflate.c too far\n"));
// copy -= state.whave;
// if (copy > state.length) { copy = state.length; }
// if (copy > left) { copy = left; }
// left -= copy;
// state.length -= copy;
// do {
// output[put++] = 0;
// } while (--copy);
// if (state.length === 0) { state.mode = LEN; }
// break;
//#endif
}
if ( copy > state . wnext ) {
copy -= state . wnext ;
from = state . wsize - copy ;
}
else {
from = state . wnext - copy ;
}
if ( copy > state . length ) { copy = state . length ; }
from _source = state . window ;
}
else { /* copy from output */
from _source = output ;
from = put - state . offset ;
copy = state . length ;
}
if ( copy > left ) { copy = left ; }
left -= copy ;
state . length -= copy ;
do {
output [ put ++ ] = from _source [ from ++ ] ;
} while ( -- copy ) ;
if ( state . length === 0 ) { state . mode = LEN ; }
break ;
case LIT :
if ( left === 0 ) { break inf _leave ; }
output [ put ++ ] = state . length ;
left -- ;
state . mode = LEN ;
break ;
case CHECK :
if ( state . wrap ) {
//=== NEEDBITS(32);
while ( bits < 32 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
// Use '|' insdead of '+' to make sure that result is signed
hold |= input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
_out -= left ;
strm . total _out += _out ;
state . total += _out ;
if ( _out ) {
strm . adler = state . check =
/*UPDATE(state.check, put - _out, _out);*/
( state . flags ? crc32 ( state . check , output , _out , put - _out ) : adler32 ( state . check , output , _out , put - _out ) ) ;
}
_out = left ;
// NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
if ( ( state . flags ? hold : zswap32 ( hold ) ) !== state . check ) {
strm . msg = 'incorrect data check' ;
state . mode = BAD ;
break ;
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
//Tracev((stderr, "inflate: check matches trailer\n"));
}
state . mode = LENGTH ;
/* falls through */
case LENGTH :
if ( state . wrap && state . flags ) {
//=== NEEDBITS(32);
while ( bits < 32 ) {
if ( have === 0 ) { break inf _leave ; }
have -- ;
hold += input [ next ++ ] << bits ;
bits += 8 ;
}
//===//
if ( hold !== ( state . total & 0xffffffff ) ) {
strm . msg = 'incorrect length check' ;
state . mode = BAD ;
break ;
}
//=== INITBITS();
hold = 0 ;
bits = 0 ;
//===//
//Tracev((stderr, "inflate: length matches trailer\n"));
}
state . mode = DONE ;
/* falls through */
case DONE :
ret = Z _STREAM _END ;
break inf _leave ;
case BAD :
ret = Z _DATA _ERROR ;
break inf _leave ;
case MEM :
return Z _MEM _ERROR ;
case SYNC :
/* falls through */
default :
return Z _STREAM _ERROR ;
}
}
// inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
/ *
Return from inflate ( ) , updating the total counts and the check value .
If there was no progress during the inflate ( ) call , return a buffer
error . Call updatewindow ( ) to create and / or update the window state .
Note : a memory error from inflate ( ) is non - recoverable .
* /
//--- RESTORE() ---
strm . next _out = put ;
strm . avail _out = left ;
strm . next _in = next ;
strm . avail _in = have ;
state . hold = hold ;
state . bits = bits ;
//---
if ( state . wsize || ( _out !== strm . avail _out && state . mode < BAD &&
( state . mode < CHECK || flush !== Z _FINISH ) ) ) {
if ( updatewindow ( strm , strm . output , strm . next _out , _out - strm . avail _out ) ) {
state . mode = MEM ;
return Z _MEM _ERROR ;
}
}
_in -= strm . avail _in ;
_out -= strm . avail _out ;
strm . total _in += _in ;
strm . total _out += _out ;
state . total += _out ;
if ( state . wrap && _out ) {
strm . adler = state . check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
( state . flags ? crc32 ( state . check , output , _out , strm . next _out - _out ) : adler32 ( state . check , output , _out , strm . next _out - _out ) ) ;
}
strm . data _type = state . bits + ( state . last ? 64 : 0 ) +
( state . mode === TYPE ? 128 : 0 ) +
( state . mode === LEN _ || state . mode === COPY _ ? 256 : 0 ) ;
if ( ( ( _in === 0 && _out === 0 ) || flush === Z _FINISH ) && ret === Z _OK ) {
ret = Z _BUF _ERROR ;
}
return ret ;
}
function inflateEnd ( strm ) {
if ( ! strm || ! strm . state /*|| strm->zfree == (free_func)0*/ ) {
return Z _STREAM _ERROR ;
}
var state = strm . state ;
if ( state . window ) {
state . window = null ;
}
strm . state = null ;
return Z _OK ;
}
function inflateGetHeader ( strm , head ) {
var state ;
/* check state */
if ( ! strm || ! strm . state ) { return Z _STREAM _ERROR ; }
state = strm . state ;
if ( ( state . wrap & 2 ) === 0 ) { return Z _STREAM _ERROR ; }
/* save header structure */
state . head = head ;
head . done = false ;
return Z _OK ;
}
function inflateSetDictionary ( strm , dictionary ) {
var dictLength = dictionary . length ;
var state ;
var dictid ;
var ret ;
/* check state */
if ( ! strm /* == Z_NULL */ || ! strm . state /* == Z_NULL */ ) { return Z _STREAM _ERROR ; }
state = strm . state ;
if ( state . wrap !== 0 && state . mode !== DICT ) {
return Z _STREAM _ERROR ;
}
/* check for correct dictionary identifier */
if ( state . mode === DICT ) {
dictid = 1 ; /* adler32(0, null, 0)*/
/* dictid = adler32(dictid, dictionary, dictLength); */
dictid = adler32 ( dictid , dictionary , dictLength , 0 ) ;
if ( dictid !== state . check ) {
return Z _DATA _ERROR ;
}
}
/ * c o p y d i c t i o n a r y t o w i n d o w u s i n g u p d a t e w i n d o w ( ) , w h i c h w i l l a m e n d t h e
existing dictionary if appropriate * /
ret = updatewindow ( strm , dictionary , dictLength , dictLength ) ;
if ( ret ) {
state . mode = MEM ;
return Z _MEM _ERROR ;
}
state . havedict = 1 ;
// Tracev((stderr, "inflate: dictionary set\n"));
return Z _OK ;
}
exports . inflateReset = inflateReset ;
exports . inflateReset2 = inflateReset2 ;
exports . inflateResetKeep = inflateResetKeep ;
exports . inflateInit = inflateInit ;
exports . inflateInit2 = inflateInit2 ;
exports . inflate = inflate ;
exports . inflateEnd = inflateEnd ;
exports . inflateGetHeader = inflateGetHeader ;
exports . inflateSetDictionary = inflateSetDictionary ;
exports . inflateInfo = 'pako inflate (from Nodeca project)' ;
/ * N o t i m p l e m e n t e d
exports . inflateCopy = inflateCopy ;
exports . inflateGetDictionary = inflateGetDictionary ;
exports . inflateMark = inflateMark ;
exports . inflatePrime = inflatePrime ;
exports . inflateSync = inflateSync ;
exports . inflateSyncPoint = inflateSyncPoint ;
exports . inflateUndermine = inflateUndermine ;
* /
} , { "../utils/common" : 2 , "./adler32" : 4 , "./crc32" : 6 , "./inffast" : 8 , "./inftrees" : 10 } ] , 10 : [ function ( require , module , exports ) {
'use strict' ;
var utils = require ( '../utils/common' ) ;
var MAXBITS = 15 ;
var ENOUGH _LENS = 852 ;
var ENOUGH _DISTS = 592 ;
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
var CODES = 0 ;
var LENS = 1 ;
var DISTS = 2 ;
var lbase = [ /* Length codes 257..285 base */
3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 13 , 15 , 17 , 19 , 23 , 27 , 31 ,
35 , 43 , 51 , 59 , 67 , 83 , 99 , 115 , 131 , 163 , 195 , 227 , 258 , 0 , 0
] ;
var lext = [ /* Length codes 257..285 extra */
16 , 16 , 16 , 16 , 16 , 16 , 16 , 16 , 17 , 17 , 17 , 17 , 18 , 18 , 18 , 18 ,
19 , 19 , 19 , 19 , 20 , 20 , 20 , 20 , 21 , 21 , 21 , 21 , 16 , 72 , 78
] ;
var dbase = [ /* Distance codes 0..29 base */
1 , 2 , 3 , 4 , 5 , 7 , 9 , 13 , 17 , 25 , 33 , 49 , 65 , 97 , 129 , 193 ,
257 , 385 , 513 , 769 , 1025 , 1537 , 2049 , 3073 , 4097 , 6145 ,
8193 , 12289 , 16385 , 24577 , 0 , 0
] ;
var dext = [ /* Distance codes 0..29 extra */
16 , 16 , 16 , 16 , 17 , 17 , 18 , 18 , 19 , 19 , 20 , 20 , 21 , 21 , 22 , 22 ,
23 , 23 , 24 , 24 , 25 , 25 , 26 , 26 , 27 , 27 ,
28 , 28 , 29 , 29 , 64 , 64
] ;
module . exports = function inflate _table ( type , lens , lens _index , codes , table , table _index , work , opts )
{
var bits = opts . bits ;
//here = opts.here; /* table entry for duplication */
var len = 0 ; /* a code's length in bits */
var sym = 0 ; /* index of code symbols */
var min = 0 , max = 0 ; /* minimum and maximum code lengths */
var root = 0 ; /* number of index bits for root table */
var curr = 0 ; /* number of index bits for current table */
var drop = 0 ; /* code bits to drop for sub-table */
var left = 0 ; /* number of prefix codes available */
var used = 0 ; /* code entries in table used */
var huff = 0 ; /* Huffman code */
var incr ; /* for incrementing code, index */
var fill ; /* index for replicating entries */
var low ; /* low bits for current root entry */
var mask ; /* mask for low root bits */
var next ; /* next available space in table */
var base = null ; /* base value table to use */
var base _index = 0 ;
// var shoextra; /* extra bits table to use */
var end ; /* use base and extra for symbol > end */
var count = new utils . Buf16 ( MAXBITS + 1 ) ; //[MAXBITS+1]; /* number of codes of each length */
var offs = new utils . Buf16 ( MAXBITS + 1 ) ; //[MAXBITS+1]; /* offsets in table for each length */
var extra = null ;
var extra _index = 0 ;
var here _bits , here _op , here _val ;
/ *
Process a set of code lengths to create a canonical Huffman code . The
code lengths are lens [ 0. . codes - 1 ] . Each length corresponds to the
symbols 0. . codes - 1. The Huffman code is generated by first sorting the
symbols by length from short to long , and retaining the symbol order
for codes with equal lengths . Then the code starts with all zero bits
for the first code of the shortest length , and the codes are integer
increments for the same length , and zeros are appended as the length
increases . For the deflate format , these bits are stored backwards
from their more natural integer increment ordering , and so when the
decoding tables are built in the large loop below , the integer codes
are incremented backwards .
This routine assumes , but does not check , that all of the entries in
lens [ ] are in the range 0. . MAXBITS . The caller must assure this .
1. . MAXBITS is interpreted as that code length . zero means that that
symbol does not occur in this code .
The codes are sorted by computing a count of codes for each length ,
creating from that a table of starting indices for each length in the
sorted table , and then entering the symbols in order in the sorted
table . The sorted table is work [ ] , with that space being provided by
the caller .
The length counts are used for other purposes as well , i . e . finding
the minimum and maximum length codes , determining if there are any
codes at all , checking for a valid set of lengths , and looking ahead
at length counts to determine sub - table sizes when building the
decoding tables .
* /
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
for ( len = 0 ; len <= MAXBITS ; len ++ ) {
count [ len ] = 0 ;
}
for ( sym = 0 ; sym < codes ; sym ++ ) {
count [ lens [ lens _index + sym ] ] ++ ;
}
/* bound code lengths, force root to be within code lengths */
root = bits ;
for ( max = MAXBITS ; max >= 1 ; max -- ) {
if ( count [ max ] !== 0 ) { break ; }
}
if ( root > max ) {
root = max ;
}
if ( max === 0 ) { /* no symbols to code at all */
//table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */
//table.bits[opts.table_index] = 1; //here.bits = (var char)1;
//table.val[opts.table_index++] = 0; //here.val = (var short)0;
table [ table _index ++ ] = ( 1 << 24 ) | ( 64 << 16 ) | 0 ;
//table.op[opts.table_index] = 64;
//table.bits[opts.table_index] = 1;
//table.val[opts.table_index++] = 0;
table [ table _index ++ ] = ( 1 << 24 ) | ( 64 << 16 ) | 0 ;
opts . bits = 1 ;
return 0 ; /* no symbols, but wait for decoding to report error */
}
for ( min = 1 ; min < max ; min ++ ) {
if ( count [ min ] !== 0 ) { break ; }
}
if ( root < min ) {
root = min ;
}
/* check for an over-subscribed or incomplete set of lengths */
left = 1 ;
for ( len = 1 ; len <= MAXBITS ; len ++ ) {
left <<= 1 ;
left -= count [ len ] ;
if ( left < 0 ) {
return - 1 ;
} /* over-subscribed */
}
if ( left > 0 && ( type === CODES || max !== 1 ) ) {
return - 1 ; /* incomplete set */
}
/* generate offsets into symbol table for each length for sorting */
offs [ 1 ] = 0 ;
for ( len = 1 ; len < MAXBITS ; len ++ ) {
offs [ len + 1 ] = offs [ len ] + count [ len ] ;
}
/* sort symbols by length, by symbol order within each length */
for ( sym = 0 ; sym < codes ; sym ++ ) {
if ( lens [ lens _index + sym ] !== 0 ) {
work [ offs [ lens [ lens _index + sym ] ] ++ ] = sym ;
}
}
/ *
Create and fill in decoding tables . In this loop , the table being
filled is at next and has curr index bits . The code being used is huff
with length len . That code is converted to an index by dropping drop
bits off of the bottom . For codes where len is less than drop + curr ,
those top drop + curr - len bits are incremented through all values to
fill the table with replicated entries .
root is the number of index bits for the root table . When len exceeds
root , sub - tables are created pointed to by the root entry with an index
of the low root bits of huff . This is saved in low to check for when a
new sub - table should be started . drop is zero when the root table is
being filled , and drop is root when sub - tables are being filled .
When a new sub - table is needed , it is necessary to look ahead in the
code lengths to determine what size sub - table is needed . The length
counts are used for this , and so count [ ] is decremented as codes are
entered in the tables .
used keeps track of how many table entries have been allocated from the
provided * table space . It is checked for LENS and DIST tables against
the constants ENOUGH _LENS and ENOUGH _DISTS to guard against changes in
the initial root table size constants . See the comments in inftrees . h
for more information .
sym increments through all symbols , and the loop terminates when
all codes of length max , i . e . all codes , have been processed . This
routine permits incomplete codes , so another loop after this one fills
in the rest of the decoding tables with invalid code markers .
* /
/* set up for code type */
// poor man optimization - use if-else instead of switch,
// to avoid deopts in old v8
if ( type === CODES ) {
base = extra = work ; /* dummy value--not used */
end = 19 ;
} else if ( type === LENS ) {
base = lbase ;
base _index -= 257 ;
extra = lext ;
extra _index -= 257 ;
end = 256 ;
} else { /* DISTS */
base = dbase ;
extra = dext ;
end = - 1 ;
}
/* initialize opts for loop */
huff = 0 ; /* starting code */
sym = 0 ; /* starting code symbol */
len = min ; /* starting code length */
next = table _index ; /* current table to fill in */
curr = root ; /* current table index bits */
drop = 0 ; /* current bits to drop from code for index */
low = - 1 ; /* trigger new sub-table when len > root */
used = 1 << root ; /* use root table entries */
mask = used - 1 ; /* mask for comparing low */
/* check available table space */
if ( ( type === LENS && used > ENOUGH _LENS ) ||
( type === DISTS && used > ENOUGH _DISTS ) ) {
return 1 ;
}
var i = 0 ;
/* process all codes and make table entries */
for ( ; ; ) {
i ++ ;
/* create table entry */
here _bits = len - drop ;
if ( work [ sym ] < end ) {
here _op = 0 ;
here _val = work [ sym ] ;
}
else if ( work [ sym ] > end ) {
here _op = extra [ extra _index + work [ sym ] ] ;
here _val = base [ base _index + work [ sym ] ] ;
}
else {
here _op = 32 + 64 ; /* end of block */
here _val = 0 ;
}
/* replicate for those indices with low len bits equal to huff */
incr = 1 << ( len - drop ) ;
fill = 1 << curr ;
min = fill ; /* save offset to next table */
do {
fill -= incr ;
table [ next + ( huff >> drop ) + fill ] = ( here _bits << 24 ) | ( here _op << 16 ) | here _val | 0 ;
} while ( fill !== 0 ) ;
/* backwards increment the len-bit code huff */
incr = 1 << ( len - 1 ) ;
while ( huff & incr ) {
incr >>= 1 ;
}
if ( incr !== 0 ) {
huff &= incr - 1 ;
huff += incr ;
} else {
huff = 0 ;
}
/* go to next symbol, update count, len */
sym ++ ;
if ( -- count [ len ] === 0 ) {
if ( len === max ) { break ; }
len = lens [ lens _index + work [ sym ] ] ;
}
/* create new sub-table if needed */
if ( len > root && ( huff & mask ) !== low ) {
/* if first time, transition to sub-tables */
if ( drop === 0 ) {
drop = root ;
}
/* increment past last table */
next += min ; /* here min is 1 << curr */
/* determine length of next table */
curr = len - drop ;
left = 1 << curr ;
while ( curr + drop < max ) {
left -= count [ curr + drop ] ;
if ( left <= 0 ) { break ; }
curr ++ ;
left <<= 1 ;
}
/* check for enough space */
used += 1 << curr ;
if ( ( type === LENS && used > ENOUGH _LENS ) ||
( type === DISTS && used > ENOUGH _DISTS ) ) {
return 1 ;
}
/* point entry in root table to sub-table */
low = huff & mask ;
/ * t a b l e . o p [ l o w ] = c u r r ;
table . bits [ low ] = root ;
table . val [ low ] = next - opts . table _index ; * /
table [ low ] = ( root << 24 ) | ( curr << 16 ) | ( next - table _index ) | 0 ;
}
}
/ * f i l l i n r e m a i n i n g t a b l e e n t r y i f c o d e i s i n c o m p l e t e ( g u a r a n t e e d t o h a v e
at most one remaining entry , since if the code is incomplete , the
maximum code length that was allowed to get this far is one bit ) * /
if ( huff !== 0 ) {
//table.op[next + huff] = 64; /* invalid code marker */
//table.bits[next + huff] = len - drop;
//table.val[next + huff] = 0;
table [ next + huff ] = ( ( len - drop ) << 24 ) | ( 64 << 16 ) | 0 ;
}
/* set return parameters */
//opts.table_index += used;
opts . bits = root ;
return 0 ;
} ;
} , { "../utils/common" : 2 } ] , 11 : [ function ( require , module , exports ) {
'use strict' ;
module . exports = {
2 : 'need dictionary' , /* Z_NEED_DICT 2 */
1 : 'stream end' , /* Z_STREAM_END 1 */
0 : '' , /* Z_OK 0 */
'-1' : 'file error' , /* Z_ERRNO (-1) */
'-2' : 'stream error' , /* Z_STREAM_ERROR (-2) */
'-3' : 'data error' , /* Z_DATA_ERROR (-3) */
'-4' : 'insufficient memory' , /* Z_MEM_ERROR (-4) */
'-5' : 'buffer error' , /* Z_BUF_ERROR (-5) */
'-6' : 'incompatible version' /* Z_VERSION_ERROR (-6) */
} ;
} , { } ] , 12 : [ function ( require , module , exports ) {
'use strict' ;
function ZStream ( ) {
/* next input byte */
this . input = null ; // JS specific, because we have no pointers
this . next _in = 0 ;
/* number of bytes available at input */
this . avail _in = 0 ;
/* total number of input bytes read so far */
this . total _in = 0 ;
/* next output byte should be put there */
this . output = null ; // JS specific, because we have no pointers
this . next _out = 0 ;
/* remaining free space at output */
this . avail _out = 0 ;
/* total number of bytes output so far */
this . total _out = 0 ;
/* last error message, NULL if no error */
this . msg = '' /*Z_NULL*/ ;
/* not visible by applications */
this . state = null ;
/* best guess about the data type: binary or text */
this . data _type = 2 /*Z_UNKNOWN*/ ;
/* adler32 value of the uncompressed data */
this . adler = 0 ;
}
module . exports = ZStream ;
} , { } ] , 13 : [ function ( require , module , exports ) {
// shim for using process in browser
var process = module . exports = { } ;
// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's inside a
// function because try/catches deoptimize in certain engines.
var cachedSetTimeout ;
var cachedClearTimeout ;
function defaultSetTimout ( ) {
throw new Error ( 'setTimeout has not been defined' ) ;
}
function defaultClearTimeout ( ) {
throw new Error ( 'clearTimeout has not been defined' ) ;
}
( function ( ) {
try {
if ( typeof setTimeout === 'function' ) {
cachedSetTimeout = setTimeout ;
} else {
cachedSetTimeout = defaultSetTimout ;
}
} catch ( e ) {
cachedSetTimeout = defaultSetTimout ;
}
try {
if ( typeof clearTimeout === 'function' ) {
cachedClearTimeout = clearTimeout ;
} else {
cachedClearTimeout = defaultClearTimeout ;
}
} catch ( e ) {
cachedClearTimeout = defaultClearTimeout ;
}
} ( ) )
function runTimeout ( fun ) {
if ( cachedSetTimeout === setTimeout ) {
//normal enviroments in sane situations
return setTimeout ( fun , 0 ) ;
}
// if setTimeout wasn't available but was latter defined
if ( ( cachedSetTimeout === defaultSetTimout || ! cachedSetTimeout ) && setTimeout ) {
cachedSetTimeout = setTimeout ;
return setTimeout ( fun , 0 ) ;
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout ( fun , 0 ) ;
} catch ( e ) {
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout . call ( null , fun , 0 ) ;
} catch ( e ) {
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout . call ( this , fun , 0 ) ;
}
}
}
function runClearTimeout ( marker ) {
if ( cachedClearTimeout === clearTimeout ) {
//normal enviroments in sane situations
return clearTimeout ( marker ) ;
}
// if clearTimeout wasn't available but was latter defined
if ( ( cachedClearTimeout === defaultClearTimeout || ! cachedClearTimeout ) && clearTimeout ) {
cachedClearTimeout = clearTimeout ;
return clearTimeout ( marker ) ;
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout ( marker ) ;
} catch ( e ) {
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout . call ( null , marker ) ;
} catch ( e ) {
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout . call ( this , marker ) ;
}
}
}
var queue = [ ] ;
var draining = false ;
var currentQueue ;
var queueIndex = - 1 ;
function cleanUpNextTick ( ) {
if ( ! draining || ! currentQueue ) {
return ;
}
draining = false ;
if ( currentQueue . length ) {
queue = currentQueue . concat ( queue ) ;
} else {
queueIndex = - 1 ;
}
if ( queue . length ) {
drainQueue ( ) ;
}
}
function drainQueue ( ) {
if ( draining ) {
return ;
}
var timeout = runTimeout ( cleanUpNextTick ) ;
draining = true ;
var len = queue . length ;
while ( len ) {
currentQueue = queue ;
queue = [ ] ;
while ( ++ queueIndex < len ) {
if ( currentQueue ) {
currentQueue [ queueIndex ] . run ( ) ;
}
}
queueIndex = - 1 ;
len = queue . length ;
}
currentQueue = null ;
draining = false ;
runClearTimeout ( timeout ) ;
}
process . nextTick = function ( fun ) {
var args = new Array ( arguments . length - 1 ) ;
if ( arguments . length > 1 ) {
for ( var i = 1 ; i < arguments . length ; i ++ ) {
args [ i - 1 ] = arguments [ i ] ;
}
}
queue . push ( new Item ( fun , args ) ) ;
if ( queue . length === 1 && ! draining ) {
runTimeout ( drainQueue ) ;
}
} ;
// v8 likes predictible objects
function Item ( fun , array ) {
this . fun = fun ;
this . array = array ;
}
Item . prototype . run = function ( ) {
this . fun . apply ( null , this . array ) ;
} ;
process . title = 'browser' ;
process . browser = true ;
process . env = { } ;
process . argv = [ ] ;
process . version = '' ; // empty string to avoid regexp issues
process . versions = { } ;
function noop ( ) { }
process . on = noop ;
process . addListener = noop ;
process . once = noop ;
process . off = noop ;
process . removeListener = noop ;
process . removeAllListeners = noop ;
process . emit = noop ;
process . binding = function ( name ) {
throw new Error ( 'process.binding is not supported' ) ;
} ;
process . cwd = function ( ) { return '/' } ;
process . chdir = function ( dir ) {
throw new Error ( 'process.chdir is not supported' ) ;
} ;
process . umask = function ( ) { return 0 ; } ;
} , { } ] , 14 : [ function ( require , module , exports ) {
'use strict' ;
// const leveljs = require('level-js')
// something about trying to store these language files in indexedDB
// causes iOS Safari to crash
var iOS = /iPad|iPhone|iPod/ . test ( navigator . userAgent ) ;
var noIDB = typeof indexedDB === 'undefined' || iOS ;
var db = noIDB ? { open : function open ( _ , cb ) {
return cb ( true ) ;
} } : leveljs ( './tessdata2' ) ;
var langdata = require ( '../common/langdata.json' ) ;
module . exports = function getLanguageData ( req , res , cb ) {
var lang = req . options . lang ;
function saveDataFile ( data ) {
try {
db . put ( lang , data , function ( err ) {
return console . log ( 'cached' , lang , err ) ;
} ) ;
} finally {
cb ( data ) ;
}
}
db . open ( { compression : false } , function ( err ) {
if ( err ) return fetchLanguageData ( req , res , cb ) ;
db . get ( lang , function ( err , data ) {
if ( err ) return fetchLanguageData ( req , res , saveDataFile ) ;
res . progress ( { status : 'found in cache ' + lang + '.traineddata' } ) ;
cb ( data ) ;
} ) ;
} ) ;
} ;
var ungzip = require ( 'pako/lib/inflate.js' ) . ungzip ;
function fetchLanguageData ( req , res , cb ) {
var lang = req . options . lang ;
var langfile = lang + '.traineddata.gz' ;
var url = req . workerOptions . langPath + langfile ;
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , url , true ) ;
xhr . responseType = 'arraybuffer' ;
xhr . onerror = function ( e ) {
xhr . onprogress = xhr . onload = null ;
cb ( xhr , null ) ;
} ;
xhr . onprogress = function ( e ) {
return res . progress ( {
status : 'downloading ' + langfile ,
loaded : e . loaded ,
progress : Math . min ( 1 , e . loaded / langdata [ lang ] )
} ) ;
} ;
xhr . onload = function ( e ) {
if ( ! ( xhr . status == 200 || xhr . status == 0 && xhr . response ) ) return res . reject ( 'Error downloading language ' + url ) ;
res . progress ( { status : 'unzipping ' + langfile , progress : 0 } ) ;
// in case the gzips are already ungzipped or extra gzipped
var response = new Uint8Array ( xhr . response ) ;
try {
var n = 2 ;
while ( response [ 0 ] == 0x1f && response [ 1 ] == 0x8b ) {
response = ungzip ( response ) ;
res . progress ( { status : 'unzipping ' + langfile , progress : 1 - 1 / n ++ } ) ;
}
} catch ( err ) {
return res . reject ( 'Error unzipping language file ' + langfile + '\n' + err . message ) ;
}
res . progress ( { status : 'unzipping ' + langfile , progress : 1 } ) ;
cb ( response ) ;
} ;
xhr . send ( ) ;
}
} , { "../common/langdata.json" : 18 , "pako/lib/inflate.js" : 1 } ] , 15 : [ function ( require , module , exports ) {
( function ( process , global ) {
'use strict' ;
var workerUtils = require ( '../common/worker.js' ) ;
if ( process . env . NODE _ENV === "development" ) {
console . debug ( 'Using Development Worker' ) ;
}
global . addEventListener ( 'message' , function ( e ) {
var packet = e . data ;
workerUtils . dispatchHandlers ( packet , function ( obj ) {
return postMessage ( obj ) ;
} ) ;
} ) ;
exports . getCore = function ( req , res ) {
if ( ! global . TesseractCore ) {
res . progress ( { status : 'loading tesseract core' , progress : 0 } ) ;
importScripts ( req . workerOptions . corePath ) ;
res . progress ( { status : 'loading tesseract core' , progress : 1 } ) ;
}
return TesseractCore ;
} ;
exports . getLanguageData = require ( './lang.js' ) ;
workerUtils . setAdapter ( module . exports ) ;
} ) . call ( this , require ( '_process' ) , typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : { } )
} , { "../common/worker.js" : 19 , "./lang.js" : 14 , "_process" : 13 } ] , 16 : [ function ( require , module , exports ) {
'use strict' ;
// This converts an image to grayscale
module . exports = function desaturate ( image ) {
var width , height ;
if ( image . data ) {
var src = image . data ;
width = image . width , height = image . height ;
var dst = new Uint8Array ( width * height ) ;
var srcLength = src . length | 0 ,
srcLength _16 = srcLength - 16 | 0 ;
for ( var i = 0 , j = 0 ; i <= srcLength _16 ; i += 16 , j += 4 ) {
// convert to grayscale 4 pixels at a time; eveything with alpha gets put in front of 50% gray
dst [ j ] = ( src [ i ] * 77 + src [ i + 1 ] * 151 + src [ i + 2 ] * 28 ) * src [ i + 3 ] + ( 255 - src [ i + 3 ] << 15 ) + 32768 >> 16 ;
dst [ j + 1 ] = ( src [ i + 4 ] * 77 + src [ i + 5 ] * 151 + src [ i + 6 ] * 28 ) * src [ i + 7 ] + ( 255 - src [ i + 7 ] << 15 ) + 32768 >> 16 ;
dst [ j + 2 ] = ( src [ i + 8 ] * 77 + src [ i + 9 ] * 151 + src [ i + 10 ] * 28 ) * src [ i + 11 ] + ( 255 - src [ i + 11 ] << 15 ) + 32768 >> 16 ;
dst [ j + 3 ] = ( src [ i + 12 ] * 77 + src [ i + 13 ] * 151 + src [ i + 14 ] * 28 ) * src [ i + 15 ] + ( 255 - src [ i + 15 ] << 15 ) + 32768 >> 16 ;
}
for ( ; i < srcLength ; i += 4 , ++ j ) {
//finish up
dst [ j ] = ( src [ i ] * 77 + src [ i + 1 ] * 151 + src [ i + 2 ] * 28 ) * src [ i + 3 ] + ( 255 - src [ i + 3 ] << 15 ) + 32768 >> 16 ;
} image = dst ;
} else {
throw 'Invalid ImageData' ;
}
return image ;
} ;
} , { } ] , 17 : [ function ( require , module , exports ) {
'use strict' ;
module . exports = function DumpLiterallyEverything ( Module , base ) {
var ri = base . GetIterator ( ) ;
var blocks = [ ] ;
var block , para , textline , word , symbol ;
function enumToString ( value , prefix ) {
return Object . keys ( Module ) . filter ( function ( e ) {
return e . substr ( 0 , prefix . length + 1 ) == prefix + '_' ;
} ) . filter ( function ( e ) {
return Module [ e ] === value ;
} ) . map ( function ( e ) {
return e . slice ( prefix . length + 1 ) ;
} ) [ 0 ] ;
}
ri . Begin ( ) ;
do {
if ( ri . IsAtBeginningOf ( Module . RIL _BLOCK ) ) {
var poly = ri . BlockPolygon ( ) ;
var polygon = null ;
// BlockPolygon() returns null when automatic page segmentation is off
if ( Module . getPointer ( poly ) > 0 ) {
var n = poly . get _n ( ) ,
px = poly . get _x ( ) ,
py = poly . get _y ( ) ,
polygon = [ ] ;
for ( var i = 0 ; i < n ; i ++ ) {
polygon . push ( [ px . getValue ( i ) , py . getValue ( i ) ] ) ;
}
Module . _ptaDestroy ( Module . getPointer ( poly ) ) ;
}
block = {
paragraphs : [ ] ,
text : ri . GetUTF8Text ( Module . RIL _BLOCK ) ,
confidence : ri . Confidence ( Module . RIL _BLOCK ) ,
baseline : ri . getBaseline ( Module . RIL _BLOCK ) ,
bbox : ri . getBoundingBox ( Module . RIL _BLOCK ) ,
blocktype : enumToString ( ri . BlockType ( ) , 'PT' ) ,
polygon : polygon
} ;
blocks . push ( block ) ;
}
if ( ri . IsAtBeginningOf ( Module . RIL _PARA ) ) {
para = {
lines : [ ] ,
text : ri . GetUTF8Text ( Module . RIL _PARA ) ,
confidence : ri . Confidence ( Module . RIL _PARA ) ,
baseline : ri . getBaseline ( Module . RIL _PARA ) ,
bbox : ri . getBoundingBox ( Module . RIL _PARA ) ,
is _ltr : ! ! ri . ParagraphIsLtr ( )
} ;
block . paragraphs . push ( para ) ;
}
if ( ri . IsAtBeginningOf ( Module . RIL _TEXTLINE ) ) {
textline = {
words : [ ] ,
text : ri . GetUTF8Text ( Module . RIL _TEXTLINE ) ,
confidence : ri . Confidence ( Module . RIL _TEXTLINE ) ,
baseline : ri . getBaseline ( Module . RIL _TEXTLINE ) ,
bbox : ri . getBoundingBox ( Module . RIL _TEXTLINE )
} ;
para . lines . push ( textline ) ;
}
if ( ri . IsAtBeginningOf ( Module . RIL _WORD ) ) {
var fontInfo = ri . getWordFontAttributes ( ) ,
wordDir = ri . WordDirection ( ) ;
word = {
symbols : [ ] ,
choices : [ ] ,
text : ri . GetUTF8Text ( Module . RIL _WORD ) ,
confidence : ri . Confidence ( Module . RIL _WORD ) ,
baseline : ri . getBaseline ( Module . RIL _WORD ) ,
bbox : ri . getBoundingBox ( Module . RIL _WORD ) ,
is _numeric : ! ! ri . WordIsNumeric ( ) ,
in _dictionary : ! ! ri . WordIsFromDictionary ( ) ,
direction : enumToString ( wordDir , 'DIR' ) ,
language : ri . WordRecognitionLanguage ( ) ,
is _bold : fontInfo . is _bold ,
is _italic : fontInfo . is _italic ,
is _underlined : fontInfo . is _underlined ,
is _monospace : fontInfo . is _monospace ,
is _serif : fontInfo . is _serif ,
is _smallcaps : fontInfo . is _smallcaps ,
font _size : fontInfo . pointsize ,
font _id : fontInfo . font _id ,
font _name : fontInfo . font _name
} ;
var wc = new Module . WordChoiceIterator ( ri ) ;
do {
word . choices . push ( {
text : wc . GetUTF8Text ( ) ,
confidence : wc . Confidence ( )
} ) ;
} while ( wc . Next ( ) ) ;
Module . destroy ( wc ) ;
textline . words . push ( word ) ;
}
var image = null ;
// var pix = ri.GetBinaryImage(Module.RIL_SYMBOL)
// var image = pix2array(pix);
// // for some reason it seems that things stop working if you destroy pics
// Module._pixDestroy(Module.getPointer(pix));
if ( ri . IsAtBeginningOf ( Module . RIL _SYMBOL ) ) {
symbol = {
choices : [ ] ,
image : image ,
text : ri . GetUTF8Text ( Module . RIL _SYMBOL ) ,
confidence : ri . Confidence ( Module . RIL _SYMBOL ) ,
baseline : ri . getBaseline ( Module . RIL _SYMBOL ) ,
bbox : ri . getBoundingBox ( Module . RIL _SYMBOL ) ,
is _superscript : ! ! ri . SymbolIsSuperscript ( ) ,
is _subscript : ! ! ri . SymbolIsSubscript ( ) ,
is _dropcap : ! ! ri . SymbolIsDropcap ( )
} ;
word . symbols . push ( symbol ) ;
var ci = new Module . ChoiceIterator ( ri ) ;
do {
symbol . choices . push ( {
text : ci . GetUTF8Text ( ) ,
confidence : ci . Confidence ( )
} ) ;
} while ( ci . Next ( ) ) ;
Module . destroy ( ci ) ;
}
} while ( ri . Next ( Module . RIL _SYMBOL ) ) ;
Module . destroy ( ri ) ;
return {
text : base . GetUTF8Text ( ) ,
html : deindent ( base . GetHOCRText ( ) ) ,
confidence : base . MeanTextConf ( ) ,
blocks : blocks ,
psm : enumToString ( base . GetPageSegMode ( ) , 'PSM' ) ,
oem : enumToString ( base . oem ( ) , 'OEM' ) ,
version : base . Version ( )
} ;
} ;
// the generated HOCR is excessively indented, so
// we get rid of that indentation
function deindent ( html ) {
var lines = html . split ( '\n' ) ;
if ( lines [ 0 ] . substring ( 0 , 2 ) === " " ) {
for ( var i = 0 ; i < lines . length ; i ++ ) {
if ( lines [ i ] . substring ( 0 , 2 ) === " " ) {
lines [ i ] = lines [ i ] . slice ( 2 ) ;
}
} ;
}
return lines . join ( '\n' ) ;
}
} , { } ] , 18 : [ function ( require , module , exports ) {
module . exports = { "afr" : 1079573 , "ara" : 1701536 , "aze" : 1420865 , "bel" : 1276820 , "ben" : 6772012 , "bul" : 1605615 , "cat" : 1652368 , "ces" : 1035441 , "chi_sim" : 17710414 , "chi_tra" : 24717749 , "chr" : 320649 , "dan-frak" : 677656 , "dan" : 1972936 , "deu-frak" : 822644 , "deu" : 991656 , "ell" : 859719 , "eng" : 9453554 , "enm" : 619254 , "epo" : 1241212 , "equ" : 821130 , "est" : 1905040 , "eus" : 1641190 , "fin" : 979418 , "fra" : 1376221 , "frk" : 5912963 , "frm" : 5147082 , "glg" : 1674938 , "grc" : 3012615 , "heb" : 1051501 , "hin" : 6590065 , "hrv" : 1926995 , "hun" : 3074473 , "ind" : 1874776 , "isl" : 1634041 , "ita" : 948593 , "ita_old" : 3436571 , "jpn" : 13507168 , "kan" : 4390317 , "kor" : 5353098 , "lav" : 1843944 , "lit" : 1779240 , "mal" : 5966263 , "meme" : 88453 , "mkd" : 1163087 , "mlt" : 1463001 , "msa" : 1665427 , "nld" : 1134708 , "nor" : 2191610 , "osd" : 4274649 , "pol" : 7024662 , "por" : 909359 , "ron" : 915680 , "rus" : 5969957 , "slk-frak" : 289885 , "slk" : 2217342 , "slv" : 1611338 , "spa" : 883170 , "spa_old" : 5647453 , "sqi" : 1667041 , "srp" : 1770244 , "swa" : 757916 , "swe" : 2451917 , "tam" : 3498763 , "tel" : 5795246 , "tgl" : 1496256 , "tha" : 3811136 , "tur" : 3563264 , "ukr" : 937566 , "vie" : 2195922 }
} , { } ] , 19 : [ function ( require , module , exports ) {
'use strict' ;
var latestJob ;
var Module ;
var base ;
var adapter = { } ;
function dispatchHandlers ( packet , send ) {
function respond ( status , data ) {
send ( {
jobId : packet . jobId ,
status : status ,
action : packet . action ,
data : data
} ) ;
}
respond . resolve = respond . bind ( this , 'resolve' ) ;
respond . reject = respond . bind ( this , 'reject' ) ;
respond . progress = respond . bind ( this , 'progress' ) ;
latestJob = respond ;
try {
if ( packet . action === 'recognize' ) {
handleRecognize ( packet . payload , respond ) ;
} else if ( packet . action === 'detect' ) {
handleDetect ( packet . payload , respond ) ;
}
} catch ( err ) {
respond . reject ( err ) ;
}
}
exports . dispatchHandlers = dispatchHandlers ;
exports . setAdapter = function setAdapter ( impl ) {
adapter = impl ;
} ;
function handleInit ( req , res ) {
var MIN _MEMORY = 100663296 ;
if ( [ 'chi_sim' , 'chi_tra' , 'jpn' ] . indexOf ( req . options . lang ) != - 1 ) {
MIN _MEMORY = 167772160 ;
}
if ( ! Module || Module . TOTAL _MEMORY < MIN _MEMORY ) {
var Core = adapter . getCore ( req , res ) ;
res . progress ( { status : 'initializing tesseract' , progress : 0 } ) ;
Module = Core ( {
TOTAL _MEMORY : MIN _MEMORY ,
TesseractProgress : function TesseractProgress ( percent ) {
latestJob . progress ( { status : 'recognizing text' , progress : Math . max ( 0 , ( percent - 30 ) / 70 ) } ) ;
} ,
onRuntimeInitialized : function onRuntimeInitialized ( ) { }
} ) ;
Module . FS _createPath ( "/" , "tessdata" , true , true ) ;
base = new Module . TessBaseAPI ( ) ;
res . progress ( { status : 'initializing tesseract' , progress : 1 } ) ;
}
}
var dump = require ( './dump.js' ) ;
var desaturate = require ( './desaturate.js' ) ;
function setImage ( Module , base , image ) {
var imgbin = desaturate ( image ) ,
width = image . width ,
height = image . height ;
var ptr = Module . allocate ( imgbin , 'i8' , Module . ALLOC _NORMAL ) ;
base . SetImage ( Module . wrapPointer ( ptr ) , width , height , 1 , width ) ;
base . SetRectangle ( 0 , 0 , width , height ) ;
return ptr ;
}
function loadLanguage ( req , res , cb ) {
var lang = req . options . lang ;
if ( ! Module . _loadedLanguages ) Module . _loadedLanguages = { } ;
if ( lang in Module . _loadedLanguages ) return cb ( ) ;
adapter . getLanguageData ( req , res , function ( data ) {
res . progress ( { status : 'loading ' + lang + '.traineddata' , progress : 0 } ) ;
Module . FS _createDataFile ( 'tessdata' , lang + ".traineddata" , data , true , false ) ;
Module . _loadedLanguages [ lang ] = true ;
res . progress ( { status : 'loading ' + lang + '.traineddata' , progress : 1 } ) ;
cb ( ) ;
} ) ;
}
function handleRecognize ( req , res ) {
handleInit ( req , res ) ;
loadLanguage ( req , res , function ( ) {
var lang = req . options . lang ;
res . progress ( { status : 'initializing api' , progress : 0 } ) ;
base . Init ( null , lang ) ;
res . progress ( { status : 'initializing api' , progress : 0.3 } ) ;
var options = req . options ;
for ( var option in options ) {
if ( options . hasOwnProperty ( option ) ) {
base . SetVariable ( option , options [ option ] ) ;
}
}
res . progress ( { status : 'initializing api' , progress : 0.6 } ) ;
var ptr = setImage ( Module , base , req . image ) ;
res . progress ( { status : 'initializing api' , progress : 1 } ) ;
base . Recognize ( null ) ;
var result = dump ( Module , base ) ;
base . End ( ) ;
Module . _free ( ptr ) ;
res . resolve ( result ) ;
} ) ;
}
function handleDetect ( req , res ) {
handleInit ( req , res ) ;
req . options . lang = 'osd' ;
loadLanguage ( req , res , function ( ) {
base . Init ( null , 'osd' ) ;
base . SetPageSegMode ( Module . PSM _OSD _ONLY ) ;
var ptr = setImage ( Module , base , req . image ) ;
var results = new Module . OSResults ( ) ;
var success = base . DetectOS ( results ) ;
if ( ! success ) {
base . End ( ) ;
Module . _free ( ptr ) ;
res . reject ( "failed to detect os" ) ;
} else {
var charset = results . get _unicharset ( ) ;
var best = results . get _best _result ( ) ;
var oid = best . get _orientation _id ( ) ,
sid = best . get _script _id ( ) ;
var result = {
tesseract _script _id : sid ,
script : charset . get _script _from _script _id ( sid ) ,
script _confidence : best . get _sconfidence ( ) ,
orientation _degrees : [ 0 , 270 , 180 , 90 ] [ oid ] ,
orientation _confidence : best . get _oconfidence ( )
} ;
base . End ( ) ;
Module . _free ( ptr ) ;
res . resolve ( result ) ;
}
} ) ;
}
} , { "./desaturate.js" : 16 , "./dump.js" : 17 } ] } , { } , [ 15 ] ) ;
