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.
1978 lines
70 KiB
1978 lines
70 KiB
/* pako 1.0.3 nodeca/pako */ ! function(t) {
|
|
if ("object" == typeof exports && "undefined" != typeof module) module.exports = t();
|
|
else if ("function" == typeof define && define.amd) define([], t);
|
|
else {
|
|
var e;
|
|
e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ?
|
|
self : this, e.pako = t()
|
|
}
|
|
}(function() {
|
|
return function t(e, a, i) {
|
|
function n(s, o) {
|
|
if (!a[s]) {
|
|
if (!e[s]) {
|
|
var l = "function" == typeof require && require;
|
|
if (!o && l) return l(s, !0);
|
|
if (r) return r(s, !0);
|
|
var h = new Error("Cannot find module '" + s + "'");
|
|
throw h.code = "MODULE_NOT_FOUND", h
|
|
}
|
|
var d = a[s] = {
|
|
exports: {}
|
|
};
|
|
e[s][0].call(d.exports, function(t) {
|
|
var a = e[s][1][t];
|
|
return n(a ? a : t)
|
|
}, d, d.exports, t, e, a, i)
|
|
}
|
|
return a[s].exports
|
|
}
|
|
for (var r = "function" == typeof require && require, s = 0; s < i.length; s++) n(i[s]);
|
|
return n
|
|
}({
|
|
1: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
if (!(this instanceof i)) return new i(t);
|
|
this.options = l.assign({
|
|
level: w,
|
|
method: v,
|
|
chunkSize: 16384,
|
|
windowBits: 15,
|
|
memLevel: 8,
|
|
strategy: p,
|
|
to: ""
|
|
}, t || {});
|
|
var e = this.options;
|
|
e.raw && e.windowBits > 0 ? e.windowBits = -e.windowBits : e.gzip && e.windowBits >
|
|
0 && e.windowBits < 16 && (e.windowBits += 16), this.err = 0, this.msg = "",
|
|
this.ended = !1, this.chunks = [], this.strm = new f, this.strm.avail_out = 0;
|
|
var a = o.deflateInit2(this.strm, e.level, e.method, e.windowBits, e.memLevel, e
|
|
.strategy);
|
|
if (a !== b) throw new Error(d[a]);
|
|
if (e.header && o.deflateSetHeader(this.strm, e.header), e.dictionary) {
|
|
var n;
|
|
if (n = "string" == typeof e.dictionary ? h.string2buf(e.dictionary) :
|
|
"[object ArrayBuffer]" === _.call(e.dictionary) ? new Uint8Array(e
|
|
.dictionary) : e.dictionary, a = o.deflateSetDictionary(this.strm, n),
|
|
a !== b) throw new Error(d[a]);
|
|
this._dict_set = !0
|
|
}
|
|
}
|
|
|
|
function n(t, e) {
|
|
var a = new i(e);
|
|
if (a.push(t, !0), a.err) throw a.msg;
|
|
return a.result
|
|
}
|
|
|
|
function r(t, e) {
|
|
return e = e || {}, e.raw = !0, n(t, e)
|
|
}
|
|
|
|
function s(t, e) {
|
|
return e = e || {}, e.gzip = !0, n(t, e)
|
|
}
|
|
var o = t("./zlib/deflate"),
|
|
l = t("./utils/common"),
|
|
h = t("./utils/strings"),
|
|
d = t("./zlib/messages"),
|
|
f = t("./zlib/zstream"),
|
|
_ = Object.prototype.toString,
|
|
u = 0,
|
|
c = 4,
|
|
b = 0,
|
|
g = 1,
|
|
m = 2,
|
|
w = -1,
|
|
p = 0,
|
|
v = 8;
|
|
i.prototype.push = function(t, e) {
|
|
var a, i, n = this.strm,
|
|
r = this.options.chunkSize;
|
|
if (this.ended) return !1;
|
|
i = e === ~~e ? e : e === !0 ? c : u, "string" == typeof t ? n.input = h
|
|
.string2buf(t) : "[object ArrayBuffer]" === _.call(t) ? n.input =
|
|
new Uint8Array(t) : n.input = t, n.next_in = 0, n.avail_in = n.input.length;
|
|
do {
|
|
if (0 === n.avail_out && (n.output = new l.Buf8(r), n.next_out = 0, n
|
|
.avail_out = r), a = o.deflate(n, i), a !== g && a !== b)
|
|
return this.onEnd(a), this.ended = !0, !1;
|
|
0 !== n.avail_out && (0 !== n.avail_in || i !== c && i !== m) || (
|
|
"string" === this.options.to ? this.onData(h.buf2binstring(l
|
|
.shrinkBuf(n.output, n.next_out))) : this.onData(l.shrinkBuf(n
|
|
.output, n.next_out)))
|
|
} while ((n.avail_in > 0 || 0 === n.avail_out) && a !== g);
|
|
return i === c ? (a = o.deflateEnd(this.strm), this.onEnd(a), this.ended = !0,
|
|
a === b) : i !== m || (this.onEnd(b), n.avail_out = 0, !0)
|
|
}, i.prototype.onData = function(t) {
|
|
this.chunks.push(t)
|
|
}, i.prototype.onEnd = function(t) {
|
|
t === b && ("string" === this.options.to ? this.result = this.chunks.join("") :
|
|
this.result = l.flattenChunks(this.chunks)), this.chunks = [], this
|
|
.err = t, this.msg = this.strm.msg
|
|
}, a.Deflate = i, a.deflate = n, a.deflateRaw = r, a.gzip = s
|
|
}, {
|
|
"./utils/common": 3,
|
|
"./utils/strings": 4,
|
|
"./zlib/deflate": 8,
|
|
"./zlib/messages": 13,
|
|
"./zlib/zstream": 15
|
|
}],
|
|
2: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
if (!(this instanceof i)) return new i(t);
|
|
this.options = o.assign({
|
|
chunkSize: 16384,
|
|
windowBits: 0,
|
|
to: ""
|
|
}, t || {});
|
|
var e = this.options;
|
|
e.raw && e.windowBits >= 0 && e.windowBits < 16 && (e.windowBits = -e.windowBits,
|
|
0 === e.windowBits && (e.windowBits = -15)), !(e.windowBits >= 0 && e
|
|
.windowBits < 16) || t && t.windowBits || (e.windowBits += 32), e
|
|
.windowBits > 15 && e.windowBits < 48 && 0 === (15 & e.windowBits) && (e
|
|
.windowBits |= 15), this.err = 0, this.msg = "", this.ended = !1, this
|
|
.chunks = [], this.strm = new f, this.strm.avail_out = 0;
|
|
var a = s.inflateInit2(this.strm, e.windowBits);
|
|
if (a !== h.Z_OK) throw new Error(d[a]);
|
|
this.header = new _, s.inflateGetHeader(this.strm, this.header)
|
|
}
|
|
|
|
function n(t, e) {
|
|
var a = new i(e);
|
|
if (a.push(t, !0), a.err) throw a.msg;
|
|
return a.result
|
|
}
|
|
|
|
function r(t, e) {
|
|
return e = e || {}, e.raw = !0, n(t, e)
|
|
}
|
|
var s = t("./zlib/inflate"),
|
|
o = t("./utils/common"),
|
|
l = t("./utils/strings"),
|
|
h = t("./zlib/constants"),
|
|
d = t("./zlib/messages"),
|
|
f = t("./zlib/zstream"),
|
|
_ = t("./zlib/gzheader"),
|
|
u = Object.prototype.toString;
|
|
i.prototype.push = function(t, e) {
|
|
var a, i, n, r, d, f, _ = this.strm,
|
|
c = this.options.chunkSize,
|
|
b = this.options.dictionary,
|
|
g = !1;
|
|
if (this.ended) return !1;
|
|
i = e === ~~e ? e : e === !0 ? h.Z_FINISH : h.Z_NO_FLUSH, "string" == typeof t ?
|
|
_.input = l.binstring2buf(t) : "[object ArrayBuffer]" === u.call(t) ? _
|
|
.input = new Uint8Array(t) : _.input = t, _.next_in = 0, _.avail_in = _
|
|
.input.length;
|
|
do {
|
|
if (0 === _.avail_out && (_.output = new o.Buf8(c), _.next_out = 0, _
|
|
.avail_out = c), a = s.inflate(_, h.Z_NO_FLUSH), a === h
|
|
.Z_NEED_DICT && b && (f = "string" == typeof b ? l.string2buf(b) :
|
|
"[object ArrayBuffer]" === u.call(b) ? new Uint8Array(b) : b, a = s
|
|
.inflateSetDictionary(this.strm, f)), a === h.Z_BUF_ERROR && g === !
|
|
0 && (a = h.Z_OK, g = !1), a !== h.Z_STREAM_END && a !== h.Z_OK)
|
|
return this.onEnd(a), this.ended = !0, !1;
|
|
_.next_out && (0 !== _.avail_out && a !== h.Z_STREAM_END && (0 !== _
|
|
.avail_in || i !== h.Z_FINISH && i !== h.Z_SYNC_FLUSH) || (
|
|
"string" === this.options.to ? (n = l.utf8border(_.output, _
|
|
.next_out), r = _.next_out - n, d = l.buf2string(_
|
|
.output, n), _.next_out = r, _.avail_out = c - r, r && o
|
|
.arraySet(_.output, _.output, n, r, 0), this.onData(d)) :
|
|
this.onData(o.shrinkBuf(_.output, _.next_out)))), 0 === _
|
|
.avail_in && 0 === _.avail_out && (g = !0)
|
|
} while ((_.avail_in > 0 || 0 === _.avail_out) && a !== h.Z_STREAM_END);
|
|
return a === h.Z_STREAM_END && (i = h.Z_FINISH), i === h.Z_FINISH ? (a = s
|
|
.inflateEnd(this.strm), this.onEnd(a), this.ended = !0, a === h.Z_OK) :
|
|
i !== h.Z_SYNC_FLUSH || (this.onEnd(h.Z_OK), _.avail_out = 0, !0)
|
|
}, i.prototype.onData = function(t) {
|
|
this.chunks.push(t)
|
|
}, i.prototype.onEnd = function(t) {
|
|
t === h.Z_OK && ("string" === this.options.to ? this.result = this.chunks.join(
|
|
"") : this.result = o.flattenChunks(this.chunks)), this.chunks = [],
|
|
this.err = t, this.msg = this.strm.msg
|
|
}, a.Inflate = i, a.inflate = n, a.inflateRaw = r, a.ungzip = n
|
|
}, {
|
|
"./utils/common": 3,
|
|
"./utils/strings": 4,
|
|
"./zlib/constants": 6,
|
|
"./zlib/gzheader": 9,
|
|
"./zlib/inflate": 11,
|
|
"./zlib/messages": 13,
|
|
"./zlib/zstream": 15
|
|
}],
|
|
3: [function(t, e, a) {
|
|
"use strict";
|
|
var i = "undefined" != typeof Uint8Array && "undefined" != typeof Uint16Array &&
|
|
"undefined" != typeof Int32Array;
|
|
a.assign = function(t) {
|
|
for (var e = Array.prototype.slice.call(arguments, 1); e.length;) {
|
|
var a = e.shift();
|
|
if (a) {
|
|
if ("object" != typeof a) throw new TypeError(a + "must be non-object");
|
|
for (var i in a) a.hasOwnProperty(i) && (t[i] = a[i])
|
|
}
|
|
}
|
|
return t
|
|
}, a.shrinkBuf = function(t, e) {
|
|
return t.length === e ? t : t.subarray ? t.subarray(0, e) : (t.length = e, t)
|
|
};
|
|
var n = {
|
|
arraySet: function(t, e, a, i, n) {
|
|
if (e.subarray && t.subarray) return void t.set(e.subarray(a, a + i),
|
|
n);
|
|
for (var r = 0; r < i; r++) t[n + r] = e[a + r]
|
|
},
|
|
flattenChunks: function(t) {
|
|
var e, a, i, n, r, s;
|
|
for (i = 0, e = 0, a = t.length; e < a; e++) i += t[e].length;
|
|
for (s = new Uint8Array(i), n = 0, e = 0, a = t.length; e < a; e++) r =
|
|
t[e], s.set(r, n), n += r.length;
|
|
return s
|
|
}
|
|
},
|
|
r = {
|
|
arraySet: function(t, e, a, i, n) {
|
|
for (var r = 0; r < i; r++) t[n + r] = e[a + r]
|
|
},
|
|
flattenChunks: function(t) {
|
|
return [].concat.apply([], t)
|
|
}
|
|
};
|
|
a.setTyped = function(t) {
|
|
t ? (a.Buf8 = Uint8Array, a.Buf16 = Uint16Array, a.Buf32 = Int32Array, a.assign(
|
|
a, n)) : (a.Buf8 = Array, a.Buf16 = Array, a.Buf32 = Array, a.assign(a,
|
|
r))
|
|
}, a.setTyped(i)
|
|
}, {}],
|
|
4: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t, e) {
|
|
if (e < 65537 && (t.subarray && s || !t.subarray && r)) return String.fromCharCode
|
|
.apply(null, n.shrinkBuf(t, e));
|
|
for (var a = "", i = 0; i < e; i++) a += String.fromCharCode(t[i]);
|
|
return a
|
|
}
|
|
var n = t("./common"),
|
|
r = !0,
|
|
s = !0;
|
|
try {
|
|
String.fromCharCode.apply(null, [0])
|
|
} catch (t) {
|
|
r = !1
|
|
}
|
|
try {
|
|
String.fromCharCode.apply(null, new Uint8Array(1))
|
|
} catch (t) {
|
|
s = !1
|
|
}
|
|
for (var o = new n.Buf8(256), l = 0; l < 256; l++) o[l] = l >= 252 ? 6 : l >= 248 ? 5 :
|
|
l >= 240 ? 4 : l >= 224 ? 3 : l >= 192 ? 2 : 1;
|
|
o[254] = o[254] = 1, a.string2buf = function(t) {
|
|
var e, a, i, r, s, o = t.length,
|
|
l = 0;
|
|
for (r = 0; r < o; r++) a = t.charCodeAt(r), 55296 === (64512 & a) && r + 1 <
|
|
o && (i = t.charCodeAt(r + 1), 56320 === (64512 & i) && (a = 65536 + (a -
|
|
55296 << 10) + (i - 56320), r++)), l += a < 128 ? 1 : a < 2048 ? 2 : a <
|
|
65536 ? 3 : 4;
|
|
for (e = new n.Buf8(l), s = 0, r = 0; s < l; r++) a = t.charCodeAt(r), 55296 ===
|
|
(64512 & a) && r + 1 < o && (i = t.charCodeAt(r + 1), 56320 === (64512 &
|
|
i) && (a = 65536 + (a - 55296 << 10) + (i - 56320), r++)), a < 128 ? e[
|
|
s++] = a : a < 2048 ? (e[s++] = 192 | a >>> 6, e[s++] = 128 | 63 & a) :
|
|
a < 65536 ? (e[s++] = 224 | a >>> 12, e[s++] = 128 | a >>> 6 & 63, e[s++] =
|
|
128 | 63 & a) : (e[s++] = 240 | a >>> 18, e[s++] = 128 | a >>> 12 & 63,
|
|
e[s++] = 128 | a >>> 6 & 63, e[s++] = 128 | 63 & a);
|
|
return e
|
|
}, a.buf2binstring = function(t) {
|
|
return i(t, t.length)
|
|
}, a.binstring2buf = function(t) {
|
|
for (var e = new n.Buf8(t.length), a = 0, i = e.length; a < i; a++) e[a] = t
|
|
.charCodeAt(a);
|
|
return e
|
|
}, a.buf2string = function(t, e) {
|
|
var a, n, r, s, l = e || t.length,
|
|
h = new Array(2 * l);
|
|
for (n = 0, a = 0; a < l;)
|
|
if (r = t[a++], r < 128) h[n++] = r;
|
|
else if (s = o[r], s > 4) h[n++] = 65533, a += s - 1;
|
|
else {
|
|
for (r &= 2 === s ? 31 : 3 === s ? 15 : 7; s > 1 && a < l;) r = r << 6 |
|
|
63 & t[a++], s--;
|
|
s > 1 ? h[n++] = 65533 : r < 65536 ? h[n++] = r : (r -= 65536, h[n++] =
|
|
55296 | r >> 10 & 1023, h[n++] = 56320 | 1023 & r)
|
|
}
|
|
return i(h, n)
|
|
}, a.utf8border = function(t, e) {
|
|
var a;
|
|
for (e = e || t.length, e > t.length && (e = t.length), a = e - 1; a >= 0 &&
|
|
128 === (192 & t[a]);) a--;
|
|
return a < 0 ? e : 0 === a ? e : a + o[t[a]] > e ? a : e
|
|
}
|
|
}, {
|
|
"./common": 3
|
|
}],
|
|
5: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t, e, a, i) {
|
|
for (var n = 65535 & t | 0, r = t >>> 16 & 65535 | 0, s = 0; 0 !== a;) {
|
|
s = a > 2e3 ? 2e3 : a, a -= s;
|
|
do n = n + e[i++] | 0, r = r + n | 0; while (--s);
|
|
n %= 65521, r %= 65521
|
|
}
|
|
return n | r << 16 | 0
|
|
}
|
|
e.exports = i
|
|
}, {}],
|
|
6: [function(t, e, a) {
|
|
"use strict";
|
|
e.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
|
|
}
|
|
}, {}],
|
|
7: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i() {
|
|
for (var t, e = [], a = 0; a < 256; a++) {
|
|
t = a;
|
|
for (var i = 0; i < 8; i++) t = 1 & t ? 3988292384 ^ t >>> 1 : t >>> 1;
|
|
e[a] = t
|
|
}
|
|
return e
|
|
}
|
|
|
|
function n(t, e, a, i) {
|
|
var n = r,
|
|
s = i + a;
|
|
t ^= -1;
|
|
for (var o = i; o < s; o++) t = t >>> 8 ^ n[255 & (t ^ e[o])];
|
|
return t ^ -1
|
|
}
|
|
var r = i();
|
|
e.exports = n
|
|
}, {}],
|
|
8: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t, e) {
|
|
return t.msg = D[e], e
|
|
}
|
|
|
|
function n(t) {
|
|
return (t << 1) - (t > 4 ? 9 : 0)
|
|
}
|
|
|
|
function r(t) {
|
|
for (var e = t.length; --e >= 0;) t[e] = 0
|
|
}
|
|
|
|
function s(t) {
|
|
var e = t.state,
|
|
a = e.pending;
|
|
a > t.avail_out && (a = t.avail_out), 0 !== a && (R.arraySet(t.output, e
|
|
.pending_buf, e.pending_out, a, t.next_out), t.next_out += a, e
|
|
.pending_out += a, t.total_out += a, t.avail_out -= a, e.pending -= a, 0 ===
|
|
e.pending && (e.pending_out = 0))
|
|
}
|
|
|
|
function o(t, e) {
|
|
C._tr_flush_block(t, t.block_start >= 0 ? t.block_start : -1, t.strstart - t
|
|
.block_start, e), t.block_start = t.strstart, s(t.strm)
|
|
}
|
|
|
|
function l(t, e) {
|
|
t.pending_buf[t.pending++] = e
|
|
}
|
|
|
|
function h(t, e) {
|
|
t.pending_buf[t.pending++] = e >>> 8 & 255, t.pending_buf[t.pending++] = 255 & e
|
|
}
|
|
|
|
function d(t, e, a, i) {
|
|
var n = t.avail_in;
|
|
return n > i && (n = i), 0 === n ? 0 : (t.avail_in -= n, R.arraySet(e, t.input, t
|
|
.next_in, n, a), 1 === t.state.wrap ? t.adler = N(t.adler, e, n, a) :
|
|
2 === t.state.wrap && (t.adler = O(t.adler, e, n, a)), t.next_in += n, t
|
|
.total_in += n, n)
|
|
}
|
|
|
|
function f(t, e) {
|
|
var a, i, n = t.max_chain_length,
|
|
r = t.strstart,
|
|
s = t.prev_length,
|
|
o = t.nice_match,
|
|
l = t.strstart > t.w_size - ft ? t.strstart - (t.w_size - ft) : 0,
|
|
h = t.window,
|
|
d = t.w_mask,
|
|
f = t.prev,
|
|
_ = t.strstart + dt,
|
|
u = h[r + s - 1],
|
|
c = h[r + s];
|
|
t.prev_length >= t.good_match && (n >>= 2), o > t.lookahead && (o = t.lookahead);
|
|
do
|
|
if (a = e, h[a + s] === c && h[a + s - 1] === u && h[a] === h[r] && h[++a] ===
|
|
h[r + 1]) {
|
|
r += 2, a++;
|
|
do; while (h[++r] === h[++a] && h[++r] === h[++a] && h[++r] === h[++a] && h[
|
|
++r] === h[++a] && h[++r] === h[++a] && h[++r] === h[++a] && h[++
|
|
r] === h[++a] && h[++r] === h[++a] && r < _);
|
|
if (i = dt - (_ - r), r = _ - dt, i > s) {
|
|
if (t.match_start = e, s = i, i >= o) break;
|
|
u = h[r + s - 1], c = h[r + s]
|
|
}
|
|
} while ((e = f[e & d]) > l && 0 !== --n);
|
|
return s <= t.lookahead ? s : t.lookahead
|
|
}
|
|
|
|
function _(t) {
|
|
var e, a, i, n, r, s = t.w_size;
|
|
do {
|
|
if (n = t.window_size - t.lookahead - t.strstart, t.strstart >= s + (s - ft)) {
|
|
R.arraySet(t.window, t.window, s, s, 0), t.match_start -= s, t.strstart -=
|
|
s, t.block_start -= s, a = t.hash_size, e = a;
|
|
do i = t.head[--e], t.head[e] = i >= s ? i - s : 0; while (--a);
|
|
a = s, e = a;
|
|
do i = t.prev[--e], t.prev[e] = i >= s ? i - s : 0; while (--a);
|
|
n += s
|
|
}
|
|
if (0 === t.strm.avail_in) break;
|
|
if (a = d(t.strm, t.window, t.strstart + t.lookahead, n), t.lookahead += a, t
|
|
.lookahead + t.insert >= ht)
|
|
for (r = t.strstart - t.insert, t.ins_h = t.window[r], t.ins_h = (t.ins_h <<
|
|
t.hash_shift ^ t.window[r + 1]) & t.hash_mask; t.insert && (t
|
|
.ins_h = (t.ins_h << t.hash_shift ^ t.window[r + ht - 1]) & t
|
|
.hash_mask, t.prev[r & t.w_mask] = t.head[t.ins_h], t.head[t
|
|
.ins_h] = r, r++, t.insert--, !(t.lookahead + t.insert < ht)););
|
|
} while (t.lookahead < ft && 0 !== t.strm.avail_in)
|
|
}
|
|
|
|
function u(t, e) {
|
|
var a = 65535;
|
|
for (a > t.pending_buf_size - 5 && (a = t.pending_buf_size - 5);;) {
|
|
if (t.lookahead <= 1) {
|
|
if (_(t), 0 === t.lookahead && e === I) return vt;
|
|
if (0 === t.lookahead) break
|
|
}
|
|
t.strstart += t.lookahead, t.lookahead = 0;
|
|
var i = t.block_start + a;
|
|
if ((0 === t.strstart || t.strstart >= i) && (t.lookahead = t.strstart - i, t
|
|
.strstart = i, o(t, !1), 0 === t.strm.avail_out)) return vt;
|
|
if (t.strstart - t.block_start >= t.w_size - ft && (o(t, !1), 0 === t.strm
|
|
.avail_out)) return vt
|
|
}
|
|
return t.insert = 0, e === F ? (o(t, !0), 0 === t.strm.avail_out ? yt : xt) : t
|
|
.strstart > t.block_start && (o(t, !1), 0 === t.strm.avail_out) ? vt : vt
|
|
}
|
|
|
|
function c(t, e) {
|
|
for (var a, i;;) {
|
|
if (t.lookahead < ft) {
|
|
if (_(t), t.lookahead < ft && e === I) return vt;
|
|
if (0 === t.lookahead) break
|
|
}
|
|
if (a = 0, t.lookahead >= ht && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t
|
|
.strstart + ht - 1]) & t.hash_mask, a = t.prev[t.strstart & t
|
|
.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), 0 !== a && t
|
|
.strstart - a <= t.w_size - ft && (t.match_length = f(t, a)), t
|
|
.match_length >= ht)
|
|
if (i = C._tr_tally(t, t.strstart - t.match_start, t.match_length - ht), t
|
|
.lookahead -= t.match_length, t.match_length <= t.max_lazy_match && t
|
|
.lookahead >= ht) {
|
|
t.match_length--;
|
|
do t.strstart++, t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t
|
|
.strstart + ht - 1]) & t.hash_mask, a = t.prev[t.strstart & t
|
|
.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart; while (
|
|
0 !== --t.match_length);
|
|
t.strstart++
|
|
} else t.strstart += t.match_length, t.match_length = 0, t.ins_h = t.window[
|
|
t.strstart], t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t
|
|
.strstart + 1]) & t.hash_mask;
|
|
else i = C._tr_tally(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++;
|
|
if (i && (o(t, !1), 0 === t.strm.avail_out)) return vt
|
|
}
|
|
return t.insert = t.strstart < ht - 1 ? t.strstart : ht - 1, e === F ? (o(t, !0),
|
|
0 === t.strm.avail_out ? yt : xt) : t.last_lit && (o(t, !1), 0 === t.strm
|
|
.avail_out) ? vt : kt
|
|
}
|
|
|
|
function b(t, e) {
|
|
for (var a, i, n;;) {
|
|
if (t.lookahead < ft) {
|
|
if (_(t), t.lookahead < ft && e === I) return vt;
|
|
if (0 === t.lookahead) break
|
|
}
|
|
if (a = 0, t.lookahead >= ht && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t
|
|
.strstart + ht - 1]) & t.hash_mask, a = t.prev[t.strstart & t
|
|
.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), t
|
|
.prev_length = t.match_length, t.prev_match = t.match_start, t
|
|
.match_length = ht - 1, 0 !== a && t.prev_length < t.max_lazy_match && t
|
|
.strstart - a <= t.w_size - ft && (t.match_length = f(t, a), t
|
|
.match_length <= 5 && (t.strategy === q || t.match_length === ht && t
|
|
.strstart - t.match_start > 4096) && (t.match_length = ht - 1)), t
|
|
.prev_length >= ht && t.match_length <= t.prev_length) {
|
|
n = t.strstart + t.lookahead - ht, i = C._tr_tally(t, t.strstart - 1 - t
|
|
.prev_match, t.prev_length - ht), t.lookahead -= t.prev_length - 1,
|
|
t.prev_length -= 2;
|
|
do ++t.strstart <= n && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t
|
|
.strstart + ht - 1]) & t.hash_mask, a = t.prev[t.strstart & t
|
|
.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart); while (0 !==
|
|
--t.prev_length);
|
|
if (t.match_available = 0, t.match_length = ht - 1, t.strstart++, i && (o(t,
|
|
!1), 0 === t.strm.avail_out)) return vt
|
|
} else if (t.match_available) {
|
|
if (i = C._tr_tally(t, 0, t.window[t.strstart - 1]), i && o(t, !1), t
|
|
.strstart++, t.lookahead--, 0 === t.strm.avail_out) return vt
|
|
} else t.match_available = 1, t.strstart++, t.lookahead--
|
|
}
|
|
return t.match_available && (i = C._tr_tally(t, 0, t.window[t.strstart - 1]), t
|
|
.match_available = 0), t.insert = t.strstart < ht - 1 ? t.strstart : ht - 1,
|
|
e === F ? (o(t, !0), 0 === t.strm.avail_out ? yt : xt) : t.last_lit && (o(t, !
|
|
1), 0 === t.strm.avail_out) ? vt : kt
|
|
}
|
|
|
|
function g(t, e) {
|
|
for (var a, i, n, r, s = t.window;;) {
|
|
if (t.lookahead <= dt) {
|
|
if (_(t), t.lookahead <= dt && e === I) return vt;
|
|
if (0 === t.lookahead) break
|
|
}
|
|
if (t.match_length = 0, t.lookahead >= ht && t.strstart > 0 && (n = t.strstart -
|
|
1, i = s[n], i === s[++n] && i === s[++n] && i === s[++n])) {
|
|
r = t.strstart + dt;
|
|
do; while (i === s[++n] && i === s[++n] && i === s[++n] && i === s[++n] &&
|
|
i === s[++n] && i === s[++n] && i === s[++n] && i === s[++n] && n < r);
|
|
t.match_length = dt - (r - n), t.match_length > t.lookahead && (t
|
|
.match_length = t.lookahead)
|
|
}
|
|
if (t.match_length >= ht ? (a = C._tr_tally(t, 1, t.match_length - ht), t
|
|
.lookahead -= t.match_length, t.strstart += t.match_length, t
|
|
.match_length = 0) : (a = C._tr_tally(t, 0, t.window[t.strstart]), t
|
|
.lookahead--, t.strstart++), a && (o(t, !1), 0 === t.strm.avail_out))
|
|
return vt
|
|
}
|
|
return t.insert = 0, e === F ? (o(t, !0), 0 === t.strm.avail_out ? yt : xt) : t
|
|
.last_lit && (o(t, !1), 0 === t.strm.avail_out) ? vt : kt
|
|
}
|
|
|
|
function m(t, e) {
|
|
for (var a;;) {
|
|
if (0 === t.lookahead && (_(t), 0 === t.lookahead)) {
|
|
if (e === I) return vt;
|
|
break
|
|
}
|
|
if (t.match_length = 0, a = C._tr_tally(t, 0, t.window[t.strstart]), t
|
|
.lookahead--, t.strstart++, a && (o(t, !1), 0 === t.strm.avail_out))
|
|
return vt
|
|
}
|
|
return t.insert = 0, e === F ? (o(t, !0), 0 === t.strm.avail_out ? yt : xt) : t
|
|
.last_lit && (o(t, !1), 0 === t.strm.avail_out) ? vt : kt
|
|
}
|
|
|
|
function w(t, e, a, i, n) {
|
|
this.good_length = t, this.max_lazy = e, this.nice_length = a, this.max_chain = i,
|
|
this.func = n
|
|
}
|
|
|
|
function p(t) {
|
|
t.window_size = 2 * t.w_size, r(t.head), t.max_lazy_match = Z[t.level].max_lazy, t
|
|
.good_match = Z[t.level].good_length, t.nice_match = Z[t.level].nice_length, t
|
|
.max_chain_length = Z[t.level].max_chain, t.strstart = 0, t.block_start = 0, t
|
|
.lookahead = 0, t.insert = 0, t.match_length = t.prev_length = ht - 1, t
|
|
.match_available = 0, t.ins_h = 0
|
|
}
|
|
|
|
function v() {
|
|
this.strm = null, this.status = 0, this.pending_buf = null, this.pending_buf_size =
|
|
0, this.pending_out = 0, this.pending = 0, this.wrap = 0, this.gzhead = null,
|
|
this.gzindex = 0, this.method = V, this.last_flush = -1, this.w_size = 0, this
|
|
.w_bits = 0, this.w_mask = 0, this.window = null, this.window_size = 0, this
|
|
.prev = null, this.head = null, this.ins_h = 0, this.hash_size = 0, this
|
|
.hash_bits = 0, this.hash_mask = 0, this.hash_shift = 0, this.block_start = 0,
|
|
this.match_length = 0, this.prev_match = 0, this.match_available = 0, this
|
|
.strstart = 0, this.match_start = 0, this.lookahead = 0, this.prev_length = 0,
|
|
this.max_chain_length = 0, this.max_lazy_match = 0, this.level = 0, this
|
|
.strategy = 0, this.good_match = 0, this.nice_match = 0, this.dyn_ltree = new R
|
|
.Buf16(2 * ot), this.dyn_dtree = new R.Buf16(2 * (2 * rt + 1)), this.bl_tree =
|
|
new R.Buf16(2 * (2 * st + 1)), r(this.dyn_ltree), r(this.dyn_dtree), r(this
|
|
.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this
|
|
.bl_count = new R.Buf16(lt + 1), this.heap = new R.Buf16(2 * nt + 1), r(this
|
|
.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new R.Buf16(2 *
|
|
nt + 1), r(this.depth), this.l_buf = 0, this.lit_bufsize = 0, this
|
|
.last_lit = 0, this.d_buf = 0, this.opt_len = 0, this.static_len = 0, this
|
|
.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0
|
|
}
|
|
|
|
function k(t) {
|
|
var e;
|
|
return t && t.state ? (t.total_in = t.total_out = 0, t.data_type = Q, e = t.state, e
|
|
.pending = 0, e.pending_out = 0, e.wrap < 0 && (e.wrap = -e.wrap), e
|
|
.status = e.wrap ? ut : wt, t.adler = 2 === e.wrap ? 0 : 1, e.last_flush =
|
|
I, C._tr_init(e), H) : i(t, K)
|
|
}
|
|
|
|
function y(t) {
|
|
var e = k(t);
|
|
return e === H && p(t.state), e
|
|
}
|
|
|
|
function x(t, e) {
|
|
return t && t.state ? 2 !== t.state.wrap ? K : (t.state.gzhead = e, H) : K
|
|
}
|
|
|
|
function z(t, e, a, n, r, s) {
|
|
if (!t) return K;
|
|
var o = 1;
|
|
if (e === Y && (e = 6), n < 0 ? (o = 0, n = -n) : n > 15 && (o = 2, n -= 16), r <
|
|
1 || r > $ || a !== V || n < 8 || n > 15 || e < 0 || e > 9 || s < 0 || s > W)
|
|
return i(t, K);
|
|
8 === n && (n = 9);
|
|
var l = new v;
|
|
return t.state = l, l.strm = t, l.wrap = o, l.gzhead = null, l.w_bits = n, l
|
|
.w_size = 1 << l.w_bits, l.w_mask = l.w_size - 1, l.hash_bits = r + 7, l
|
|
.hash_size = 1 << l.hash_bits, l.hash_mask = l.hash_size - 1, l.hash_shift = ~~(
|
|
(l.hash_bits + ht - 1) / ht), l.window = new R.Buf8(2 * l.w_size), l.head =
|
|
new R.Buf16(l.hash_size), l.prev = new R.Buf16(l.w_size), l.lit_bufsize = 1 <<
|
|
r + 6, l.pending_buf_size = 4 * l.lit_bufsize, l.pending_buf = new R.Buf8(l
|
|
.pending_buf_size), l.d_buf = 1 * l.lit_bufsize, l.l_buf = 3 * l
|
|
.lit_bufsize, l.level = e, l.strategy = s, l.method = a, y(t)
|
|
}
|
|
|
|
function B(t, e) {
|
|
return z(t, e, V, tt, et, J)
|
|
}
|
|
|
|
function S(t, e) {
|
|
var a, o, d, f;
|
|
if (!t || !t.state || e > L || e < 0) return t ? i(t, K) : K;
|
|
if (o = t.state, !t.output || !t.input && 0 !== t.avail_in || o.status === pt &&
|
|
e !== F) return i(t, 0 === t.avail_out ? P : K);
|
|
if (o.strm = t, a = o.last_flush, o.last_flush = e, o.status === ut)
|
|
if (2 === o.wrap) t.adler = 0, l(o, 31), l(o, 139), l(o, 8), o.gzhead ? (l(o, (o
|
|
.gzhead.text ? 1 : 0) + (o.gzhead.hcrc ? 2 : 0) + (o.gzhead
|
|
.extra ? 4 : 0) + (o.gzhead.name ? 8 : 0) + (o.gzhead.comment ?
|
|
16 : 0)), l(o, 255 & o.gzhead.time), l(o, o.gzhead.time >> 8 & 255),
|
|
l(o, o.gzhead.time >> 16 & 255), l(o, o.gzhead.time >> 24 & 255), l(o,
|
|
9 === o.level ? 2 : o.strategy >= G || o.level < 2 ? 4 : 0), l(o,
|
|
255 & o.gzhead.os), o.gzhead.extra && o.gzhead.extra.length && (l(o,
|
|
255 & o.gzhead.extra.length), l(o, o.gzhead.extra.length >> 8 &
|
|
255)), o.gzhead.hcrc && (t.adler = O(t.adler, o.pending_buf, o
|
|
.pending, 0)), o.gzindex = 0, o.status = ct) : (l(o, 0), l(o, 0), l(
|
|
o, 0), l(o, 0), l(o, 0), l(o, 9 === o.level ? 2 : o.strategy >= G ||
|
|
o.level < 2 ? 4 : 0), l(o, zt), o.status = wt);
|
|
else {
|
|
var _ = V + (o.w_bits - 8 << 4) << 8,
|
|
u = -1;
|
|
u = o.strategy >= G || o.level < 2 ? 0 : o.level < 6 ? 1 : 6 === o.level ?
|
|
2 : 3, _ |= u << 6, 0 !== o.strstart && (_ |= _t), _ += 31 - _ % 31, o
|
|
.status = wt, h(o, _), 0 !== o.strstart && (h(o, t.adler >>> 16), h(o,
|
|
65535 & t.adler)), t.adler = 1
|
|
} if (o.status === ct)
|
|
if (o.gzhead.extra) {
|
|
for (d = o.pending; o.gzindex < (65535 & o.gzhead.extra.length) && (o
|
|
.pending !== o.pending_buf_size || (o.gzhead.hcrc && o.pending >
|
|
d && (t.adler = O(t.adler, o.pending_buf, o.pending - d, d)), s(
|
|
t), d = o.pending, o.pending !== o.pending_buf_size));) l(o,
|
|
255 & o.gzhead.extra[o.gzindex]), o.gzindex++;
|
|
o.gzhead.hcrc && o.pending > d && (t.adler = O(t.adler, o.pending_buf, o
|
|
.pending - d, d)), o.gzindex === o.gzhead.extra.length && (o
|
|
.gzindex = 0, o.status = bt)
|
|
} else o.status = bt;
|
|
if (o.status === bt)
|
|
if (o.gzhead.name) {
|
|
d = o.pending;
|
|
do {
|
|
if (o.pending === o.pending_buf_size && (o.gzhead.hcrc && o.pending >
|
|
d && (t.adler = O(t.adler, o.pending_buf, o.pending - d, d)), s(
|
|
t), d = o.pending, o.pending === o.pending_buf_size)) {
|
|
f = 1;
|
|
break
|
|
}
|
|
f = o.gzindex < o.gzhead.name.length ? 255 & o.gzhead.name.charCodeAt(o
|
|
.gzindex++) : 0, l(o, f)
|
|
} while (0 !== f);
|
|
o.gzhead.hcrc && o.pending > d && (t.adler = O(t.adler, o.pending_buf, o
|
|
.pending - d, d)), 0 === f && (o.gzindex = 0, o.status = gt)
|
|
} else o.status = gt;
|
|
if (o.status === gt)
|
|
if (o.gzhead.comment) {
|
|
d = o.pending;
|
|
do {
|
|
if (o.pending === o.pending_buf_size && (o.gzhead.hcrc && o.pending >
|
|
d && (t.adler = O(t.adler, o.pending_buf, o.pending - d, d)), s(
|
|
t), d = o.pending, o.pending === o.pending_buf_size)) {
|
|
f = 1;
|
|
break
|
|
}
|
|
f = o.gzindex < o.gzhead.comment.length ? 255 & o.gzhead.comment
|
|
.charCodeAt(o.gzindex++) : 0, l(o, f)
|
|
} while (0 !== f);
|
|
o.gzhead.hcrc && o.pending > d && (t.adler = O(t.adler, o.pending_buf, o
|
|
.pending - d, d)), 0 === f && (o.status = mt)
|
|
} else o.status = mt;
|
|
if (o.status === mt && (o.gzhead.hcrc ? (o.pending + 2 > o.pending_buf_size && s(t),
|
|
o.pending + 2 <= o.pending_buf_size && (l(o, 255 & t.adler), l(o, t
|
|
.adler >> 8 & 255), t.adler = 0, o.status = wt)) : o.status = wt), 0 !==
|
|
o.pending) {
|
|
if (s(t), 0 === t.avail_out) return o.last_flush = -1, H
|
|
} else if (0 === t.avail_in && n(e) <= n(a) && e !== F) return i(t, P);
|
|
if (o.status === pt && 0 !== t.avail_in) return i(t, P);
|
|
if (0 !== t.avail_in || 0 !== o.lookahead || e !== I && o.status !== pt) {
|
|
var c = o.strategy === G ? m(o, e) : o.strategy === X ? g(o, e) : Z[o.level]
|
|
.func(o, e);
|
|
if (c !== yt && c !== xt || (o.status = pt), c === vt || c === yt) return 0 ===
|
|
t.avail_out && (o.last_flush = -1), H;
|
|
if (c === kt && (e === U ? C._tr_align(o) : e !== L && (C._tr_stored_block(o, 0,
|
|
0, !1), e === T && (r(o.head), 0 === o.lookahead && (o
|
|
.strstart = 0, o.block_start = 0, o.insert = 0))), s(t), 0 === t
|
|
.avail_out)) return o.last_flush = -1, H
|
|
}
|
|
return e !== F ? H : o.wrap <= 0 ? j : (2 === o.wrap ? (l(o, 255 & t.adler), l(o, t
|
|
.adler >> 8 & 255), l(o, t.adler >> 16 & 255), l(o, t.adler >> 24 &
|
|
255), l(o, 255 & t.total_in), l(o, t.total_in >> 8 & 255), l(o, t
|
|
.total_in >> 16 & 255), l(o, t.total_in >> 24 & 255)) : (h(o, t
|
|
.adler >>> 16), h(o, 65535 & t.adler)), s(t), o.wrap > 0 && (o.wrap = -o
|
|
.wrap), 0 !== o.pending ? H : j)
|
|
}
|
|
|
|
function E(t) {
|
|
var e;
|
|
return t && t.state ? (e = t.state.status, e !== ut && e !== ct && e !== bt && e !==
|
|
gt && e !== mt && e !== wt && e !== pt ? i(t, K) : (t.state = null, e ===
|
|
wt ? i(t, M) : H)) : K
|
|
}
|
|
|
|
function A(t, e) {
|
|
var a, i, n, s, o, l, h, d, f = e.length;
|
|
if (!t || !t.state) return K;
|
|
if (a = t.state, s = a.wrap, 2 === s || 1 === s && a.status !== ut || a.lookahead)
|
|
return K;
|
|
for (1 === s && (t.adler = N(t.adler, e, f, 0)), a.wrap = 0, f >= a.w_size && (0 ===
|
|
s && (r(a.head), a.strstart = 0, a.block_start = 0, a.insert = 0), d = new R
|
|
.Buf8(a.w_size), R.arraySet(d, e, f - a.w_size, a.w_size, 0), e = d, f = a
|
|
.w_size), o = t.avail_in, l = t.next_in, h = t.input, t.avail_in = f, t
|
|
.next_in = 0, t.input = e, _(a); a.lookahead >= ht;) {
|
|
i = a.strstart, n = a.lookahead - (ht - 1);
|
|
do a.ins_h = (a.ins_h << a.hash_shift ^ a.window[i + ht - 1]) & a.hash_mask, a
|
|
.prev[i & a.w_mask] = a.head[a.ins_h], a.head[a.ins_h] = i, i++; while (--
|
|
n);
|
|
a.strstart = i, a.lookahead = ht - 1, _(a)
|
|
}
|
|
return a.strstart += a.lookahead, a.block_start = a.strstart, a.insert = a
|
|
.lookahead, a.lookahead = 0, a.match_length = a.prev_length = ht - 1, a
|
|
.match_available = 0, t.next_in = l, t.input = h, t.avail_in = o, a.wrap = s, H
|
|
}
|
|
var Z, R = t("../utils/common"),
|
|
C = t("./trees"),
|
|
N = t("./adler32"),
|
|
O = t("./crc32"),
|
|
D = t("./messages"),
|
|
I = 0,
|
|
U = 1,
|
|
T = 3,
|
|
F = 4,
|
|
L = 5,
|
|
H = 0,
|
|
j = 1,
|
|
K = -2,
|
|
M = -3,
|
|
P = -5,
|
|
Y = -1,
|
|
q = 1,
|
|
G = 2,
|
|
X = 3,
|
|
W = 4,
|
|
J = 0,
|
|
Q = 2,
|
|
V = 8,
|
|
$ = 9,
|
|
tt = 15,
|
|
et = 8,
|
|
at = 29,
|
|
it = 256,
|
|
nt = it + 1 + at,
|
|
rt = 30,
|
|
st = 19,
|
|
ot = 2 * nt + 1,
|
|
lt = 15,
|
|
ht = 3,
|
|
dt = 258,
|
|
ft = dt + ht + 1,
|
|
_t = 32,
|
|
ut = 42,
|
|
ct = 69,
|
|
bt = 73,
|
|
gt = 91,
|
|
mt = 103,
|
|
wt = 113,
|
|
pt = 666,
|
|
vt = 1,
|
|
kt = 2,
|
|
yt = 3,
|
|
xt = 4,
|
|
zt = 3;
|
|
Z = [new w(0, 0, 0, 0, u), new w(4, 4, 8, 4, c), new w(4, 5, 16, 8, c), new w(4, 6, 32,
|
|
32, c), new w(4, 4, 16, 16, b), new w(8, 16, 32, 32, b), new w(8, 16, 128,
|
|
128, b), new w(8, 32, 128, 256, b), new w(32, 128, 258, 1024, b), new w(32,
|
|
258, 258, 4096, b)], a.deflateInit = B, a.deflateInit2 = z, a.deflateReset = y,
|
|
a.deflateResetKeep = k, a.deflateSetHeader = x, a.deflate = S, a.deflateEnd = E, a
|
|
.deflateSetDictionary = A, a.deflateInfo = "pako deflate (from Nodeca project)"
|
|
}, {
|
|
"../utils/common": 3,
|
|
"./adler32": 5,
|
|
"./crc32": 7,
|
|
"./messages": 13,
|
|
"./trees": 14
|
|
}],
|
|
9: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i() {
|
|
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
|
|
}
|
|
e.exports = i
|
|
}, {}],
|
|
10: [function(t, e, a) {
|
|
"use strict";
|
|
var i = 30,
|
|
n = 12;
|
|
e.exports = function(t, e) {
|
|
var a, r, s, o, l, h, d, f, _, u, c, b, g, m, w, p, v, k, y, x, z, B, S, E, A;
|
|
a = t.state, r = t.next_in, E = t.input, s = r + (t.avail_in - 5), o = t
|
|
.next_out, A = t.output, l = o - (e - t.avail_out), h = o + (t.avail_out -
|
|
257), d = a.dmax, f = a.wsize, _ = a.whave, u = a.wnext, c = a.window,
|
|
b = a.hold, g = a.bits, m = a.lencode, w = a.distcode, p = (1 << a
|
|
.lenbits) - 1, v = (1 << a.distbits) - 1;
|
|
t: do {
|
|
g < 15 && (b += E[r++] << g, g += 8, b += E[r++] << g, g += 8), k = m[
|
|
b & p];
|
|
e: for (;;) {
|
|
if (y = k >>> 24, b >>>= y, g -= y, y = k >>> 16 & 255, 0 === y)
|
|
A[o++] = 65535 & k;
|
|
else {
|
|
if (!(16 & y)) {
|
|
if (0 === (64 & y)) {
|
|
k = m[(65535 & k) + (b & (1 << y) - 1)];
|
|
continue e
|
|
}
|
|
if (32 & y) {
|
|
a.mode = n;
|
|
break t
|
|
}
|
|
t.msg = "invalid literal/length code", a.mode = i;
|
|
break t
|
|
}
|
|
x = 65535 & k, y &= 15, y && (g < y && (b += E[r++] << g,
|
|
g += 8), x += b & (1 << y) - 1, b >>>= y, g -=
|
|
y), g < 15 && (b += E[r++] << g, g += 8, b += E[
|
|
r++] << g, g += 8), k = w[b & v];
|
|
a: for (;;) {
|
|
if (y = k >>> 24, b >>>= y, g -= y, y = k >>> 16 &
|
|
255, !(16 & y)) {
|
|
if (0 === (64 & y)) {
|
|
k = w[(65535 & k) + (b & (1 << y) - 1)];
|
|
continue a
|
|
}
|
|
t.msg = "invalid distance code", a.mode = i;
|
|
break t
|
|
}
|
|
if (z = 65535 & k, y &= 15, g < y && (b += E[r++] <<
|
|
g, g += 8, g < y && (b += E[r++] << g, g +=
|
|
8)), z += b & (1 << y) - 1, z > d) {
|
|
t.msg = "invalid distance too far back", a
|
|
.mode = i;
|
|
break t
|
|
}
|
|
if (b >>>= y, g -= y, y = o - l, z > y) {
|
|
if (y = z - y, y > _ && a.sane) {
|
|
t.msg = "invalid distance too far back", a
|
|
.mode = i;
|
|
break t
|
|
}
|
|
if (B = 0, S = c, 0 === u) {
|
|
if (B += f - y, y < x) {
|
|
x -= y;
|
|
do A[o++] = c[B++]; while (--y);
|
|
B = o - z, S = A
|
|
}
|
|
} else if (u < y) {
|
|
if (B += f + u - y, y -= u, y < x) {
|
|
x -= y;
|
|
do A[o++] = c[B++]; while (--y);
|
|
if (B = 0, u < x) {
|
|
y = u, x -= y;
|
|
do A[o++] = c[B++]; while (--y);
|
|
B = o - z, S = A
|
|
}
|
|
}
|
|
} else if (B += u - y, y < x) {
|
|
x -= y;
|
|
do A[o++] = c[B++]; while (--y);
|
|
B = o - z, S = A
|
|
}
|
|
for (; x > 2;) A[o++] = S[B++], A[o++] = S[B++],
|
|
A[o++] = S[B++], x -= 3;
|
|
x && (A[o++] = S[B++], x > 1 && (A[o++] = S[
|
|
B++]))
|
|
} else {
|
|
B = o - z;
|
|
do A[o++] = A[B++], A[o++] = A[B++], A[o++] = A[
|
|
B++], x -= 3; while (x > 2);
|
|
x && (A[o++] = A[B++], x > 1 && (A[o++] = A[
|
|
B++]))
|
|
}
|
|
break
|
|
}
|
|
}
|
|
break
|
|
}
|
|
} while (r < s && o < h);
|
|
x = g >> 3, r -= x, g -= x << 3, b &= (1 << g) - 1, t.next_in = r, t.next_out =
|
|
o, t.avail_in = r < s ? 5 + (s - r) : 5 - (r - s), t.avail_out = o < h ?
|
|
257 + (h - o) : 257 - (o - h), a.hold = b, a.bits = g
|
|
}
|
|
}, {}],
|
|
11: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
return (t >>> 24 & 255) + (t >>> 8 & 65280) + ((65280 & t) << 8) + ((255 & t) << 24)
|
|
}
|
|
|
|
function n() {
|
|
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 w.Buf16(320), this.work = new w.Buf16(288), this.lendyn = null, this
|
|
.distdyn = null, this.sane = 0, this.back = 0, this.was = 0
|
|
}
|
|
|
|
function r(t) {
|
|
var e;
|
|
return t && t.state ? (e = t.state, t.total_in = t.total_out = e.total = 0, t.msg =
|
|
"", e.wrap && (t.adler = 1 & e.wrap), e.mode = T, e.last = 0, e.havedict =
|
|
0, e.dmax = 32768, e.head = null, e.hold = 0, e.bits = 0, e.lencode = e
|
|
.lendyn = new w.Buf32(bt), e.distcode = e.distdyn = new w.Buf32(gt), e
|
|
.sane = 1, e.back = -1, Z) : N
|
|
}
|
|
|
|
function s(t) {
|
|
var e;
|
|
return t && t.state ? (e = t.state, e.wsize = 0, e.whave = 0, e.wnext = 0, r(t)) : N
|
|
}
|
|
|
|
function o(t, e) {
|
|
var a, i;
|
|
return t && t.state ? (i = t.state, e < 0 ? (a = 0, e = -e) : (a = (e >> 4) + 1, e <
|
|
48 && (e &= 15)), e && (e < 8 || e > 15) ? N : (null !== i.window && i
|
|
.wbits !== e && (i.window = null), i.wrap = a, i.wbits = e, s(t))) : N
|
|
}
|
|
|
|
function l(t, e) {
|
|
var a, i;
|
|
return t ? (i = new n, t.state = i, i.window = null, a = o(t, e), a !== Z && (t
|
|
.state = null), a) : N
|
|
}
|
|
|
|
function h(t) {
|
|
return l(t, wt)
|
|
}
|
|
|
|
function d(t) {
|
|
if (pt) {
|
|
var e;
|
|
for (g = new w.Buf32(512), m = new w.Buf32(32), e = 0; e < 144;) t.lens[e++] =
|
|
8;
|
|
for (; e < 256;) t.lens[e++] = 9;
|
|
for (; e < 280;) t.lens[e++] = 7;
|
|
for (; e < 288;) t.lens[e++] = 8;
|
|
for (y(z, t.lens, 0, 288, g, 0, t.work, {
|
|
bits: 9
|
|
}), e = 0; e < 32;) t.lens[e++] = 5;
|
|
y(B, t.lens, 0, 32, m, 0, t.work, {
|
|
bits: 5
|
|
}), pt = !1
|
|
}
|
|
t.lencode = g, t.lenbits = 9, t.distcode = m, t.distbits = 5
|
|
}
|
|
|
|
function f(t, e, a, i) {
|
|
var n, r = t.state;
|
|
return null === r.window && (r.wsize = 1 << r.wbits, r.wnext = 0, r.whave = 0, r
|
|
.window = new w.Buf8(r.wsize)), i >= r.wsize ? (w.arraySet(r.window, e, a -
|
|
r.wsize, r.wsize, 0), r.wnext = 0, r.whave = r.wsize) : (n = r.wsize - r
|
|
.wnext, n > i && (n = i), w.arraySet(r.window, e, a - i, n, r.wnext), i -=
|
|
n, i ? (w.arraySet(r.window, e, a - i, i, 0), r.wnext = i, r.whave = r
|
|
.wsize) : (r.wnext += n, r.wnext === r.wsize && (r.wnext = 0), r.whave <
|
|
r.wsize && (r.whave += n))), 0
|
|
}
|
|
|
|
function _(t, e) {
|
|
var a, n, r, s, o, l, h, _, u, c, b, g, m, bt, gt, mt, wt, pt, vt, kt, yt, xt, zt,
|
|
Bt, St = 0,
|
|
Et = new w.Buf8(4),
|
|
At = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
|
if (!t || !t.state || !t.output || !t.input && 0 !== t.avail_in) return N;
|
|
a = t.state, a.mode === X && (a.mode = W), o = t.next_out, r = t.output, h = t
|
|
.avail_out, s = t.next_in, n = t.input, l = t.avail_in, _ = a.hold, u = a.bits,
|
|
c = l, b = h, xt = Z;
|
|
t: for (;;) switch (a.mode) {
|
|
case T:
|
|
if (0 === a.wrap) {
|
|
a.mode = W;
|
|
break
|
|
}
|
|
for (; u < 16;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (2 & a.wrap && 35615 === _) {
|
|
a.check = 0, Et[0] = 255 & _, Et[1] = _ >>> 8 & 255, a.check =
|
|
v(a.check, Et, 2, 0), _ = 0, u = 0, a.mode = F;
|
|
break
|
|
}
|
|
if (a.flags = 0, a.head && (a.head.done = !1), !(1 & a.wrap) || (((
|
|
255 & _) << 8) + (_ >> 8)) % 31) {
|
|
t.msg = "incorrect header check", a.mode = _t;
|
|
break
|
|
}
|
|
if ((15 & _) !== U) {
|
|
t.msg = "unknown compression method", a.mode = _t;
|
|
break
|
|
}
|
|
if (_ >>>= 4, u -= 4, yt = (15 & _) + 8, 0 === a.wbits) a.wbits =
|
|
yt;
|
|
else if (yt > a.wbits) {
|
|
t.msg = "invalid window size", a.mode = _t;
|
|
break
|
|
}
|
|
a.dmax = 1 << yt, t.adler = a.check = 1, a.mode = 512 & _ ? q : X,
|
|
_ = 0, u = 0;
|
|
break;
|
|
case F:
|
|
for (; u < 16;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (a.flags = _, (255 & a.flags) !== U) {
|
|
t.msg = "unknown compression method", a.mode = _t;
|
|
break
|
|
}
|
|
if (57344 & a.flags) {
|
|
t.msg = "unknown header flags set", a.mode = _t;
|
|
break
|
|
}
|
|
a.head && (a.head.text = _ >> 8 & 1), 512 & a.flags && (Et[0] =
|
|
255 & _, Et[1] = _ >>> 8 & 255, a.check = v(a.check, Et, 2,
|
|
0)), _ = 0, u = 0, a.mode = L;
|
|
case L:
|
|
for (; u < 32;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
a.head && (a.head.time = _), 512 & a.flags && (Et[0] = 255 & _, Et[
|
|
1] = _ >>> 8 & 255, Et[2] = _ >>> 16 & 255, Et[3] =
|
|
_ >>> 24 & 255, a.check = v(a.check, Et, 4, 0)), _ = 0, u =
|
|
0, a.mode = H;
|
|
case H:
|
|
for (; u < 16;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
a.head && (a.head.xflags = 255 & _, a.head.os = _ >> 8), 512 & a
|
|
.flags && (Et[0] = 255 & _, Et[1] = _ >>> 8 & 255, a.check = v(a
|
|
.check, Et, 2, 0)), _ = 0, u = 0, a.mode = j;
|
|
case j:
|
|
if (1024 & a.flags) {
|
|
for (; u < 16;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
a.length = _, a.head && (a.head.extra_len = _), 512 & a.flags &&
|
|
(Et[0] = 255 & _, Et[1] = _ >>> 8 & 255, a.check = v(a
|
|
.check, Et, 2, 0)), _ = 0, u = 0
|
|
} else a.head && (a.head.extra = null);
|
|
a.mode = K;
|
|
case K:
|
|
if (1024 & a.flags && (g = a.length, g > l && (g = l), g && (a
|
|
.head && (yt = a.head.extra_len - a.length, a.head
|
|
.extra || (a.head.extra = new Array(a.head
|
|
.extra_len)), w.arraySet(a.head.extra, n, s, g,
|
|
yt)), 512 & a.flags && (a.check = v(a.check, n,
|
|
g, s)), l -= g, s += g, a.length -= g), a.length))
|
|
break t;
|
|
a.length = 0, a.mode = M;
|
|
case M:
|
|
if (2048 & a.flags) {
|
|
if (0 === l) break t;
|
|
g = 0;
|
|
do yt = n[s + g++], a.head && yt && a.length < 65536 && (a.head
|
|
.name += String.fromCharCode(yt)); while (yt && g < l);
|
|
if (512 & a.flags && (a.check = v(a.check, n, g, s)), l -= g,
|
|
s += g, yt) break t
|
|
} else a.head && (a.head.name = null);
|
|
a.length = 0, a.mode = P;
|
|
case P:
|
|
if (4096 & a.flags) {
|
|
if (0 === l) break t;
|
|
g = 0;
|
|
do yt = n[s + g++], a.head && yt && a.length < 65536 && (a.head
|
|
.comment += String.fromCharCode(yt)); while (yt && g < l);
|
|
if (512 & a.flags && (a.check = v(a.check, n, g, s)), l -= g,
|
|
s += g, yt) break t
|
|
} else a.head && (a.head.comment = null);
|
|
a.mode = Y;
|
|
case Y:
|
|
if (512 & a.flags) {
|
|
for (; u < 16;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (_ !== (65535 & a.check)) {
|
|
t.msg = "header crc mismatch", a.mode = _t;
|
|
break
|
|
}
|
|
_ = 0, u = 0
|
|
}
|
|
a.head && (a.head.hcrc = a.flags >> 9 & 1, a.head.done = !0), t
|
|
.adler = a.check = 0, a.mode = X;
|
|
break;
|
|
case q:
|
|
for (; u < 32;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
t.adler = a.check = i(_), _ = 0, u = 0, a.mode = G;
|
|
case G:
|
|
if (0 === a.havedict) return t.next_out = o, t.avail_out = h, t
|
|
.next_in = s, t.avail_in = l, a.hold = _, a.bits = u, C;
|
|
t.adler = a.check = 1, a.mode = X;
|
|
case X:
|
|
if (e === E || e === A) break t;
|
|
case W:
|
|
if (a.last) {
|
|
_ >>>= 7 & u, u -= 7 & u, a.mode = ht;
|
|
break
|
|
}
|
|
for (; u < 3;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
switch (a.last = 1 & _, _ >>>= 1, u -= 1, 3 & _) {
|
|
case 0:
|
|
a.mode = J;
|
|
break;
|
|
case 1:
|
|
if (d(a), a.mode = at, e === A) {
|
|
_ >>>= 2, u -= 2;
|
|
break t
|
|
}
|
|
break;
|
|
case 2:
|
|
a.mode = $;
|
|
break;
|
|
case 3:
|
|
t.msg = "invalid block type", a.mode = _t
|
|
}
|
|
_ >>>= 2, u -= 2;
|
|
break;
|
|
case J:
|
|
for (_ >>>= 7 & u, u -= 7 & u; u < 32;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if ((65535 & _) !== (_ >>> 16 ^ 65535)) {
|
|
t.msg = "invalid stored block lengths", a.mode = _t;
|
|
break
|
|
}
|
|
if (a.length = 65535 & _, _ = 0, u = 0, a.mode = Q, e === A)
|
|
break t;
|
|
case Q:
|
|
a.mode = V;
|
|
case V:
|
|
if (g = a.length) {
|
|
if (g > l && (g = l), g > h && (g = h), 0 === g) break t;
|
|
w.arraySet(r, n, s, g, o), l -= g, s += g, h -= g, o += g, a
|
|
.length -= g;
|
|
break
|
|
}
|
|
a.mode = X;
|
|
break;
|
|
case $:
|
|
for (; u < 14;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (a.nlen = (31 & _) + 257, _ >>>= 5, u -= 5, a.ndist = (31 & _) +
|
|
1, _ >>>= 5, u -= 5, a.ncode = (15 & _) + 4, _ >>>= 4, u -= 4, a
|
|
.nlen > 286 || a.ndist > 30) {
|
|
t.msg = "too many length or distance symbols", a.mode = _t;
|
|
break
|
|
}
|
|
a.have = 0, a.mode = tt;
|
|
case tt:
|
|
for (; a.have < a.ncode;) {
|
|
for (; u < 3;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
a.lens[At[a.have++]] = 7 & _, _ >>>= 3, u -= 3
|
|
}
|
|
for (; a.have < 19;) a.lens[At[a.have++]] = 0;
|
|
if (a.lencode = a.lendyn, a.lenbits = 7, zt = {
|
|
bits: a.lenbits
|
|
}, xt = y(x, a.lens, 0, 19, a.lencode, 0, a.work, zt), a
|
|
.lenbits = zt.bits, xt) {
|
|
t.msg = "invalid code lengths set", a.mode = _t;
|
|
break
|
|
}
|
|
a.have = 0, a.mode = et;
|
|
case et:
|
|
for (; a.have < a.nlen + a.ndist;) {
|
|
for (; St = a.lencode[_ & (1 << a.lenbits) - 1], gt = St >>> 24,
|
|
mt = St >>> 16 & 255, wt = 65535 & St, !(gt <= u);) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (wt < 16) _ >>>= gt, u -= gt, a.lens[a.have++] = wt;
|
|
else {
|
|
if (16 === wt) {
|
|
for (Bt = gt + 2; u < Bt;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (_ >>>= gt, u -= gt, 0 === a.have) {
|
|
t.msg = "invalid bit length repeat", a.mode = _t;
|
|
break
|
|
}
|
|
yt = a.lens[a.have - 1], g = 3 + (3 & _), _ >>>= 2, u -=
|
|
2
|
|
} else if (17 === wt) {
|
|
for (Bt = gt + 3; u < Bt;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
_ >>>= gt, u -= gt, yt = 0, g = 3 + (7 & _), _ >>>= 3,
|
|
u -= 3
|
|
} else {
|
|
for (Bt = gt + 7; u < Bt;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
_ >>>= gt, u -= gt, yt = 0, g = 11 + (127 & _), _ >>>=
|
|
7, u -= 7
|
|
}
|
|
if (a.have + g > a.nlen + a.ndist) {
|
|
t.msg = "invalid bit length repeat", a.mode = _t;
|
|
break
|
|
}
|
|
for (; g--;) a.lens[a.have++] = yt
|
|
}
|
|
}
|
|
if (a.mode === _t) break;
|
|
if (0 === a.lens[256]) {
|
|
t.msg = "invalid code -- missing end-of-block", a.mode = _t;
|
|
break
|
|
}
|
|
if (a.lenbits = 9, zt = {
|
|
bits: a.lenbits
|
|
}, xt = y(z, a.lens, 0, a.nlen, a.lencode, 0, a.work, zt), a
|
|
.lenbits = zt.bits, xt) {
|
|
t.msg = "invalid literal/lengths set", a.mode = _t;
|
|
break
|
|
}
|
|
if (a.distbits = 6, a.distcode = a.distdyn, zt = {
|
|
bits: a.distbits
|
|
}, xt = y(B, a.lens, a.nlen, a.ndist, a.distcode, 0, a.work,
|
|
zt), a.distbits = zt.bits, xt) {
|
|
t.msg = "invalid distances set", a.mode = _t;
|
|
break
|
|
}
|
|
if (a.mode = at, e === A) break t;
|
|
case at:
|
|
a.mode = it;
|
|
case it:
|
|
if (l >= 6 && h >= 258) {
|
|
t.next_out = o, t.avail_out = h, t.next_in = s, t.avail_in = l,
|
|
a.hold = _, a.bits = u, k(t, b), o = t.next_out, r = t
|
|
.output, h = t.avail_out, s = t.next_in, n = t.input, l = t
|
|
.avail_in, _ = a.hold, u = a.bits, a.mode === X && (a
|
|
.back = -1);
|
|
break
|
|
}
|
|
for (a.back = 0; St = a.lencode[_ & (1 << a.lenbits) - 1], gt =
|
|
St >>> 24, mt = St >>> 16 & 255, wt = 65535 & St, !(gt <= u);) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (mt && 0 === (240 & mt)) {
|
|
for (pt = gt, vt = mt, kt = wt; St = a.lencode[kt + ((_ & (1 <<
|
|
pt + vt) - 1) >> pt)], gt = St >>> 24, mt = St >>> 16 &
|
|
255, wt = 65535 & St, !(pt + gt <= u);) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
_ >>>= pt, u -= pt, a.back += pt
|
|
}
|
|
if (_ >>>= gt, u -= gt, a.back += gt, a.length = wt, 0 === mt) {
|
|
a.mode = lt;
|
|
break
|
|
}
|
|
if (32 & mt) {
|
|
a.back = -1, a.mode = X;
|
|
break
|
|
}
|
|
if (64 & mt) {
|
|
t.msg = "invalid literal/length code", a.mode = _t;
|
|
break
|
|
}
|
|
a.extra = 15 & mt, a.mode = nt;
|
|
case nt:
|
|
if (a.extra) {
|
|
for (Bt = a.extra; u < Bt;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
a.length += _ & (1 << a.extra) - 1, _ >>>= a.extra, u -= a
|
|
.extra, a.back += a.extra
|
|
}
|
|
a.was = a.length, a.mode = rt;
|
|
case rt:
|
|
for (; St = a.distcode[_ & (1 << a.distbits) - 1], gt = St >>> 24,
|
|
mt = St >>> 16 & 255, wt = 65535 & St, !(gt <= u);) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (0 === (240 & mt)) {
|
|
for (pt = gt, vt = mt, kt = wt; St = a.distcode[kt + ((_ & (1 <<
|
|
pt + vt) - 1) >> pt)], gt = St >>> 24, mt = St >>> 16 &
|
|
255, wt = 65535 & St, !(pt + gt <= u);) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
_ >>>= pt, u -= pt, a.back += pt
|
|
}
|
|
if (_ >>>= gt, u -= gt, a.back += gt, 64 & mt) {
|
|
t.msg = "invalid distance code", a.mode = _t;
|
|
break
|
|
}
|
|
a.offset = wt, a.extra = 15 & mt, a.mode = st;
|
|
case st:
|
|
if (a.extra) {
|
|
for (Bt = a.extra; u < Bt;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
a.offset += _ & (1 << a.extra) - 1, _ >>>= a.extra, u -= a
|
|
.extra, a.back += a.extra
|
|
}
|
|
if (a.offset > a.dmax) {
|
|
t.msg = "invalid distance too far back", a.mode = _t;
|
|
break
|
|
}
|
|
a.mode = ot;
|
|
case ot:
|
|
if (0 === h) break t;
|
|
if (g = b - h, a.offset > g) {
|
|
if (g = a.offset - g, g > a.whave && a.sane) {
|
|
t.msg = "invalid distance too far back", a.mode = _t;
|
|
break
|
|
}
|
|
g > a.wnext ? (g -= a.wnext, m = a.wsize - g) : m = a.wnext - g,
|
|
g > a.length && (g = a.length), bt = a.window
|
|
} else bt = r, m = o - a.offset, g = a.length;
|
|
g > h && (g = h), h -= g, a.length -= g;
|
|
do r[o++] = bt[m++]; while (--g);
|
|
0 === a.length && (a.mode = it);
|
|
break;
|
|
case lt:
|
|
if (0 === h) break t;
|
|
r[o++] = a.length, h--, a.mode = it;
|
|
break;
|
|
case ht:
|
|
if (a.wrap) {
|
|
for (; u < 32;) {
|
|
if (0 === l) break t;
|
|
l--, _ |= n[s++] << u, u += 8
|
|
}
|
|
if (b -= h, t.total_out += b, a.total += b, b && (t.adler = a
|
|
.check = a.flags ? v(a.check, r, b, o - b) : p(a.check,
|
|
r, b, o - b)), b = h, (a.flags ? _ : i(_)) !== a
|
|
.check) {
|
|
t.msg = "incorrect data check", a.mode = _t;
|
|
break
|
|
}
|
|
_ = 0, u = 0
|
|
}
|
|
a.mode = dt;
|
|
case dt:
|
|
if (a.wrap && a.flags) {
|
|
for (; u < 32;) {
|
|
if (0 === l) break t;
|
|
l--, _ += n[s++] << u, u += 8
|
|
}
|
|
if (_ !== (4294967295 & a.total)) {
|
|
t.msg = "incorrect length check", a.mode = _t;
|
|
break
|
|
}
|
|
_ = 0, u = 0
|
|
}
|
|
a.mode = ft;
|
|
case ft:
|
|
xt = R;
|
|
break t;
|
|
case _t:
|
|
xt = O;
|
|
break t;
|
|
case ut:
|
|
return D;
|
|
case ct:
|
|
default:
|
|
return N
|
|
}
|
|
return t.next_out = o, t.avail_out = h, t.next_in = s, t.avail_in = l, a.hold = _, a
|
|
.bits = u, (a.wsize || b !== t.avail_out && a.mode < _t && (a.mode < ht || e !==
|
|
S)) && f(t, t.output, t.next_out, b - t.avail_out) ? (a.mode = ut, D) : (
|
|
c -= t.avail_in, b -= t.avail_out, t.total_in += c, t.total_out += b, a
|
|
.total += b, a.wrap && b && (t.adler = a.check = a.flags ? v(a.check, r, b,
|
|
t.next_out - b) : p(a.check, r, b, t.next_out - b)), t.data_type = a
|
|
.bits + (a.last ? 64 : 0) + (a.mode === X ? 128 : 0) + (a.mode === at || a
|
|
.mode === Q ? 256 : 0), (0 === c && 0 === b || e === S) && xt === Z && (
|
|
xt = I), xt)
|
|
}
|
|
|
|
function u(t) {
|
|
if (!t || !t.state) return N;
|
|
var e = t.state;
|
|
return e.window && (e.window = null), t.state = null, Z
|
|
}
|
|
|
|
function c(t, e) {
|
|
var a;
|
|
return t && t.state ? (a = t.state, 0 === (2 & a.wrap) ? N : (a.head = e, e.done = !
|
|
1, Z)) : N
|
|
}
|
|
|
|
function b(t, e) {
|
|
var a, i, n, r = e.length;
|
|
return t && t.state ? (a = t.state, 0 !== a.wrap && a.mode !== G ? N : a.mode ===
|
|
G && (i = 1, i = p(i, e, r, 0), i !== a.check) ? O : (n = f(t, e, r, r)) ? (
|
|
a.mode = ut, D) : (a.havedict = 1, Z)) : N
|
|
}
|
|
var g, m, w = t("../utils/common"),
|
|
p = t("./adler32"),
|
|
v = t("./crc32"),
|
|
k = t("./inffast"),
|
|
y = t("./inftrees"),
|
|
x = 0,
|
|
z = 1,
|
|
B = 2,
|
|
S = 4,
|
|
E = 5,
|
|
A = 6,
|
|
Z = 0,
|
|
R = 1,
|
|
C = 2,
|
|
N = -2,
|
|
O = -3,
|
|
D = -4,
|
|
I = -5,
|
|
U = 8,
|
|
T = 1,
|
|
F = 2,
|
|
L = 3,
|
|
H = 4,
|
|
j = 5,
|
|
K = 6,
|
|
M = 7,
|
|
P = 8,
|
|
Y = 9,
|
|
q = 10,
|
|
G = 11,
|
|
X = 12,
|
|
W = 13,
|
|
J = 14,
|
|
Q = 15,
|
|
V = 16,
|
|
$ = 17,
|
|
tt = 18,
|
|
et = 19,
|
|
at = 20,
|
|
it = 21,
|
|
nt = 22,
|
|
rt = 23,
|
|
st = 24,
|
|
ot = 25,
|
|
lt = 26,
|
|
ht = 27,
|
|
dt = 28,
|
|
ft = 29,
|
|
_t = 30,
|
|
ut = 31,
|
|
ct = 32,
|
|
bt = 852,
|
|
gt = 592,
|
|
mt = 15,
|
|
wt = mt,
|
|
pt = !0;
|
|
a.inflateReset = s, a.inflateReset2 = o, a.inflateResetKeep = r, a.inflateInit = h, a
|
|
.inflateInit2 = l, a.inflate = _, a.inflateEnd = u, a.inflateGetHeader = c, a
|
|
.inflateSetDictionary = b, a.inflateInfo = "pako inflate (from Nodeca project)"
|
|
}, {
|
|
"../utils/common": 3,
|
|
"./adler32": 5,
|
|
"./crc32": 7,
|
|
"./inffast": 10,
|
|
"./inftrees": 12
|
|
}],
|
|
12: [function(t, e, a) {
|
|
"use strict";
|
|
var i = t("../utils/common"),
|
|
n = 15,
|
|
r = 852,
|
|
s = 592,
|
|
o = 0,
|
|
l = 1,
|
|
h = 2,
|
|
d = [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
|
|
],
|
|
f = [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
|
|
],
|
|
_ = [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
|
|
],
|
|
u = [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
|
|
];
|
|
e.exports = function(t, e, a, c, b, g, m, w) {
|
|
var p, v, k, y, x, z, B, S, E, A = w.bits,
|
|
Z = 0,
|
|
R = 0,
|
|
C = 0,
|
|
N = 0,
|
|
O = 0,
|
|
D = 0,
|
|
I = 0,
|
|
U = 0,
|
|
T = 0,
|
|
F = 0,
|
|
L = null,
|
|
H = 0,
|
|
j = new i.Buf16(n + 1),
|
|
K = new i.Buf16(n + 1),
|
|
M = null,
|
|
P = 0;
|
|
for (Z = 0; Z <= n; Z++) j[Z] = 0;
|
|
for (R = 0; R < c; R++) j[e[a + R]]++;
|
|
for (O = A, N = n; N >= 1 && 0 === j[N]; N--);
|
|
if (O > N && (O = N), 0 === N) return b[g++] = 20971520, b[g++] = 20971520, w
|
|
.bits = 1, 0;
|
|
for (C = 1; C < N && 0 === j[C]; C++);
|
|
for (O < C && (O = C), U = 1, Z = 1; Z <= n; Z++)
|
|
if (U <<= 1, U -= j[Z], U < 0) return -1;
|
|
if (U > 0 && (t === o || 1 !== N)) return -1;
|
|
for (K[1] = 0, Z = 1; Z < n; Z++) K[Z + 1] = K[Z] + j[Z];
|
|
for (R = 0; R < c; R++) 0 !== e[a + R] && (m[K[e[a + R]]++] = R);
|
|
if (t === o ? (L = M = m, z = 19) : t === l ? (L = d, H -= 257, M = f, P -= 257,
|
|
z = 256) : (L = _, M = u, z = -1), F = 0, R = 0, Z = C, x = g, D = O,
|
|
I = 0, k = -1, T = 1 << O, y = T - 1, t === l && T > r || t === h && T > s)
|
|
return 1;
|
|
for (var Y = 0;;) {
|
|
Y++, B = Z - I, m[R] < z ? (S = 0, E = m[R]) : m[R] > z ? (S = M[P + m[R]],
|
|
E = L[H + m[R]]) : (S = 96, E = 0), p = 1 << Z - I, v = 1 << D, C =
|
|
v;
|
|
do v -= p, b[x + (F >> I) + v] = B << 24 | S << 16 | E | 0; while (0 !== v);
|
|
for (p = 1 << Z - 1; F & p;) p >>= 1;
|
|
if (0 !== p ? (F &= p - 1, F += p) : F = 0, R++, 0 === --j[Z]) {
|
|
if (Z === N) break;
|
|
Z = e[a + m[R]]
|
|
}
|
|
if (Z > O && (F & y) !== k) {
|
|
for (0 === I && (I = O), x += C, D = Z - I, U = 1 << D; D + I < N && (
|
|
U -= j[D + I], !(U <= 0));) D++, U <<= 1;
|
|
if (T += 1 << D, t === l && T > r || t === h && T > s) return 1;
|
|
k = F & y, b[k] = O << 24 | D << 16 | x - g | 0
|
|
}
|
|
}
|
|
return 0 !== F && (b[x + F] = Z - I << 24 | 64 << 16 | 0), w.bits = O, 0
|
|
}
|
|
}, {
|
|
"../utils/common": 3
|
|
}],
|
|
13: [function(t, e, a) {
|
|
"use strict";
|
|
e.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"
|
|
}
|
|
}, {}],
|
|
14: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i(t) {
|
|
for (var e = t.length; --e >= 0;) t[e] = 0
|
|
}
|
|
|
|
function n(t, e, a, i, n) {
|
|
this.static_tree = t, this.extra_bits = e, this.extra_base = a, this.elems = i, this
|
|
.max_length = n, this.has_stree = t && t.length
|
|
}
|
|
|
|
function r(t, e) {
|
|
this.dyn_tree = t, this.max_code = 0, this.stat_desc = e
|
|
}
|
|
|
|
function s(t) {
|
|
return t < 256 ? lt[t] : lt[256 + (t >>> 7)]
|
|
}
|
|
|
|
function o(t, e) {
|
|
t.pending_buf[t.pending++] = 255 & e, t.pending_buf[t.pending++] = e >>> 8 & 255
|
|
}
|
|
|
|
function l(t, e, a) {
|
|
t.bi_valid > W - a ? (t.bi_buf |= e << t.bi_valid & 65535, o(t, t.bi_buf), t
|
|
.bi_buf = e >> W - t.bi_valid, t.bi_valid += a - W) : (t.bi_buf |= e << t
|
|
.bi_valid & 65535, t.bi_valid += a)
|
|
}
|
|
|
|
function h(t, e, a) {
|
|
l(t, a[2 * e], a[2 * e + 1])
|
|
}
|
|
|
|
function d(t, e) {
|
|
var a = 0;
|
|
do a |= 1 & t, t >>>= 1, a <<= 1; while (--e > 0);
|
|
return a >>> 1
|
|
}
|
|
|
|
function f(t) {
|
|
16 === t.bi_valid ? (o(t, t.bi_buf), t.bi_buf = 0, t.bi_valid = 0) : t.bi_valid >=
|
|
8 && (t.pending_buf[t.pending++] = 255 & t.bi_buf, t.bi_buf >>= 8, t.bi_valid -=
|
|
8)
|
|
}
|
|
|
|
function _(t, e) {
|
|
var a, i, n, r, s, o, l = e.dyn_tree,
|
|
h = e.max_code,
|
|
d = e.stat_desc.static_tree,
|
|
f = e.stat_desc.has_stree,
|
|
_ = e.stat_desc.extra_bits,
|
|
u = e.stat_desc.extra_base,
|
|
c = e.stat_desc.max_length,
|
|
b = 0;
|
|
for (r = 0; r <= X; r++) t.bl_count[r] = 0;
|
|
for (l[2 * t.heap[t.heap_max] + 1] = 0, a = t.heap_max + 1; a < G; a++) i = t.heap[
|
|
a], r = l[2 * l[2 * i + 1] + 1] + 1, r > c && (r = c, b++), l[2 * i + 1] =
|
|
r, i > h || (t.bl_count[r]++, s = 0, i >= u && (s = _[i - u]), o = l[2 * i], t
|
|
.opt_len += o * (r + s), f && (t.static_len += o * (d[2 * i + 1] + s)));
|
|
if (0 !== b) {
|
|
do {
|
|
for (r = c - 1; 0 === t.bl_count[r];) r--;
|
|
t.bl_count[r]--, t.bl_count[r + 1] += 2, t.bl_count[c]--, b -= 2
|
|
} while (b > 0);
|
|
for (r = c; 0 !== r; r--)
|
|
for (i = t.bl_count[r]; 0 !== i;) n = t.heap[--a], n > h || (l[2 * n +
|
|
1] !== r && (t.opt_len += (r - l[2 * n + 1]) * l[2 * n], l[2 * n +
|
|
1] = r), i--)
|
|
}
|
|
}
|
|
|
|
function u(t, e, a) {
|
|
var i, n, r = new Array(X + 1),
|
|
s = 0;
|
|
for (i = 1; i <= X; i++) r[i] = s = s + a[i - 1] << 1;
|
|
for (n = 0; n <= e; n++) {
|
|
var o = t[2 * n + 1];
|
|
0 !== o && (t[2 * n] = d(r[o]++, o))
|
|
}
|
|
}
|
|
|
|
function c() {
|
|
var t, e, a, i, r, s = new Array(X + 1);
|
|
for (a = 0, i = 0; i < K - 1; i++)
|
|
for (dt[i] = a, t = 0; t < 1 << et[i]; t++) ht[a++] = i;
|
|
for (ht[a - 1] = i, r = 0, i = 0; i < 16; i++)
|
|
for (ft[i] = r, t = 0; t < 1 << at[i]; t++) lt[r++] = i;
|
|
for (r >>= 7; i < Y; i++)
|
|
for (ft[i] = r << 7, t = 0; t < 1 << at[i] - 7; t++) lt[256 + r++] = i;
|
|
for (e = 0; e <= X; e++) s[e] = 0;
|
|
for (t = 0; t <= 143;) st[2 * t + 1] = 8, t++, s[8]++;
|
|
for (; t <= 255;) st[2 * t + 1] = 9, t++, s[9]++;
|
|
for (; t <= 279;) st[2 * t + 1] = 7, t++, s[7]++;
|
|
for (; t <= 287;) st[2 * t + 1] = 8, t++, s[8]++;
|
|
for (u(st, P + 1, s), t = 0; t < Y; t++) ot[2 * t + 1] = 5, ot[2 * t] = d(t, 5);
|
|
_t = new n(st, et, M + 1, P, X), ut = new n(ot, at, 0, Y, X), ct = new n(new Array(
|
|
0), it, 0, q, J)
|
|
}
|
|
|
|
function b(t) {
|
|
var e;
|
|
for (e = 0; e < P; e++) t.dyn_ltree[2 * e] = 0;
|
|
for (e = 0; e < Y; e++) t.dyn_dtree[2 * e] = 0;
|
|
for (e = 0; e < q; e++) t.bl_tree[2 * e] = 0;
|
|
t.dyn_ltree[2 * Q] = 1, t.opt_len = t.static_len = 0, t.last_lit = t.matches = 0
|
|
}
|
|
|
|
function g(t) {
|
|
t.bi_valid > 8 ? o(t, t.bi_buf) : t.bi_valid > 0 && (t.pending_buf[t.pending++] = t
|
|
.bi_buf), t.bi_buf = 0, t.bi_valid = 0
|
|
}
|
|
|
|
function m(t, e, a, i) {
|
|
g(t), i && (o(t, a), o(t, ~a)), N.arraySet(t.pending_buf, t.window, e, a, t
|
|
.pending), t.pending += a
|
|
}
|
|
|
|
function w(t, e, a, i) {
|
|
var n = 2 * e,
|
|
r = 2 * a;
|
|
return t[n] < t[r] || t[n] === t[r] && i[e] <= i[a]
|
|
}
|
|
|
|
function p(t, e, a) {
|
|
for (var i = t.heap[a], n = a << 1; n <= t.heap_len && (n < t.heap_len && w(e, t
|
|
.heap[n + 1], t.heap[n], t.depth) && n++, !w(e, i, t.heap[n], t.depth));) t
|
|
.heap[a] = t.heap[n], a = n, n <<= 1;
|
|
t.heap[a] = i
|
|
}
|
|
|
|
function v(t, e, a) {
|
|
var i, n, r, o, d = 0;
|
|
if (0 !== t.last_lit)
|
|
do i = t.pending_buf[t.d_buf + 2 * d] << 8 | t.pending_buf[t.d_buf + 2 * d + 1],
|
|
n = t.pending_buf[t.l_buf + d], d++, 0 === i ? h(t, n, e) : (r = ht[n], h(t,
|
|
r + M + 1, e), o = et[r], 0 !== o && (n -= dt[r], l(t, n, o)), i--,
|
|
r = s(i), h(t, r, a), o = at[r], 0 !== o && (i -= ft[r], l(t, i, o))
|
|
); while (d < t.last_lit);
|
|
h(t, Q, e)
|
|
}
|
|
|
|
function k(t, e) {
|
|
var a, i, n, r = e.dyn_tree,
|
|
s = e.stat_desc.static_tree,
|
|
o = e.stat_desc.has_stree,
|
|
l = e.stat_desc.elems,
|
|
h = -1;
|
|
for (t.heap_len = 0, t.heap_max = G, a = 0; a < l; a++) 0 !== r[2 * a] ? (t.heap[++t
|
|
.heap_len] = h = a, t.depth[a] = 0) : r[2 * a + 1] = 0;
|
|
for (; t.heap_len < 2;) n = t.heap[++t.heap_len] = h < 2 ? ++h : 0, r[2 * n] = 1, t
|
|
.depth[n] = 0, t.opt_len--, o && (t.static_len -= s[2 * n + 1]);
|
|
for (e.max_code = h, a = t.heap_len >> 1; a >= 1; a--) p(t, r, a);
|
|
n = l;
|
|
do a = t.heap[1], t.heap[1] = t.heap[t.heap_len--], p(t, r, 1), i = t.heap[1], t
|
|
.heap[--t.heap_max] = a, t.heap[--t.heap_max] = i, r[2 * n] = r[2 * a] + r[2 *
|
|
i], t.depth[n] = (t.depth[a] >= t.depth[i] ? t.depth[a] : t.depth[i]) + 1,
|
|
r[2 * a + 1] = r[2 * i + 1] = n, t.heap[1] = n++, p(t, r, 1); while (t
|
|
.heap_len >= 2);
|
|
t.heap[--t.heap_max] = t.heap[1], _(t, e), u(r, h, t.bl_count)
|
|
}
|
|
|
|
function y(t, e, a) {
|
|
var i, n, r = -1,
|
|
s = e[1],
|
|
o = 0,
|
|
l = 7,
|
|
h = 4;
|
|
for (0 === s && (l = 138, h = 3), e[2 * (a + 1) + 1] = 65535, i = 0; i <= a; i++)
|
|
n = s, s = e[2 * (i + 1) + 1], ++o < l && n === s || (o < h ? t.bl_tree[2 *
|
|
n] += o : 0 !== n ? (n !== r && t.bl_tree[2 * n]++, t.bl_tree[2 * V]++) :
|
|
o <= 10 ? t.bl_tree[2 * $]++ : t.bl_tree[2 * tt]++, o = 0, r = n, 0 === s ?
|
|
(l = 138, h = 3) : n === s ? (l = 6, h = 3) : (l = 7, h = 4))
|
|
}
|
|
|
|
function x(t, e, a) {
|
|
var i, n, r = -1,
|
|
s = e[1],
|
|
o = 0,
|
|
d = 7,
|
|
f = 4;
|
|
for (0 === s && (d = 138, f = 3), i = 0; i <= a; i++)
|
|
if (n = s, s = e[2 * (i + 1) + 1], !(++o < d && n === s)) {
|
|
if (o < f) {
|
|
do h(t, n, t.bl_tree); while (0 !== --o)
|
|
} else 0 !== n ? (n !== r && (h(t, n, t.bl_tree), o--), h(t, V, t.bl_tree),
|
|
l(t, o - 3, 2)) : o <= 10 ? (h(t, $, t.bl_tree), l(t, o - 3, 3)) : (
|
|
h(t, tt, t.bl_tree), l(t, o - 11, 7));
|
|
o = 0, r = n, 0 === s ? (d = 138, f = 3) : n === s ? (d = 6, f = 3) : (d =
|
|
7, f = 4)
|
|
}
|
|
}
|
|
|
|
function z(t) {
|
|
var e;
|
|
for (y(t, t.dyn_ltree, t.l_desc.max_code), y(t, t.dyn_dtree, t.d_desc.max_code), k(
|
|
t, t.bl_desc), e = q - 1; e >= 3 && 0 === t.bl_tree[2 * nt[e] + 1]; e--);
|
|
return t.opt_len += 3 * (e + 1) + 5 + 5 + 4, e
|
|
}
|
|
|
|
function B(t, e, a, i) {
|
|
var n;
|
|
for (l(t, e - 257, 5), l(t, a - 1, 5), l(t, i - 4, 4), n = 0; n < i; n++) l(t, t
|
|
.bl_tree[2 * nt[n] + 1], 3);
|
|
x(t, t.dyn_ltree, e - 1), x(t, t.dyn_dtree, a - 1)
|
|
}
|
|
|
|
function S(t) {
|
|
var e, a = 4093624447;
|
|
for (e = 0; e <= 31; e++, a >>>= 1)
|
|
if (1 & a && 0 !== t.dyn_ltree[2 * e]) return D;
|
|
if (0 !== t.dyn_ltree[18] || 0 !== t.dyn_ltree[20] || 0 !== t.dyn_ltree[26])
|
|
return I;
|
|
for (e = 32; e < M; e++)
|
|
if (0 !== t.dyn_ltree[2 * e]) return I;
|
|
return D
|
|
}
|
|
|
|
function E(t) {
|
|
bt || (c(), bt = !0), t.l_desc = new r(t.dyn_ltree, _t), t.d_desc = new r(t
|
|
.dyn_dtree, ut), t.bl_desc = new r(t.bl_tree, ct), t.bi_buf = 0, t
|
|
.bi_valid = 0, b(t)
|
|
}
|
|
|
|
function A(t, e, a, i) {
|
|
l(t, (T << 1) + (i ? 1 : 0), 3), m(t, e, a, !0)
|
|
}
|
|
|
|
function Z(t) {
|
|
l(t, F << 1, 3), h(t, Q, st), f(t)
|
|
}
|
|
|
|
function R(t, e, a, i) {
|
|
var n, r, s = 0;
|
|
t.level > 0 ? (t.strm.data_type === U && (t.strm.data_type = S(t)), k(t, t.l_desc),
|
|
k(t, t.d_desc), s = z(t), n = t.opt_len + 3 + 7 >>> 3, r = t.static_len +
|
|
3 + 7 >>> 3, r <= n && (n = r)) : n = r = a + 5, a + 4 <= n && e !== -1 ? A(
|
|
t, e, a, i) : t.strategy === O || r === n ? (l(t, (F << 1) + (i ? 1 : 0),
|
|
3), v(t, st, ot)) : (l(t, (L << 1) + (i ? 1 : 0), 3), B(t, t.l_desc
|
|
.max_code + 1, t.d_desc.max_code + 1, s + 1), v(t, t.dyn_ltree, t
|
|
.dyn_dtree)), b(t), i && g(t)
|
|
}
|
|
|
|
function C(t, e, a) {
|
|
return t.pending_buf[t.d_buf + 2 * t.last_lit] = e >>> 8 & 255, t.pending_buf[t
|
|
.d_buf + 2 * t.last_lit + 1] = 255 & e, t.pending_buf[t.l_buf + t
|
|
.last_lit] = 255 & a, t.last_lit++, 0 === e ? t.dyn_ltree[2 * a]++ : (t
|
|
.matches++, e--, t.dyn_ltree[2 * (ht[a] + M + 1)]++, t.dyn_dtree[2 * s(e)]++
|
|
), t.last_lit === t.lit_bufsize - 1
|
|
}
|
|
var N = t("../utils/common"),
|
|
O = 4,
|
|
D = 0,
|
|
I = 1,
|
|
U = 2,
|
|
T = 0,
|
|
F = 1,
|
|
L = 2,
|
|
H = 3,
|
|
j = 258,
|
|
K = 29,
|
|
M = 256,
|
|
P = M + 1 + K,
|
|
Y = 30,
|
|
q = 19,
|
|
G = 2 * P + 1,
|
|
X = 15,
|
|
W = 16,
|
|
J = 7,
|
|
Q = 256,
|
|
V = 16,
|
|
$ = 17,
|
|
tt = 18,
|
|
et = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5,
|
|
5, 5, 0
|
|
],
|
|
at = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11,
|
|
11, 12, 12, 13, 13
|
|
],
|
|
it = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7],
|
|
nt = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
|
|
rt = 512,
|
|
st = new Array(2 * (P + 2));
|
|
i(st);
|
|
var ot = new Array(2 * Y);
|
|
i(ot);
|
|
var lt = new Array(rt);
|
|
i(lt);
|
|
var ht = new Array(j - H + 1);
|
|
i(ht);
|
|
var dt = new Array(K);
|
|
i(dt);
|
|
var ft = new Array(Y);
|
|
i(ft);
|
|
var _t, ut, ct, bt = !1;
|
|
a._tr_init = E, a._tr_stored_block = A, a._tr_flush_block = R, a._tr_tally = C, a
|
|
._tr_align = Z
|
|
}, {
|
|
"../utils/common": 3
|
|
}],
|
|
15: [function(t, e, a) {
|
|
"use strict";
|
|
|
|
function i() {
|
|
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
|
|
}
|
|
e.exports = i
|
|
}, {}],
|
|
"/": [function(t, e, a) {
|
|
"use strict";
|
|
var i = t("./lib/utils/common").assign,
|
|
n = t("./lib/deflate"),
|
|
r = t("./lib/inflate"),
|
|
s = t("./lib/zlib/constants"),
|
|
o = {};
|
|
i(o, n, r, s), e.exports = o
|
|
}, {
|
|
"./lib/deflate": 1,
|
|
"./lib/inflate": 2,
|
|
"./lib/utils/common": 3,
|
|
"./lib/zlib/constants": 6
|
|
}]
|
|
}, {}, [])("/")
|
|
});
|
|
|