3230 lines
109 KiB
JavaScript
3230 lines
109 KiB
JavaScript
|
|
||
|
|
/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
|
||
|
|
(function (global, factory) {
|
||
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.pako = {}));
|
||
|
|
})(this, (function (exports) { 'use strict';
|
||
|
|
|
||
|
|
// Note: adler32 takes 12% for level 0 and 2% for level 6.
|
||
|
|
// It isn't worth it to make additional optimizations as in original.
|
||
|
|
// Small size is preferable.
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
var adler32 = 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;
|
||
|
|
};
|
||
|
|
var adler32_1 = adler32;
|
||
|
|
|
||
|
|
// Note: we can't get significant speed boost here.
|
||
|
|
// So write code to minimize size - no pregenerated tables
|
||
|
|
// and array tools dependencies.
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
|
||
|
|
// Use ordinary array, since untyped makes no boost here
|
||
|
|
var makeTable = 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 = new Uint32Array(makeTable());
|
||
|
|
var crc32 = function crc32(crc, buf, len, pos) {
|
||
|
|
var t = crcTable;
|
||
|
|
var end = pos + len;
|
||
|
|
crc ^= -1;
|
||
|
|
for (var i = pos; i < end; i++) {
|
||
|
|
crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 0xFF];
|
||
|
|
}
|
||
|
|
return crc ^ -1; // >>> 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
var crc32_1 = crc32;
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
|
||
|
|
// See state defs from inflate.js
|
||
|
|
var BAD$1 = 16209; /* got a data error -- remain here until reset */
|
||
|
|
var TYPE$1 = 16191; /* 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 16K input buffer and a 64K 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.
|
||
|
|
*/
|
||
|
|
var inffast = function inflate_fast(strm, start) {
|
||
|
|
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 */
|
||
|
|
var 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;
|
||
|
|
|
||
|
|
/* decode literals and length/distances until end-of-block or not enough
|
||
|
|
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$1;
|
||
|
|
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$1;
|
||
|
|
break top;
|
||
|
|
}
|
||
|
|
|
||
|
|
// (!) This block is disabled in zlib defaults,
|
||
|
|
// 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$1;
|
||
|
|
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$1;
|
||
|
|
break top;
|
||
|
|
} else {
|
||
|
|
strm.msg = 'invalid literal/length code';
|
||
|
|
state.mode = BAD$1;
|
||
|
|
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;
|
||
|
|
};
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
var MAXBITS = 15;
|
||
|
|
var ENOUGH_LENS$1 = 852;
|
||
|
|
var ENOUGH_DISTS$1 = 592;
|
||
|
|
//const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
|
||
|
|
|
||
|
|
var CODES$1 = 0;
|
||
|
|
var LENS$1 = 1;
|
||
|
|
var DISTS$1 = 2;
|
||
|
|
var lbase = new Uint16Array([/* 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 = new Uint8Array([/* 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 = new Uint16Array([/* 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 = new Uint8Array([/* 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]);
|
||
|
|
var inflate_table = 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 */
|
||
|
|
// let shoextra; /* extra bits table to use */
|
||
|
|
var match; /* use base and extra for symbol >= match */
|
||
|
|
var count = new Uint16Array(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
|
||
|
|
var offs = new Uint16Array(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
|
||
|
|
var extra = null;
|
||
|
|
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$1 || 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$1) {
|
||
|
|
base = extra = work; /* dummy value--not used */
|
||
|
|
match = 20;
|
||
|
|
} else if (type === LENS$1) {
|
||
|
|
base = lbase;
|
||
|
|
extra = lext;
|
||
|
|
match = 257;
|
||
|
|
} else {
|
||
|
|
/* DISTS */
|
||
|
|
base = dbase;
|
||
|
|
extra = dext;
|
||
|
|
match = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* 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$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* process all codes and make table entries */
|
||
|
|
for (;;) {
|
||
|
|
/* create table entry */
|
||
|
|
here_bits = len - drop;
|
||
|
|
if (work[sym] + 1 < match) {
|
||
|
|
here_op = 0;
|
||
|
|
here_val = work[sym];
|
||
|
|
} else if (work[sym] >= match) {
|
||
|
|
here_op = extra[work[sym] - match];
|
||
|
|
here_val = base[work[sym] - match];
|
||
|
|
} 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$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* point entry in root table to sub-table */
|
||
|
|
low = huff & mask;
|
||
|
|
/*table.op[low] = curr;
|
||
|
|
table.bits[low] = root;
|
||
|
|
table.val[low] = next - opts.table_index;*/
|
||
|
|
table[low] = root << 24 | curr << 16 | next - table_index | 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* fill in remaining table entry if code is incomplete (guaranteed to have
|
||
|
|
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;
|
||
|
|
};
|
||
|
|
var inftrees = inflate_table;
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
var constants$1 = {
|
||
|
|
/* 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,
|
||
|
|
/* Return codes for the compression/decompression functions. Negative values
|
||
|
|
* 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
|
||
|
|
};
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
|
||
|
|
var CODES = 0;
|
||
|
|
var LENS = 1;
|
||
|
|
var DISTS = 2;
|
||
|
|
|
||
|
|
/* Public constants ==========================================================*/
|
||
|
|
/* ===========================================================================*/
|
||
|
|
|
||
|
|
var Z_FINISH$1 = constants$1.Z_FINISH,
|
||
|
|
Z_BLOCK = constants$1.Z_BLOCK,
|
||
|
|
Z_TREES = constants$1.Z_TREES,
|
||
|
|
Z_OK$1 = constants$1.Z_OK,
|
||
|
|
Z_STREAM_END$1 = constants$1.Z_STREAM_END,
|
||
|
|
Z_NEED_DICT$1 = constants$1.Z_NEED_DICT,
|
||
|
|
Z_STREAM_ERROR$1 = constants$1.Z_STREAM_ERROR,
|
||
|
|
Z_DATA_ERROR$1 = constants$1.Z_DATA_ERROR,
|
||
|
|
Z_MEM_ERROR$1 = constants$1.Z_MEM_ERROR,
|
||
|
|
Z_BUF_ERROR = constants$1.Z_BUF_ERROR,
|
||
|
|
Z_DEFLATED = constants$1.Z_DEFLATED;
|
||
|
|
|
||
|
|
/* STATES ====================================================================*/
|
||
|
|
/* ===========================================================================*/
|
||
|
|
|
||
|
|
var HEAD = 16180; /* i: waiting for magic header */
|
||
|
|
var FLAGS = 16181; /* i: waiting for method and flags (gzip) */
|
||
|
|
var TIME = 16182; /* i: waiting for modification time (gzip) */
|
||
|
|
var OS = 16183; /* i: waiting for extra flags and operating system (gzip) */
|
||
|
|
var EXLEN = 16184; /* i: waiting for extra length (gzip) */
|
||
|
|
var EXTRA = 16185; /* i: waiting for extra bytes (gzip) */
|
||
|
|
var NAME = 16186; /* i: waiting for end of file name (gzip) */
|
||
|
|
var COMMENT = 16187; /* i: waiting for end of comment (gzip) */
|
||
|
|
var HCRC = 16188; /* i: waiting for header crc (gzip) */
|
||
|
|
var DICTID = 16189; /* i: waiting for dictionary check value */
|
||
|
|
var DICT = 16190; /* waiting for inflateSetDictionary() call */
|
||
|
|
var TYPE = 16191; /* i: waiting for type bits, including last-flag bit */
|
||
|
|
var TYPEDO = 16192; /* i: same, but skip check to exit inflate on new block */
|
||
|
|
var STORED = 16193; /* i: waiting for stored size (length and complement) */
|
||
|
|
var COPY_ = 16194; /* i/o: same as COPY below, but only first time in */
|
||
|
|
var COPY = 16195; /* i/o: waiting for input or output to copy stored block */
|
||
|
|
var TABLE = 16196; /* i: waiting for dynamic block table lengths */
|
||
|
|
var LENLENS = 16197; /* i: waiting for code length code lengths */
|
||
|
|
var CODELENS = 16198; /* i: waiting for length/lit and distance code lengths */
|
||
|
|
var LEN_ = 16199; /* i: same as LEN below, but only first time in */
|
||
|
|
var LEN = 16200; /* i: waiting for length/lit/eob code */
|
||
|
|
var LENEXT = 16201; /* i: waiting for length extra bits */
|
||
|
|
var DIST = 16202; /* i: waiting for distance code */
|
||
|
|
var DISTEXT = 16203; /* i: waiting for distance extra bits */
|
||
|
|
var MATCH = 16204; /* o: waiting for output space to copy string */
|
||
|
|
var LIT = 16205; /* o: waiting for output space to write literal */
|
||
|
|
var CHECK = 16206; /* i: waiting for 32-bit check value */
|
||
|
|
var LENGTH = 16207; /* i: waiting for 32-bit length (gzip) */
|
||
|
|
var DONE = 16208; /* finished check, done -- remain here until reset */
|
||
|
|
var BAD = 16209; /* got a data error -- remain here until reset */
|
||
|
|
var MEM = 16210; /* got an inflate() memory error -- remain here until reset */
|
||
|
|
var SYNC = 16211; /* looking for synchronization bytes to restart inflate() */
|
||
|
|
|
||
|
|
/* ===========================================================================*/
|
||
|
|
|
||
|
|
var ENOUGH_LENS = 852;
|
||
|
|
var ENOUGH_DISTS = 592;
|
||
|
|
//const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
|
||
|
|
|
||
|
|
var MAX_WBITS = 15;
|
||
|
|
/* 32K LZ77 window */
|
||
|
|
var DEF_WBITS = MAX_WBITS;
|
||
|
|
var zswap32 = function zswap32(q) {
|
||
|
|
return (q >>> 24 & 0xff) + (q >>> 8 & 0xff00) + ((q & 0xff00) << 8) + ((q & 0xff) << 24);
|
||
|
|
};
|
||
|
|
function InflateState() {
|
||
|
|
this.strm = null; /* pointer back to this zlib stream */
|
||
|
|
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,
|
||
|
|
bit 2 true to validate check value */
|
||
|
|
this.havedict = false; /* true if dictionary provided */
|
||
|
|
this.flags = 0; /* gzip header method and flags (0 if zlib), or
|
||
|
|
-1 if raw or no header yet */
|
||
|
|
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 Uint16Array(320); /* temporary storage for code lengths */
|
||
|
|
this.work = new Uint16Array(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 Int32Array(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 */
|
||
|
|
}
|
||
|
|
|
||
|
|
var inflateStateCheck = function inflateStateCheck(strm) {
|
||
|
|
if (!strm) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
var state = strm.state;
|
||
|
|
if (!state || state.strm !== strm || state.mode < HEAD || state.mode > SYNC) {
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
};
|
||
|
|
var inflateResetKeep = function inflateResetKeep(strm) {
|
||
|
|
if (inflateStateCheck(strm)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
var 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.flags = -1;
|
||
|
|
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 Int32Array(ENOUGH_LENS);
|
||
|
|
state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);
|
||
|
|
state.sane = 1;
|
||
|
|
state.back = -1;
|
||
|
|
//Tracev((stderr, "inflate: reset\n"));
|
||
|
|
return Z_OK$1;
|
||
|
|
};
|
||
|
|
var inflateReset = function inflateReset(strm) {
|
||
|
|
if (inflateStateCheck(strm)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
var state = strm.state;
|
||
|
|
state.wsize = 0;
|
||
|
|
state.whave = 0;
|
||
|
|
state.wnext = 0;
|
||
|
|
return inflateResetKeep(strm);
|
||
|
|
};
|
||
|
|
var inflateReset2 = function inflateReset2(strm, windowBits) {
|
||
|
|
var wrap;
|
||
|
|
|
||
|
|
/* get the state */
|
||
|
|
if (inflateStateCheck(strm)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
var state = strm.state;
|
||
|
|
|
||
|
|
/* extract wrap request from windowBits parameter */
|
||
|
|
if (windowBits < 0) {
|
||
|
|
wrap = 0;
|
||
|
|
windowBits = -windowBits;
|
||
|
|
} else {
|
||
|
|
wrap = (windowBits >> 4) + 5;
|
||
|
|
if (windowBits < 48) {
|
||
|
|
windowBits &= 15;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* set number of window bits, free window if different */
|
||
|
|
if (windowBits && (windowBits < 8 || windowBits > 15)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
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);
|
||
|
|
};
|
||
|
|
var inflateInit2 = function inflateInit2(strm, windowBits) {
|
||
|
|
if (!strm) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
//strm.msg = Z_NULL; /* in case we return an error */
|
||
|
|
|
||
|
|
var state = new InflateState();
|
||
|
|
|
||
|
|
//if (state === Z_NULL) return Z_MEM_ERROR;
|
||
|
|
//Tracev((stderr, "inflate: allocated\n"));
|
||
|
|
strm.state = state;
|
||
|
|
state.strm = strm;
|
||
|
|
state.window = null /*Z_NULL*/;
|
||
|
|
state.mode = HEAD; /* to pass state test in inflateReset2() */
|
||
|
|
var ret = inflateReset2(strm, windowBits);
|
||
|
|
if (ret !== Z_OK$1) {
|
||
|
|
strm.state = null /*Z_NULL*/;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
var inflateInit = 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 2K 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
|
||
|
|
|
||
|
|
var fixedtables = function fixedtables(state) {
|
||
|
|
/* build fixed huffman tables if first call (may not be thread safe) */
|
||
|
|
if (virgin) {
|
||
|
|
lenfix = new Int32Array(512);
|
||
|
|
distfix = new Int32Array(32);
|
||
|
|
|
||
|
|
/* literal/length table */
|
||
|
|
var 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;
|
||
|
|
}
|
||
|
|
inftrees(LENS, state.lens, 0, 288, lenfix, 0, state.work, {
|
||
|
|
bits: 9
|
||
|
|
});
|
||
|
|
|
||
|
|
/* distance table */
|
||
|
|
sym = 0;
|
||
|
|
while (sym < 32) {
|
||
|
|
state.lens[sym++] = 5;
|
||
|
|
}
|
||
|
|
inftrees(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 32K) 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 32K to inflate() should provide a speed
|
||
|
|
advantage, since only the last 32K of output is copied to the sliding window
|
||
|
|
upon return from inflate(), and since all distances after the first 32K 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.
|
||
|
|
*/
|
||
|
|
var updatewindow = 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 Uint8Array(state.wsize);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* copy state->wsize or less output bytes into the circular window */
|
||
|
|
if (copy >= state.wsize) {
|
||
|
|
state.window.set(src.subarray(end - state.wsize, end), 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);
|
||
|
|
state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);
|
||
|
|
copy -= dist;
|
||
|
|
if (copy) {
|
||
|
|
//zmemcpy(state->window, end - copy, copy);
|
||
|
|
state.window.set(src.subarray(end - copy, end), 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;
|
||
|
|
};
|
||
|
|
var inflate$1 = 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)
|
||
|
|
//let 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 Uint8Array(4); /* buffer for gzip header crc calculation */
|
||
|
|
var opts;
|
||
|
|
var n; // temporary variable for NEED_BITS
|
||
|
|
|
||
|
|
var order = /* permutation of code lengths */
|
||
|
|
new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
|
||
|
|
if (inflateStateCheck(strm) || !strm.output || !strm.input && strm.avail_in !== 0) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
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$1;
|
||
|
|
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 */
|
||
|
|
if (state.wbits === 0) {
|
||
|
|
state.wbits = 15;
|
||
|
|
}
|
||
|
|
state.check = 0 /*crc32(0L, Z_NULL, 0)*/;
|
||
|
|
//=== CRC2(state.check, hold);
|
||
|
|
hbuf[0] = hold & 0xff;
|
||
|
|
hbuf[1] = hold >>> 8 & 0xff;
|
||
|
|
state.check = crc32_1(state.check, hbuf, 2, 0);
|
||
|
|
//===//
|
||
|
|
|
||
|
|
//=== INITBITS();
|
||
|
|
hold = 0;
|
||
|
|
bits = 0;
|
||
|
|
//===//
|
||
|
|
state.mode = FLAGS;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
if (len > 15 || len > state.wbits) {
|
||
|
|
strm.msg = 'invalid window size';
|
||
|
|
state.mode = BAD;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// !!! pako patch. Force use `options.windowBits` if passed.
|
||
|
|
// Required to always use max window size by default.
|
||
|
|
state.dmax = 1 << state.wbits;
|
||
|
|
//state.dmax = 1 << len;
|
||
|
|
|
||
|
|
state.flags = 0; /* indicate zlib header */
|
||
|
|
//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 && state.wrap & 4) {
|
||
|
|
//=== CRC2(state.check, hold);
|
||
|
|
hbuf[0] = hold & 0xff;
|
||
|
|
hbuf[1] = hold >>> 8 & 0xff;
|
||
|
|
state.check = crc32_1(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 && state.wrap & 4) {
|
||
|
|
//=== 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_1(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 && state.wrap & 4) {
|
||
|
|
//=== CRC2(state.check, hold);
|
||
|
|
hbuf[0] = hold & 0xff;
|
||
|
|
hbuf[1] = hold >>> 8 & 0xff;
|
||
|
|
state.check = crc32_1(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 && state.wrap & 4) {
|
||
|
|
//=== CRC2(state.check, hold);
|
||
|
|
hbuf[0] = hold & 0xff;
|
||
|
|
hbuf[1] = hold >>> 8 & 0xff;
|
||
|
|
state.check = crc32_1(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 convenient processing later
|
||
|
|
state.head.extra = new Uint8Array(state.head.extra_len);
|
||
|
|
}
|
||
|
|
state.head.extra.set(input.subarray(next,
|
||
|
|
// extra field is limited to 65536 bytes
|
||
|
|
// - no need for additional size check
|
||
|
|
next + 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.wrap & 4) {
|
||
|
|
state.check = crc32_1(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.wrap & 4) {
|
||
|
|
state.check = crc32_1(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.wrap & 4) {
|
||
|
|
state.check = crc32_1(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 (state.wrap & 4 && 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$1;
|
||
|
|
}
|
||
|
|
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); ---
|
||
|
|
output.set(input.subarray(next, 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 = inftrees(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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* build code tables -- note: do not change the lenbits or distbits
|
||
|
|
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 = inftrees(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 = inftrees(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;
|
||
|
|
//---
|
||
|
|
inffast(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 defaults,
|
||
|
|
// 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 '|' instead of '+' to make sure that result is signed
|
||
|
|
hold |= input[next++] << bits;
|
||
|
|
bits += 8;
|
||
|
|
}
|
||
|
|
//===//
|
||
|
|
_out -= left;
|
||
|
|
strm.total_out += _out;
|
||
|
|
state.total += _out;
|
||
|
|
if (state.wrap & 4 && _out) {
|
||
|
|
strm.adler = state.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
|
||
|
|
state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
|
||
|
|
}
|
||
|
|
_out = left;
|
||
|
|
// NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
|
||
|
|
if (state.wrap & 4 && (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 (state.wrap & 4 && 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$1;
|
||
|
|
break inf_leave;
|
||
|
|
case BAD:
|
||
|
|
ret = Z_DATA_ERROR$1;
|
||
|
|
break inf_leave;
|
||
|
|
case MEM:
|
||
|
|
return Z_MEM_ERROR$1;
|
||
|
|
case SYNC:
|
||
|
|
/* falls through */
|
||
|
|
default:
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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$1)) {
|
||
|
|
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) ;
|
||
|
|
}
|
||
|
|
_in -= strm.avail_in;
|
||
|
|
_out -= strm.avail_out;
|
||
|
|
strm.total_in += _in;
|
||
|
|
strm.total_out += _out;
|
||
|
|
state.total += _out;
|
||
|
|
if (state.wrap & 4 && _out) {
|
||
|
|
strm.adler = state.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
|
||
|
|
state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(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$1) && ret === Z_OK$1) {
|
||
|
|
ret = Z_BUF_ERROR;
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
};
|
||
|
|
var inflateEnd = function inflateEnd(strm) {
|
||
|
|
if (inflateStateCheck(strm)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
var state = strm.state;
|
||
|
|
if (state.window) {
|
||
|
|
state.window = null;
|
||
|
|
}
|
||
|
|
strm.state = null;
|
||
|
|
return Z_OK$1;
|
||
|
|
};
|
||
|
|
var inflateGetHeader = function inflateGetHeader(strm, head) {
|
||
|
|
/* check state */
|
||
|
|
if (inflateStateCheck(strm)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
var state = strm.state;
|
||
|
|
if ((state.wrap & 2) === 0) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* save header structure */
|
||
|
|
state.head = head;
|
||
|
|
head.done = false;
|
||
|
|
return Z_OK$1;
|
||
|
|
};
|
||
|
|
var inflateSetDictionary = function inflateSetDictionary(strm, dictionary) {
|
||
|
|
var dictLength = dictionary.length;
|
||
|
|
var state;
|
||
|
|
var dictid;
|
||
|
|
var ret;
|
||
|
|
|
||
|
|
/* check state */
|
||
|
|
if (inflateStateCheck(strm)) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
state = strm.state;
|
||
|
|
if (state.wrap !== 0 && state.mode !== DICT) {
|
||
|
|
return Z_STREAM_ERROR$1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* check for correct dictionary identifier */
|
||
|
|
if (state.mode === DICT) {
|
||
|
|
dictid = 1; /* adler32(0, null, 0)*/
|
||
|
|
/* dictid = adler32(dictid, dictionary, dictLength); */
|
||
|
|
dictid = adler32_1(dictid, dictionary, dictLength, 0);
|
||
|
|
if (dictid !== state.check) {
|
||
|
|
return Z_DATA_ERROR$1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/* copy dictionary to window using updatewindow(), which will amend the
|
||
|
|
existing dictionary if appropriate */
|
||
|
|
ret = updatewindow(strm, dictionary, dictLength, dictLength);
|
||
|
|
if (ret) {
|
||
|
|
state.mode = MEM;
|
||
|
|
return Z_MEM_ERROR$1;
|
||
|
|
}
|
||
|
|
state.havedict = 1;
|
||
|
|
// Tracev((stderr, "inflate: dictionary set\n"));
|
||
|
|
return Z_OK$1;
|
||
|
|
};
|
||
|
|
var inflateReset_1 = inflateReset;
|
||
|
|
var inflateReset2_1 = inflateReset2;
|
||
|
|
var inflateResetKeep_1 = inflateResetKeep;
|
||
|
|
var inflateInit_1 = inflateInit;
|
||
|
|
var inflateInit2_1 = inflateInit2;
|
||
|
|
var inflate_2$1 = inflate$1;
|
||
|
|
var inflateEnd_1 = inflateEnd;
|
||
|
|
var inflateGetHeader_1 = inflateGetHeader;
|
||
|
|
var inflateSetDictionary_1 = inflateSetDictionary;
|
||
|
|
var inflateInfo = 'pako inflate (from Nodeca project)';
|
||
|
|
|
||
|
|
/* Not implemented
|
||
|
|
module.exports.inflateCodesUsed = inflateCodesUsed;
|
||
|
|
module.exports.inflateCopy = inflateCopy;
|
||
|
|
module.exports.inflateGetDictionary = inflateGetDictionary;
|
||
|
|
module.exports.inflateMark = inflateMark;
|
||
|
|
module.exports.inflatePrime = inflatePrime;
|
||
|
|
module.exports.inflateSync = inflateSync;
|
||
|
|
module.exports.inflateSyncPoint = inflateSyncPoint;
|
||
|
|
module.exports.inflateUndermine = inflateUndermine;
|
||
|
|
module.exports.inflateValidate = inflateValidate;
|
||
|
|
*/
|
||
|
|
|
||
|
|
var inflate_1$1 = {
|
||
|
|
inflateReset: inflateReset_1,
|
||
|
|
inflateReset2: inflateReset2_1,
|
||
|
|
inflateResetKeep: inflateResetKeep_1,
|
||
|
|
inflateInit: inflateInit_1,
|
||
|
|
inflateInit2: inflateInit2_1,
|
||
|
|
inflate: inflate_2$1,
|
||
|
|
inflateEnd: inflateEnd_1,
|
||
|
|
inflateGetHeader: inflateGetHeader_1,
|
||
|
|
inflateSetDictionary: inflateSetDictionary_1,
|
||
|
|
inflateInfo: inflateInfo
|
||
|
|
};
|
||
|
|
|
||
|
|
function _typeof(obj) {
|
||
|
|
"@babel/helpers - typeof";
|
||
|
|
|
||
|
|
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
|
||
|
|
return typeof obj;
|
||
|
|
} : function (obj) {
|
||
|
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||
|
|
}, _typeof(obj);
|
||
|
|
}
|
||
|
|
|
||
|
|
var _has = function _has(obj, key) {
|
||
|
|
return Object.prototype.hasOwnProperty.call(obj, key);
|
||
|
|
};
|
||
|
|
var assign = function assign(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 (_has(source, p)) {
|
||
|
|
obj[p] = source[p];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return obj;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Join array of chunks to single array.
|
||
|
|
var flattenChunks = function flattenChunks(chunks) {
|
||
|
|
// calculate data length
|
||
|
|
var len = 0;
|
||
|
|
for (var i = 0, l = chunks.length; i < l; i++) {
|
||
|
|
len += chunks[i].length;
|
||
|
|
}
|
||
|
|
|
||
|
|
// join chunks
|
||
|
|
var result = new Uint8Array(len);
|
||
|
|
for (var _i = 0, pos = 0, _l = chunks.length; _i < _l; _i++) {
|
||
|
|
var chunk = chunks[_i];
|
||
|
|
result.set(chunk, pos);
|
||
|
|
pos += chunk.length;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var common = {
|
||
|
|
assign: assign,
|
||
|
|
flattenChunks: flattenChunks
|
||
|
|
};
|
||
|
|
|
||
|
|
// String encode/decode helpers
|
||
|
|
|
||
|
|
// 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 Safari
|
||
|
|
//
|
||
|
|
var STR_APPLY_UIA_OK = true;
|
||
|
|
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 Uint8Array(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)
|
||
|
|
var string2buf = function string2buf(str) {
|
||
|
|
if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {
|
||
|
|
return new TextEncoder().encode(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 Uint8Array(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
|
||
|
|
var buf2binstring = function buf2binstring(buf, len) {
|
||
|
|
// On Chrome, the arguments in a function call that are allowed is `65534`.
|
||
|
|
// If the length of the buffer is smaller than that, we can use this optimization,
|
||
|
|
// otherwise we will take a slower path.
|
||
|
|
if (len < 65534) {
|
||
|
|
if (buf.subarray && STR_APPLY_UIA_OK) {
|
||
|
|
return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var result = '';
|
||
|
|
for (var i = 0; i < len; i++) {
|
||
|
|
result += String.fromCharCode(buf[i]);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
// convert array to string
|
||
|
|
var buf2string = function buf2string(buf, max) {
|
||
|
|
var len = max || buf.length;
|
||
|
|
if (typeof TextDecoder === 'function' && TextDecoder.prototype.decode) {
|
||
|
|
return new TextDecoder().decode(buf.subarray(0, max));
|
||
|
|
}
|
||
|
|
var i, out;
|
||
|
|
|
||
|
|
// 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;) {
|
||
|
|
var c = buf[i++];
|
||
|
|
// quick process ascii
|
||
|
|
if (c < 0x80) {
|
||
|
|
utf16buf[out++] = c;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
var 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);
|
||
|
|
var utf8border = function utf8border(buf, max) {
|
||
|
|
max = max || buf.length;
|
||
|
|
if (max > buf.length) {
|
||
|
|
max = buf.length;
|
||
|
|
}
|
||
|
|
|
||
|
|
// go back from last position, until start of sequence found
|
||
|
|
var pos = max - 1;
|
||
|
|
while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) {
|
||
|
|
pos--;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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 buffer is too small,
|
||
|
|
// return max too.
|
||
|
|
if (pos === 0) {
|
||
|
|
return max;
|
||
|
|
}
|
||
|
|
return pos + _utf8len[buf[pos]] > max ? pos : max;
|
||
|
|
};
|
||
|
|
var strings = {
|
||
|
|
string2buf: string2buf,
|
||
|
|
buf2string: buf2string,
|
||
|
|
utf8border: utf8border
|
||
|
|
};
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
var messages = {
|
||
|
|
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) */
|
||
|
|
};
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
var zstream = ZStream;
|
||
|
|
|
||
|
|
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||
|
|
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
|
||
|
|
//
|
||
|
|
// This software is provided 'as-is', without any express or implied
|
||
|
|
// warranty. In no event will the authors be held liable for any damages
|
||
|
|
// arising from the use of this software.
|
||
|
|
//
|
||
|
|
// Permission is granted to anyone to use this software for any purpose,
|
||
|
|
// including commercial applications, and to alter it and redistribute it
|
||
|
|
// freely, subject to the following restrictions:
|
||
|
|
//
|
||
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
||
|
|
// claim that you wrote the original software. If you use this software
|
||
|
|
// in a product, an acknowledgment in the product documentation would be
|
||
|
|
// appreciated but is not required.
|
||
|
|
// 2. Altered source versions must be plainly marked as such, and must not be
|
||
|
|
// misrepresented as being the original software.
|
||
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
var gzheader = GZheader;
|
||
|
|
|
||
|
|
var toString = Object.prototype.toString;
|
||
|
|
|
||
|
|
/* Public constants ==========================================================*/
|
||
|
|
/* ===========================================================================*/
|
||
|
|
|
||
|
|
var Z_NO_FLUSH = constants$1.Z_NO_FLUSH,
|
||
|
|
Z_FINISH = constants$1.Z_FINISH,
|
||
|
|
Z_OK = constants$1.Z_OK,
|
||
|
|
Z_STREAM_END = constants$1.Z_STREAM_END,
|
||
|
|
Z_NEED_DICT = constants$1.Z_NEED_DICT,
|
||
|
|
Z_STREAM_ERROR = constants$1.Z_STREAM_ERROR,
|
||
|
|
Z_DATA_ERROR = constants$1.Z_DATA_ERROR,
|
||
|
|
Z_MEM_ERROR = constants$1.Z_MEM_ERROR;
|
||
|
|
|
||
|
|
/* ===========================================================================*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* class Inflate
|
||
|
|
*
|
||
|
|
* Generic JS-style wrapper for zlib calls. If you don't need
|
||
|
|
* streaming behaviour - use more simple functions: [[inflate]]
|
||
|
|
* and [[inflateRaw]].
|
||
|
|
**/
|
||
|
|
|
||
|
|
/* internal
|
||
|
|
* inflate.chunks -> Array
|
||
|
|
*
|
||
|
|
* Chunks of output data, if [[Inflate#onData]] not overridden.
|
||
|
|
**/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Inflate.result -> Uint8Array|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).
|
||
|
|
**/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 (16K 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
|
||
|
|
* const pako = require('pako')
|
||
|
|
* const chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])
|
||
|
|
* const chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);
|
||
|
|
*
|
||
|
|
* const 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) {
|
||
|
|
this.options = common.assign({
|
||
|
|
chunkSize: 1024 * 64,
|
||
|
|
windowBits: 15,
|
||
|
|
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 = inflate_1$1.inflateInit2(this.strm, opt.windowBits);
|
||
|
|
if (status !== Z_OK) {
|
||
|
|
throw new Error(messages[status]);
|
||
|
|
}
|
||
|
|
this.header = new gzheader();
|
||
|
|
inflate_1$1.inflateGetHeader(this.strm, this.header);
|
||
|
|
|
||
|
|
// Setup dictionary
|
||
|
|
if (opt.dictionary) {
|
||
|
|
// Convert data if needed
|
||
|
|
if (typeof opt.dictionary === 'string') {
|
||
|
|
opt.dictionary = strings.string2buf(opt.dictionary);
|
||
|
|
} else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
|
||
|
|
opt.dictionary = new Uint8Array(opt.dictionary);
|
||
|
|
}
|
||
|
|
if (opt.raw) {
|
||
|
|
//In raw mode we need to set the dictionary early
|
||
|
|
status = inflate_1$1.inflateSetDictionary(this.strm, opt.dictionary);
|
||
|
|
if (status !== Z_OK) {
|
||
|
|
throw new Error(messages[status]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Inflate#push(data[, flush_mode]) -> Boolean
|
||
|
|
* - data (Uint8Array|ArrayBuffer): input data
|
||
|
|
* - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE
|
||
|
|
* flush modes. See constants. Skipped or `false` means Z_NO_FLUSH,
|
||
|
|
* `true` means Z_FINISH.
|
||
|
|
*
|
||
|
|
* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
|
||
|
|
* new output chunks. Returns `true` on success. If end of stream detected,
|
||
|
|
* [[Inflate#onEnd]] will be called.
|
||
|
|
*
|
||
|
|
* `flush_mode` is not needed for normal operation, because end of stream
|
||
|
|
* detected automatically. You may try to use it for advanced things, but
|
||
|
|
* this functionality was not tested.
|
||
|
|
*
|
||
|
|
* On fail call [[Inflate#onEnd]] with error code and return false.
|
||
|
|
*
|
||
|
|
* ##### Example
|
||
|
|
*
|
||
|
|
* ```javascript
|
||
|
|
* push(chunk, false); // push one of data chunks
|
||
|
|
* ...
|
||
|
|
* push(chunk, true); // push last chunk
|
||
|
|
* ```
|
||
|
|
**/
|
||
|
|
Inflate.prototype.push = function (data, flush_mode) {
|
||
|
|
var strm = this.strm;
|
||
|
|
var chunkSize = this.options.chunkSize;
|
||
|
|
var dictionary = this.options.dictionary;
|
||
|
|
var status, _flush_mode, last_avail_out;
|
||
|
|
if (this.ended) return false;
|
||
|
|
if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;else _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH;
|
||
|
|
|
||
|
|
// Convert data if needed
|
||
|
|
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;
|
||
|
|
for (;;) {
|
||
|
|
if (strm.avail_out === 0) {
|
||
|
|
strm.output = new Uint8Array(chunkSize);
|
||
|
|
strm.next_out = 0;
|
||
|
|
strm.avail_out = chunkSize;
|
||
|
|
}
|
||
|
|
status = inflate_1$1.inflate(strm, _flush_mode);
|
||
|
|
if (status === Z_NEED_DICT && dictionary) {
|
||
|
|
status = inflate_1$1.inflateSetDictionary(strm, dictionary);
|
||
|
|
if (status === Z_OK) {
|
||
|
|
status = inflate_1$1.inflate(strm, _flush_mode);
|
||
|
|
} else if (status === Z_DATA_ERROR) {
|
||
|
|
// Replace code with more verbose
|
||
|
|
status = Z_NEED_DICT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Skip snyc markers if more data follows and not raw mode
|
||
|
|
while (strm.avail_in > 0 && status === Z_STREAM_END && strm.state.wrap > 0 && data[strm.next_in] !== 0) {
|
||
|
|
inflate_1$1.inflateReset(strm);
|
||
|
|
status = inflate_1$1.inflate(strm, _flush_mode);
|
||
|
|
}
|
||
|
|
switch (status) {
|
||
|
|
case Z_STREAM_ERROR:
|
||
|
|
case Z_DATA_ERROR:
|
||
|
|
case Z_NEED_DICT:
|
||
|
|
case Z_MEM_ERROR:
|
||
|
|
this.onEnd(status);
|
||
|
|
this.ended = true;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Remember real `avail_out` value, because we may patch out buffer content
|
||
|
|
// to align utf8 strings boundaries.
|
||
|
|
last_avail_out = strm.avail_out;
|
||
|
|
if (strm.next_out) {
|
||
|
|
if (strm.avail_out === 0 || status === Z_STREAM_END) {
|
||
|
|
if (this.options.to === 'string') {
|
||
|
|
var next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
|
||
|
|
var tail = strm.next_out - next_out_utf8;
|
||
|
|
var utf8str = strings.buf2string(strm.output, next_out_utf8);
|
||
|
|
|
||
|
|
// move tail & realign counters
|
||
|
|
strm.next_out = tail;
|
||
|
|
strm.avail_out = chunkSize - tail;
|
||
|
|
if (tail) strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0);
|
||
|
|
this.onData(utf8str);
|
||
|
|
} else {
|
||
|
|
this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Must repeat iteration if out buffer is full
|
||
|
|
if (status === Z_OK && last_avail_out === 0) continue;
|
||
|
|
|
||
|
|
// Finalize if end of stream reached.
|
||
|
|
if (status === Z_STREAM_END) {
|
||
|
|
status = inflate_1$1.inflateEnd(this.strm);
|
||
|
|
this.onEnd(status);
|
||
|
|
this.ended = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (strm.avail_in === 0) break;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Inflate#onData(chunk) -> Void
|
||
|
|
* - chunk (Uint8Array|String): output data. 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). By default - join collected chunks,
|
||
|
|
* free memory and fill `results` / `err` properties.
|
||
|
|
**/
|
||
|
|
Inflate.prototype.onEnd = function (status) {
|
||
|
|
// On success - join
|
||
|
|
if (status === Z_OK) {
|
||
|
|
if (this.options.to === 'string') {
|
||
|
|
this.result = this.chunks.join('');
|
||
|
|
} else {
|
||
|
|
this.result = common.flattenChunks(this.chunks);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.chunks = [];
|
||
|
|
this.err = status;
|
||
|
|
this.msg = this.strm.msg;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* inflate(data[, options]) -> Uint8Array|String
|
||
|
|
* - data (Uint8Array|ArrayBuffer): 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
|
||
|
|
* const pako = require('pako');
|
||
|
|
* const input = pako.deflate(new Uint8Array([1,2,3,4,5,6,7,8,9]));
|
||
|
|
* let output;
|
||
|
|
*
|
||
|
|
* try {
|
||
|
|
* output = pako.inflate(input);
|
||
|
|
* } catch (err) {
|
||
|
|
* console.log(err);
|
||
|
|
* }
|
||
|
|
* ```
|
||
|
|
**/
|
||
|
|
function inflate(input, options) {
|
||
|
|
var inflator = new Inflate(options);
|
||
|
|
inflator.push(input);
|
||
|
|
|
||
|
|
// That will never happens, if you don't cheat with options :)
|
||
|
|
if (inflator.err) throw inflator.msg || messages[inflator.err];
|
||
|
|
return inflator.result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* inflateRaw(data[, options]) -> Uint8Array|String
|
||
|
|
* - data (Uint8Array|ArrayBuffer): 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|String
|
||
|
|
* - data (Uint8Array|ArrayBuffer): input data to decompress.
|
||
|
|
* - options (Object): zlib inflate options.
|
||
|
|
*
|
||
|
|
* Just shortcut to [[inflate]], because it autodetects format
|
||
|
|
* by header.content. Done for convenience.
|
||
|
|
**/
|
||
|
|
|
||
|
|
var Inflate_1 = Inflate;
|
||
|
|
var inflate_2 = inflate;
|
||
|
|
var inflateRaw_1 = inflateRaw;
|
||
|
|
var ungzip = inflate;
|
||
|
|
var constants = constants$1;
|
||
|
|
var inflate_1 = {
|
||
|
|
Inflate: Inflate_1,
|
||
|
|
inflate: inflate_2,
|
||
|
|
inflateRaw: inflateRaw_1,
|
||
|
|
ungzip: ungzip,
|
||
|
|
constants: constants
|
||
|
|
};
|
||
|
|
|
||
|
|
exports.Inflate = Inflate_1;
|
||
|
|
exports.constants = constants;
|
||
|
|
exports["default"] = inflate_1;
|
||
|
|
exports.inflate = inflate_2;
|
||
|
|
exports.inflateRaw = inflateRaw_1;
|
||
|
|
exports.ungzip = ungzip;
|
||
|
|
|
||
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
|
|
||
|
|
}));
|