You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1464 lines
54 KiB
1464 lines
54 KiB
9 months ago
|
!(function (e) {
|
||
|
|
'object' == typeof exports && 'undefined' != typeof module
|
||
|
|
? (module.exports = e())
|
||
|
|
: 'function' == typeof define && define.amd
|
||
|
|
? define([], e)
|
||
|
|
: (('undefined' != typeof window
|
||
|
|
? window
|
||
|
|
: 'undefined' != typeof global
|
||
|
|
? global
|
||
|
|
: 'undefined' != typeof self
|
||
|
|
? self
|
||
|
|
: this
|
||
|
|
).pako = e());
|
||
|
|
})(function () {
|
||
|
|
return (function e(t, i, n) {
|
||
|
|
function a(o, s) {
|
||
|
|
if (!i[o]) {
|
||
|
|
if (!t[o]) {
|
||
|
|
var f = 'function' == typeof require && require;
|
||
|
|
if (!s && f) return f(o, !0);
|
||
|
|
if (r) return r(o, !0);
|
||
|
|
var l = new Error("Cannot find module '" + o + "'");
|
||
|
|
throw ((l.code = 'MODULE_NOT_FOUND'), l);
|
||
|
|
}
|
||
|
|
var d = (i[o] = { exports: {} });
|
||
|
|
t[o][0].call(
|
||
|
|
d.exports,
|
||
|
|
function (e) {
|
||
|
|
return a(t[o][1][e] || e);
|
||
|
|
},
|
||
|
|
d,
|
||
|
|
d.exports,
|
||
|
|
e,
|
||
|
|
t,
|
||
|
|
i,
|
||
|
|
n
|
||
|
|
);
|
||
|
|
}
|
||
|
|
return i[o].exports;
|
||
|
|
}
|
||
|
|
for (var r = 'function' == typeof require && require, o = 0; o < n.length; o++) a(n[o]);
|
||
|
|
return a;
|
||
|
|
})(
|
||
|
|
{
|
||
|
|
1: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
var n =
|
||
|
|
'undefined' != typeof Uint8Array &&
|
||
|
|
'undefined' != typeof Uint16Array &&
|
||
|
|
'undefined' != typeof Int32Array;
|
||
|
|
(i.assign = function (e) {
|
||
|
|
for (var t, i, n = Array.prototype.slice.call(arguments, 1); n.length; ) {
|
||
|
|
var a = n.shift();
|
||
|
|
if (a) {
|
||
|
|
if ('object' != typeof a) throw new TypeError(a + 'must be non-object');
|
||
|
|
for (var r in a)
|
||
|
|
(t = a), (i = r), Object.prototype.hasOwnProperty.call(t, i) && (e[r] = a[r]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return e;
|
||
|
|
}),
|
||
|
|
(i.shrinkBuf = function (e, t) {
|
||
|
|
return e.length === t ? e : e.subarray ? e.subarray(0, t) : ((e.length = t), e);
|
||
|
|
});
|
||
|
|
var a = {
|
||
|
|
arraySet: function (e, t, i, n, a) {
|
||
|
|
if (t.subarray && e.subarray) e.set(t.subarray(i, i + n), a);
|
||
|
|
else for (var r = 0; r < n; r++) e[a + r] = t[i + r];
|
||
|
|
},
|
||
|
|
flattenChunks: function (e) {
|
||
|
|
var t, i, n, a, r, o;
|
||
|
|
for (t = n = 0, i = e.length; t < i; t++) n += e[t].length;
|
||
|
|
for (o = new Uint8Array(n), t = a = 0, i = e.length; t < i; t++)
|
||
|
|
(r = e[t]), o.set(r, a), (a += r.length);
|
||
|
|
return o;
|
||
|
|
},
|
||
|
|
},
|
||
|
|
r = {
|
||
|
|
arraySet: function (e, t, i, n, a) {
|
||
|
|
for (var r = 0; r < n; r++) e[a + r] = t[i + r];
|
||
|
|
},
|
||
|
|
flattenChunks: function (e) {
|
||
|
|
return [].concat.apply([], e);
|
||
|
|
},
|
||
|
|
};
|
||
|
|
(i.setTyped = function (e) {
|
||
|
|
e
|
||
|
|
? ((i.Buf8 = Uint8Array),
|
||
|
|
(i.Buf16 = Uint16Array),
|
||
|
|
(i.Buf32 = Int32Array),
|
||
|
|
i.assign(i, a))
|
||
|
|
: ((i.Buf8 = Array), (i.Buf16 = Array), (i.Buf32 = Array), i.assign(i, r));
|
||
|
|
}),
|
||
|
|
i.setTyped(n);
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
2: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
var n = e('./common'),
|
||
|
|
a = !0,
|
||
|
|
r = !0;
|
||
|
|
try {
|
||
|
|
String.fromCharCode.apply(null, [0]);
|
||
|
|
} catch (e) {
|
||
|
|
a = !1;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
String.fromCharCode.apply(null, new Uint8Array(1));
|
||
|
|
} catch (e) {
|
||
|
|
r = !1;
|
||
|
|
}
|
||
|
|
for (var o = new n.Buf8(256), s = 0; s < 256; s++)
|
||
|
|
o[s] = 252 <= s ? 6 : 248 <= s ? 5 : 240 <= s ? 4 : 224 <= s ? 3 : 192 <= s ? 2 : 1;
|
||
|
|
function f(e, t) {
|
||
|
|
if (t < 65534 && ((e.subarray && r) || (!e.subarray && a)))
|
||
|
|
return String.fromCharCode.apply(null, n.shrinkBuf(e, t));
|
||
|
|
for (var i = '', o = 0; o < t; o++) i += String.fromCharCode(e[o]);
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
(o[254] = o[254] = 1),
|
||
|
|
(i.string2buf = function (e) {
|
||
|
|
var t,
|
||
|
|
i,
|
||
|
|
a,
|
||
|
|
r,
|
||
|
|
o,
|
||
|
|
s = e.length,
|
||
|
|
f = 0;
|
||
|
|
for (r = 0; r < s; r++)
|
||
|
|
55296 == (64512 & (i = e.charCodeAt(r))) &&
|
||
|
|
r + 1 < s &&
|
||
|
|
56320 == (64512 & (a = e.charCodeAt(r + 1))) &&
|
||
|
|
((i = 65536 + ((i - 55296) << 10) + (a - 56320)), r++),
|
||
|
|
(f += i < 128 ? 1 : i < 2048 ? 2 : i < 65536 ? 3 : 4);
|
||
|
|
for (t = new n.Buf8(f), r = o = 0; o < f; r++)
|
||
|
|
55296 == (64512 & (i = e.charCodeAt(r))) &&
|
||
|
|
r + 1 < s &&
|
||
|
|
56320 == (64512 & (a = e.charCodeAt(r + 1))) &&
|
||
|
|
((i = 65536 + ((i - 55296) << 10) + (a - 56320)), r++),
|
||
|
|
i < 128
|
||
|
|
? (t[o++] = i)
|
||
|
|
: (i < 2048
|
||
|
|
? (t[o++] = 192 | (i >>> 6))
|
||
|
|
: (i < 65536
|
||
|
|
? (t[o++] = 224 | (i >>> 12))
|
||
|
|
: ((t[o++] = 240 | (i >>> 18)), (t[o++] = 128 | ((i >>> 12) & 63))),
|
||
|
|
(t[o++] = 128 | ((i >>> 6) & 63))),
|
||
|
|
(t[o++] = 128 | (63 & i)));
|
||
|
|
return t;
|
||
|
|
}),
|
||
|
|
(i.buf2binstring = function (e) {
|
||
|
|
return f(e, e.length);
|
||
|
|
}),
|
||
|
|
(i.binstring2buf = function (e) {
|
||
|
|
for (var t = new n.Buf8(e.length), i = 0, a = t.length; i < a; i++)
|
||
|
|
t[i] = e.charCodeAt(i);
|
||
|
|
return t;
|
||
|
|
}),
|
||
|
|
(i.buf2string = function (e, t) {
|
||
|
|
var i,
|
||
|
|
n,
|
||
|
|
a,
|
||
|
|
r,
|
||
|
|
s = t || e.length,
|
||
|
|
l = new Array(2 * s);
|
||
|
|
for (i = n = 0; i < s; )
|
||
|
|
if ((a = e[i++]) < 128) l[n++] = a;
|
||
|
|
else if (4 < (r = o[a])) (l[n++] = 65533), (i += r - 1);
|
||
|
|
else {
|
||
|
|
for (a &= 2 === r ? 31 : 3 === r ? 15 : 7; 1 < r && i < s; )
|
||
|
|
(a = (a << 6) | (63 & e[i++])), r--;
|
||
|
|
1 < r
|
||
|
|
? (l[n++] = 65533)
|
||
|
|
: a < 65536
|
||
|
|
? (l[n++] = a)
|
||
|
|
: ((a -= 65536),
|
||
|
|
(l[n++] = 55296 | ((a >> 10) & 1023)),
|
||
|
|
(l[n++] = 56320 | (1023 & a)));
|
||
|
|
}
|
||
|
|
return f(l, n);
|
||
|
|
}),
|
||
|
|
(i.utf8border = function (e, t) {
|
||
|
|
var i;
|
||
|
|
for (
|
||
|
|
(t = t || e.length) > e.length && (t = e.length), i = t - 1;
|
||
|
|
0 <= i && 128 == (192 & e[i]);
|
||
|
|
|
||
|
|
)
|
||
|
|
i--;
|
||
|
|
return i < 0 || 0 === i ? t : i + o[e[i]] > t ? i : t;
|
||
|
|
});
|
||
|
|
},
|
||
|
|
{ './common': 1 },
|
||
|
|
],
|
||
|
|
3: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
t.exports = function (e, t, i, n) {
|
||
|
|
for (var a = (65535 & e) | 0, r = ((e >>> 16) & 65535) | 0, o = 0; 0 !== i; ) {
|
||
|
|
for (i -= o = 2e3 < i ? 2e3 : i; (r = (r + (a = (a + t[n++]) | 0)) | 0), --o; );
|
||
|
|
(a %= 65521), (r %= 65521);
|
||
|
|
}
|
||
|
|
return a | (r << 16) | 0;
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
4: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
t.exports = {
|
||
|
|
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,
|
||
|
|
Z_OK: 0,
|
||
|
|
Z_STREAM_END: 1,
|
||
|
|
Z_NEED_DICT: 2,
|
||
|
|
Z_ERRNO: -1,
|
||
|
|
Z_STREAM_ERROR: -2,
|
||
|
|
Z_DATA_ERROR: -3,
|
||
|
|
Z_BUF_ERROR: -5,
|
||
|
|
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,
|
||
|
|
Z_BINARY: 0,
|
||
|
|
Z_TEXT: 1,
|
||
|
|
Z_UNKNOWN: 2,
|
||
|
|
Z_DEFLATED: 8,
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
5: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
var n = (function () {
|
||
|
|
for (var e, t = [], i = 0; i < 256; i++) {
|
||
|
|
e = i;
|
||
|
|
for (var n = 0; n < 8; n++) e = 1 & e ? 3988292384 ^ (e >>> 1) : e >>> 1;
|
||
|
|
t[i] = e;
|
||
|
|
}
|
||
|
|
return t;
|
||
|
|
})();
|
||
|
|
t.exports = function (e, t, i, a) {
|
||
|
|
var r = n,
|
||
|
|
o = a + i;
|
||
|
|
e ^= -1;
|
||
|
|
for (var s = a; s < o; s++) e = (e >>> 8) ^ r[255 & (e ^ t[s])];
|
||
|
|
return -1 ^ e;
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
6: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
t.exports = function () {
|
||
|
|
(this.text = 0),
|
||
|
|
(this.time = 0),
|
||
|
|
(this.xflags = 0),
|
||
|
|
(this.os = 0),
|
||
|
|
(this.extra = null),
|
||
|
|
(this.extra_len = 0),
|
||
|
|
(this.name = ''),
|
||
|
|
(this.comment = ''),
|
||
|
|
(this.hcrc = 0),
|
||
|
|
(this.done = !1);
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
7: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
t.exports = function (e, t) {
|
||
|
|
var i, n, a, r, o, s, f, l, d, c, u, h, b, m, w, k, _, g, v, p, x, y, S, E, Z;
|
||
|
|
(i = e.state),
|
||
|
|
(n = e.next_in),
|
||
|
|
(E = e.input),
|
||
|
|
(a = n + (e.avail_in - 5)),
|
||
|
|
(r = e.next_out),
|
||
|
|
(Z = e.output),
|
||
|
|
(o = r - (t - e.avail_out)),
|
||
|
|
(s = r + (e.avail_out - 257)),
|
||
|
|
(f = i.dmax),
|
||
|
|
(l = i.wsize),
|
||
|
|
(d = i.whave),
|
||
|
|
(c = i.wnext),
|
||
|
|
(u = i.window),
|
||
|
|
(h = i.hold),
|
||
|
|
(b = i.bits),
|
||
|
|
(m = i.lencode),
|
||
|
|
(w = i.distcode),
|
||
|
|
(k = (1 << i.lenbits) - 1),
|
||
|
|
(_ = (1 << i.distbits) - 1);
|
||
|
|
e: do {
|
||
|
|
b < 15 && ((h += E[n++] << b), (b += 8), (h += E[n++] << b), (b += 8)),
|
||
|
|
(g = m[h & k]);
|
||
|
|
t: for (;;) {
|
||
|
|
if (((h >>>= v = g >>> 24), (b -= v), 0 == (v = (g >>> 16) & 255)))
|
||
|
|
Z[r++] = 65535 & g;
|
||
|
|
else {
|
||
|
|
if (!(16 & v)) {
|
||
|
|
if (0 == (64 & v)) {
|
||
|
|
g = m[(65535 & g) + (h & ((1 << v) - 1))];
|
||
|
|
continue t;
|
||
|
|
}
|
||
|
|
if (32 & v) {
|
||
|
|
i.mode = 12;
|
||
|
|
break e;
|
||
|
|
}
|
||
|
|
(e.msg = 'invalid literal/length code'), (i.mode = 30);
|
||
|
|
break e;
|
||
|
|
}
|
||
|
|
(p = 65535 & g),
|
||
|
|
(v &= 15) &&
|
||
|
|
(b < v && ((h += E[n++] << b), (b += 8)),
|
||
|
|
(p += h & ((1 << v) - 1)),
|
||
|
|
(h >>>= v),
|
||
|
|
(b -= v)),
|
||
|
|
b < 15 && ((h += E[n++] << b), (b += 8), (h += E[n++] << b), (b += 8)),
|
||
|
|
(g = w[h & _]);
|
||
|
|
i: for (;;) {
|
||
|
|
if (((h >>>= v = g >>> 24), (b -= v), !(16 & (v = (g >>> 16) & 255)))) {
|
||
|
|
if (0 == (64 & v)) {
|
||
|
|
g = w[(65535 & g) + (h & ((1 << v) - 1))];
|
||
|
|
continue i;
|
||
|
|
}
|
||
|
|
(e.msg = 'invalid distance code'), (i.mode = 30);
|
||
|
|
break e;
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
((x = 65535 & g),
|
||
|
|
b < (v &= 15) &&
|
||
|
|
((h += E[n++] << b), (b += 8) < v && ((h += E[n++] << b), (b += 8))),
|
||
|
|
f < (x += h & ((1 << v) - 1)))
|
||
|
|
) {
|
||
|
|
(e.msg = 'invalid distance too far back'), (i.mode = 30);
|
||
|
|
break e;
|
||
|
|
}
|
||
|
|
if (((h >>>= v), (b -= v), (v = r - o) < x)) {
|
||
|
|
if (d < (v = x - v) && i.sane) {
|
||
|
|
(e.msg = 'invalid distance too far back'), (i.mode = 30);
|
||
|
|
break e;
|
||
|
|
}
|
||
|
|
if (((S = u), (y = 0) === c)) {
|
||
|
|
if (((y += l - v), v < p)) {
|
||
|
|
for (p -= v; (Z[r++] = u[y++]), --v; );
|
||
|
|
(y = r - x), (S = Z);
|
||
|
|
}
|
||
|
|
} else if (c < v) {
|
||
|
|
if (((y += l + c - v), (v -= c) < p)) {
|
||
|
|
for (p -= v; (Z[r++] = u[y++]), --v; );
|
||
|
|
if (((y = 0), c < p)) {
|
||
|
|
for (p -= v = c; (Z[r++] = u[y++]), --v; );
|
||
|
|
(y = r - x), (S = Z);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (((y += c - v), v < p)) {
|
||
|
|
for (p -= v; (Z[r++] = u[y++]), --v; );
|
||
|
|
(y = r - x), (S = Z);
|
||
|
|
}
|
||
|
|
for (; 2 < p; )
|
||
|
|
(Z[r++] = S[y++]), (Z[r++] = S[y++]), (Z[r++] = S[y++]), (p -= 3);
|
||
|
|
p && ((Z[r++] = S[y++]), 1 < p && (Z[r++] = S[y++]));
|
||
|
|
} else {
|
||
|
|
for (
|
||
|
|
y = r - x;
|
||
|
|
(Z[r++] = Z[y++]), (Z[r++] = Z[y++]), (Z[r++] = Z[y++]), 2 < (p -= 3);
|
||
|
|
|
||
|
|
);
|
||
|
|
p && ((Z[r++] = Z[y++]), 1 < p && (Z[r++] = Z[y++]));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} while (n < a && r < s);
|
||
|
|
(n -= p = b >> 3),
|
||
|
|
(h &= (1 << (b -= p << 3)) - 1),
|
||
|
|
(e.next_in = n),
|
||
|
|
(e.next_out = r),
|
||
|
|
(e.avail_in = n < a ? a - n + 5 : 5 - (n - a)),
|
||
|
|
(e.avail_out = r < s ? s - r + 257 : 257 - (r - s)),
|
||
|
|
(i.hold = h),
|
||
|
|
(i.bits = b);
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
8: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
var n = e('../utils/common'),
|
||
|
|
a = e('./adler32'),
|
||
|
|
r = e('./crc32'),
|
||
|
|
o = e('./inffast'),
|
||
|
|
s = e('./inftrees'),
|
||
|
|
f = -2;
|
||
|
|
function l(e) {
|
||
|
|
return (
|
||
|
|
((e >>> 24) & 255) + ((e >>> 8) & 65280) + ((65280 & e) << 8) + ((255 & e) << 24)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
function d() {
|
||
|
|
(this.mode = 0),
|
||
|
|
(this.last = !1),
|
||
|
|
(this.wrap = 0),
|
||
|
|
(this.havedict = !1),
|
||
|
|
(this.flags = 0),
|
||
|
|
(this.dmax = 0),
|
||
|
|
(this.check = 0),
|
||
|
|
(this.total = 0),
|
||
|
|
(this.head = null),
|
||
|
|
(this.wbits = 0),
|
||
|
|
(this.wsize = 0),
|
||
|
|
(this.whave = 0),
|
||
|
|
(this.wnext = 0),
|
||
|
|
(this.window = null),
|
||
|
|
(this.hold = 0),
|
||
|
|
(this.bits = 0),
|
||
|
|
(this.length = 0),
|
||
|
|
(this.offset = 0),
|
||
|
|
(this.extra = 0),
|
||
|
|
(this.lencode = null),
|
||
|
|
(this.distcode = null),
|
||
|
|
(this.lenbits = 0),
|
||
|
|
(this.distbits = 0),
|
||
|
|
(this.ncode = 0),
|
||
|
|
(this.nlen = 0),
|
||
|
|
(this.ndist = 0),
|
||
|
|
(this.have = 0),
|
||
|
|
(this.next = null),
|
||
|
|
(this.lens = new n.Buf16(320)),
|
||
|
|
(this.work = new n.Buf16(288)),
|
||
|
|
(this.lendyn = null),
|
||
|
|
(this.distdyn = null),
|
||
|
|
(this.sane = 0),
|
||
|
|
(this.back = 0),
|
||
|
|
(this.was = 0);
|
||
|
|
}
|
||
|
|
function c(e) {
|
||
|
|
var t;
|
||
|
|
return e && e.state
|
||
|
|
? ((t = e.state),
|
||
|
|
(e.total_in = e.total_out = t.total = 0),
|
||
|
|
(e.msg = ''),
|
||
|
|
t.wrap && (e.adler = 1 & t.wrap),
|
||
|
|
(t.mode = 1),
|
||
|
|
(t.last = 0),
|
||
|
|
(t.havedict = 0),
|
||
|
|
(t.dmax = 32768),
|
||
|
|
(t.head = null),
|
||
|
|
(t.hold = 0),
|
||
|
|
(t.bits = 0),
|
||
|
|
(t.lencode = t.lendyn = new n.Buf32(852)),
|
||
|
|
(t.distcode = t.distdyn = new n.Buf32(592)),
|
||
|
|
(t.sane = 1),
|
||
|
|
(t.back = -1),
|
||
|
|
0)
|
||
|
|
: f;
|
||
|
|
}
|
||
|
|
function u(e) {
|
||
|
|
var t;
|
||
|
|
return e && e.state
|
||
|
|
? (((t = e.state).wsize = 0), (t.whave = 0), (t.wnext = 0), c(e))
|
||
|
|
: f;
|
||
|
|
}
|
||
|
|
function h(e, t) {
|
||
|
|
var i, n;
|
||
|
|
return e && e.state
|
||
|
|
? ((n = e.state),
|
||
|
|
t < 0 ? ((i = 0), (t = -t)) : ((i = 1 + (t >> 4)), t < 48 && (t &= 15)),
|
||
|
|
t && (t < 8 || 15 < t)
|
||
|
|
? f
|
||
|
|
: (null !== n.window && n.wbits !== t && (n.window = null),
|
||
|
|
(n.wrap = i),
|
||
|
|
(n.wbits = t),
|
||
|
|
u(e)))
|
||
|
|
: f;
|
||
|
|
}
|
||
|
|
function b(e, t) {
|
||
|
|
var i, n;
|
||
|
|
return e
|
||
|
|
? ((n = new d()),
|
||
|
|
((e.state = n).window = null),
|
||
|
|
0 !== (i = h(e, t)) && (e.state = null),
|
||
|
|
i)
|
||
|
|
: f;
|
||
|
|
}
|
||
|
|
var m,
|
||
|
|
w,
|
||
|
|
k = !0;
|
||
|
|
function _(e) {
|
||
|
|
if (k) {
|
||
|
|
var t;
|
||
|
|
for (m = new n.Buf32(512), w = new n.Buf32(32), t = 0; t < 144; ) e.lens[t++] = 8;
|
||
|
|
for (; t < 256; ) e.lens[t++] = 9;
|
||
|
|
for (; t < 280; ) e.lens[t++] = 7;
|
||
|
|
for (; t < 288; ) e.lens[t++] = 8;
|
||
|
|
for (s(1, e.lens, 0, 288, m, 0, e.work, { bits: 9 }), t = 0; t < 32; )
|
||
|
|
e.lens[t++] = 5;
|
||
|
|
s(2, e.lens, 0, 32, w, 0, e.work, { bits: 5 }), (k = !1);
|
||
|
|
}
|
||
|
|
(e.lencode = m), (e.lenbits = 9), (e.distcode = w), (e.distbits = 5);
|
||
|
|
}
|
||
|
|
function g(e, t, i, a) {
|
||
|
|
var r,
|
||
|
|
o = e.state;
|
||
|
|
return (
|
||
|
|
null === o.window &&
|
||
|
|
((o.wsize = 1 << o.wbits),
|
||
|
|
(o.wnext = 0),
|
||
|
|
(o.whave = 0),
|
||
|
|
(o.window = new n.Buf8(o.wsize))),
|
||
|
|
a >= o.wsize
|
||
|
|
? (n.arraySet(o.window, t, i - o.wsize, o.wsize, 0),
|
||
|
|
(o.wnext = 0),
|
||
|
|
(o.whave = o.wsize))
|
||
|
|
: (a < (r = o.wsize - o.wnext) && (r = a),
|
||
|
|
n.arraySet(o.window, t, i - a, r, o.wnext),
|
||
|
|
(a -= r)
|
||
|
|
? (n.arraySet(o.window, t, i - a, a, 0), (o.wnext = a), (o.whave = o.wsize))
|
||
|
|
: ((o.wnext += r),
|
||
|
|
o.wnext === o.wsize && (o.wnext = 0),
|
||
|
|
o.whave < o.wsize && (o.whave += r))),
|
||
|
|
0
|
||
|
|
);
|
||
|
|
}
|
||
|
|
(i.inflateReset = u),
|
||
|
|
(i.inflateReset2 = h),
|
||
|
|
(i.inflateResetKeep = c),
|
||
|
|
(i.inflateInit = function (e) {
|
||
|
|
return b(e, 15);
|
||
|
|
}),
|
||
|
|
(i.inflateInit2 = b),
|
||
|
|
(i.inflate = function (e, t) {
|
||
|
|
var i,
|
||
|
|
d,
|
||
|
|
c,
|
||
|
|
u,
|
||
|
|
h,
|
||
|
|
b,
|
||
|
|
m,
|
||
|
|
w,
|
||
|
|
k,
|
||
|
|
v,
|
||
|
|
p,
|
||
|
|
x,
|
||
|
|
y,
|
||
|
|
S,
|
||
|
|
E,
|
||
|
|
Z,
|
||
|
|
B,
|
||
|
|
A,
|
||
|
|
z,
|
||
|
|
R,
|
||
|
|
N,
|
||
|
|
O,
|
||
|
|
C,
|
||
|
|
I,
|
||
|
|
D = 0,
|
||
|
|
T = new n.Buf8(4),
|
||
|
|
U = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
||
|
|
if (!e || !e.state || !e.output || (!e.input && 0 !== e.avail_in)) return f;
|
||
|
|
12 === (i = e.state).mode && (i.mode = 13),
|
||
|
|
(h = e.next_out),
|
||
|
|
(c = e.output),
|
||
|
|
(m = e.avail_out),
|
||
|
|
(u = e.next_in),
|
||
|
|
(d = e.input),
|
||
|
|
(b = e.avail_in),
|
||
|
|
(w = i.hold),
|
||
|
|
(k = i.bits),
|
||
|
|
(v = b),
|
||
|
|
(p = m),
|
||
|
|
(O = 0);
|
||
|
|
e: for (;;)
|
||
|
|
switch (i.mode) {
|
||
|
|
case 1:
|
||
|
|
if (0 === i.wrap) {
|
||
|
|
i.mode = 13;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
for (; k < 16; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (2 & i.wrap && 35615 === w) {
|
||
|
|
(T[(i.check = 0)] = 255 & w),
|
||
|
|
(T[1] = (w >>> 8) & 255),
|
||
|
|
(i.check = r(i.check, T, 2, 0)),
|
||
|
|
(k = w = 0),
|
||
|
|
(i.mode = 2);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
((i.flags = 0),
|
||
|
|
i.head && (i.head.done = !1),
|
||
|
|
!(1 & i.wrap) || (((255 & w) << 8) + (w >> 8)) % 31)
|
||
|
|
) {
|
||
|
|
(e.msg = 'incorrect header check'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (8 != (15 & w)) {
|
||
|
|
(e.msg = 'unknown compression method'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (((k -= 4), (N = 8 + (15 & (w >>>= 4))), 0 === i.wbits)) i.wbits = N;
|
||
|
|
else if (N > i.wbits) {
|
||
|
|
(e.msg = 'invalid window size'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
(i.dmax = 1 << N),
|
||
|
|
(e.adler = i.check = 1),
|
||
|
|
(i.mode = 512 & w ? 10 : 12),
|
||
|
|
(k = w = 0);
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
for (; k < 16; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (((i.flags = w), 8 != (255 & i.flags))) {
|
||
|
|
(e.msg = 'unknown compression method'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (57344 & i.flags) {
|
||
|
|
(e.msg = 'unknown header flags set'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
i.head && (i.head.text = (w >> 8) & 1),
|
||
|
|
512 & i.flags &&
|
||
|
|
((T[0] = 255 & w),
|
||
|
|
(T[1] = (w >>> 8) & 255),
|
||
|
|
(i.check = r(i.check, T, 2, 0))),
|
||
|
|
(k = w = 0),
|
||
|
|
(i.mode = 3);
|
||
|
|
case 3:
|
||
|
|
for (; k < 32; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
i.head && (i.head.time = w),
|
||
|
|
512 & i.flags &&
|
||
|
|
((T[0] = 255 & w),
|
||
|
|
(T[1] = (w >>> 8) & 255),
|
||
|
|
(T[2] = (w >>> 16) & 255),
|
||
|
|
(T[3] = (w >>> 24) & 255),
|
||
|
|
(i.check = r(i.check, T, 4, 0))),
|
||
|
|
(k = w = 0),
|
||
|
|
(i.mode = 4);
|
||
|
|
case 4:
|
||
|
|
for (; k < 16; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
i.head && ((i.head.xflags = 255 & w), (i.head.os = w >> 8)),
|
||
|
|
512 & i.flags &&
|
||
|
|
((T[0] = 255 & w),
|
||
|
|
(T[1] = (w >>> 8) & 255),
|
||
|
|
(i.check = r(i.check, T, 2, 0))),
|
||
|
|
(k = w = 0),
|
||
|
|
(i.mode = 5);
|
||
|
|
case 5:
|
||
|
|
if (1024 & i.flags) {
|
||
|
|
for (; k < 16; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(i.length = w),
|
||
|
|
i.head && (i.head.extra_len = w),
|
||
|
|
512 & i.flags &&
|
||
|
|
((T[0] = 255 & w),
|
||
|
|
(T[1] = (w >>> 8) & 255),
|
||
|
|
(i.check = r(i.check, T, 2, 0))),
|
||
|
|
(k = w = 0);
|
||
|
|
} else i.head && (i.head.extra = null);
|
||
|
|
i.mode = 6;
|
||
|
|
case 6:
|
||
|
|
if (
|
||
|
|
1024 & i.flags &&
|
||
|
|
(b < (x = i.length) && (x = b),
|
||
|
|
x &&
|
||
|
|
(i.head &&
|
||
|
|
((N = i.head.extra_len - i.length),
|
||
|
|
i.head.extra || (i.head.extra = new Array(i.head.extra_len)),
|
||
|
|
n.arraySet(i.head.extra, d, u, x, N)),
|
||
|
|
512 & i.flags && (i.check = r(i.check, d, x, u)),
|
||
|
|
(b -= x),
|
||
|
|
(u += x),
|
||
|
|
(i.length -= x)),
|
||
|
|
i.length)
|
||
|
|
)
|
||
|
|
break e;
|
||
|
|
(i.length = 0), (i.mode = 7);
|
||
|
|
case 7:
|
||
|
|
if (2048 & i.flags) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
for (
|
||
|
|
x = 0;
|
||
|
|
(N = d[u + x++]),
|
||
|
|
i.head &&
|
||
|
|
N &&
|
||
|
|
i.length < 65536 &&
|
||
|
|
(i.head.name += String.fromCharCode(N)),
|
||
|
|
N && x < b;
|
||
|
|
|
||
|
|
);
|
||
|
|
if ((512 & i.flags && (i.check = r(i.check, d, x, u)), (b -= x), (u += x), N))
|
||
|
|
break e;
|
||
|
|
} else i.head && (i.head.name = null);
|
||
|
|
(i.length = 0), (i.mode = 8);
|
||
|
|
case 8:
|
||
|
|
if (4096 & i.flags) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
for (
|
||
|
|
x = 0;
|
||
|
|
(N = d[u + x++]),
|
||
|
|
i.head &&
|
||
|
|
N &&
|
||
|
|
i.length < 65536 &&
|
||
|
|
(i.head.comment += String.fromCharCode(N)),
|
||
|
|
N && x < b;
|
||
|
|
|
||
|
|
);
|
||
|
|
if ((512 & i.flags && (i.check = r(i.check, d, x, u)), (b -= x), (u += x), N))
|
||
|
|
break e;
|
||
|
|
} else i.head && (i.head.comment = null);
|
||
|
|
i.mode = 9;
|
||
|
|
case 9:
|
||
|
|
if (512 & i.flags) {
|
||
|
|
for (; k < 16; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (w !== (65535 & i.check)) {
|
||
|
|
(e.msg = 'header crc mismatch'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
k = w = 0;
|
||
|
|
}
|
||
|
|
i.head && ((i.head.hcrc = (i.flags >> 9) & 1), (i.head.done = !0)),
|
||
|
|
(e.adler = i.check = 0),
|
||
|
|
(i.mode = 12);
|
||
|
|
break;
|
||
|
|
case 10:
|
||
|
|
for (; k < 32; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(e.adler = i.check = l(w)), (k = w = 0), (i.mode = 11);
|
||
|
|
case 11:
|
||
|
|
if (0 === i.havedict)
|
||
|
|
return (
|
||
|
|
(e.next_out = h),
|
||
|
|
(e.avail_out = m),
|
||
|
|
(e.next_in = u),
|
||
|
|
(e.avail_in = b),
|
||
|
|
(i.hold = w),
|
||
|
|
(i.bits = k),
|
||
|
|
2
|
||
|
|
);
|
||
|
|
(e.adler = i.check = 1), (i.mode = 12);
|
||
|
|
case 12:
|
||
|
|
if (5 === t || 6 === t) break e;
|
||
|
|
case 13:
|
||
|
|
if (i.last) {
|
||
|
|
(w >>>= 7 & k), (k -= 7 & k), (i.mode = 27);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
for (; k < 3; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
switch (((i.last = 1 & w), (k -= 1), 3 & (w >>>= 1))) {
|
||
|
|
case 0:
|
||
|
|
i.mode = 14;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
if ((_(i), (i.mode = 20), 6 !== t)) break;
|
||
|
|
(w >>>= 2), (k -= 2);
|
||
|
|
break e;
|
||
|
|
case 2:
|
||
|
|
i.mode = 17;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
(e.msg = 'invalid block type'), (i.mode = 30);
|
||
|
|
}
|
||
|
|
(w >>>= 2), (k -= 2);
|
||
|
|
break;
|
||
|
|
case 14:
|
||
|
|
for (w >>>= 7 & k, k -= 7 & k; k < 32; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if ((65535 & w) != ((w >>> 16) ^ 65535)) {
|
||
|
|
(e.msg = 'invalid stored block lengths'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (((i.length = 65535 & w), (k = w = 0), (i.mode = 15), 6 === t)) break e;
|
||
|
|
case 15:
|
||
|
|
i.mode = 16;
|
||
|
|
case 16:
|
||
|
|
if ((x = i.length)) {
|
||
|
|
if ((b < x && (x = b), m < x && (x = m), 0 === x)) break e;
|
||
|
|
n.arraySet(c, d, u, x, h),
|
||
|
|
(b -= x),
|
||
|
|
(u += x),
|
||
|
|
(m -= x),
|
||
|
|
(h += x),
|
||
|
|
(i.length -= x);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
i.mode = 12;
|
||
|
|
break;
|
||
|
|
case 17:
|
||
|
|
for (; k < 14; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
((i.nlen = 257 + (31 & w)),
|
||
|
|
(w >>>= 5),
|
||
|
|
(k -= 5),
|
||
|
|
(i.ndist = 1 + (31 & w)),
|
||
|
|
(w >>>= 5),
|
||
|
|
(k -= 5),
|
||
|
|
(i.ncode = 4 + (15 & w)),
|
||
|
|
(w >>>= 4),
|
||
|
|
(k -= 4),
|
||
|
|
286 < i.nlen || 30 < i.ndist)
|
||
|
|
) {
|
||
|
|
(e.msg = 'too many length or distance symbols'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
(i.have = 0), (i.mode = 18);
|
||
|
|
case 18:
|
||
|
|
for (; i.have < i.ncode; ) {
|
||
|
|
for (; k < 3; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(i.lens[U[i.have++]] = 7 & w), (w >>>= 3), (k -= 3);
|
||
|
|
}
|
||
|
|
for (; i.have < 19; ) i.lens[U[i.have++]] = 0;
|
||
|
|
if (
|
||
|
|
((i.lencode = i.lendyn),
|
||
|
|
(i.lenbits = 7),
|
||
|
|
(C = { bits: i.lenbits }),
|
||
|
|
(O = s(0, i.lens, 0, 19, i.lencode, 0, i.work, C)),
|
||
|
|
(i.lenbits = C.bits),
|
||
|
|
O)
|
||
|
|
) {
|
||
|
|
(e.msg = 'invalid code lengths set'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
(i.have = 0), (i.mode = 19);
|
||
|
|
case 19:
|
||
|
|
for (; i.have < i.nlen + i.ndist; ) {
|
||
|
|
for (
|
||
|
|
;
|
||
|
|
(Z = ((D = i.lencode[w & ((1 << i.lenbits) - 1)]) >>> 16) & 255),
|
||
|
|
(B = 65535 & D),
|
||
|
|
!((E = D >>> 24) <= k);
|
||
|
|
|
||
|
|
) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (B < 16) (w >>>= E), (k -= E), (i.lens[i.have++] = B);
|
||
|
|
else {
|
||
|
|
if (16 === B) {
|
||
|
|
for (I = E + 2; k < I; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (((w >>>= E), (k -= E), 0 === i.have)) {
|
||
|
|
(e.msg = 'invalid bit length repeat'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
(N = i.lens[i.have - 1]), (x = 3 + (3 & w)), (w >>>= 2), (k -= 2);
|
||
|
|
} else if (17 === B) {
|
||
|
|
for (I = E + 3; k < I; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(k -= E), (N = 0), (x = 3 + (7 & (w >>>= E))), (w >>>= 3), (k -= 3);
|
||
|
|
} else {
|
||
|
|
for (I = E + 7; k < I; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(k -= E), (N = 0), (x = 11 + (127 & (w >>>= E))), (w >>>= 7), (k -= 7);
|
||
|
|
}
|
||
|
|
if (i.have + x > i.nlen + i.ndist) {
|
||
|
|
(e.msg = 'invalid bit length repeat'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
for (; x--; ) i.lens[i.have++] = N;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (30 === i.mode) break;
|
||
|
|
if (0 === i.lens[256]) {
|
||
|
|
(e.msg = 'invalid code -- missing end-of-block'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
((i.lenbits = 9),
|
||
|
|
(C = { bits: i.lenbits }),
|
||
|
|
(O = s(1, i.lens, 0, i.nlen, i.lencode, 0, i.work, C)),
|
||
|
|
(i.lenbits = C.bits),
|
||
|
|
O)
|
||
|
|
) {
|
||
|
|
(e.msg = 'invalid literal/lengths set'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
((i.distbits = 6),
|
||
|
|
(i.distcode = i.distdyn),
|
||
|
|
(C = { bits: i.distbits }),
|
||
|
|
(O = s(2, i.lens, i.nlen, i.ndist, i.distcode, 0, i.work, C)),
|
||
|
|
(i.distbits = C.bits),
|
||
|
|
O)
|
||
|
|
) {
|
||
|
|
(e.msg = 'invalid distances set'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (((i.mode = 20), 6 === t)) break e;
|
||
|
|
case 20:
|
||
|
|
i.mode = 21;
|
||
|
|
case 21:
|
||
|
|
if (6 <= b && 258 <= m) {
|
||
|
|
(e.next_out = h),
|
||
|
|
(e.avail_out = m),
|
||
|
|
(e.next_in = u),
|
||
|
|
(e.avail_in = b),
|
||
|
|
(i.hold = w),
|
||
|
|
(i.bits = k),
|
||
|
|
o(e, p),
|
||
|
|
(h = e.next_out),
|
||
|
|
(c = e.output),
|
||
|
|
(m = e.avail_out),
|
||
|
|
(u = e.next_in),
|
||
|
|
(d = e.input),
|
||
|
|
(b = e.avail_in),
|
||
|
|
(w = i.hold),
|
||
|
|
(k = i.bits),
|
||
|
|
12 === i.mode && (i.back = -1);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
for (
|
||
|
|
i.back = 0;
|
||
|
|
(Z = ((D = i.lencode[w & ((1 << i.lenbits) - 1)]) >>> 16) & 255),
|
||
|
|
(B = 65535 & D),
|
||
|
|
!((E = D >>> 24) <= k);
|
||
|
|
|
||
|
|
) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (Z && 0 == (240 & Z)) {
|
||
|
|
for (
|
||
|
|
A = E, z = Z, R = B;
|
||
|
|
(Z = ((D = i.lencode[R + ((w & ((1 << (A + z)) - 1)) >> A)]) >>> 16) & 255),
|
||
|
|
(B = 65535 & D),
|
||
|
|
!(A + (E = D >>> 24) <= k);
|
||
|
|
|
||
|
|
) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(w >>>= A), (k -= A), (i.back += A);
|
||
|
|
}
|
||
|
|
if (((w >>>= E), (k -= E), (i.back += E), (i.length = B), 0 === Z)) {
|
||
|
|
i.mode = 26;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (32 & Z) {
|
||
|
|
(i.back = -1), (i.mode = 12);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (64 & Z) {
|
||
|
|
(e.msg = 'invalid literal/length code'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
(i.extra = 15 & Z), (i.mode = 22);
|
||
|
|
case 22:
|
||
|
|
if (i.extra) {
|
||
|
|
for (I = i.extra; k < I; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(i.length += w & ((1 << i.extra) - 1)),
|
||
|
|
(w >>>= i.extra),
|
||
|
|
(k -= i.extra),
|
||
|
|
(i.back += i.extra);
|
||
|
|
}
|
||
|
|
(i.was = i.length), (i.mode = 23);
|
||
|
|
case 23:
|
||
|
|
for (
|
||
|
|
;
|
||
|
|
(Z = ((D = i.distcode[w & ((1 << i.distbits) - 1)]) >>> 16) & 255),
|
||
|
|
(B = 65535 & D),
|
||
|
|
!((E = D >>> 24) <= k);
|
||
|
|
|
||
|
|
) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (0 == (240 & Z)) {
|
||
|
|
for (
|
||
|
|
A = E, z = Z, R = B;
|
||
|
|
(Z =
|
||
|
|
((D = i.distcode[R + ((w & ((1 << (A + z)) - 1)) >> A)]) >>> 16) & 255),
|
||
|
|
(B = 65535 & D),
|
||
|
|
!(A + (E = D >>> 24) <= k);
|
||
|
|
|
||
|
|
) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(w >>>= A), (k -= A), (i.back += A);
|
||
|
|
}
|
||
|
|
if (((w >>>= E), (k -= E), (i.back += E), 64 & Z)) {
|
||
|
|
(e.msg = 'invalid distance code'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
(i.offset = B), (i.extra = 15 & Z), (i.mode = 24);
|
||
|
|
case 24:
|
||
|
|
if (i.extra) {
|
||
|
|
for (I = i.extra; k < I; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
(i.offset += w & ((1 << i.extra) - 1)),
|
||
|
|
(w >>>= i.extra),
|
||
|
|
(k -= i.extra),
|
||
|
|
(i.back += i.extra);
|
||
|
|
}
|
||
|
|
if (i.offset > i.dmax) {
|
||
|
|
(e.msg = 'invalid distance too far back'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
i.mode = 25;
|
||
|
|
case 25:
|
||
|
|
if (0 === m) break e;
|
||
|
|
if (((x = p - m), i.offset > x)) {
|
||
|
|
if ((x = i.offset - x) > i.whave && i.sane) {
|
||
|
|
(e.msg = 'invalid distance too far back'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
x > i.wnext ? ((x -= i.wnext), (y = i.wsize - x)) : (y = i.wnext - x),
|
||
|
|
x > i.length && (x = i.length),
|
||
|
|
(S = i.window);
|
||
|
|
} else (S = c), (y = h - i.offset), (x = i.length);
|
||
|
|
for (m < x && (x = m), m -= x, i.length -= x; (c[h++] = S[y++]), --x; );
|
||
|
|
0 === i.length && (i.mode = 21);
|
||
|
|
break;
|
||
|
|
case 26:
|
||
|
|
if (0 === m) break e;
|
||
|
|
(c[h++] = i.length), m--, (i.mode = 21);
|
||
|
|
break;
|
||
|
|
case 27:
|
||
|
|
if (i.wrap) {
|
||
|
|
for (; k < 32; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w |= d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (
|
||
|
|
((p -= m),
|
||
|
|
(e.total_out += p),
|
||
|
|
(i.total += p),
|
||
|
|
p &&
|
||
|
|
(e.adler = i.check =
|
||
|
|
i.flags ? r(i.check, c, p, h - p) : a(i.check, c, p, h - p)),
|
||
|
|
(p = m),
|
||
|
|
(i.flags ? w : l(w)) !== i.check)
|
||
|
|
) {
|
||
|
|
(e.msg = 'incorrect data check'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
k = w = 0;
|
||
|
|
}
|
||
|
|
i.mode = 28;
|
||
|
|
case 28:
|
||
|
|
if (i.wrap && i.flags) {
|
||
|
|
for (; k < 32; ) {
|
||
|
|
if (0 === b) break e;
|
||
|
|
b--, (w += d[u++] << k), (k += 8);
|
||
|
|
}
|
||
|
|
if (w !== (4294967295 & i.total)) {
|
||
|
|
(e.msg = 'incorrect length check'), (i.mode = 30);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
k = w = 0;
|
||
|
|
}
|
||
|
|
i.mode = 29;
|
||
|
|
case 29:
|
||
|
|
O = 1;
|
||
|
|
break e;
|
||
|
|
case 30:
|
||
|
|
O = -3;
|
||
|
|
break e;
|
||
|
|
case 31:
|
||
|
|
return -4;
|
||
|
|
default:
|
||
|
|
return f;
|
||
|
|
}
|
||
|
|
return (
|
||
|
|
(e.next_out = h),
|
||
|
|
(e.avail_out = m),
|
||
|
|
(e.next_in = u),
|
||
|
|
(e.avail_in = b),
|
||
|
|
(i.hold = w),
|
||
|
|
(i.bits = k),
|
||
|
|
(i.wsize || (p !== e.avail_out && i.mode < 30 && (i.mode < 27 || 4 !== t))) &&
|
||
|
|
g(e, e.output, e.next_out, p - e.avail_out)
|
||
|
|
? ((i.mode = 31), -4)
|
||
|
|
: ((v -= e.avail_in),
|
||
|
|
(p -= e.avail_out),
|
||
|
|
(e.total_in += v),
|
||
|
|
(e.total_out += p),
|
||
|
|
(i.total += p),
|
||
|
|
i.wrap &&
|
||
|
|
p &&
|
||
|
|
(e.adler = i.check =
|
||
|
|
i.flags
|
||
|
|
? r(i.check, c, p, e.next_out - p)
|
||
|
|
: a(i.check, c, p, e.next_out - p)),
|
||
|
|
(e.data_type =
|
||
|
|
i.bits +
|
||
|
|
(i.last ? 64 : 0) +
|
||
|
|
(12 === i.mode ? 128 : 0) +
|
||
|
|
(20 === i.mode || 15 === i.mode ? 256 : 0)),
|
||
|
|
((0 === v && 0 === p) || 4 === t) && 0 === O && (O = -5),
|
||
|
|
O)
|
||
|
|
);
|
||
|
|
}),
|
||
|
|
(i.inflateEnd = function (e) {
|
||
|
|
if (!e || !e.state) return f;
|
||
|
|
var t = e.state;
|
||
|
|
return t.window && (t.window = null), (e.state = null), 0;
|
||
|
|
}),
|
||
|
|
(i.inflateGetHeader = function (e, t) {
|
||
|
|
var i;
|
||
|
|
return e && e.state
|
||
|
|
? 0 == (2 & (i = e.state).wrap)
|
||
|
|
? f
|
||
|
|
: (((i.head = t).done = !1), 0)
|
||
|
|
: f;
|
||
|
|
}),
|
||
|
|
(i.inflateSetDictionary = function (e, t) {
|
||
|
|
var i,
|
||
|
|
n = t.length;
|
||
|
|
return e && e.state
|
||
|
|
? 0 !== (i = e.state).wrap && 11 !== i.mode
|
||
|
|
? f
|
||
|
|
: 11 === i.mode && a(1, t, n, 0) !== i.check
|
||
|
|
? -3
|
||
|
|
: g(e, t, n, n)
|
||
|
|
? ((i.mode = 31), -4)
|
||
|
|
: ((i.havedict = 1), 0)
|
||
|
|
: f;
|
||
|
|
}),
|
||
|
|
(i.inflateInfo = 'pako inflate (from Nodeca project)');
|
||
|
|
},
|
||
|
|
{ '../utils/common': 1, './adler32': 3, './crc32': 5, './inffast': 7, './inftrees': 9 },
|
||
|
|
],
|
||
|
|
9: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
var n = e('../utils/common'),
|
||
|
|
a = [
|
||
|
|
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,
|
||
|
|
],
|
||
|
|
r = [
|
||
|
|
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,
|
||
|
|
],
|
||
|
|
o = [
|
||
|
|
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,
|
||
|
|
],
|
||
|
|
s = [
|
||
|
|
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,
|
||
|
|
];
|
||
|
|
t.exports = function (e, t, i, f, l, d, c, u) {
|
||
|
|
var h,
|
||
|
|
b,
|
||
|
|
m,
|
||
|
|
w,
|
||
|
|
k,
|
||
|
|
_,
|
||
|
|
g,
|
||
|
|
v,
|
||
|
|
p,
|
||
|
|
x = u.bits,
|
||
|
|
y = 0,
|
||
|
|
S = 0,
|
||
|
|
E = 0,
|
||
|
|
Z = 0,
|
||
|
|
B = 0,
|
||
|
|
A = 0,
|
||
|
|
z = 0,
|
||
|
|
R = 0,
|
||
|
|
N = 0,
|
||
|
|
O = 0,
|
||
|
|
C = null,
|
||
|
|
I = 0,
|
||
|
|
D = new n.Buf16(16),
|
||
|
|
T = new n.Buf16(16),
|
||
|
|
U = null,
|
||
|
|
F = 0;
|
||
|
|
for (y = 0; y <= 15; y++) D[y] = 0;
|
||
|
|
for (S = 0; S < f; S++) D[t[i + S]]++;
|
||
|
|
for (B = x, Z = 15; 1 <= Z && 0 === D[Z]; Z--);
|
||
|
|
if ((Z < B && (B = Z), 0 === Z))
|
||
|
|
return (l[d++] = 20971520), (l[d++] = 20971520), (u.bits = 1), 0;
|
||
|
|
for (E = 1; E < Z && 0 === D[E]; E++);
|
||
|
|
for (B < E && (B = E), y = R = 1; y <= 15; y++)
|
||
|
|
if (((R <<= 1), (R -= D[y]) < 0)) return -1;
|
||
|
|
if (0 < R && (0 === e || 1 !== Z)) return -1;
|
||
|
|
for (T[1] = 0, y = 1; y < 15; y++) T[y + 1] = T[y] + D[y];
|
||
|
|
for (S = 0; S < f; S++) 0 !== t[i + S] && (c[T[t[i + S]]++] = S);
|
||
|
|
if (
|
||
|
|
(0 === e
|
||
|
|
? ((C = U = c), (_ = 19))
|
||
|
|
: 1 === e
|
||
|
|
? ((C = a), (I -= 257), (U = r), (F -= 257), (_ = 256))
|
||
|
|
: ((C = o), (U = s), (_ = -1)),
|
||
|
|
(y = E),
|
||
|
|
(k = d),
|
||
|
|
(z = S = O = 0),
|
||
|
|
(m = -1),
|
||
|
|
(w = (N = 1 << (A = B)) - 1),
|
||
|
|
(1 === e && 852 < N) || (2 === e && 592 < N))
|
||
|
|
)
|
||
|
|
return 1;
|
||
|
|
for (;;) {
|
||
|
|
for (
|
||
|
|
g = y - z,
|
||
|
|
c[S] < _
|
||
|
|
? ((v = 0), (p = c[S]))
|
||
|
|
: c[S] > _
|
||
|
|
? ((v = U[F + c[S]]), (p = C[I + c[S]]))
|
||
|
|
: ((v = 96), (p = 0)),
|
||
|
|
h = 1 << (y - z),
|
||
|
|
E = b = 1 << A;
|
||
|
|
(l[k + (O >> z) + (b -= h)] = (g << 24) | (v << 16) | p | 0), 0 !== b;
|
||
|
|
|
||
|
|
);
|
||
|
|
for (h = 1 << (y - 1); O & h; ) h >>= 1;
|
||
|
|
if ((0 !== h ? ((O &= h - 1), (O += h)) : (O = 0), S++, 0 == --D[y])) {
|
||
|
|
if (y === Z) break;
|
||
|
|
y = t[i + c[S]];
|
||
|
|
}
|
||
|
|
if (B < y && (O & w) !== m) {
|
||
|
|
for (
|
||
|
|
0 === z && (z = B), k += E, R = 1 << (A = y - z);
|
||
|
|
A + z < Z && !((R -= D[A + z]) <= 0);
|
||
|
|
|
||
|
|
)
|
||
|
|
A++, (R <<= 1);
|
||
|
|
if (((N += 1 << A), (1 === e && 852 < N) || (2 === e && 592 < N))) return 1;
|
||
|
|
l[(m = O & w)] = (B << 24) | (A << 16) | (k - d) | 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0 !== O && (l[k + O] = ((y - z) << 24) | (64 << 16) | 0), (u.bits = B), 0;
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{ '../utils/common': 1 },
|
||
|
|
],
|
||
|
|
10: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
t.exports = {
|
||
|
|
2: 'need dictionary',
|
||
|
|
1: 'stream end',
|
||
|
|
0: '',
|
||
|
|
'-1': 'file error',
|
||
|
|
'-2': 'stream error',
|
||
|
|
'-3': 'data error',
|
||
|
|
'-4': 'insufficient memory',
|
||
|
|
'-5': 'buffer error',
|
||
|
|
'-6': 'incompatible version',
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
11: [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
t.exports = function () {
|
||
|
|
(this.input = null),
|
||
|
|
(this.next_in = 0),
|
||
|
|
(this.avail_in = 0),
|
||
|
|
(this.total_in = 0),
|
||
|
|
(this.output = null),
|
||
|
|
(this.next_out = 0),
|
||
|
|
(this.avail_out = 0),
|
||
|
|
(this.total_out = 0),
|
||
|
|
(this.msg = ''),
|
||
|
|
(this.state = null),
|
||
|
|
(this.data_type = 2),
|
||
|
|
(this.adler = 0);
|
||
|
|
};
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
],
|
||
|
|
'/lib/inflate.js': [
|
||
|
|
function (e, t, i) {
|
||
|
|
'use strict';
|
||
|
|
var n = e('./zlib/inflate'),
|
||
|
|
a = e('./utils/common'),
|
||
|
|
r = e('./utils/strings'),
|
||
|
|
o = e('./zlib/constants'),
|
||
|
|
s = e('./zlib/messages'),
|
||
|
|
f = e('./zlib/zstream'),
|
||
|
|
l = e('./zlib/gzheader'),
|
||
|
|
d = Object.prototype.toString;
|
||
|
|
function c(e) {
|
||
|
|
if (!(this instanceof c)) return new c(e);
|
||
|
|
this.options = a.assign({ chunkSize: 16384, windowBits: 0, to: '' }, e || {});
|
||
|
|
var t = this.options;
|
||
|
|
t.raw &&
|
||
|
|
0 <= t.windowBits &&
|
||
|
|
t.windowBits < 16 &&
|
||
|
|
((t.windowBits = -t.windowBits), 0 === t.windowBits && (t.windowBits = -15)),
|
||
|
|
!(0 <= t.windowBits && t.windowBits < 16) ||
|
||
|
|
(e && e.windowBits) ||
|
||
|
|
(t.windowBits += 32),
|
||
|
|
15 < t.windowBits &&
|
||
|
|
t.windowBits < 48 &&
|
||
|
|
0 == (15 & t.windowBits) &&
|
||
|
|
(t.windowBits |= 15),
|
||
|
|
(this.err = 0),
|
||
|
|
(this.msg = ''),
|
||
|
|
(this.ended = !1),
|
||
|
|
(this.chunks = []),
|
||
|
|
(this.strm = new f()),
|
||
|
|
(this.strm.avail_out = 0);
|
||
|
|
var i = n.inflateInit2(this.strm, t.windowBits);
|
||
|
|
if (i !== o.Z_OK) throw new Error(s[i]);
|
||
|
|
if (
|
||
|
|
((this.header = new l()),
|
||
|
|
n.inflateGetHeader(this.strm, this.header),
|
||
|
|
t.dictionary &&
|
||
|
|
('string' == typeof t.dictionary
|
||
|
|
? (t.dictionary = r.string2buf(t.dictionary))
|
||
|
|
: '[object ArrayBuffer]' === d.call(t.dictionary) &&
|
||
|
|
(t.dictionary = new Uint8Array(t.dictionary)),
|
||
|
|
t.raw && (i = n.inflateSetDictionary(this.strm, t.dictionary)) !== o.Z_OK))
|
||
|
|
)
|
||
|
|
throw new Error(s[i]);
|
||
|
|
}
|
||
|
|
function u(e, t) {
|
||
|
|
var i = new c(t);
|
||
|
|
if ((i.push(e, !0), i.err)) throw i.msg || s[i.err];
|
||
|
|
return i.result;
|
||
|
|
}
|
||
|
|
(c.prototype.push = function (e, t) {
|
||
|
|
var i,
|
||
|
|
s,
|
||
|
|
f,
|
||
|
|
l,
|
||
|
|
c,
|
||
|
|
u = this.strm,
|
||
|
|
h = this.options.chunkSize,
|
||
|
|
b = this.options.dictionary,
|
||
|
|
m = !1;
|
||
|
|
if (this.ended) return !1;
|
||
|
|
(s = t === ~~t ? t : !0 === t ? o.Z_FINISH : o.Z_NO_FLUSH),
|
||
|
|
'string' == typeof e
|
||
|
|
? (u.input = r.binstring2buf(e))
|
||
|
|
: '[object ArrayBuffer]' === d.call(e)
|
||
|
|
? (u.input = new Uint8Array(e))
|
||
|
|
: (u.input = e),
|
||
|
|
(u.next_in = 0),
|
||
|
|
(u.avail_in = u.input.length);
|
||
|
|
do {
|
||
|
|
if (
|
||
|
|
(0 === u.avail_out &&
|
||
|
|
((u.output = new a.Buf8(h)), (u.next_out = 0), (u.avail_out = h)),
|
||
|
|
(i = n.inflate(u, o.Z_NO_FLUSH)) === o.Z_NEED_DICT &&
|
||
|
|
b &&
|
||
|
|
(i = n.inflateSetDictionary(this.strm, b)),
|
||
|
|
i === o.Z_BUF_ERROR && !0 === m && ((i = o.Z_OK), (m = !1)),
|
||
|
|
i !== o.Z_STREAM_END && i !== o.Z_OK)
|
||
|
|
)
|
||
|
|
return this.onEnd(i), !(this.ended = !0);
|
||
|
|
u.next_out &&
|
||
|
|
((0 !== u.avail_out &&
|
||
|
|
i !== o.Z_STREAM_END &&
|
||
|
|
(0 !== u.avail_in || (s !== o.Z_FINISH && s !== o.Z_SYNC_FLUSH))) ||
|
||
|
|
('string' === this.options.to
|
||
|
|
? ((f = r.utf8border(u.output, u.next_out)),
|
||
|
|
(l = u.next_out - f),
|
||
|
|
(c = r.buf2string(u.output, f)),
|
||
|
|
(u.next_out = l),
|
||
|
|
(u.avail_out = h - l),
|
||
|
|
l && a.arraySet(u.output, u.output, f, l, 0),
|
||
|
|
this.onData(c))
|
||
|
|
: this.onData(a.shrinkBuf(u.output, u.next_out)))),
|
||
|
|
0 === u.avail_in && 0 === u.avail_out && (m = !0);
|
||
|
|
} while ((0 < u.avail_in || 0 === u.avail_out) && i !== o.Z_STREAM_END);
|
||
|
|
return (
|
||
|
|
i === o.Z_STREAM_END && (s = o.Z_FINISH),
|
||
|
|
s === o.Z_FINISH
|
||
|
|
? ((i = n.inflateEnd(this.strm)), this.onEnd(i), (this.ended = !0), i === o.Z_OK)
|
||
|
|
: s !== o.Z_SYNC_FLUSH || (this.onEnd(o.Z_OK), !(u.avail_out = 0))
|
||
|
|
);
|
||
|
|
}),
|
||
|
|
(c.prototype.onData = function (e) {
|
||
|
|
this.chunks.push(e);
|
||
|
|
}),
|
||
|
|
(c.prototype.onEnd = function (e) {
|
||
|
|
e === o.Z_OK &&
|
||
|
|
('string' === this.options.to
|
||
|
|
? (this.result = this.chunks.join(''))
|
||
|
|
: (this.result = a.flattenChunks(this.chunks))),
|
||
|
|
(this.chunks = []),
|
||
|
|
(this.err = e),
|
||
|
|
(this.msg = this.strm.msg);
|
||
|
|
}),
|
||
|
|
(i.Inflate = c),
|
||
|
|
(i.inflate = u),
|
||
|
|
(i.inflateRaw = function (e, t) {
|
||
|
|
return ((t = t || {}).raw = !0), u(e, t);
|
||
|
|
}),
|
||
|
|
(i.ungzip = u);
|
||
|
|
},
|
||
|
|
{
|
||
|
|
'./utils/common': 1,
|
||
|
|
'./utils/strings': 2,
|
||
|
|
'./zlib/constants': 4,
|
||
|
|
'./zlib/gzheader': 6,
|
||
|
|
'./zlib/inflate': 8,
|
||
|
|
'./zlib/messages': 10,
|
||
|
|
'./zlib/zstream': 11,
|
||
|
|
},
|
||
|
|
],
|
||
|
|
},
|
||
|
|
{},
|
||
|
|
[]
|
||
|
|
)('/lib/inflate.js');
|
||
|
|
});
|