3717 lines
148 KiB
JavaScript
3717 lines
148 KiB
JavaScript
|
|
window = globalThis;;
|
||
|
|
|
||
|
|
var CryptoJS = CryptoJS || (function (Math, undefined) {
|
||
|
|
var C = {};
|
||
|
|
var C_lib = C.lib = {};
|
||
|
|
var Base = C_lib.Base = (function () {
|
||
|
|
function F() {};
|
||
|
|
return {
|
||
|
|
extend: function (overrides) {
|
||
|
|
F.prototype = this;
|
||
|
|
var subtype = new F();
|
||
|
|
if (overrides) {
|
||
|
|
subtype.mixIn(overrides);
|
||
|
|
}
|
||
|
|
if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
|
||
|
|
subtype.init = function () {
|
||
|
|
subtype.$super.init.apply(this, arguments);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
subtype.init.prototype = subtype;
|
||
|
|
subtype.$super = this;
|
||
|
|
return subtype;
|
||
|
|
}, create: function () {
|
||
|
|
var instance = this.extend();
|
||
|
|
instance.init.apply(instance, arguments);
|
||
|
|
return instance;
|
||
|
|
}, init: function () {}, mixIn: function (properties) {
|
||
|
|
for (var propertyName in properties) {
|
||
|
|
if (properties.hasOwnProperty(propertyName)) {
|
||
|
|
this[propertyName] = properties[propertyName];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (properties.hasOwnProperty('toString')) {
|
||
|
|
this.toString = properties.toString;
|
||
|
|
}
|
||
|
|
}, clone: function () {
|
||
|
|
return this.init.prototype.extend(this);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}());
|
||
|
|
var WordArray = C_lib.WordArray = Base.extend({
|
||
|
|
init: function (words, sigBytes) {
|
||
|
|
words = this.words = words || [];
|
||
|
|
if (sigBytes != undefined) {
|
||
|
|
this.sigBytes = sigBytes;
|
||
|
|
} else {
|
||
|
|
this.sigBytes = words.length * 4;
|
||
|
|
}
|
||
|
|
}, toString: function (encoder) {
|
||
|
|
return (encoder || Hex).stringify(this);
|
||
|
|
}, concat: function (wordArray) {
|
||
|
|
var thisWords = this.words;
|
||
|
|
var thatWords = wordArray.words;
|
||
|
|
var thisSigBytes = this.sigBytes;
|
||
|
|
var thatSigBytes = wordArray.sigBytes;
|
||
|
|
this.clamp();
|
||
|
|
if (thisSigBytes % 4) {
|
||
|
|
for (var i = 0; i < thatSigBytes; i++) {
|
||
|
|
var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
||
|
|
thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
|
||
|
|
}
|
||
|
|
} else if (thatWords.length > 0xffff) {
|
||
|
|
for (var i = 0; i < thatSigBytes; i += 4) {
|
||
|
|
thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
thisWords.push.apply(thisWords, thatWords);
|
||
|
|
}
|
||
|
|
this.sigBytes += thatSigBytes;
|
||
|
|
return this;
|
||
|
|
}, clamp: function () {
|
||
|
|
var words = this.words;
|
||
|
|
var sigBytes = this.sigBytes;
|
||
|
|
words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
|
||
|
|
words.length = Math.ceil(sigBytes / 4);
|
||
|
|
}, clone: function () {
|
||
|
|
var clone = Base.clone.call(this);
|
||
|
|
clone.words = this.words.slice(0);
|
||
|
|
return clone;
|
||
|
|
}, random: function (nBytes) {
|
||
|
|
var words = [];
|
||
|
|
var r = (function (m_w) {
|
||
|
|
var m_w = m_w;
|
||
|
|
var m_z = 0x3ade68b1;
|
||
|
|
var mask = 0xffffffff;
|
||
|
|
return function () {
|
||
|
|
m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
|
||
|
|
m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
|
||
|
|
var result = ((m_z << 0x10) + m_w) & mask;
|
||
|
|
result /= 0x100000000;
|
||
|
|
result += 0.5;
|
||
|
|
return result * (Math.random() > .5 ? 1 : -1);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
for (var i = 0, rcache; i < nBytes; i += 4) {
|
||
|
|
var _r = r((rcache || Math.random()) * 0x100000000);
|
||
|
|
rcache = _r() * 0x3ade67b7;
|
||
|
|
words.push((_r() * 0x100000000) | 0);
|
||
|
|
}
|
||
|
|
return new WordArray.init(words, nBytes);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
var C_enc = C.enc = {};
|
||
|
|
var Hex = C_enc.Hex = {
|
||
|
|
stringify: function (wordArray) {
|
||
|
|
var words = wordArray.words;
|
||
|
|
var sigBytes = wordArray.sigBytes;
|
||
|
|
var hexChars = [];
|
||
|
|
for (var i = 0; i < sigBytes; i++) {
|
||
|
|
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
||
|
|
hexChars.push((bite >>> 4).toString(16));
|
||
|
|
hexChars.push((bite & 0x0f).toString(16));
|
||
|
|
}
|
||
|
|
return hexChars.join('');
|
||
|
|
}, parse: function (hexStr) {
|
||
|
|
var hexStrLength = hexStr.length;
|
||
|
|
var words = [];
|
||
|
|
for (var i = 0; i < hexStrLength; i += 2) {
|
||
|
|
words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
|
||
|
|
}
|
||
|
|
return new WordArray.init(words, hexStrLength / 2);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var Latin1 = C_enc.Latin1 = {
|
||
|
|
stringify: function (wordArray) {
|
||
|
|
var words = wordArray.words;
|
||
|
|
var sigBytes = wordArray.sigBytes;
|
||
|
|
var latin1Chars = [];
|
||
|
|
for (var i = 0; i < sigBytes; i++) {
|
||
|
|
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
||
|
|
latin1Chars.push(String.fromCharCode(bite));
|
||
|
|
}
|
||
|
|
return latin1Chars.join('');
|
||
|
|
}, parse: function (latin1Str) {
|
||
|
|
var latin1StrLength = latin1Str.length;
|
||
|
|
var words = [];
|
||
|
|
for (var i = 0; i < latin1StrLength; i++) {
|
||
|
|
words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
|
||
|
|
}
|
||
|
|
return new WordArray.init(words, latin1StrLength);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var Utf8 = C_enc.Utf8 = {
|
||
|
|
stringify: function (wordArray) {
|
||
|
|
try {
|
||
|
|
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
|
||
|
|
} catch (e) {
|
||
|
|
throw new Error('Malformed UTF-8 data');
|
||
|
|
}
|
||
|
|
}, parse: function (utf8Str) {
|
||
|
|
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
|
||
|
|
reset: function () {
|
||
|
|
this._data = new WordArray.init();
|
||
|
|
this._nDataBytes = 0;
|
||
|
|
}, _append: function (data) {
|
||
|
|
if (typeof data == 'string') {
|
||
|
|
data = Utf8.parse(data);
|
||
|
|
}
|
||
|
|
this._data.concat(data);
|
||
|
|
this._nDataBytes += data.sigBytes;
|
||
|
|
}, _process: function (doFlush) {
|
||
|
|
var data = this._data;
|
||
|
|
var dataWords = data.words;
|
||
|
|
var dataSigBytes = data.sigBytes;
|
||
|
|
var blockSize = this.blockSize;
|
||
|
|
var blockSizeBytes = blockSize * 4;
|
||
|
|
var nBlocksReady = dataSigBytes / blockSizeBytes;
|
||
|
|
if (doFlush) {
|
||
|
|
nBlocksReady = Math.ceil(nBlocksReady);
|
||
|
|
} else {
|
||
|
|
nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
|
||
|
|
}
|
||
|
|
var nWordsReady = nBlocksReady * blockSize;
|
||
|
|
var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
|
||
|
|
if (nWordsReady) {
|
||
|
|
for (var offset = 0; offset < nWordsReady; offset += blockSize) {
|
||
|
|
this._doProcessBlock(dataWords, offset);
|
||
|
|
}
|
||
|
|
var processedWords = dataWords.splice(0, nWordsReady);
|
||
|
|
data.sigBytes -= nBytesReady;
|
||
|
|
}
|
||
|
|
return new WordArray.init(processedWords, nBytesReady);
|
||
|
|
}, clone: function () {
|
||
|
|
var clone = Base.clone.call(this);
|
||
|
|
clone._data = this._data.clone();
|
||
|
|
return clone;
|
||
|
|
}, _minBufferSize: 0
|
||
|
|
});
|
||
|
|
var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
|
||
|
|
cfg: Base.extend(),
|
||
|
|
init: function (cfg) {
|
||
|
|
this.cfg = this.cfg.extend(cfg);
|
||
|
|
this.reset();
|
||
|
|
}, reset: function () {
|
||
|
|
BufferedBlockAlgorithm.reset.call(this);
|
||
|
|
this._doReset();
|
||
|
|
}, update: function (messageUpdate) {
|
||
|
|
this._append(messageUpdate);
|
||
|
|
this._process();
|
||
|
|
return this;
|
||
|
|
}, finalize: function (messageUpdate) {
|
||
|
|
if (messageUpdate) {
|
||
|
|
this._append(messageUpdate);
|
||
|
|
}
|
||
|
|
var hash = this._doFinalize();
|
||
|
|
return hash;
|
||
|
|
}, blockSize: 512 / 32,
|
||
|
|
_createHelper: function (hasher) {
|
||
|
|
return function (message, cfg) {
|
||
|
|
return new hasher.init(cfg).finalize(message);
|
||
|
|
};
|
||
|
|
}, _createHmacHelper: function (hasher) {
|
||
|
|
return function (message, key) {
|
||
|
|
return new C_algo.HMAC.init(hasher, key).finalize(message);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
var C_algo = C.algo = {};
|
||
|
|
return C;
|
||
|
|
}(Math));
|
||
|
|
|
||
|
|
(function () {
|
||
|
|
var C = CryptoJS;
|
||
|
|
var C_lib = C.lib;
|
||
|
|
var WordArray = C_lib.WordArray;
|
||
|
|
var C_enc = C.enc;
|
||
|
|
var Base64 = C_enc.Base64 = {
|
||
|
|
stringify: function (wordArray) {
|
||
|
|
var words = wordArray.words;
|
||
|
|
var sigBytes = wordArray.sigBytes;
|
||
|
|
var map = this._map;
|
||
|
|
wordArray.clamp();
|
||
|
|
var base64Chars = [];
|
||
|
|
for (var i = 0; i < sigBytes; i += 3) {
|
||
|
|
var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
||
|
|
var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
|
||
|
|
var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
|
||
|
|
var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
|
||
|
|
for (var j = 0;
|
||
|
|
(j < 4) && (i + j * 0.75 < sigBytes); j++) {
|
||
|
|
base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var paddingChar = map.charAt(64);
|
||
|
|
if (paddingChar) {
|
||
|
|
while (base64Chars.length % 4) {
|
||
|
|
base64Chars.push(paddingChar);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return base64Chars.join('');
|
||
|
|
}, parse: function (base64Str) {
|
||
|
|
var base64StrLength = base64Str.length;
|
||
|
|
var map = this._map;
|
||
|
|
var reverseMap = this._reverseMap;
|
||
|
|
if (!reverseMap) {
|
||
|
|
reverseMap = this._reverseMap = [];
|
||
|
|
for (var j = 0; j < map.length; j++) {
|
||
|
|
reverseMap[map.charCodeAt(j)] = j;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var paddingChar = map.charAt(64);
|
||
|
|
if (paddingChar) {
|
||
|
|
var paddingIndex = base64Str.indexOf(paddingChar);
|
||
|
|
if (paddingIndex !== -1) {
|
||
|
|
base64StrLength = paddingIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return parseLoop(base64Str, base64StrLength, reverseMap);
|
||
|
|
}, _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
|
||
|
|
};
|
||
|
|
function parseLoop(base64Str, base64StrLength, reverseMap) {
|
||
|
|
var words = [];
|
||
|
|
var nBytes = 0;
|
||
|
|
for (var i = 0; i < base64StrLength; i++) {
|
||
|
|
if (i % 4) {
|
||
|
|
var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
|
||
|
|
var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
|
||
|
|
words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
|
||
|
|
nBytes++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return WordArray.create(words, nBytes);
|
||
|
|
}
|
||
|
|
}());
|
||
|
|
|
||
|
|
function B64_Encrypt(word) {
|
||
|
|
var src = CryptoJS.enc.Utf8.parse(word);
|
||
|
|
return CryptoJS.enc.Base64.stringify(src);
|
||
|
|
}
|
||
|
|
|
||
|
|
function B64_Decrypt(word) {
|
||
|
|
var src = CryptoJS.enc.Base64.parse(word);
|
||
|
|
return CryptoJS.enc.Utf8.stringify(src);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
!function (e) {
|
||
|
|
function t(t) {
|
||
|
|
for (var r, o, a = t[0], c = t[1], i = t[2], u = 0, d = []; u < a.length; u++)
|
||
|
|
o = a[u],
|
||
|
|
Object.prototype.hasOwnProperty.call(b, o) && b[o] && d.push(b[o][0]),
|
||
|
|
b[o] = 0;
|
||
|
|
for (r in c)
|
||
|
|
Object.prototype.hasOwnProperty.call(c, r) && (e[r] = c[r]);
|
||
|
|
for (P && P(t); d.length; )
|
||
|
|
d.shift()();
|
||
|
|
return g.push.apply(g, i || []),
|
||
|
|
n()
|
||
|
|
}
|
||
|
|
function n() {
|
||
|
|
for (var e, t = 0; t < g.length; t++) {
|
||
|
|
for (var n = g[t], r = !0, o = 1; o < n.length; o++) {
|
||
|
|
var a = n[o];
|
||
|
|
0 !== b[a] && (r = !1)
|
||
|
|
}
|
||
|
|
r && (g.splice(t--, 1),
|
||
|
|
e = v(v.s = n[0]))
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
var r, o, a = {}, c = {
|
||
|
|
2: 0
|
||
|
|
}, i = {}, u = {}, d = {}, f = {}, l = !1, s = {}, p = {}, h = "", m = ["mms-static-1.pddugc.com", "mms-static-2.pddpic.com", "mms-static.pddpic.com", "mms-static.pinduoduo.com"], b = {
|
||
|
|
2: 0
|
||
|
|
}, g = [];
|
||
|
|
function v(t) {
|
||
|
|
console.log('v[t]:::',t)
|
||
|
|
if (a[t])
|
||
|
|
return a[t].exports;
|
||
|
|
var n = a[t] = {
|
||
|
|
i: t,
|
||
|
|
l: !1,
|
||
|
|
exports: {}
|
||
|
|
};
|
||
|
|
return e[t].call(n.exports, n, n.exports, v),
|
||
|
|
n.l = !0,
|
||
|
|
n.exports
|
||
|
|
}
|
||
|
|
v.e = function(e) {
|
||
|
|
var t = [];
|
||
|
|
c[e] ? t.push(c[e]) : 0 !== c[e] && {
|
||
|
|
3: 1,
|
||
|
|
5: 1,
|
||
|
|
8: 1,
|
||
|
|
9: 1,
|
||
|
|
10: 1,
|
||
|
|
12: 1,
|
||
|
|
13: 1
|
||
|
|
}[e] && t.push(c[e] = new Promise((function(t, n) {
|
||
|
|
for (var r = ({
|
||
|
|
0: "defaultVendors~mercha~50a2d7c7",
|
||
|
|
3: "notificationPushCompoents",
|
||
|
|
5: "defaultVendors~merchantApp",
|
||
|
|
8: "merchantApp",
|
||
|
|
9: "platformConnect"
|
||
|
|
}[e] || e) + "." + {
|
||
|
|
0: "afbf4",
|
||
|
|
3: "fec4b",
|
||
|
|
4: "2ae1b",
|
||
|
|
5: "289cd",
|
||
|
|
8: "f288d",
|
||
|
|
9: "9a46f",
|
||
|
|
10: "fd7cd",
|
||
|
|
11: "58a8f",
|
||
|
|
12: "69822",
|
||
|
|
13: "8d151",
|
||
|
|
14: "6617b"
|
||
|
|
}[e] + ".css", o = v.p + r, a = document.getElementsByTagName("link"), i = 0; i < a.length; i++) {
|
||
|
|
var u = (f = a[i]).getAttribute("data-href") || f.getAttribute("href");
|
||
|
|
if ("stylesheet" === f.rel && (u === r || u === o))
|
||
|
|
return t()
|
||
|
|
}
|
||
|
|
var d = document.getElementsByTagName("style");
|
||
|
|
for (i = 0; i < d.length; i++) {
|
||
|
|
var f;
|
||
|
|
if ((u = (f = d[i]).getAttribute("data-href")) === r || u === o)
|
||
|
|
return t()
|
||
|
|
}
|
||
|
|
var l = document.createElement("link");
|
||
|
|
l.rel = "stylesheet",
|
||
|
|
l.type = "text/css",
|
||
|
|
l.onload = t,
|
||
|
|
l.onerror = function(t) {
|
||
|
|
var r = t && t.target && t.target.src || o
|
||
|
|
, a = new Error("Loading CSS chunk " + e + " failed.\n(" + r + ")");
|
||
|
|
a.code = "CSS_CHUNK_LOAD_FAILED",
|
||
|
|
a.request = r,
|
||
|
|
delete c[e],
|
||
|
|
l.parentNode.removeChild(l),
|
||
|
|
n(a)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
l.href = o,
|
||
|
|
document.getElementsByTagName("head")[0].appendChild(l)
|
||
|
|
}
|
||
|
|
)).then((function() {
|
||
|
|
c[e] = 0
|
||
|
|
}
|
||
|
|
)));
|
||
|
|
var n = b[e];
|
||
|
|
if (0 !== n)
|
||
|
|
if (n)
|
||
|
|
t.push(n[2]);
|
||
|
|
else {
|
||
|
|
var r = new Promise((function(t, r) {
|
||
|
|
n = b[e] = [t, r]
|
||
|
|
}
|
||
|
|
));
|
||
|
|
t.push(n[2] = r);
|
||
|
|
var o, a = document.createElement("script");
|
||
|
|
a.charset = "utf-8",
|
||
|
|
a.timeout = 120,
|
||
|
|
v.nc && a.setAttribute("nonce", v.nc),
|
||
|
|
a.src = function(e) {
|
||
|
|
return v.p + "chat-merchant-v20250710.17.12.12/static/js/" + ({
|
||
|
|
0: "defaultVendors~mercha~50a2d7c7",
|
||
|
|
3: "notificationPushCompoents",
|
||
|
|
5: "defaultVendors~merchantApp",
|
||
|
|
8: "merchantApp",
|
||
|
|
9: "platformConnect"
|
||
|
|
}[e] || e) + ".bundle." + {
|
||
|
|
0: "afbf4fbcbf199c869573",
|
||
|
|
3: "fec4bbc91da8d558973f",
|
||
|
|
4: "2ae1b8b04ce874f950b9",
|
||
|
|
5: "289cddfa35ea3af3db37",
|
||
|
|
8: "f288dd6ab07e36401bd7",
|
||
|
|
9: "9a46ff970bb747bbe76d",
|
||
|
|
10: "fd7cdf4260120a49bae9",
|
||
|
|
11: "58a8fbceb12d0f6cdd28",
|
||
|
|
12: "69822c50b71be5380329",
|
||
|
|
13: "8d1516ce3604ccad0348",
|
||
|
|
14: "6617b80f8673c646e468"
|
||
|
|
}[e] + ".js"
|
||
|
|
}(e);
|
||
|
|
var i = new Error;
|
||
|
|
o = function(t) {
|
||
|
|
a.onerror = a.onload = null,
|
||
|
|
clearTimeout(u);
|
||
|
|
var n = b[e];
|
||
|
|
if (0 !== n) {
|
||
|
|
if (n) {
|
||
|
|
var r = t && ("load" === t.type ? "missing" : t.type)
|
||
|
|
, o = t && t.target && t.target.src;
|
||
|
|
i.message = "Loading chunk " + e + " failed.\n(" + r + ": " + o + ")",
|
||
|
|
i.name = "ChunkLoadError",
|
||
|
|
i.type = r,
|
||
|
|
i.request = o,
|
||
|
|
n[1](i)
|
||
|
|
}
|
||
|
|
b[e] = void 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var u = setTimeout((function() {
|
||
|
|
o({
|
||
|
|
type: "timeout",
|
||
|
|
target: a
|
||
|
|
})
|
||
|
|
}
|
||
|
|
), 12e4);
|
||
|
|
a.onerror = a.onload = o,
|
||
|
|
document.head.appendChild(a)
|
||
|
|
}
|
||
|
|
return v.onChunkPromiseSettled && v.onChunkPromiseSettled(t, e),
|
||
|
|
Promise.all(t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.m = e,
|
||
|
|
v.c = a,
|
||
|
|
v.d = function(e, t, n) {
|
||
|
|
v.o(e, t) || Object.defineProperty(e, t, {
|
||
|
|
enumerable: !0,
|
||
|
|
get: n
|
||
|
|
})
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.r = function(e) {
|
||
|
|
"undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e, Symbol.toStringTag, {
|
||
|
|
value: "Module"
|
||
|
|
}),
|
||
|
|
Object.defineProperty(e, "__esModule", {
|
||
|
|
value: !0
|
||
|
|
})
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.t = function(e, t) {
|
||
|
|
if (1 & t && (e = v(e)),
|
||
|
|
8 & t)
|
||
|
|
return e;
|
||
|
|
if (4 & t && "object" == typeof e && e && e.__esModule)
|
||
|
|
return e;
|
||
|
|
var n = Object.create(null);
|
||
|
|
if (v.r(n),
|
||
|
|
Object.defineProperty(n, "default", {
|
||
|
|
enumerable: !0,
|
||
|
|
value: e
|
||
|
|
}),
|
||
|
|
2 & t && "string" != typeof e)
|
||
|
|
for (var r in e)
|
||
|
|
v.d(n, r, function(t) {
|
||
|
|
return e[t]
|
||
|
|
}
|
||
|
|
.bind(null, r));
|
||
|
|
return n
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.n = function(e) {
|
||
|
|
var t = e && e.__esModule ? function() {
|
||
|
|
return e.default
|
||
|
|
}
|
||
|
|
: function() {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
;
|
||
|
|
return v.d(t, "a", t),
|
||
|
|
t
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.o = function(e, t) {
|
||
|
|
return Object.prototype.hasOwnProperty.call(e, t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.p = "https://mms-static.pinduoduo.com/chat-merchant/",
|
||
|
|
v.oe = function(e) {
|
||
|
|
throw console.error(e),
|
||
|
|
e
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var y = window.webpackJsonp = window.webpackJsonp || []
|
||
|
|
, w = y.push.bind(y);
|
||
|
|
y.push = t,
|
||
|
|
y = y.slice();
|
||
|
|
for (var _ = 0; _ < y.length; _++)
|
||
|
|
t(y[_]);
|
||
|
|
var P = w;
|
||
|
|
v.oldE = v.e,
|
||
|
|
v.initRetryConfig = function () {
|
||
|
|
!function (e) {
|
||
|
|
var t = "";
|
||
|
|
e && (t = e.split("/")[2] || "")
|
||
|
|
}(o = v.p || window.__webpack_public_path__ || "");
|
||
|
|
h = function (e) {
|
||
|
|
var t = "";
|
||
|
|
if (e) {
|
||
|
|
var n = e.split("/").slice(3);
|
||
|
|
n.length && (t = n.join("/"))
|
||
|
|
}
|
||
|
|
return t
|
||
|
|
}(o),
|
||
|
|
r = 4
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.getRetryPublicPath = function (e) {
|
||
|
|
if (!s.hasOwnProperty(e))
|
||
|
|
return o;
|
||
|
|
var t = "";
|
||
|
|
return p.hasOwnProperty(e) ? p[e] = (p[e] + 1) % m.length : p[e] = 0,
|
||
|
|
("http" === (t = m[p[e]] || "").slice(0, 4) ? "" : "https://") + t + ("/" === t[t.length - 1] ? "" : "/") + h
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.resetRetryMap = function (e) {
|
||
|
|
delete p[e],
|
||
|
|
delete s[e],
|
||
|
|
delete f[e],
|
||
|
|
delete u[e],
|
||
|
|
delete i[e],
|
||
|
|
delete d[e]
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.checkCouldRetry = function (e) {
|
||
|
|
if ((d[e] || []).length === u[e]) {
|
||
|
|
var t = f[e];
|
||
|
|
if (!t)
|
||
|
|
return;
|
||
|
|
t(e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.onChunkPromiseSettled = function (e, t) {
|
||
|
|
u[t] = e.length;
|
||
|
|
for (var n = function (e, t) {
|
||
|
|
d[e] = d[e] || [],
|
||
|
|
d[e].push(t);
|
||
|
|
var n = u[e]
|
||
|
|
, r = d[e];
|
||
|
|
n > 1 && r.length === n && r.indexOf("rejected") >= 0 && v.checkCouldRetry(e)
|
||
|
|
}, r = 0; r < e.length; r++) {
|
||
|
|
var o = e[r];
|
||
|
|
o.registered || (o.then((function () {
|
||
|
|
n(t, "resolved")
|
||
|
|
}
|
||
|
|
), (function (e) {
|
||
|
|
n(t, "rejected")
|
||
|
|
}
|
||
|
|
)),
|
||
|
|
o.registered = !0)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.e = function (e) {
|
||
|
|
if (i.hasOwnProperty(e))
|
||
|
|
return i[e];
|
||
|
|
l || (v.initRetryConfig(),
|
||
|
|
l = !0);
|
||
|
|
var t = v.getRetryPublicPath(e);
|
||
|
|
v.p = t,
|
||
|
|
window.__webpack_public_path__ && (window.__webpack_public_path__ = t);
|
||
|
|
var n = v.oldE(e).then((function () {
|
||
|
|
v.resetRetryMap(e)
|
||
|
|
}
|
||
|
|
)).catch((function (t) {
|
||
|
|
if ((s.hasOwnProperty(e) ? s[e] : r) < 1)
|
||
|
|
throw v.resetRetryMap(e),
|
||
|
|
t.name && (t.name += "(dynamicChunkRetryTimes: " + r + ")"),
|
||
|
|
t;
|
||
|
|
return new Promise((function (t) {
|
||
|
|
f[e] = function (e) {
|
||
|
|
var n = s.hasOwnProperty(e) ? s[e] : r;
|
||
|
|
s[e] = n - 1,
|
||
|
|
delete d[e],
|
||
|
|
delete i[e];
|
||
|
|
var o = v.e(e);
|
||
|
|
t(o)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
v.checkCouldRetry(e)
|
||
|
|
}
|
||
|
|
))
|
||
|
|
}
|
||
|
|
));
|
||
|
|
return i[e] = n,
|
||
|
|
n
|
||
|
|
},
|
||
|
|
window.wang = v;
|
||
|
|
}({
|
||
|
|
450:function(t, e, n) {
|
||
|
|
var r, o, i, a;
|
||
|
|
function s(t) {
|
||
|
|
return "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? typeof t : t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t
|
||
|
|
}
|
||
|
|
a = function() {
|
||
|
|
return function t(e, n, r) {
|
||
|
|
function o(a, s) {
|
||
|
|
if (!n[a]) {
|
||
|
|
if (!e[a]) {
|
||
|
|
if (i)
|
||
|
|
return i(a, !0);
|
||
|
|
var u = new Error("Cannot find module '" + a + "'");
|
||
|
|
throw u.code = "MODULE_NOT_FOUND",
|
||
|
|
u
|
||
|
|
}
|
||
|
|
var c = n[a] = {
|
||
|
|
exports: {}
|
||
|
|
};
|
||
|
|
e[a][0].call(c.exports, (function(t) {
|
||
|
|
return o(e[a][1][t] || t)
|
||
|
|
}
|
||
|
|
), c, c.exports, t, e, n, r)
|
||
|
|
}
|
||
|
|
return n[a].exports
|
||
|
|
}
|
||
|
|
for (var i = !1, a = 0; a < r.length; a++)
|
||
|
|
o(r[a]);
|
||
|
|
return o
|
||
|
|
}({
|
||
|
|
1: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
function r(t, e) {
|
||
|
|
return Object.prototype.hasOwnProperty.call(t, e)
|
||
|
|
}
|
||
|
|
var o = "undefined" != typeof Uint8Array && "undefined" != typeof Uint16Array && "undefined" != typeof Int32Array;
|
||
|
|
n.assign = function(t) {
|
||
|
|
for (var e = Array.prototype.slice.call(arguments, 1); e.length; ) {
|
||
|
|
var n = e.shift();
|
||
|
|
if (n) {
|
||
|
|
if ("object" != s(n))
|
||
|
|
throw new TypeError(n + "must be non-object");
|
||
|
|
for (var o in n)
|
||
|
|
r(n, o) && (t[o] = n[o])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return t
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.shrinkBuf = function(t, e) {
|
||
|
|
return t.length === e ? t : t.subarray ? t.subarray(0, e) : (t.length = e,
|
||
|
|
t)
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var i = {
|
||
|
|
arraySet: function(t, e, n, r, o) {
|
||
|
|
if (e.subarray && t.subarray)
|
||
|
|
t.set(e.subarray(n, n + r), o);
|
||
|
|
else
|
||
|
|
for (var i = 0; i < r; i++)
|
||
|
|
t[o + i] = e[n + i]
|
||
|
|
},
|
||
|
|
flattenChunks: function(t) {
|
||
|
|
var e, n, r, o, i, a;
|
||
|
|
for (r = 0,
|
||
|
|
e = 0,
|
||
|
|
n = t.length; e < n; e++)
|
||
|
|
r += t[e].length;
|
||
|
|
for (a = new Uint8Array(r),
|
||
|
|
o = 0,
|
||
|
|
e = 0,
|
||
|
|
n = t.length; e < n; e++)
|
||
|
|
i = t[e],
|
||
|
|
a.set(i, o),
|
||
|
|
o += i.length;
|
||
|
|
return a
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, a = {
|
||
|
|
arraySet: function(t, e, n, r, o) {
|
||
|
|
for (var i = 0; i < r; i++)
|
||
|
|
t[o + i] = e[n + i]
|
||
|
|
},
|
||
|
|
flattenChunks: function(t) {
|
||
|
|
return [].concat.apply([], t)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
n.setTyped = function(t) {
|
||
|
|
t ? (n.Buf8 = Uint8Array,
|
||
|
|
n.Buf16 = Uint16Array,
|
||
|
|
n.Buf32 = Int32Array,
|
||
|
|
n.assign(n, i)) : (n.Buf8 = Array,
|
||
|
|
n.Buf16 = Array,
|
||
|
|
n.Buf32 = Array,
|
||
|
|
n.assign(n, a))
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.setTyped(o)
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
2: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
function r(t, e) {
|
||
|
|
if (e < 65537 && (t.subarray && a || !t.subarray && i))
|
||
|
|
return String.fromCharCode.apply(null, o.shrinkBuf(t, e));
|
||
|
|
for (var n = "", r = 0; r < e; r++)
|
||
|
|
n += String.fromCharCode(t[r]);
|
||
|
|
return n
|
||
|
|
}
|
||
|
|
var o = t("./common")
|
||
|
|
, i = !0
|
||
|
|
, a = !0;
|
||
|
|
try {
|
||
|
|
String.fromCharCode.apply(null, [0])
|
||
|
|
} catch (t) {
|
||
|
|
i = !1
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
String.fromCharCode.apply(null, new Uint8Array(1))
|
||
|
|
} catch (t) {
|
||
|
|
a = !1
|
||
|
|
}
|
||
|
|
for (var s = new o.Buf8(256), u = 0; u < 256; u++)
|
||
|
|
s[u] = u >= 252 ? 6 : u >= 248 ? 5 : u >= 240 ? 4 : u >= 224 ? 3 : u >= 192 ? 2 : 1;
|
||
|
|
s[254] = s[254] = 1,
|
||
|
|
n.string2buf = function(t) {
|
||
|
|
var e, n, r, i, a, s = t.length, u = 0;
|
||
|
|
for (i = 0; i < s; i++)
|
||
|
|
55296 == (64512 & (n = t.charCodeAt(i))) && i + 1 < s && 56320 == (64512 & (r = t.charCodeAt(i + 1))) && (n = 65536 + (n - 55296 << 10) + (r - 56320),
|
||
|
|
i++),
|
||
|
|
u += n < 128 ? 1 : n < 2048 ? 2 : n < 65536 ? 3 : 4;
|
||
|
|
for (e = new o.Buf8(u),
|
||
|
|
a = 0,
|
||
|
|
i = 0; a < u; i++)
|
||
|
|
55296 == (64512 & (n = t.charCodeAt(i))) && i + 1 < s && 56320 == (64512 & (r = t.charCodeAt(i + 1))) && (n = 65536 + (n - 55296 << 10) + (r - 56320),
|
||
|
|
i++),
|
||
|
|
n < 128 ? e[a++] = n : n < 2048 ? (e[a++] = 192 | n >>> 6,
|
||
|
|
e[a++] = 128 | 63 & n) : n < 65536 ? (e[a++] = 224 | n >>> 12,
|
||
|
|
e[a++] = 128 | n >>> 6 & 63,
|
||
|
|
e[a++] = 128 | 63 & n) : (e[a++] = 240 | n >>> 18,
|
||
|
|
e[a++] = 128 | n >>> 12 & 63,
|
||
|
|
e[a++] = 128 | n >>> 6 & 63,
|
||
|
|
e[a++] = 128 | 63 & n);
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.buf2binstring = function(t) {
|
||
|
|
return r(t, t.length)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.binstring2buf = function(t) {
|
||
|
|
for (var e = new o.Buf8(t.length), n = 0, r = e.length; n < r; n++)
|
||
|
|
e[n] = t.charCodeAt(n);
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.buf2string = function(t, e) {
|
||
|
|
var n, o, i, a, u = e || t.length, c = new Array(2 * u);
|
||
|
|
for (o = 0,
|
||
|
|
n = 0; n < u; )
|
||
|
|
if ((i = t[n++]) < 128)
|
||
|
|
c[o++] = i;
|
||
|
|
else if ((a = s[i]) > 4)
|
||
|
|
c[o++] = 65533,
|
||
|
|
n += a - 1;
|
||
|
|
else {
|
||
|
|
for (i &= 2 === a ? 31 : 3 === a ? 15 : 7; a > 1 && n < u; )
|
||
|
|
i = i << 6 | 63 & t[n++],
|
||
|
|
a--;
|
||
|
|
a > 1 ? c[o++] = 65533 : i < 65536 ? c[o++] = i : (i -= 65536,
|
||
|
|
c[o++] = 55296 | i >> 10 & 1023,
|
||
|
|
c[o++] = 56320 | 1023 & i)
|
||
|
|
}
|
||
|
|
return r(c, o)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.utf8border = function(t, e) {
|
||
|
|
var n;
|
||
|
|
for ((e = e || t.length) > t.length && (e = t.length),
|
||
|
|
n = e - 1; n >= 0 && 128 == (192 & t[n]); )
|
||
|
|
n--;
|
||
|
|
return n < 0 || 0 === n ? e : n + s[t[n]] > e ? n : e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
"./common": 1
|
||
|
|
}],
|
||
|
|
3: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
e.exports = function(t, e, n, r) {
|
||
|
|
for (var o = 65535 & t | 0, i = t >>> 16 & 65535 | 0, a = 0; 0 !== n; ) {
|
||
|
|
n -= a = n > 2e3 ? 2e3 : n;
|
||
|
|
do {
|
||
|
|
i = i + (o = o + e[r++] | 0) | 0
|
||
|
|
} while (--a);
|
||
|
|
o %= 65521,
|
||
|
|
i %= 65521
|
||
|
|
}
|
||
|
|
return o | i << 16 | 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
4: [function(t, e, n) {
|
||
|
|
"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
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
5: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
var r = function() {
|
||
|
|
for (var t, e = [], n = 0; n < 256; n++) {
|
||
|
|
t = n;
|
||
|
|
for (var r = 0; r < 8; r++)
|
||
|
|
t = 1 & t ? 3988292384 ^ t >>> 1 : t >>> 1;
|
||
|
|
e[n] = t
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}();
|
||
|
|
e.exports = function(t, e, n, o) {
|
||
|
|
var i = r
|
||
|
|
, a = o + n;
|
||
|
|
t ^= -1;
|
||
|
|
for (var s = o; s < a; s++)
|
||
|
|
t = t >>> 8 ^ i[255 & (t ^ e[s])];
|
||
|
|
return -1 ^ t
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
6: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
e.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(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
e.exports = function(t, e) {
|
||
|
|
var n, r, o, i, a, s, u, c, f, d, l, p, h, m, v, g, y, w, _, b, x, S, O, C, k;
|
||
|
|
n = t.state,
|
||
|
|
r = t.next_in,
|
||
|
|
C = t.input,
|
||
|
|
o = r + (t.avail_in - 5),
|
||
|
|
i = t.next_out,
|
||
|
|
k = t.output,
|
||
|
|
a = i - (e - t.avail_out),
|
||
|
|
s = i + (t.avail_out - 257),
|
||
|
|
u = n.dmax,
|
||
|
|
c = n.wsize,
|
||
|
|
f = n.whave,
|
||
|
|
d = n.wnext,
|
||
|
|
l = n.window,
|
||
|
|
p = n.hold,
|
||
|
|
h = n.bits,
|
||
|
|
m = n.lencode,
|
||
|
|
v = n.distcode,
|
||
|
|
g = (1 << n.lenbits) - 1,
|
||
|
|
y = (1 << n.distbits) - 1;
|
||
|
|
t: do {
|
||
|
|
h < 15 && (p += C[r++] << h,
|
||
|
|
h += 8,
|
||
|
|
p += C[r++] << h,
|
||
|
|
h += 8),
|
||
|
|
w = m[p & g];
|
||
|
|
e: for (; ; ) {
|
||
|
|
if (p >>>= _ = w >>> 24,
|
||
|
|
h -= _,
|
||
|
|
0 == (_ = w >>> 16 & 255))
|
||
|
|
k[i++] = 65535 & w;
|
||
|
|
else {
|
||
|
|
if (!(16 & _)) {
|
||
|
|
if (0 == (64 & _)) {
|
||
|
|
w = m[(65535 & w) + (p & (1 << _) - 1)];
|
||
|
|
continue e
|
||
|
|
}
|
||
|
|
if (32 & _) {
|
||
|
|
n.mode = 12;
|
||
|
|
break t
|
||
|
|
}
|
||
|
|
t.msg = "invalid literal/length code",
|
||
|
|
n.mode = 30;
|
||
|
|
break t
|
||
|
|
}
|
||
|
|
b = 65535 & w,
|
||
|
|
(_ &= 15) && (h < _ && (p += C[r++] << h,
|
||
|
|
h += 8),
|
||
|
|
b += p & (1 << _) - 1,
|
||
|
|
p >>>= _,
|
||
|
|
h -= _),
|
||
|
|
h < 15 && (p += C[r++] << h,
|
||
|
|
h += 8,
|
||
|
|
p += C[r++] << h,
|
||
|
|
h += 8),
|
||
|
|
w = v[p & y];
|
||
|
|
n: for (; ; ) {
|
||
|
|
if (p >>>= _ = w >>> 24,
|
||
|
|
h -= _,
|
||
|
|
!(16 & (_ = w >>> 16 & 255))) {
|
||
|
|
if (0 == (64 & _)) {
|
||
|
|
w = v[(65535 & w) + (p & (1 << _) - 1)];
|
||
|
|
continue n
|
||
|
|
}
|
||
|
|
t.msg = "invalid distance code",
|
||
|
|
n.mode = 30;
|
||
|
|
break t
|
||
|
|
}
|
||
|
|
if (x = 65535 & w,
|
||
|
|
h < (_ &= 15) && (p += C[r++] << h,
|
||
|
|
(h += 8) < _ && (p += C[r++] << h,
|
||
|
|
h += 8)),
|
||
|
|
(x += p & (1 << _) - 1) > u) {
|
||
|
|
t.msg = "invalid distance too far back",
|
||
|
|
n.mode = 30;
|
||
|
|
break t
|
||
|
|
}
|
||
|
|
if (p >>>= _,
|
||
|
|
h -= _,
|
||
|
|
x > (_ = i - a)) {
|
||
|
|
if ((_ = x - _) > f && n.sane) {
|
||
|
|
t.msg = "invalid distance too far back",
|
||
|
|
n.mode = 30;
|
||
|
|
break t
|
||
|
|
}
|
||
|
|
if (S = 0,
|
||
|
|
O = l,
|
||
|
|
0 === d) {
|
||
|
|
if (S += c - _,
|
||
|
|
_ < b) {
|
||
|
|
b -= _;
|
||
|
|
do {
|
||
|
|
k[i++] = l[S++]
|
||
|
|
} while (--_);
|
||
|
|
S = i - x,
|
||
|
|
O = k
|
||
|
|
}
|
||
|
|
} else if (d < _) {
|
||
|
|
if (S += c + d - _,
|
||
|
|
(_ -= d) < b) {
|
||
|
|
b -= _;
|
||
|
|
do {
|
||
|
|
k[i++] = l[S++]
|
||
|
|
} while (--_);
|
||
|
|
if (S = 0,
|
||
|
|
d < b) {
|
||
|
|
b -= _ = d;
|
||
|
|
do {
|
||
|
|
k[i++] = l[S++]
|
||
|
|
} while (--_);
|
||
|
|
S = i - x,
|
||
|
|
O = k
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (S += d - _,
|
||
|
|
_ < b) {
|
||
|
|
b -= _;
|
||
|
|
do {
|
||
|
|
k[i++] = l[S++]
|
||
|
|
} while (--_);
|
||
|
|
S = i - x,
|
||
|
|
O = k
|
||
|
|
}
|
||
|
|
for (; b > 2; )
|
||
|
|
k[i++] = O[S++],
|
||
|
|
k[i++] = O[S++],
|
||
|
|
k[i++] = O[S++],
|
||
|
|
b -= 3;
|
||
|
|
b && (k[i++] = O[S++],
|
||
|
|
b > 1 && (k[i++] = O[S++]))
|
||
|
|
} else {
|
||
|
|
S = i - x;
|
||
|
|
do {
|
||
|
|
k[i++] = k[S++],
|
||
|
|
k[i++] = k[S++],
|
||
|
|
k[i++] = k[S++],
|
||
|
|
b -= 3
|
||
|
|
} while (b > 2);
|
||
|
|
b && (k[i++] = k[S++],
|
||
|
|
b > 1 && (k[i++] = k[S++]))
|
||
|
|
}
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break
|
||
|
|
}
|
||
|
|
} while (r < o && i < s);
|
||
|
|
r -= b = h >> 3,
|
||
|
|
p &= (1 << (h -= b << 3)) - 1,
|
||
|
|
t.next_in = r,
|
||
|
|
t.next_out = i,
|
||
|
|
t.avail_in = r < o ? o - r + 5 : 5 - (r - o),
|
||
|
|
t.avail_out = i < s ? s - i + 257 : 257 - (i - s),
|
||
|
|
n.hold = p,
|
||
|
|
n.bits = h
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
8: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
function r(t) {
|
||
|
|
return (t >>> 24 & 255) + (t >>> 8 & 65280) + ((65280 & t) << 8) + ((255 & t) << 24)
|
||
|
|
}
|
||
|
|
function o() {
|
||
|
|
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 p.Buf16(320),
|
||
|
|
this.work = new p.Buf16(288),
|
||
|
|
this.lendyn = null,
|
||
|
|
this.distdyn = null,
|
||
|
|
this.sane = 0,
|
||
|
|
this.back = 0,
|
||
|
|
this.was = 0
|
||
|
|
}
|
||
|
|
function i(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 = x,
|
||
|
|
e.last = 0,
|
||
|
|
e.havedict = 0,
|
||
|
|
e.dmax = 32768,
|
||
|
|
e.head = null,
|
||
|
|
e.hold = 0,
|
||
|
|
e.bits = 0,
|
||
|
|
e.lencode = e.lendyn = new p.Buf32(O),
|
||
|
|
e.distcode = e.distdyn = new p.Buf32(C),
|
||
|
|
e.sane = 1,
|
||
|
|
e.back = -1,
|
||
|
|
_) : b
|
||
|
|
}
|
||
|
|
function a(t) {
|
||
|
|
var e;
|
||
|
|
return t && t.state ? ((e = t.state).wsize = 0,
|
||
|
|
e.whave = 0,
|
||
|
|
e.wnext = 0,
|
||
|
|
i(t)) : b
|
||
|
|
}
|
||
|
|
function s(t, e) {
|
||
|
|
var n, r;
|
||
|
|
return t && t.state ? (r = t.state,
|
||
|
|
e < 0 ? (n = 0,
|
||
|
|
e = -e) : (n = 1 + (e >> 4),
|
||
|
|
e < 48 && (e &= 15)),
|
||
|
|
e && (e < 8 || e > 15) ? b : (null !== r.window && r.wbits !== e && (r.window = null),
|
||
|
|
r.wrap = n,
|
||
|
|
r.wbits = e,
|
||
|
|
a(t))) : b
|
||
|
|
}
|
||
|
|
function u(t, e) {
|
||
|
|
var n, r;
|
||
|
|
return t ? (r = new o,
|
||
|
|
t.state = r,
|
||
|
|
r.window = null,
|
||
|
|
(n = s(t, e)) !== _ && (t.state = null),
|
||
|
|
n) : b
|
||
|
|
}
|
||
|
|
function c(t) {
|
||
|
|
if (k) {
|
||
|
|
var e;
|
||
|
|
for (d = new p.Buf32(512),
|
||
|
|
l = new p.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 (g(y, t.lens, 0, 288, d, 0, t.work, {
|
||
|
|
bits: 9
|
||
|
|
}),
|
||
|
|
e = 0; e < 32; )
|
||
|
|
t.lens[e++] = 5;
|
||
|
|
g(w, t.lens, 0, 32, l, 0, t.work, {
|
||
|
|
bits: 5
|
||
|
|
}),
|
||
|
|
k = !1
|
||
|
|
}
|
||
|
|
t.lencode = d,
|
||
|
|
t.lenbits = 9,
|
||
|
|
t.distcode = l,
|
||
|
|
t.distbits = 5
|
||
|
|
}
|
||
|
|
function f(t, e, n, r) {
|
||
|
|
var o, i = t.state;
|
||
|
|
return null === i.window && (i.wsize = 1 << i.wbits,
|
||
|
|
i.wnext = 0,
|
||
|
|
i.whave = 0,
|
||
|
|
i.window = new p.Buf8(i.wsize)),
|
||
|
|
r >= i.wsize ? (p.arraySet(i.window, e, n - i.wsize, i.wsize, 0),
|
||
|
|
i.wnext = 0,
|
||
|
|
i.whave = i.wsize) : ((o = i.wsize - i.wnext) > r && (o = r),
|
||
|
|
p.arraySet(i.window, e, n - r, o, i.wnext),
|
||
|
|
(r -= o) ? (p.arraySet(i.window, e, n - r, r, 0),
|
||
|
|
i.wnext = r,
|
||
|
|
i.whave = i.wsize) : (i.wnext += o,
|
||
|
|
i.wnext === i.wsize && (i.wnext = 0),
|
||
|
|
i.whave < i.wsize && (i.whave += o))),
|
||
|
|
0
|
||
|
|
}
|
||
|
|
var d, l, p = t("../utils/common"), h = t("./adler32"), m = t("./crc32"), v = t("./inffast"), g = t("./inftrees"), y = 1, w = 2, _ = 0, b = -2, x = 1, S = 12, O = 852, C = 592, k = !0;
|
||
|
|
n.inflateReset = a,
|
||
|
|
n.inflateReset2 = s,
|
||
|
|
n.inflateResetKeep = i,
|
||
|
|
n.inflateInit = function(t) {
|
||
|
|
return u(t, 15)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.inflateInit2 = u,
|
||
|
|
n.inflate = function(t, e) {
|
||
|
|
var n, o, i, a, s, u, d, l, O, C, k, E, T, D, M, A, I, W, P, N, R, j, L, q, U = 0, B = new p.Buf8(4), H = [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 b;
|
||
|
|
(n = t.state).mode === S && (n.mode = 13),
|
||
|
|
s = t.next_out,
|
||
|
|
i = t.output,
|
||
|
|
d = t.avail_out,
|
||
|
|
a = t.next_in,
|
||
|
|
o = t.input,
|
||
|
|
u = t.avail_in,
|
||
|
|
l = n.hold,
|
||
|
|
O = n.bits,
|
||
|
|
C = u,
|
||
|
|
k = d,
|
||
|
|
j = _;
|
||
|
|
t: for (; ; )
|
||
|
|
switch (n.mode) {
|
||
|
|
case x:
|
||
|
|
if (0 === n.wrap) {
|
||
|
|
n.mode = 13;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
for (; O < 16; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (2 & n.wrap && 35615 === l) {
|
||
|
|
n.check = 0,
|
||
|
|
B[0] = 255 & l,
|
||
|
|
B[1] = l >>> 8 & 255,
|
||
|
|
n.check = m(n.check, B, 2, 0),
|
||
|
|
l = 0,
|
||
|
|
O = 0,
|
||
|
|
n.mode = 2;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (n.flags = 0,
|
||
|
|
n.head && (n.head.done = !1),
|
||
|
|
!(1 & n.wrap) || (((255 & l) << 8) + (l >> 8)) % 31) {
|
||
|
|
t.msg = "incorrect header check",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (8 != (15 & l)) {
|
||
|
|
t.msg = "unknown compression method",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (O -= 4,
|
||
|
|
R = 8 + (15 & (l >>>= 4)),
|
||
|
|
0 === n.wbits)
|
||
|
|
n.wbits = R;
|
||
|
|
else if (R > n.wbits) {
|
||
|
|
t.msg = "invalid window size",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.dmax = 1 << R,
|
||
|
|
t.adler = n.check = 1,
|
||
|
|
n.mode = 512 & l ? 10 : S,
|
||
|
|
l = 0,
|
||
|
|
O = 0;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
for (; O < 16; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (n.flags = l,
|
||
|
|
8 != (255 & n.flags)) {
|
||
|
|
t.msg = "unknown compression method",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (57344 & n.flags) {
|
||
|
|
t.msg = "unknown header flags set",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.head && (n.head.text = l >> 8 & 1),
|
||
|
|
512 & n.flags && (B[0] = 255 & l,
|
||
|
|
B[1] = l >>> 8 & 255,
|
||
|
|
n.check = m(n.check, B, 2, 0)),
|
||
|
|
l = 0,
|
||
|
|
O = 0,
|
||
|
|
n.mode = 3;
|
||
|
|
case 3:
|
||
|
|
for (; O < 32; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
n.head && (n.head.time = l),
|
||
|
|
512 & n.flags && (B[0] = 255 & l,
|
||
|
|
B[1] = l >>> 8 & 255,
|
||
|
|
B[2] = l >>> 16 & 255,
|
||
|
|
B[3] = l >>> 24 & 255,
|
||
|
|
n.check = m(n.check, B, 4, 0)),
|
||
|
|
l = 0,
|
||
|
|
O = 0,
|
||
|
|
n.mode = 4;
|
||
|
|
case 4:
|
||
|
|
for (; O < 16; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
n.head && (n.head.xflags = 255 & l,
|
||
|
|
n.head.os = l >> 8),
|
||
|
|
512 & n.flags && (B[0] = 255 & l,
|
||
|
|
B[1] = l >>> 8 & 255,
|
||
|
|
n.check = m(n.check, B, 2, 0)),
|
||
|
|
l = 0,
|
||
|
|
O = 0,
|
||
|
|
n.mode = 5;
|
||
|
|
case 5:
|
||
|
|
if (1024 & n.flags) {
|
||
|
|
for (; O < 16; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
n.length = l,
|
||
|
|
n.head && (n.head.extra_len = l),
|
||
|
|
512 & n.flags && (B[0] = 255 & l,
|
||
|
|
B[1] = l >>> 8 & 255,
|
||
|
|
n.check = m(n.check, B, 2, 0)),
|
||
|
|
l = 0,
|
||
|
|
O = 0
|
||
|
|
} else
|
||
|
|
n.head && (n.head.extra = null);
|
||
|
|
n.mode = 6;
|
||
|
|
case 6:
|
||
|
|
if (1024 & n.flags && ((E = n.length) > u && (E = u),
|
||
|
|
E && (n.head && (R = n.head.extra_len - n.length,
|
||
|
|
n.head.extra || (n.head.extra = new Array(n.head.extra_len)),
|
||
|
|
p.arraySet(n.head.extra, o, a, E, R)),
|
||
|
|
512 & n.flags && (n.check = m(n.check, o, E, a)),
|
||
|
|
u -= E,
|
||
|
|
a += E,
|
||
|
|
n.length -= E),
|
||
|
|
n.length))
|
||
|
|
break t;
|
||
|
|
n.length = 0,
|
||
|
|
n.mode = 7;
|
||
|
|
case 7:
|
||
|
|
if (2048 & n.flags) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
E = 0;
|
||
|
|
do {
|
||
|
|
R = o[a + E++],
|
||
|
|
n.head && R && n.length < 65536 && (n.head.name += String.fromCharCode(R))
|
||
|
|
} while (R && E < u);
|
||
|
|
if (512 & n.flags && (n.check = m(n.check, o, E, a)),
|
||
|
|
u -= E,
|
||
|
|
a += E,
|
||
|
|
R)
|
||
|
|
break t
|
||
|
|
} else
|
||
|
|
n.head && (n.head.name = null);
|
||
|
|
n.length = 0,
|
||
|
|
n.mode = 8;
|
||
|
|
case 8:
|
||
|
|
if (4096 & n.flags) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
E = 0;
|
||
|
|
do {
|
||
|
|
R = o[a + E++],
|
||
|
|
n.head && R && n.length < 65536 && (n.head.comment += String.fromCharCode(R))
|
||
|
|
} while (R && E < u);
|
||
|
|
if (512 & n.flags && (n.check = m(n.check, o, E, a)),
|
||
|
|
u -= E,
|
||
|
|
a += E,
|
||
|
|
R)
|
||
|
|
break t
|
||
|
|
} else
|
||
|
|
n.head && (n.head.comment = null);
|
||
|
|
n.mode = 9;
|
||
|
|
case 9:
|
||
|
|
if (512 & n.flags) {
|
||
|
|
for (; O < 16; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (l !== (65535 & n.check)) {
|
||
|
|
t.msg = "header crc mismatch",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
l = 0,
|
||
|
|
O = 0
|
||
|
|
}
|
||
|
|
n.head && (n.head.hcrc = n.flags >> 9 & 1,
|
||
|
|
n.head.done = !0),
|
||
|
|
t.adler = n.check = 0,
|
||
|
|
n.mode = S;
|
||
|
|
break;
|
||
|
|
case 10:
|
||
|
|
for (; O < 32; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
t.adler = n.check = r(l),
|
||
|
|
l = 0,
|
||
|
|
O = 0,
|
||
|
|
n.mode = 11;
|
||
|
|
case 11:
|
||
|
|
if (0 === n.havedict)
|
||
|
|
return t.next_out = s,
|
||
|
|
t.avail_out = d,
|
||
|
|
t.next_in = a,
|
||
|
|
t.avail_in = u,
|
||
|
|
n.hold = l,
|
||
|
|
n.bits = O,
|
||
|
|
2;
|
||
|
|
t.adler = n.check = 1,
|
||
|
|
n.mode = S;
|
||
|
|
case S:
|
||
|
|
if (5 === e || 6 === e)
|
||
|
|
break t;
|
||
|
|
case 13:
|
||
|
|
if (n.last) {
|
||
|
|
l >>>= 7 & O,
|
||
|
|
O -= 7 & O,
|
||
|
|
n.mode = 27;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
for (; O < 3; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
switch (n.last = 1 & l,
|
||
|
|
O -= 1,
|
||
|
|
3 & (l >>>= 1)) {
|
||
|
|
case 0:
|
||
|
|
n.mode = 14;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
if (c(n),
|
||
|
|
n.mode = 20,
|
||
|
|
6 === e) {
|
||
|
|
l >>>= 2,
|
||
|
|
O -= 2;
|
||
|
|
break t
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
n.mode = 17;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
t.msg = "invalid block type",
|
||
|
|
n.mode = 30
|
||
|
|
}
|
||
|
|
l >>>= 2,
|
||
|
|
O -= 2;
|
||
|
|
break;
|
||
|
|
case 14:
|
||
|
|
for (l >>>= 7 & O,
|
||
|
|
O -= 7 & O; O < 32; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if ((65535 & l) != (l >>> 16 ^ 65535)) {
|
||
|
|
t.msg = "invalid stored block lengths",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (n.length = 65535 & l,
|
||
|
|
l = 0,
|
||
|
|
O = 0,
|
||
|
|
n.mode = 15,
|
||
|
|
6 === e)
|
||
|
|
break t;
|
||
|
|
case 15:
|
||
|
|
n.mode = 16;
|
||
|
|
case 16:
|
||
|
|
if (E = n.length) {
|
||
|
|
if (E > u && (E = u),
|
||
|
|
E > d && (E = d),
|
||
|
|
0 === E)
|
||
|
|
break t;
|
||
|
|
p.arraySet(i, o, a, E, s),
|
||
|
|
u -= E,
|
||
|
|
a += E,
|
||
|
|
d -= E,
|
||
|
|
s += E,
|
||
|
|
n.length -= E;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.mode = S;
|
||
|
|
break;
|
||
|
|
case 17:
|
||
|
|
for (; O < 14; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (n.nlen = 257 + (31 & l),
|
||
|
|
l >>>= 5,
|
||
|
|
O -= 5,
|
||
|
|
n.ndist = 1 + (31 & l),
|
||
|
|
l >>>= 5,
|
||
|
|
O -= 5,
|
||
|
|
n.ncode = 4 + (15 & l),
|
||
|
|
l >>>= 4,
|
||
|
|
O -= 4,
|
||
|
|
n.nlen > 286 || n.ndist > 30) {
|
||
|
|
t.msg = "too many length or distance symbols",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.have = 0,
|
||
|
|
n.mode = 18;
|
||
|
|
case 18:
|
||
|
|
for (; n.have < n.ncode; ) {
|
||
|
|
for (; O < 3; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
n.lens[H[n.have++]] = 7 & l,
|
||
|
|
l >>>= 3,
|
||
|
|
O -= 3
|
||
|
|
}
|
||
|
|
for (; n.have < 19; )
|
||
|
|
n.lens[H[n.have++]] = 0;
|
||
|
|
if (n.lencode = n.lendyn,
|
||
|
|
n.lenbits = 7,
|
||
|
|
L = {
|
||
|
|
bits: n.lenbits
|
||
|
|
},
|
||
|
|
j = g(0, n.lens, 0, 19, n.lencode, 0, n.work, L),
|
||
|
|
n.lenbits = L.bits,
|
||
|
|
j) {
|
||
|
|
t.msg = "invalid code lengths set",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.have = 0,
|
||
|
|
n.mode = 19;
|
||
|
|
case 19:
|
||
|
|
for (; n.have < n.nlen + n.ndist; ) {
|
||
|
|
for (; A = (U = n.lencode[l & (1 << n.lenbits) - 1]) >>> 16 & 255,
|
||
|
|
I = 65535 & U,
|
||
|
|
!((M = U >>> 24) <= O); ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (I < 16)
|
||
|
|
l >>>= M,
|
||
|
|
O -= M,
|
||
|
|
n.lens[n.have++] = I;
|
||
|
|
else {
|
||
|
|
if (16 === I) {
|
||
|
|
for (q = M + 2; O < q; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (l >>>= M,
|
||
|
|
O -= M,
|
||
|
|
0 === n.have) {
|
||
|
|
t.msg = "invalid bit length repeat",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
R = n.lens[n.have - 1],
|
||
|
|
E = 3 + (3 & l),
|
||
|
|
l >>>= 2,
|
||
|
|
O -= 2
|
||
|
|
} else if (17 === I) {
|
||
|
|
for (q = M + 3; O < q; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
O -= M,
|
||
|
|
R = 0,
|
||
|
|
E = 3 + (7 & (l >>>= M)),
|
||
|
|
l >>>= 3,
|
||
|
|
O -= 3
|
||
|
|
} else {
|
||
|
|
for (q = M + 7; O < q; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
O -= M,
|
||
|
|
R = 0,
|
||
|
|
E = 11 + (127 & (l >>>= M)),
|
||
|
|
l >>>= 7,
|
||
|
|
O -= 7
|
||
|
|
}
|
||
|
|
if (n.have + E > n.nlen + n.ndist) {
|
||
|
|
t.msg = "invalid bit length repeat",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
for (; E--; )
|
||
|
|
n.lens[n.have++] = R
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (30 === n.mode)
|
||
|
|
break;
|
||
|
|
if (0 === n.lens[256]) {
|
||
|
|
t.msg = "invalid code -- missing end-of-block",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (n.lenbits = 9,
|
||
|
|
L = {
|
||
|
|
bits: n.lenbits
|
||
|
|
},
|
||
|
|
j = g(y, n.lens, 0, n.nlen, n.lencode, 0, n.work, L),
|
||
|
|
n.lenbits = L.bits,
|
||
|
|
j) {
|
||
|
|
t.msg = "invalid literal/lengths set",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (n.distbits = 6,
|
||
|
|
n.distcode = n.distdyn,
|
||
|
|
L = {
|
||
|
|
bits: n.distbits
|
||
|
|
},
|
||
|
|
j = g(w, n.lens, n.nlen, n.ndist, n.distcode, 0, n.work, L),
|
||
|
|
n.distbits = L.bits,
|
||
|
|
j) {
|
||
|
|
t.msg = "invalid distances set",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (n.mode = 20,
|
||
|
|
6 === e)
|
||
|
|
break t;
|
||
|
|
case 20:
|
||
|
|
n.mode = 21;
|
||
|
|
case 21:
|
||
|
|
if (u >= 6 && d >= 258) {
|
||
|
|
t.next_out = s,
|
||
|
|
t.avail_out = d,
|
||
|
|
t.next_in = a,
|
||
|
|
t.avail_in = u,
|
||
|
|
n.hold = l,
|
||
|
|
n.bits = O,
|
||
|
|
v(t, k),
|
||
|
|
s = t.next_out,
|
||
|
|
i = t.output,
|
||
|
|
d = t.avail_out,
|
||
|
|
a = t.next_in,
|
||
|
|
o = t.input,
|
||
|
|
u = t.avail_in,
|
||
|
|
l = n.hold,
|
||
|
|
O = n.bits,
|
||
|
|
n.mode === S && (n.back = -1);
|
||
|
|
break
|
||
|
|
}
|
||
|
|
for (n.back = 0; A = (U = n.lencode[l & (1 << n.lenbits) - 1]) >>> 16 & 255,
|
||
|
|
I = 65535 & U,
|
||
|
|
!((M = U >>> 24) <= O); ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (A && 0 == (240 & A)) {
|
||
|
|
for (W = M,
|
||
|
|
P = A,
|
||
|
|
N = I; A = (U = n.lencode[N + ((l & (1 << W + P) - 1) >> W)]) >>> 16 & 255,
|
||
|
|
I = 65535 & U,
|
||
|
|
!(W + (M = U >>> 24) <= O); ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
l >>>= W,
|
||
|
|
O -= W,
|
||
|
|
n.back += W
|
||
|
|
}
|
||
|
|
if (l >>>= M,
|
||
|
|
O -= M,
|
||
|
|
n.back += M,
|
||
|
|
n.length = I,
|
||
|
|
0 === A) {
|
||
|
|
n.mode = 26;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (32 & A) {
|
||
|
|
n.back = -1,
|
||
|
|
n.mode = S;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (64 & A) {
|
||
|
|
t.msg = "invalid literal/length code",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.extra = 15 & A,
|
||
|
|
n.mode = 22;
|
||
|
|
case 22:
|
||
|
|
if (n.extra) {
|
||
|
|
for (q = n.extra; O < q; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
n.length += l & (1 << n.extra) - 1,
|
||
|
|
l >>>= n.extra,
|
||
|
|
O -= n.extra,
|
||
|
|
n.back += n.extra
|
||
|
|
}
|
||
|
|
n.was = n.length,
|
||
|
|
n.mode = 23;
|
||
|
|
case 23:
|
||
|
|
for (; A = (U = n.distcode[l & (1 << n.distbits) - 1]) >>> 16 & 255,
|
||
|
|
I = 65535 & U,
|
||
|
|
!((M = U >>> 24) <= O); ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (0 == (240 & A)) {
|
||
|
|
for (W = M,
|
||
|
|
P = A,
|
||
|
|
N = I; A = (U = n.distcode[N + ((l & (1 << W + P) - 1) >> W)]) >>> 16 & 255,
|
||
|
|
I = 65535 & U,
|
||
|
|
!(W + (M = U >>> 24) <= O); ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
l >>>= W,
|
||
|
|
O -= W,
|
||
|
|
n.back += W
|
||
|
|
}
|
||
|
|
if (l >>>= M,
|
||
|
|
O -= M,
|
||
|
|
n.back += M,
|
||
|
|
64 & A) {
|
||
|
|
t.msg = "invalid distance code",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.offset = I,
|
||
|
|
n.extra = 15 & A,
|
||
|
|
n.mode = 24;
|
||
|
|
case 24:
|
||
|
|
if (n.extra) {
|
||
|
|
for (q = n.extra; O < q; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
n.offset += l & (1 << n.extra) - 1,
|
||
|
|
l >>>= n.extra,
|
||
|
|
O -= n.extra,
|
||
|
|
n.back += n.extra
|
||
|
|
}
|
||
|
|
if (n.offset > n.dmax) {
|
||
|
|
t.msg = "invalid distance too far back",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n.mode = 25;
|
||
|
|
case 25:
|
||
|
|
if (0 === d)
|
||
|
|
break t;
|
||
|
|
if (E = k - d,
|
||
|
|
n.offset > E) {
|
||
|
|
if ((E = n.offset - E) > n.whave && n.sane) {
|
||
|
|
t.msg = "invalid distance too far back",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
E > n.wnext ? (E -= n.wnext,
|
||
|
|
T = n.wsize - E) : T = n.wnext - E,
|
||
|
|
E > n.length && (E = n.length),
|
||
|
|
D = n.window
|
||
|
|
} else
|
||
|
|
D = i,
|
||
|
|
T = s - n.offset,
|
||
|
|
E = n.length;
|
||
|
|
E > d && (E = d),
|
||
|
|
d -= E,
|
||
|
|
n.length -= E;
|
||
|
|
do {
|
||
|
|
i[s++] = D[T++]
|
||
|
|
} while (--E);
|
||
|
|
0 === n.length && (n.mode = 21);
|
||
|
|
break;
|
||
|
|
case 26:
|
||
|
|
if (0 === d)
|
||
|
|
break t;
|
||
|
|
i[s++] = n.length,
|
||
|
|
d--,
|
||
|
|
n.mode = 21;
|
||
|
|
break;
|
||
|
|
case 27:
|
||
|
|
if (n.wrap) {
|
||
|
|
for (; O < 32; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l |= o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (k -= d,
|
||
|
|
t.total_out += k,
|
||
|
|
n.total += k,
|
||
|
|
k && (t.adler = n.check = n.flags ? m(n.check, i, k, s - k) : h(n.check, i, k, s - k)),
|
||
|
|
k = d,
|
||
|
|
(n.flags ? l : r(l)) !== n.check) {
|
||
|
|
t.msg = "incorrect data check",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
l = 0,
|
||
|
|
O = 0
|
||
|
|
}
|
||
|
|
n.mode = 28;
|
||
|
|
case 28:
|
||
|
|
if (n.wrap && n.flags) {
|
||
|
|
for (; O < 32; ) {
|
||
|
|
if (0 === u)
|
||
|
|
break t;
|
||
|
|
u--,
|
||
|
|
l += o[a++] << O,
|
||
|
|
O += 8
|
||
|
|
}
|
||
|
|
if (l !== (4294967295 & n.total)) {
|
||
|
|
t.msg = "incorrect length check",
|
||
|
|
n.mode = 30;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
l = 0,
|
||
|
|
O = 0
|
||
|
|
}
|
||
|
|
n.mode = 29;
|
||
|
|
case 29:
|
||
|
|
j = 1;
|
||
|
|
break t;
|
||
|
|
case 30:
|
||
|
|
j = -3;
|
||
|
|
break t;
|
||
|
|
case 31:
|
||
|
|
return -4;
|
||
|
|
case 32:
|
||
|
|
default:
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
return t.next_out = s,
|
||
|
|
t.avail_out = d,
|
||
|
|
t.next_in = a,
|
||
|
|
t.avail_in = u,
|
||
|
|
n.hold = l,
|
||
|
|
n.bits = O,
|
||
|
|
(n.wsize || k !== t.avail_out && n.mode < 30 && (n.mode < 27 || 4 !== e)) && f(t, t.output, t.next_out, k - t.avail_out) ? (n.mode = 31,
|
||
|
|
-4) : (C -= t.avail_in,
|
||
|
|
k -= t.avail_out,
|
||
|
|
t.total_in += C,
|
||
|
|
t.total_out += k,
|
||
|
|
n.total += k,
|
||
|
|
n.wrap && k && (t.adler = n.check = n.flags ? m(n.check, i, k, t.next_out - k) : h(n.check, i, k, t.next_out - k)),
|
||
|
|
t.data_type = n.bits + (n.last ? 64 : 0) + (n.mode === S ? 128 : 0) + (20 === n.mode || 15 === n.mode ? 256 : 0),
|
||
|
|
(0 === C && 0 === k || 4 === e) && j === _ && (j = -5),
|
||
|
|
j)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.inflateEnd = function(t) {
|
||
|
|
if (!t || !t.state)
|
||
|
|
return b;
|
||
|
|
var e = t.state;
|
||
|
|
return e.window && (e.window = null),
|
||
|
|
t.state = null,
|
||
|
|
_
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.inflateGetHeader = function(t, e) {
|
||
|
|
var n;
|
||
|
|
return t && t.state ? 0 == (2 & (n = t.state).wrap) ? b : (n.head = e,
|
||
|
|
e.done = !1,
|
||
|
|
_) : b
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.inflateSetDictionary = function(t, e) {
|
||
|
|
var n, r = e.length;
|
||
|
|
return t && t.state ? 0 !== (n = t.state).wrap && 11 !== n.mode ? b : 11 === n.mode && h(1, e, r, 0) !== n.check ? -3 : f(t, e, r, r) ? (n.mode = 31,
|
||
|
|
-4) : (n.havedict = 1,
|
||
|
|
_) : b
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.inflateInfo = "pako inflate (from Nodeca project)"
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
"../utils/common": 1,
|
||
|
|
"./adler32": 3,
|
||
|
|
"./crc32": 5,
|
||
|
|
"./inffast": 7,
|
||
|
|
"./inftrees": 9
|
||
|
|
}],
|
||
|
|
9: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
var r = t("../utils/common")
|
||
|
|
, o = [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]
|
||
|
|
, i = [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]
|
||
|
|
, a = [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];
|
||
|
|
e.exports = function(t, e, n, u, c, f, d, l) {
|
||
|
|
var p, h, m, v, g, y, w, _, b, x = l.bits, S = 0, O = 0, C = 0, k = 0, E = 0, T = 0, D = 0, M = 0, A = 0, I = 0, W = null, P = 0, N = new r.Buf16(16), R = new r.Buf16(16), j = null, L = 0;
|
||
|
|
for (S = 0; S <= 15; S++)
|
||
|
|
N[S] = 0;
|
||
|
|
for (O = 0; O < u; O++)
|
||
|
|
N[e[n + O]]++;
|
||
|
|
for (E = x,
|
||
|
|
k = 15; k >= 1 && 0 === N[k]; k--)
|
||
|
|
;
|
||
|
|
if (E > k && (E = k),
|
||
|
|
0 === k)
|
||
|
|
return c[f++] = 20971520,
|
||
|
|
c[f++] = 20971520,
|
||
|
|
l.bits = 1,
|
||
|
|
0;
|
||
|
|
for (C = 1; C < k && 0 === N[C]; C++)
|
||
|
|
;
|
||
|
|
for (E < C && (E = C),
|
||
|
|
M = 1,
|
||
|
|
S = 1; S <= 15; S++)
|
||
|
|
if (M <<= 1,
|
||
|
|
(M -= N[S]) < 0)
|
||
|
|
return -1;
|
||
|
|
if (M > 0 && (0 === t || 1 !== k))
|
||
|
|
return -1;
|
||
|
|
for (R[1] = 0,
|
||
|
|
S = 1; S < 15; S++)
|
||
|
|
R[S + 1] = R[S] + N[S];
|
||
|
|
for (O = 0; O < u; O++)
|
||
|
|
0 !== e[n + O] && (d[R[e[n + O]]++] = O);
|
||
|
|
if (0 === t ? (W = j = d,
|
||
|
|
y = 19) : 1 === t ? (W = o,
|
||
|
|
P -= 257,
|
||
|
|
j = i,
|
||
|
|
L -= 257,
|
||
|
|
y = 256) : (W = a,
|
||
|
|
j = s,
|
||
|
|
y = -1),
|
||
|
|
I = 0,
|
||
|
|
O = 0,
|
||
|
|
S = C,
|
||
|
|
g = f,
|
||
|
|
T = E,
|
||
|
|
D = 0,
|
||
|
|
m = -1,
|
||
|
|
v = (A = 1 << E) - 1,
|
||
|
|
1 === t && A > 852 || 2 === t && A > 592)
|
||
|
|
return 1;
|
||
|
|
for (; ; ) {
|
||
|
|
w = S - D,
|
||
|
|
d[O] < y ? (_ = 0,
|
||
|
|
b = d[O]) : d[O] > y ? (_ = j[L + d[O]],
|
||
|
|
b = W[P + d[O]]) : (_ = 96,
|
||
|
|
b = 0),
|
||
|
|
p = 1 << S - D,
|
||
|
|
C = h = 1 << T;
|
||
|
|
do {
|
||
|
|
c[g + (I >> D) + (h -= p)] = w << 24 | _ << 16 | b | 0
|
||
|
|
} while (0 !== h);
|
||
|
|
for (p = 1 << S - 1; I & p; )
|
||
|
|
p >>= 1;
|
||
|
|
if (0 !== p ? (I &= p - 1,
|
||
|
|
I += p) : I = 0,
|
||
|
|
O++,
|
||
|
|
0 == --N[S]) {
|
||
|
|
if (S === k)
|
||
|
|
break;
|
||
|
|
S = e[n + d[O]]
|
||
|
|
}
|
||
|
|
if (S > E && (I & v) !== m) {
|
||
|
|
for (0 === D && (D = E),
|
||
|
|
g += C,
|
||
|
|
M = 1 << (T = S - D); T + D < k && !((M -= N[T + D]) <= 0); )
|
||
|
|
T++,
|
||
|
|
M <<= 1;
|
||
|
|
if (A += 1 << T,
|
||
|
|
1 === t && A > 852 || 2 === t && A > 592)
|
||
|
|
return 1;
|
||
|
|
c[m = I & v] = E << 24 | T << 16 | g - f | 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0 !== I && (c[g + I] = S - D << 24 | 64 << 16 | 0),
|
||
|
|
l.bits = E,
|
||
|
|
0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
"../utils/common": 1
|
||
|
|
}],
|
||
|
|
10: [function(t, e, n) {
|
||
|
|
"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"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
11: [function(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
e.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(t, e, n) {
|
||
|
|
"use strict";
|
||
|
|
function r(t) {
|
||
|
|
if (!(this instanceof r))
|
||
|
|
return new r(t);
|
||
|
|
this.options = a.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 n = i.inflateInit2(this.strm, e.windowBits);
|
||
|
|
if (n !== u.Z_OK)
|
||
|
|
throw new Error(c[n]);
|
||
|
|
this.header = new d,
|
||
|
|
i.inflateGetHeader(this.strm, this.header)
|
||
|
|
}
|
||
|
|
function o(t, e) {
|
||
|
|
var n = new r(e);
|
||
|
|
if (n.push(t, !0),
|
||
|
|
n.err)
|
||
|
|
throw n.msg || c[n.err];
|
||
|
|
return n.result
|
||
|
|
}
|
||
|
|
var i = t("./zlib/inflate")
|
||
|
|
, a = t("./utils/common")
|
||
|
|
, s = t("./utils/strings")
|
||
|
|
, u = t("./zlib/constants")
|
||
|
|
, c = t("./zlib/messages")
|
||
|
|
, f = t("./zlib/zstream")
|
||
|
|
, d = t("./zlib/gzheader")
|
||
|
|
, l = Object.prototype.toString;
|
||
|
|
r.prototype.push = function(t, e) {
|
||
|
|
var n, r, o, c, f, d, p = this.strm, h = this.options.chunkSize, m = this.options.dictionary, v = !1;
|
||
|
|
if (this.ended)
|
||
|
|
return !1;
|
||
|
|
r = e === ~~e ? e : !0 === e ? u.Z_FINISH : u.Z_NO_FLUSH,
|
||
|
|
"string" == typeof t ? p.input = s.binstring2buf(t) : "[object ArrayBuffer]" === l.call(t) ? p.input = new Uint8Array(t) : p.input = t,
|
||
|
|
p.next_in = 0,
|
||
|
|
p.avail_in = p.input.length;
|
||
|
|
do {
|
||
|
|
if (0 === p.avail_out && (p.output = new a.Buf8(h),
|
||
|
|
p.next_out = 0,
|
||
|
|
p.avail_out = h),
|
||
|
|
(n = i.inflate(p, u.Z_NO_FLUSH)) === u.Z_NEED_DICT && m && (d = "string" == typeof m ? s.string2buf(m) : "[object ArrayBuffer]" === l.call(m) ? new Uint8Array(m) : m,
|
||
|
|
n = i.inflateSetDictionary(this.strm, d)),
|
||
|
|
n === u.Z_BUF_ERROR && !0 === v && (n = u.Z_OK,
|
||
|
|
v = !1),
|
||
|
|
n !== u.Z_STREAM_END && n !== u.Z_OK)
|
||
|
|
return this.onEnd(n),
|
||
|
|
this.ended = !0,
|
||
|
|
!1;
|
||
|
|
p.next_out && (0 !== p.avail_out && n !== u.Z_STREAM_END && (0 !== p.avail_in || r !== u.Z_FINISH && r !== u.Z_SYNC_FLUSH) || ("string" === this.options.to ? (o = s.utf8border(p.output, p.next_out),
|
||
|
|
c = p.next_out - o,
|
||
|
|
f = s.buf2string(p.output, o),
|
||
|
|
p.next_out = c,
|
||
|
|
p.avail_out = h - c,
|
||
|
|
c && a.arraySet(p.output, p.output, o, c, 0),
|
||
|
|
this.onData(f)) : this.onData(a.shrinkBuf(p.output, p.next_out)))),
|
||
|
|
0 === p.avail_in && 0 === p.avail_out && (v = !0)
|
||
|
|
} while ((p.avail_in > 0 || 0 === p.avail_out) && n !== u.Z_STREAM_END);
|
||
|
|
return n === u.Z_STREAM_END && (r = u.Z_FINISH),
|
||
|
|
r === u.Z_FINISH ? (n = i.inflateEnd(this.strm),
|
||
|
|
this.onEnd(n),
|
||
|
|
this.ended = !0,
|
||
|
|
n === u.Z_OK) : r !== u.Z_SYNC_FLUSH || (this.onEnd(u.Z_OK),
|
||
|
|
p.avail_out = 0,
|
||
|
|
!0)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.onData = function(t) {
|
||
|
|
this.chunks.push(t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.onEnd = function(t) {
|
||
|
|
t === u.Z_OK && ("string" === this.options.to ? this.result = this.chunks.join("") : this.result = a.flattenChunks(this.chunks)),
|
||
|
|
this.chunks = [],
|
||
|
|
this.err = t,
|
||
|
|
this.msg = this.strm.msg
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.Inflate = r,
|
||
|
|
n.inflate = o,
|
||
|
|
n.inflateRaw = function(t, e) {
|
||
|
|
return (e = e || {}).raw = !0,
|
||
|
|
o(t, e)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.ungzip = o
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
"./utils/common": 1,
|
||
|
|
"./utils/strings": 2,
|
||
|
|
"./zlib/constants": 4,
|
||
|
|
"./zlib/gzheader": 6,
|
||
|
|
"./zlib/inflate": 8,
|
||
|
|
"./zlib/messages": 10,
|
||
|
|
"./zlib/zstream": 11
|
||
|
|
}]
|
||
|
|
}, {}, [])("/lib/inflate.js")
|
||
|
|
}
|
||
|
|
,
|
||
|
|
"object" == s(e) && void 0 !== t ? t.exports = a() : (o = [],
|
||
|
|
void 0 === (i = "function" == typeof (r = a) ? r.apply(e, o) : r) || (t.exports = i))
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
!function(b) {
|
||
|
|
var r, u, t, n;
|
||
|
|
r = {
|
||
|
|
1: [function(t, e) {
|
||
|
|
e.exports = function(t, e) {
|
||
|
|
for (var n = Array(arguments.length - 1), r = 0, o = 2, i = !0; o < arguments.length; )
|
||
|
|
n[r++] = arguments[o++];
|
||
|
|
return new Promise((function(o, a) {
|
||
|
|
n[r] = function(t) {
|
||
|
|
if (i)
|
||
|
|
if (i = !1,
|
||
|
|
t)
|
||
|
|
a(t);
|
||
|
|
else {
|
||
|
|
for (var e = Array(arguments.length - 1), n = 0; n < e.length; )
|
||
|
|
e[n++] = arguments[n];
|
||
|
|
o.apply(null, e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
;
|
||
|
|
try {
|
||
|
|
t.apply(e || null, n)
|
||
|
|
} catch (t) {
|
||
|
|
i && (i = !1,
|
||
|
|
a(t))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
2: [function(t, e, n) {
|
||
|
|
var r = n;
|
||
|
|
r.length = function(t) {
|
||
|
|
var e = t.length;
|
||
|
|
if (!e)
|
||
|
|
return 0;
|
||
|
|
for (var n = 0; 1 < --e % 4 && "=" === t.charAt(e); )
|
||
|
|
++n;
|
||
|
|
return Math.ceil(3 * t.length) / 4 - n
|
||
|
|
}
|
||
|
|
;
|
||
|
|
for (var o = Array(64), i = Array(123), a = 0; a < 64; )
|
||
|
|
i[o[a] = a < 26 ? a + 65 : a < 52 ? a + 71 : a < 62 ? a - 4 : a - 59 | 43] = a++;
|
||
|
|
r.encode = function(t, e, n) {
|
||
|
|
for (var r, i = null, a = [], s = 0, u = 0; e < n; ) {
|
||
|
|
var c = t[e++];
|
||
|
|
switch (u) {
|
||
|
|
case 0:
|
||
|
|
a[s++] = o[c >> 2],
|
||
|
|
r = (3 & c) << 4,
|
||
|
|
u = 1;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
a[s++] = o[r | c >> 4],
|
||
|
|
r = (15 & c) << 2,
|
||
|
|
u = 2;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
a[s++] = o[r | c >> 6],
|
||
|
|
a[s++] = o[63 & c],
|
||
|
|
u = 0
|
||
|
|
}
|
||
|
|
8191 < s && ((i || (i = [])).push(String.fromCharCode.apply(String, a)),
|
||
|
|
s = 0)
|
||
|
|
}
|
||
|
|
return u && (a[s++] = o[r],
|
||
|
|
a[s++] = 61,
|
||
|
|
1 === u && (a[s++] = 61)),
|
||
|
|
i ? (s && i.push(String.fromCharCode.apply(String, a.slice(0, s))),
|
||
|
|
i.join("")) : String.fromCharCode.apply(String, a.slice(0, s))
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var s = "invalid encoding";
|
||
|
|
r.decode = function(t, e, n) {
|
||
|
|
for (var r, o = n, a = 0, u = 0; u < t.length; ) {
|
||
|
|
var c = t.charCodeAt(u++);
|
||
|
|
if (61 === c && 1 < a)
|
||
|
|
break;
|
||
|
|
if ((c = i[c]) === b)
|
||
|
|
throw Error(s);
|
||
|
|
switch (a) {
|
||
|
|
case 0:
|
||
|
|
r = c,
|
||
|
|
a = 1;
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
e[n++] = r << 2 | (48 & c) >> 4,
|
||
|
|
r = c,
|
||
|
|
a = 2;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
e[n++] = (15 & r) << 4 | (60 & c) >> 2,
|
||
|
|
r = c,
|
||
|
|
a = 3;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
e[n++] = (3 & r) << 6 | c,
|
||
|
|
a = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (1 === a)
|
||
|
|
throw Error(s);
|
||
|
|
return n - o
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.test = function(t) {
|
||
|
|
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(t)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
3: [function(t, e) {
|
||
|
|
function n() {
|
||
|
|
this.t = {}
|
||
|
|
}
|
||
|
|
(e.exports = n).prototype.on = function(t, e, n) {
|
||
|
|
return (this.t[t] || (this.t[t] = [])).push({
|
||
|
|
fn: e,
|
||
|
|
ctx: n || this
|
||
|
|
}),
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.prototype.off = function(t, e) {
|
||
|
|
if (t === b)
|
||
|
|
this.t = {};
|
||
|
|
else if (e === b)
|
||
|
|
this.t[t] = [];
|
||
|
|
else
|
||
|
|
for (var n = this.t[t], r = 0; r < n.length; )
|
||
|
|
n[r].fn === e ? n.splice(r, 1) : ++r;
|
||
|
|
return this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
n.prototype.emit = function(t) {
|
||
|
|
var e = this.t[t];
|
||
|
|
if (e) {
|
||
|
|
for (var n = [], r = 1; r < arguments.length; )
|
||
|
|
n.push(arguments[r++]);
|
||
|
|
for (r = 0; r < e.length; )
|
||
|
|
e[r].fn.apply(e[r++].ctx, n)
|
||
|
|
}
|
||
|
|
return this
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
4: [function(t, e) {
|
||
|
|
function n(t) {
|
||
|
|
return "undefined" != typeof Float32Array ? function() {
|
||
|
|
var e = new Float32Array([-0])
|
||
|
|
, n = new Uint8Array(e.buffer)
|
||
|
|
, r = 128 === n[3];
|
||
|
|
function o(t, r, o) {
|
||
|
|
e[0] = t,
|
||
|
|
r[o] = n[0],
|
||
|
|
r[o + 1] = n[1],
|
||
|
|
r[o + 2] = n[2],
|
||
|
|
r[o + 3] = n[3]
|
||
|
|
}
|
||
|
|
function i(t, r, o) {
|
||
|
|
e[0] = t,
|
||
|
|
r[o] = n[3],
|
||
|
|
r[o + 1] = n[2],
|
||
|
|
r[o + 2] = n[1],
|
||
|
|
r[o + 3] = n[0]
|
||
|
|
}
|
||
|
|
function a(t, r) {
|
||
|
|
return n[0] = t[r],
|
||
|
|
n[1] = t[r + 1],
|
||
|
|
n[2] = t[r + 2],
|
||
|
|
n[3] = t[r + 3],
|
||
|
|
e[0]
|
||
|
|
}
|
||
|
|
function s(t, r) {
|
||
|
|
return n[3] = t[r],
|
||
|
|
n[2] = t[r + 1],
|
||
|
|
n[1] = t[r + 2],
|
||
|
|
n[0] = t[r + 3],
|
||
|
|
e[0]
|
||
|
|
}
|
||
|
|
t.writeFloatLE = r ? o : i,
|
||
|
|
t.writeFloatBE = r ? i : o,
|
||
|
|
t.readFloatLE = r ? a : s,
|
||
|
|
t.readFloatBE = r ? s : a
|
||
|
|
}() : function() {
|
||
|
|
function e(t, e, n, r) {
|
||
|
|
var o = e < 0 ? 1 : 0;
|
||
|
|
if (o && (e = -e),
|
||
|
|
0 === e)
|
||
|
|
t(0 < 1 / e ? 0 : 2147483648, n, r);
|
||
|
|
else if (isNaN(e))
|
||
|
|
t(2143289344, n, r);
|
||
|
|
else if (34028234663852886e22 < e)
|
||
|
|
t((o << 31 | 2139095040) >>> 0, n, r);
|
||
|
|
else if (e < 11754943508222875e-54)
|
||
|
|
t((o << 31 | Math.round(e / 1401298464324817e-60)) >>> 0, n, r);
|
||
|
|
else {
|
||
|
|
var i = Math.floor(Math.log(e) / Math.LN2);
|
||
|
|
t((o << 31 | i + 127 << 23 | 8388607 & Math.round(e * Math.pow(2, -i) * 8388608)) >>> 0, n, r)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function n(t, e, n) {
|
||
|
|
var r = t(e, n)
|
||
|
|
, o = 2 * (r >> 31) + 1
|
||
|
|
, i = r >>> 23 & 255
|
||
|
|
, a = 8388607 & r;
|
||
|
|
return 255 === i ? a ? NaN : o * (1 / 0) : 0 === i ? 1401298464324817e-60 * o * a : o * Math.pow(2, i - 150) * (a + 8388608)
|
||
|
|
}
|
||
|
|
t.writeFloatLE = e.bind(null, r),
|
||
|
|
t.writeFloatBE = e.bind(null, o),
|
||
|
|
t.readFloatLE = n.bind(null, i),
|
||
|
|
t.readFloatBE = n.bind(null, a)
|
||
|
|
}(),
|
||
|
|
"undefined" != typeof Float64Array ? function() {
|
||
|
|
var e = new Float64Array([-0])
|
||
|
|
, n = new Uint8Array(e.buffer)
|
||
|
|
, r = 128 === n[7];
|
||
|
|
function o(t, r, o) {
|
||
|
|
e[0] = t,
|
||
|
|
r[o] = n[0],
|
||
|
|
r[o + 1] = n[1],
|
||
|
|
r[o + 2] = n[2],
|
||
|
|
r[o + 3] = n[3],
|
||
|
|
r[o + 4] = n[4],
|
||
|
|
r[o + 5] = n[5],
|
||
|
|
r[o + 6] = n[6],
|
||
|
|
r[o + 7] = n[7]
|
||
|
|
}
|
||
|
|
function i(t, r, o) {
|
||
|
|
e[0] = t,
|
||
|
|
r[o] = n[7],
|
||
|
|
r[o + 1] = n[6],
|
||
|
|
r[o + 2] = n[5],
|
||
|
|
r[o + 3] = n[4],
|
||
|
|
r[o + 4] = n[3],
|
||
|
|
r[o + 5] = n[2],
|
||
|
|
r[o + 6] = n[1],
|
||
|
|
r[o + 7] = n[0]
|
||
|
|
}
|
||
|
|
function a(t, r) {
|
||
|
|
return n[0] = t[r],
|
||
|
|
n[1] = t[r + 1],
|
||
|
|
n[2] = t[r + 2],
|
||
|
|
n[3] = t[r + 3],
|
||
|
|
n[4] = t[r + 4],
|
||
|
|
n[5] = t[r + 5],
|
||
|
|
n[6] = t[r + 6],
|
||
|
|
n[7] = t[r + 7],
|
||
|
|
e[0]
|
||
|
|
}
|
||
|
|
function s(t, r) {
|
||
|
|
return n[7] = t[r],
|
||
|
|
n[6] = t[r + 1],
|
||
|
|
n[5] = t[r + 2],
|
||
|
|
n[4] = t[r + 3],
|
||
|
|
n[3] = t[r + 4],
|
||
|
|
n[2] = t[r + 5],
|
||
|
|
n[1] = t[r + 6],
|
||
|
|
n[0] = t[r + 7],
|
||
|
|
e[0]
|
||
|
|
}
|
||
|
|
t.writeDoubleLE = r ? o : i,
|
||
|
|
t.writeDoubleBE = r ? i : o,
|
||
|
|
t.readDoubleLE = r ? a : s,
|
||
|
|
t.readDoubleBE = r ? s : a
|
||
|
|
}() : function() {
|
||
|
|
function e(t, e, n, r, o, i) {
|
||
|
|
var a = r < 0 ? 1 : 0;
|
||
|
|
if (a && (r = -r),
|
||
|
|
0 === r)
|
||
|
|
t(0, o, i + e),
|
||
|
|
t(0 < 1 / r ? 0 : 2147483648, o, i + n);
|
||
|
|
else if (isNaN(r))
|
||
|
|
t(0, o, i + e),
|
||
|
|
t(2146959360, o, i + n);
|
||
|
|
else if (17976931348623157e292 < r)
|
||
|
|
t(0, o, i + e),
|
||
|
|
t((a << 31 | 2146435072) >>> 0, o, i + n);
|
||
|
|
else {
|
||
|
|
var s;
|
||
|
|
if (r < 22250738585072014e-324)
|
||
|
|
t((s = r / 5e-324) >>> 0, o, i + e),
|
||
|
|
t((a << 31 | s / 4294967296) >>> 0, o, i + n);
|
||
|
|
else {
|
||
|
|
var u = Math.floor(Math.log(r) / Math.LN2);
|
||
|
|
1024 === u && (u = 1023),
|
||
|
|
t(4503599627370496 * (s = r * Math.pow(2, -u)) >>> 0, o, i + e),
|
||
|
|
t((a << 31 | u + 1023 << 20 | 1048576 * s & 1048575) >>> 0, o, i + n)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function n(t, e, n, r, o) {
|
||
|
|
var i = t(r, o + e)
|
||
|
|
, a = t(r, o + n)
|
||
|
|
, s = 2 * (a >> 31) + 1
|
||
|
|
, u = a >>> 20 & 2047
|
||
|
|
, c = 4294967296 * (1048575 & a) + i;
|
||
|
|
return 2047 === u ? c ? NaN : s * (1 / 0) : 0 === u ? 5e-324 * s * c : s * Math.pow(2, u - 1075) * (c + 4503599627370496)
|
||
|
|
}
|
||
|
|
t.writeDoubleLE = e.bind(null, r, 0, 4),
|
||
|
|
t.writeDoubleBE = e.bind(null, o, 4, 0),
|
||
|
|
t.readDoubleLE = n.bind(null, i, 0, 4),
|
||
|
|
t.readDoubleBE = n.bind(null, a, 4, 0)
|
||
|
|
}(),
|
||
|
|
t
|
||
|
|
}
|
||
|
|
function r(t, e, n) {
|
||
|
|
e[n] = 255 & t,
|
||
|
|
e[n + 1] = t >>> 8 & 255,
|
||
|
|
e[n + 2] = t >>> 16 & 255,
|
||
|
|
e[n + 3] = t >>> 24
|
||
|
|
}
|
||
|
|
function o(t, e, n) {
|
||
|
|
e[n] = t >>> 24,
|
||
|
|
e[n + 1] = t >>> 16 & 255,
|
||
|
|
e[n + 2] = t >>> 8 & 255,
|
||
|
|
e[n + 3] = 255 & t
|
||
|
|
}
|
||
|
|
function i(t, e) {
|
||
|
|
return (t[e] | t[e + 1] << 8 | t[e + 2] << 16 | t[e + 3] << 24) >>> 0
|
||
|
|
}
|
||
|
|
function a(t, e) {
|
||
|
|
return (t[e] << 24 | t[e + 1] << 16 | t[e + 2] << 8 | t[e + 3]) >>> 0
|
||
|
|
}
|
||
|
|
e.exports = n(n)
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
5: [function(t, n, i) {
|
||
|
|
function r(t) {
|
||
|
|
try {
|
||
|
|
var n = eval("require")(t);
|
||
|
|
if (n && (n.length || Object.keys(n).length))
|
||
|
|
return n
|
||
|
|
} catch (t) {}
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
n.exports = r
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
6: [function(t, e) {
|
||
|
|
e.exports = function(t, e, n) {
|
||
|
|
var r = n || 8192
|
||
|
|
, o = r >>> 1
|
||
|
|
, i = null
|
||
|
|
, a = r;
|
||
|
|
return function(n) {
|
||
|
|
if (n < 1 || o < n)
|
||
|
|
return t(n);
|
||
|
|
r < a + n && (i = t(r),
|
||
|
|
a = 0);
|
||
|
|
var s = e.call(i, a, a += n);
|
||
|
|
return 7 & a && (a = 1 + (7 | a)),
|
||
|
|
s
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
7: [function(t, e, n) {
|
||
|
|
var r = n;
|
||
|
|
r.length = function(t) {
|
||
|
|
for (var e = 0, n = 0, r = 0; r < t.length; ++r)
|
||
|
|
(n = t.charCodeAt(r)) < 128 ? e += 1 : n < 2048 ? e += 2 : 55296 == (64512 & n) && 56320 == (64512 & t.charCodeAt(r + 1)) ? (++r,
|
||
|
|
e += 4) : e += 3;
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.read = function(t, e, n) {
|
||
|
|
if (n - e < 1)
|
||
|
|
return "";
|
||
|
|
for (var r, o = null, i = [], a = 0; e < n; )
|
||
|
|
(r = t[e++]) < 128 ? i[a++] = r : 191 < r && r < 224 ? i[a++] = (31 & r) << 6 | 63 & t[e++] : 239 < r && r < 365 ? (r = ((7 & r) << 18 | (63 & t[e++]) << 12 | (63 & t[e++]) << 6 | 63 & t[e++]) - 65536,
|
||
|
|
i[a++] = 55296 + (r >> 10),
|
||
|
|
i[a++] = 56320 + (1023 & r)) : i[a++] = (15 & r) << 12 | (63 & t[e++]) << 6 | 63 & t[e++],
|
||
|
|
8191 < a && ((o || (o = [])).push(String.fromCharCode.apply(String, i)),
|
||
|
|
a = 0);
|
||
|
|
return o ? (a && o.push(String.fromCharCode.apply(String, i.slice(0, a))),
|
||
|
|
o.join("")) : String.fromCharCode.apply(String, i.slice(0, a))
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.write = function(t, e, n) {
|
||
|
|
for (var r, o, i = n, a = 0; a < t.length; ++a)
|
||
|
|
(r = t.charCodeAt(a)) < 128 ? e[n++] = r : (r < 2048 ? e[n++] = r >> 6 | 192 : (55296 == (64512 & r) && 56320 == (64512 & (o = t.charCodeAt(a + 1))) ? (r = 65536 + ((1023 & r) << 10) + (1023 & o),
|
||
|
|
++a,
|
||
|
|
e[n++] = r >> 18 | 240,
|
||
|
|
e[n++] = r >> 12 & 63 | 128) : e[n++] = r >> 12 | 224,
|
||
|
|
e[n++] = r >> 6 & 63 | 128),
|
||
|
|
e[n++] = 63 & r | 128);
|
||
|
|
return n - i
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
8: [function(t, e, n) {
|
||
|
|
var r = n;
|
||
|
|
function o() {
|
||
|
|
r.Reader.n(r.BufferReader),
|
||
|
|
r.util.n()
|
||
|
|
}
|
||
|
|
r.build = "minimal",
|
||
|
|
r.Writer = t(16),
|
||
|
|
r.BufferWriter = t(17),
|
||
|
|
r.Reader = t(9),
|
||
|
|
r.BufferReader = t(10),
|
||
|
|
r.util = t(15),
|
||
|
|
r.rpc = t(12),
|
||
|
|
r.roots = t(11),
|
||
|
|
r.configure = o,
|
||
|
|
r.Writer.n(r.BufferWriter),
|
||
|
|
o()
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
10: 10,
|
||
|
|
11: 11,
|
||
|
|
12: 12,
|
||
|
|
15: 15,
|
||
|
|
16: 16,
|
||
|
|
17: 17,
|
||
|
|
9: 9
|
||
|
|
}],
|
||
|
|
9: [function(t, e) {
|
||
|
|
e.exports = s;
|
||
|
|
var n, r = t(15), o = r.LongBits, i = r.utf8;
|
||
|
|
function a(t, e) {
|
||
|
|
return RangeError("index out of range: " + t.pos + " + " + (e || 1) + " > " + t.len)
|
||
|
|
}
|
||
|
|
function s(t) {
|
||
|
|
this.buf = t,
|
||
|
|
this.pos = 0,
|
||
|
|
this.len = t.length
|
||
|
|
}
|
||
|
|
var u, c = "undefined" != typeof Uint8Array ? function(t) {
|
||
|
|
if (t instanceof Uint8Array || Array.isArray(t))
|
||
|
|
return new s(t);
|
||
|
|
throw Error("illegal buffer")
|
||
|
|
}
|
||
|
|
: function(t) {
|
||
|
|
if (Array.isArray(t))
|
||
|
|
return new s(t);
|
||
|
|
throw Error("illegal buffer")
|
||
|
|
}
|
||
|
|
;
|
||
|
|
function f() {
|
||
|
|
var t = new o(0,0)
|
||
|
|
, e = 0;
|
||
|
|
if (!(4 < this.len - this.pos)) {
|
||
|
|
for (; e < 3; ++e) {
|
||
|
|
if (this.pos >= this.len)
|
||
|
|
throw a(this);
|
||
|
|
if (t.lo = (t.lo | (127 & this.buf[this.pos]) << 7 * e) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return t
|
||
|
|
}
|
||
|
|
return t.lo = (t.lo | (127 & this.buf[this.pos++]) << 7 * e) >>> 0,
|
||
|
|
t
|
||
|
|
}
|
||
|
|
for (; e < 4; ++e)
|
||
|
|
if (t.lo = (t.lo | (127 & this.buf[this.pos]) << 7 * e) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return t;
|
||
|
|
if (t.lo = (t.lo | (127 & this.buf[this.pos]) << 28) >>> 0,
|
||
|
|
t.hi = (t.hi | (127 & this.buf[this.pos]) >> 4) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return t;
|
||
|
|
if (e = 0,
|
||
|
|
4 < this.len - this.pos) {
|
||
|
|
for (; e < 5; ++e)
|
||
|
|
if (t.hi = (t.hi | (127 & this.buf[this.pos]) << 7 * e + 3) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return t
|
||
|
|
} else
|
||
|
|
for (; e < 5; ++e) {
|
||
|
|
if (this.pos >= this.len)
|
||
|
|
throw a(this);
|
||
|
|
if (t.hi = (t.hi | (127 & this.buf[this.pos]) << 7 * e + 3) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return t
|
||
|
|
}
|
||
|
|
throw Error("invalid varint encoding")
|
||
|
|
}
|
||
|
|
function d(t, e) {
|
||
|
|
return (t[e - 4] | t[e - 3] << 8 | t[e - 2] << 16 | t[e - 1] << 24) >>> 0
|
||
|
|
}
|
||
|
|
function l() {
|
||
|
|
if (this.pos + 8 > this.len)
|
||
|
|
throw a(this, 8);
|
||
|
|
return new o(d(this.buf, this.pos += 4),d(this.buf, this.pos += 4))
|
||
|
|
}
|
||
|
|
s.create = r.Buffer ? function(t) {
|
||
|
|
return (s.create = function(t) {
|
||
|
|
return r.Buffer.isBuffer(t) ? new n(t) : c(t)
|
||
|
|
}
|
||
|
|
)(t)
|
||
|
|
}
|
||
|
|
: c,
|
||
|
|
s.prototype.i = r.Array.prototype.subarray || r.Array.prototype.slice,
|
||
|
|
s.prototype.uint32 = (u = 4294967295,
|
||
|
|
function() {
|
||
|
|
if (u = (127 & this.buf[this.pos]) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return u;
|
||
|
|
if (u = (u | (127 & this.buf[this.pos]) << 7) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return u;
|
||
|
|
if (u = (u | (127 & this.buf[this.pos]) << 14) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return u;
|
||
|
|
if (u = (u | (127 & this.buf[this.pos]) << 21) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return u;
|
||
|
|
if (u = (u | (15 & this.buf[this.pos]) << 28) >>> 0,
|
||
|
|
this.buf[this.pos++] < 128)
|
||
|
|
return u;
|
||
|
|
if ((this.pos += 5) > this.len)
|
||
|
|
throw this.pos = this.len,
|
||
|
|
a(this, 10);
|
||
|
|
return u
|
||
|
|
}
|
||
|
|
),
|
||
|
|
s.prototype.int32 = function() {
|
||
|
|
return 0 | this.uint32()
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.sint32 = function() {
|
||
|
|
var t = this.uint32();
|
||
|
|
return t >>> 1 ^ -(1 & t) | 0
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.bool = function() {
|
||
|
|
return 0 !== this.uint32()
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.fixed32 = function() {
|
||
|
|
if (this.pos + 4 > this.len)
|
||
|
|
throw a(this, 4);
|
||
|
|
return d(this.buf, this.pos += 4)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.sfixed32 = function() {
|
||
|
|
if (this.pos + 4 > this.len)
|
||
|
|
throw a(this, 4);
|
||
|
|
return 0 | d(this.buf, this.pos += 4)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.float = function() {
|
||
|
|
if (this.pos + 4 > this.len)
|
||
|
|
throw a(this, 4);
|
||
|
|
var t = r.float.readFloatLE(this.buf, this.pos);
|
||
|
|
return this.pos += 4,
|
||
|
|
t
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.double = function() {
|
||
|
|
if (this.pos + 8 > this.len)
|
||
|
|
throw a(this, 4);
|
||
|
|
var t = r.float.readDoubleLE(this.buf, this.pos);
|
||
|
|
return this.pos += 8,
|
||
|
|
t
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.bytes = function() {
|
||
|
|
var t = this.uint32()
|
||
|
|
, e = this.pos
|
||
|
|
, n = this.pos + t;
|
||
|
|
if (n > this.len)
|
||
|
|
throw a(this, t);
|
||
|
|
return this.pos += t,
|
||
|
|
Array.isArray(this.buf) ? this.buf.slice(e, n) : e === n ? new this.buf.constructor(0) : this.i.call(this.buf, e, n)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.string = function() {
|
||
|
|
var t = this.bytes();
|
||
|
|
return i.read(t, 0, t.length)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.skip = function(t) {
|
||
|
|
if ("number" == typeof t) {
|
||
|
|
if (this.pos + t > this.len)
|
||
|
|
throw a(this, t);
|
||
|
|
this.pos += t
|
||
|
|
} else
|
||
|
|
do {
|
||
|
|
if (this.pos >= this.len)
|
||
|
|
throw a(this)
|
||
|
|
} while (128 & this.buf[this.pos++]);
|
||
|
|
return this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.prototype.skipType = function(t) {
|
||
|
|
switch (t) {
|
||
|
|
case 0:
|
||
|
|
this.skip();
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
this.skip(8);
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
this.skip(this.uint32());
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
for (; 4 != (t = 7 & this.uint32()); )
|
||
|
|
this.skipType(t);
|
||
|
|
break;
|
||
|
|
case 5:
|
||
|
|
this.skip(4);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw Error("invalid wire type " + t + " at offset " + this.pos)
|
||
|
|
}
|
||
|
|
return this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
s.n = function(t) {
|
||
|
|
n = t;
|
||
|
|
var e = r.Long ? "toLong" : "toNumber";
|
||
|
|
r.merge(s.prototype, {
|
||
|
|
int64: function() {
|
||
|
|
return f.call(this)[e](!1)
|
||
|
|
},
|
||
|
|
uint64: function() {
|
||
|
|
return f.call(this)[e](!0)
|
||
|
|
},
|
||
|
|
sint64: function() {
|
||
|
|
return f.call(this).zzDecode()[e](!1)
|
||
|
|
},
|
||
|
|
fixed64: function() {
|
||
|
|
return l.call(this)[e](!0)
|
||
|
|
},
|
||
|
|
sfixed64: function() {
|
||
|
|
return l.call(this)[e](!1)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
15: 15
|
||
|
|
}],
|
||
|
|
10: [function(t, e) {
|
||
|
|
e.exports = o;
|
||
|
|
var n = t(9);
|
||
|
|
(o.prototype = Object.create(n.prototype)).constructor = o;
|
||
|
|
var r = t(15);
|
||
|
|
function o(t) {
|
||
|
|
n.call(this, t)
|
||
|
|
}
|
||
|
|
r.Buffer && (o.prototype.i = r.Buffer.prototype.slice),
|
||
|
|
o.prototype.string = function() {
|
||
|
|
var t = this.uint32();
|
||
|
|
return this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + t, this.len))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
15: 15,
|
||
|
|
9: 9
|
||
|
|
}],
|
||
|
|
11: [function(t, e) {
|
||
|
|
e.exports = {}
|
||
|
|
}
|
||
|
|
, {}],
|
||
|
|
12: [function(t, e, n) {
|
||
|
|
n.Service = t(13)
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
13: 13
|
||
|
|
}],
|
||
|
|
13: [function(t, e) {
|
||
|
|
e.exports = r;
|
||
|
|
var n = t(15);
|
||
|
|
function r(t, e, r) {
|
||
|
|
if ("function" != typeof t)
|
||
|
|
throw TypeError("rpcImpl must be a function");
|
||
|
|
n.EventEmitter.call(this),
|
||
|
|
this.rpcImpl = t,
|
||
|
|
this.requestDelimited = !!e,
|
||
|
|
this.responseDelimited = !!r
|
||
|
|
}
|
||
|
|
((r.prototype = Object.create(n.EventEmitter.prototype)).constructor = r).prototype.rpcCall = function t(e, r, o, i, a) {
|
||
|
|
if (!i)
|
||
|
|
throw TypeError("request must be specified");
|
||
|
|
var s = this;
|
||
|
|
if (!a)
|
||
|
|
return n.asPromise(t, s, e, r, o, i);
|
||
|
|
if (!s.rpcImpl)
|
||
|
|
return setTimeout((function() {
|
||
|
|
a(Error("already ended"))
|
||
|
|
}
|
||
|
|
), 0),
|
||
|
|
b;
|
||
|
|
try {
|
||
|
|
return s.rpcImpl(e, r[s.requestDelimited ? "encodeDelimited" : "encode"](i).finish(), (function(t, n) {
|
||
|
|
if (t)
|
||
|
|
return s.emit("error", t, e),
|
||
|
|
a(t);
|
||
|
|
if (null === n)
|
||
|
|
return s.end(!0),
|
||
|
|
b;
|
||
|
|
if (!(n instanceof o))
|
||
|
|
try {
|
||
|
|
n = o[s.responseDelimited ? "decodeDelimited" : "decode"](n)
|
||
|
|
} catch (t) {
|
||
|
|
return s.emit("error", t, e),
|
||
|
|
a(t)
|
||
|
|
}
|
||
|
|
return s.emit("data", n, e),
|
||
|
|
a(null, n)
|
||
|
|
}
|
||
|
|
))
|
||
|
|
} catch (t) {
|
||
|
|
return s.emit("error", t, e),
|
||
|
|
setTimeout((function() {
|
||
|
|
a(t)
|
||
|
|
}
|
||
|
|
), 0),
|
||
|
|
b
|
||
|
|
}
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.end = function(t) {
|
||
|
|
return this.rpcImpl && (t || this.rpcImpl(null, null, null),
|
||
|
|
this.rpcImpl = null,
|
||
|
|
this.emit("end").off()),
|
||
|
|
this
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
15: 15
|
||
|
|
}],
|
||
|
|
14: [function(t, e) {
|
||
|
|
e.exports = r;
|
||
|
|
var n = t(15);
|
||
|
|
function r(t, e) {
|
||
|
|
this.lo = t >>> 0,
|
||
|
|
this.hi = e >>> 0
|
||
|
|
}
|
||
|
|
var o = r.zero = new r(0,0);
|
||
|
|
o.toNumber = function() {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
,
|
||
|
|
o.zzEncode = o.zzDecode = function() {
|
||
|
|
return this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
o.length = function() {
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var i = r.zeroHash = "\0\0\0\0\0\0\0\0";
|
||
|
|
r.fromNumber = function(t) {
|
||
|
|
if (0 === t)
|
||
|
|
return o;
|
||
|
|
var e = t < 0;
|
||
|
|
e && (t = -t);
|
||
|
|
var n = t >>> 0
|
||
|
|
, i = (t - n) / 4294967296 >>> 0;
|
||
|
|
return e && (i = ~i >>> 0,
|
||
|
|
n = ~n >>> 0,
|
||
|
|
4294967295 < ++n && (n = 0,
|
||
|
|
4294967295 < ++i && (i = 0))),
|
||
|
|
new r(n,i)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.from = function(t) {
|
||
|
|
if ("number" == typeof t)
|
||
|
|
return r.fromNumber(t);
|
||
|
|
if (n.isString(t)) {
|
||
|
|
if (!n.Long)
|
||
|
|
return r.fromNumber(parseInt(t, 10));
|
||
|
|
t = n.Long.fromString(t)
|
||
|
|
}
|
||
|
|
return t.low || t.high ? new r(t.low >>> 0,t.high >>> 0) : o
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.toNumber = function(t) {
|
||
|
|
if (!t && this.hi >>> 31) {
|
||
|
|
var e = 1 + ~this.lo >>> 0
|
||
|
|
, n = ~this.hi >>> 0;
|
||
|
|
return e || (n = n + 1 >>> 0),
|
||
|
|
-(e + 4294967296 * n)
|
||
|
|
}
|
||
|
|
return this.lo + 4294967296 * this.hi
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.toLong = function(t) {
|
||
|
|
return n.Long ? new n.Long(0 | this.lo,0 | this.hi,!!t) : {
|
||
|
|
low: 0 | this.lo,
|
||
|
|
high: 0 | this.hi,
|
||
|
|
unsigned: !!t
|
||
|
|
}
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var a = String.prototype.charCodeAt;
|
||
|
|
r.fromHash = function(t) {
|
||
|
|
return t === i ? o : new r((a.call(t, 0) | a.call(t, 1) << 8 | a.call(t, 2) << 16 | a.call(t, 3) << 24) >>> 0,(a.call(t, 4) | a.call(t, 5) << 8 | a.call(t, 6) << 16 | a.call(t, 7) << 24) >>> 0)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.toHash = function() {
|
||
|
|
return String.fromCharCode(255 & this.lo, this.lo >>> 8 & 255, this.lo >>> 16 & 255, this.lo >>> 24, 255 & this.hi, this.hi >>> 8 & 255, this.hi >>> 16 & 255, this.hi >>> 24)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.zzEncode = function() {
|
||
|
|
var t = this.hi >> 31;
|
||
|
|
return this.hi = ((this.hi << 1 | this.lo >>> 31) ^ t) >>> 0,
|
||
|
|
this.lo = (this.lo << 1 ^ t) >>> 0,
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.zzDecode = function() {
|
||
|
|
var t = -(1 & this.lo);
|
||
|
|
return this.lo = ((this.lo >>> 1 | this.hi << 31) ^ t) >>> 0,
|
||
|
|
this.hi = (this.hi >>> 1 ^ t) >>> 0,
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.prototype.length = function() {
|
||
|
|
var t = this.lo
|
||
|
|
, e = (this.lo >>> 28 | this.hi << 4) >>> 0
|
||
|
|
, n = this.hi >>> 24;
|
||
|
|
return 0 === n ? 0 === e ? t < 16384 ? t < 128 ? 1 : 2 : t < 2097152 ? 3 : 4 : e < 16384 ? e < 128 ? 5 : 6 : e < 2097152 ? 7 : 8 : n < 128 ? 9 : 10
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
15: 15
|
||
|
|
}],
|
||
|
|
15: [function(t, e, n) {
|
||
|
|
var r = n;
|
||
|
|
function o(t, e, n) {
|
||
|
|
for (var r = Object.keys(e), o = 0; o < r.length; ++o)
|
||
|
|
t[r[o]] !== b && n || (t[r[o]] = e[r[o]]);
|
||
|
|
return t
|
||
|
|
}
|
||
|
|
function i(t) {
|
||
|
|
function e(t, n) {
|
||
|
|
if (!(this instanceof e))
|
||
|
|
return new e(t,n);
|
||
|
|
Object.defineProperty(this, "message", {
|
||
|
|
get: function() {
|
||
|
|
return t
|
||
|
|
}
|
||
|
|
}),
|
||
|
|
Error.captureStackTrace ? Error.captureStackTrace(this, e) : Object.defineProperty(this, "stack", {
|
||
|
|
value: Error().stack || ""
|
||
|
|
}),
|
||
|
|
n && o(this, n)
|
||
|
|
}
|
||
|
|
return (e.prototype = Object.create(Error.prototype)).constructor = e,
|
||
|
|
Object.defineProperty(e.prototype, "name", {
|
||
|
|
get: function() {
|
||
|
|
return t
|
||
|
|
}
|
||
|
|
}),
|
||
|
|
e.prototype.toString = function() {
|
||
|
|
return this.name + ": " + this.message
|
||
|
|
}
|
||
|
|
,
|
||
|
|
e
|
||
|
|
}
|
||
|
|
r.asPromise = t(1),
|
||
|
|
r.base64 = t(2),
|
||
|
|
r.EventEmitter = t(3),
|
||
|
|
r.float = t(4),
|
||
|
|
r.inquire = t(5),
|
||
|
|
r.utf8 = t(7),
|
||
|
|
r.pool = t(6),
|
||
|
|
r.LongBits = t(14),
|
||
|
|
r.global = "undefined" != typeof window && window || void 0 !== global && global || "undefined" != typeof self && self || this,
|
||
|
|
r.emptyArray = Object.freeze ? Object.freeze([]) : [],
|
||
|
|
r.emptyObject = Object.freeze ? Object.freeze({}) : {},
|
||
|
|
r.isNode = !!(r.global.process && r.global.process.versions && r.global.process.versions.node),
|
||
|
|
r.isInteger = Number.isInteger || function(t) {
|
||
|
|
return "number" == typeof t && isFinite(t) && Math.floor(t) === t
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.isString = function(t) {
|
||
|
|
return "string" == typeof t || t instanceof String
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.isObject = function(t) {
|
||
|
|
return t && "object" == _typeof(t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.isset = r.isSet = function(t, e) {
|
||
|
|
var n = t[e];
|
||
|
|
return !(null == n || !t.hasOwnProperty(e)) && ("object" != _typeof(n) || 0 < (Array.isArray(n) ? n.length : Object.keys(n).length))
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.Buffer = function() {
|
||
|
|
try {
|
||
|
|
var t = r.inquire("buffer").Buffer;
|
||
|
|
return t.prototype.utf8Write ? t : null
|
||
|
|
} catch (t) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
}(),
|
||
|
|
r.r = null,
|
||
|
|
r.u = null,
|
||
|
|
r.newBuffer = function(t) {
|
||
|
|
return "number" == typeof t ? r.Buffer ? r.u(t) : new r.Array(t) : r.Buffer ? r.r(t) : "undefined" == typeof Uint8Array ? t : new Uint8Array(t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.Array = "undefined" != typeof Uint8Array ? Uint8Array : Array,
|
||
|
|
r.Long = r.global.dcodeIO && r.global.dcodeIO.Long || r.global.Long || r.inquire("long"),
|
||
|
|
r.key2Re = /^true|false|0|1$/,
|
||
|
|
r.key32Re = /^-?(?:0|[1-9][0-9]*)$/,
|
||
|
|
r.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/,
|
||
|
|
r.longToHash = function(t) {
|
||
|
|
return t ? r.LongBits.from(t).toHash() : r.LongBits.zeroHash
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.longFromHash = function(t, e) {
|
||
|
|
var n = r.LongBits.fromHash(t);
|
||
|
|
return r.Long ? r.Long.fromBits(n.lo, n.hi, e) : n.toNumber(!!e)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.merge = o,
|
||
|
|
r.lcFirst = function(t) {
|
||
|
|
return t.charAt(0).toLowerCase() + t.substring(1)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.newError = i,
|
||
|
|
r.ProtocolError = i("ProtocolError"),
|
||
|
|
r.oneOfGetter = function(t) {
|
||
|
|
for (var e = {}, n = 0; n < t.length; ++n)
|
||
|
|
e[t[n]] = 1;
|
||
|
|
return function() {
|
||
|
|
for (var t = Object.keys(this), n = t.length - 1; -1 < n; --n)
|
||
|
|
if (1 === e[t[n]] && this[t[n]] !== b && null !== this[t[n]])
|
||
|
|
return t[n]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.oneOfSetter = function(t) {
|
||
|
|
return function(e) {
|
||
|
|
for (var n = 0; n < t.length; ++n)
|
||
|
|
t[n] !== e && delete this[t[n]]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.toJSONOptions = {
|
||
|
|
longs: String,
|
||
|
|
enums: String,
|
||
|
|
bytes: String,
|
||
|
|
json: !0
|
||
|
|
},
|
||
|
|
r.n = function() {
|
||
|
|
var t = r.Buffer;
|
||
|
|
t ? (r.r = t.from !== Uint8Array.from && t.from || function(e, n) {
|
||
|
|
return new t(e,n)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.u = t.allocUnsafe || function(e) {
|
||
|
|
return new t(e)
|
||
|
|
}
|
||
|
|
) : r.r = r.u = null
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
1: 1,
|
||
|
|
14: 14,
|
||
|
|
2: 2,
|
||
|
|
3: 3,
|
||
|
|
4: 4,
|
||
|
|
5: 5,
|
||
|
|
6: 6,
|
||
|
|
7: 7
|
||
|
|
}],
|
||
|
|
16: [function(t, e) {
|
||
|
|
e.exports = f;
|
||
|
|
var n, r = t(15), o = r.LongBits, i = r.base64, a = r.utf8;
|
||
|
|
function s(t, e, n) {
|
||
|
|
this.fn = t,
|
||
|
|
this.len = e,
|
||
|
|
this.next = b,
|
||
|
|
this.val = n
|
||
|
|
}
|
||
|
|
function u() {}
|
||
|
|
function c(t) {
|
||
|
|
this.head = t.head,
|
||
|
|
this.tail = t.tail,
|
||
|
|
this.len = t.len,
|
||
|
|
this.next = t.states
|
||
|
|
}
|
||
|
|
function f() {
|
||
|
|
this.len = 0,
|
||
|
|
this.head = new s(u,0,0),
|
||
|
|
this.tail = this.head,
|
||
|
|
this.states = null
|
||
|
|
}
|
||
|
|
function d(t, e, n) {
|
||
|
|
e[n] = 255 & t
|
||
|
|
}
|
||
|
|
function l(t, e) {
|
||
|
|
this.len = t,
|
||
|
|
this.next = b,
|
||
|
|
this.val = e
|
||
|
|
}
|
||
|
|
function p(t, e, n) {
|
||
|
|
for (; t.hi; )
|
||
|
|
e[n++] = 127 & t.lo | 128,
|
||
|
|
t.lo = (t.lo >>> 7 | t.hi << 25) >>> 0,
|
||
|
|
t.hi >>>= 7;
|
||
|
|
for (; 127 < t.lo; )
|
||
|
|
e[n++] = 127 & t.lo | 128,
|
||
|
|
t.lo = t.lo >>> 7;
|
||
|
|
e[n++] = t.lo
|
||
|
|
}
|
||
|
|
function h(t, e, n) {
|
||
|
|
e[n] = 255 & t,
|
||
|
|
e[n + 1] = t >>> 8 & 255,
|
||
|
|
e[n + 2] = t >>> 16 & 255,
|
||
|
|
e[n + 3] = t >>> 24
|
||
|
|
}
|
||
|
|
f.create = r.Buffer ? function() {
|
||
|
|
return (f.create = function() {
|
||
|
|
return new n
|
||
|
|
}
|
||
|
|
)()
|
||
|
|
}
|
||
|
|
: function() {
|
||
|
|
return new f
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.alloc = function(t) {
|
||
|
|
return new r.Array(t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
r.Array !== Array && (f.alloc = r.pool(f.alloc, r.Array.prototype.subarray)),
|
||
|
|
f.prototype.e = function(t, e, n) {
|
||
|
|
return this.tail = this.tail.next = new s(t,e,n),
|
||
|
|
this.len += e,
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
(l.prototype = Object.create(s.prototype)).fn = function(t, e, n) {
|
||
|
|
for (; 127 < t; )
|
||
|
|
e[n++] = 127 & t | 128,
|
||
|
|
t >>>= 7;
|
||
|
|
e[n] = t
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.uint32 = function(t) {
|
||
|
|
return this.len += (this.tail = this.tail.next = new l((t >>>= 0) < 128 ? 1 : t < 16384 ? 2 : t < 2097152 ? 3 : t < 268435456 ? 4 : 5,t)).len,
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.int32 = function(t) {
|
||
|
|
return t < 0 ? this.e(p, 10, o.fromNumber(t)) : this.uint32(t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.sint32 = function(t) {
|
||
|
|
return this.uint32((t << 1 ^ t >> 31) >>> 0)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.int64 = f.prototype.uint64 = function(t) {
|
||
|
|
var e = o.from(t);
|
||
|
|
return this.e(p, e.length(), e)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.sint64 = function(t) {
|
||
|
|
var e = o.from(t).zzEncode();
|
||
|
|
return this.e(p, e.length(), e)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.bool = function(t) {
|
||
|
|
return this.e(d, 1, t ? 1 : 0)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.sfixed32 = f.prototype.fixed32 = function(t) {
|
||
|
|
return this.e(h, 4, t >>> 0)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.sfixed64 = f.prototype.fixed64 = function(t) {
|
||
|
|
var e = o.from(t);
|
||
|
|
return this.e(h, 4, e.lo).e(h, 4, e.hi)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.float = function(t) {
|
||
|
|
return this.e(r.float.writeFloatLE, 4, t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.double = function(t) {
|
||
|
|
return this.e(r.float.writeDoubleLE, 8, t)
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var m = r.Array.prototype.set ? function(t, e, n) {
|
||
|
|
e.set(t, n)
|
||
|
|
}
|
||
|
|
: function(t, e, n) {
|
||
|
|
for (var r = 0; r < t.length; ++r)
|
||
|
|
e[n + r] = t[r]
|
||
|
|
}
|
||
|
|
;
|
||
|
|
f.prototype.bytes = function(t) {
|
||
|
|
var e = t.length >>> 0;
|
||
|
|
if (!e)
|
||
|
|
return this.e(d, 1, 0);
|
||
|
|
if (r.isString(t)) {
|
||
|
|
var n = f.alloc(e = i.length(t));
|
||
|
|
i.decode(t, n, 0),
|
||
|
|
t = n
|
||
|
|
}
|
||
|
|
return this.uint32(e).e(m, e, t)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.string = function(t) {
|
||
|
|
var e = a.length(t);
|
||
|
|
return e ? this.uint32(e).e(a.write, e, t) : this.e(d, 1, 0)
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.fork = function() {
|
||
|
|
return this.states = new c(this),
|
||
|
|
this.head = this.tail = new s(u,0,0),
|
||
|
|
this.len = 0,
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.reset = function() {
|
||
|
|
return this.states ? (this.head = this.states.head,
|
||
|
|
this.tail = this.states.tail,
|
||
|
|
this.len = this.states.len,
|
||
|
|
this.states = this.states.next) : (this.head = this.tail = new s(u,0,0),
|
||
|
|
this.len = 0),
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.ldelim = function() {
|
||
|
|
var t = this.head
|
||
|
|
, e = this.tail
|
||
|
|
, n = this.len;
|
||
|
|
return this.reset().uint32(n),
|
||
|
|
n && (this.tail.next = t.next,
|
||
|
|
this.tail = e,
|
||
|
|
this.len += n),
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.prototype.finish = function() {
|
||
|
|
for (var t = this.head.next, e = this.constructor.alloc(this.len), n = 0; t; )
|
||
|
|
t.fn(t.val, e, n),
|
||
|
|
n += t.len,
|
||
|
|
t = t.next;
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
,
|
||
|
|
f.n = function(t) {
|
||
|
|
n = t
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
15: 15
|
||
|
|
}],
|
||
|
|
17: [function(t, e) {
|
||
|
|
e.exports = i;
|
||
|
|
var n = t(16);
|
||
|
|
(i.prototype = Object.create(n.prototype)).constructor = i;
|
||
|
|
var r = t(15)
|
||
|
|
, o = r.Buffer;
|
||
|
|
function i() {
|
||
|
|
n.call(this)
|
||
|
|
}
|
||
|
|
i.alloc = function(t) {
|
||
|
|
return (i.alloc = r.u)(t)
|
||
|
|
}
|
||
|
|
;
|
||
|
|
var a = o && o.prototype instanceof Uint8Array && "set" === o.prototype.set.name ? function(t, e, n) {
|
||
|
|
e.set(t, n)
|
||
|
|
}
|
||
|
|
: function(t, e, n) {
|
||
|
|
if (t.copy)
|
||
|
|
t.copy(e, n, 0, t.length);
|
||
|
|
else
|
||
|
|
for (var r = 0; r < t.length; )
|
||
|
|
e[n++] = t[r++]
|
||
|
|
}
|
||
|
|
;
|
||
|
|
function s(t, e, n) {
|
||
|
|
t.length < 40 ? r.utf8.write(t, e, n) : e.utf8Write(t, n)
|
||
|
|
}
|
||
|
|
i.prototype.bytes = function(t) {
|
||
|
|
r.isString(t) && (t = r.r(t, "base64"));
|
||
|
|
var e = t.length >>> 0;
|
||
|
|
return this.uint32(e),
|
||
|
|
e && this.e(a, e, t),
|
||
|
|
this
|
||
|
|
}
|
||
|
|
,
|
||
|
|
i.prototype.string = function(t) {
|
||
|
|
var e = o.byteLength(t);
|
||
|
|
return this.uint32(e),
|
||
|
|
e && this.e(s, e, t),
|
||
|
|
this
|
||
|
|
}
|
||
|
|
}
|
||
|
|
, {
|
||
|
|
15: 15,
|
||
|
|
16: 16
|
||
|
|
}]
|
||
|
|
},
|
||
|
|
u = {},
|
||
|
|
t = [8],
|
||
|
|
n = function t(e) {
|
||
|
|
var n = u[e];
|
||
|
|
return n || r[e][0].call(n = u[e] = {
|
||
|
|
exports: {}
|
||
|
|
}, t, n, n.exports),
|
||
|
|
n.exports
|
||
|
|
};
|
||
|
|
window.nnnnnn = n
|
||
|
|
}()
|
||
|
|
|
||
|
|
yt = {
|
||
|
|
Reader: window.nnnnnn(9)
|
||
|
|
}
|
||
|
|
yt.Reader.n();
|
||
|
|
|
||
|
|
var zdecode = function(t, n, count) {
|
||
|
|
window.nnnnnn(9).n();
|
||
|
|
if (count == 1){
|
||
|
|
var e = {
|
||
|
|
"1": [
|
||
|
|
"command",
|
||
|
|
"string",
|
||
|
|
""
|
||
|
|
],
|
||
|
|
"2": [
|
||
|
|
"protocol",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"3": [
|
||
|
|
"errorCode",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"4": [
|
||
|
|
"bizCode",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"5": [
|
||
|
|
"bizErrorMsg",
|
||
|
|
"string",
|
||
|
|
""
|
||
|
|
],
|
||
|
|
"6": [
|
||
|
|
"compress",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"9": [
|
||
|
|
"extension",
|
||
|
|
"bytes",
|
||
|
|
[]
|
||
|
|
],
|
||
|
|
"10": [
|
||
|
|
"body",
|
||
|
|
"bytes",
|
||
|
|
[]
|
||
|
|
],
|
||
|
|
"11": [
|
||
|
|
"downstreamSeq",
|
||
|
|
"uint64",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"12": [
|
||
|
|
"conId",
|
||
|
|
"uint64",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"13": [
|
||
|
|
"ctxId",
|
||
|
|
"uint64",
|
||
|
|
0
|
||
|
|
]
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else if (count == 2){
|
||
|
|
var e = {
|
||
|
|
"1": [
|
||
|
|
"uid",
|
||
|
|
"string",
|
||
|
|
""
|
||
|
|
],
|
||
|
|
"2": [
|
||
|
|
"titanid",
|
||
|
|
"string",
|
||
|
|
""
|
||
|
|
],
|
||
|
|
"3": [
|
||
|
|
"os",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"4": [
|
||
|
|
"bizType",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"5": [
|
||
|
|
"msgId",
|
||
|
|
"string",
|
||
|
|
""
|
||
|
|
],
|
||
|
|
"6": [
|
||
|
|
"payload",
|
||
|
|
"bytes",
|
||
|
|
[]
|
||
|
|
],
|
||
|
|
"7": [
|
||
|
|
"additionalMap",
|
||
|
|
"{string,string",
|
||
|
|
null
|
||
|
|
],
|
||
|
|
"8": [
|
||
|
|
"subType",
|
||
|
|
"uint32",
|
||
|
|
0
|
||
|
|
],
|
||
|
|
"9": [
|
||
|
|
"timestamp",
|
||
|
|
"uint64",
|
||
|
|
0
|
||
|
|
]
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
var e = {
|
||
|
|
"1": [
|
||
|
|
"$1",
|
||
|
|
"string",
|
||
|
|
null
|
||
|
|
],
|
||
|
|
"2": [
|
||
|
|
"$2",
|
||
|
|
"string",
|
||
|
|
null
|
||
|
|
]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var zzz = {
|
||
|
|
"command": "",
|
||
|
|
"protocol": 0,
|
||
|
|
"errorCode": 0,
|
||
|
|
"bizCode": 0,
|
||
|
|
"bizErrorMsg": "",
|
||
|
|
"compress": 0,
|
||
|
|
"extension": new Uint8Array(0),
|
||
|
|
"body": new Uint8Array(0),
|
||
|
|
"downstreamSeq": 0,
|
||
|
|
"conId": 0,
|
||
|
|
"ctxId": 0
|
||
|
|
}
|
||
|
|
t instanceof yt.Reader || (t = yt.Reader.create(t));
|
||
|
|
for (var i = void 0 === n ? t.len : t.pos + n, a = zzz; t.pos < i; ) {
|
||
|
|
var s = t.uint32()
|
||
|
|
, u = s >>> 3;
|
||
|
|
if (0 < u && e[u]) {
|
||
|
|
var c = e[u][0]
|
||
|
|
, f = e[u][1];
|
||
|
|
if ("{" === f.charAt(0))
|
||
|
|
(a[c] = {}),
|
||
|
|
u = zdecode(t, t.uint32(), 3),
|
||
|
|
a[c][u.$1] = u.$2;
|
||
|
|
else if ("[" === f.charAt(0) || "<" === f.charAt(0))
|
||
|
|
if (f = f.substring(1),
|
||
|
|
a[c] && a[c].length || (a[c] = []),
|
||
|
|
void 0 !== bt[f] && 2 == (7 & s))
|
||
|
|
for (var d = t.uint32() + t.pos; t.pos < d; )
|
||
|
|
a[c].push(Object.call(t, f));
|
||
|
|
else
|
||
|
|
a[c].push(Object.call(t, f));
|
||
|
|
else
|
||
|
|
a[c] = window.nnnnnn(9).prototype[f].call(t)
|
||
|
|
} else
|
||
|
|
t.skipType(7 & s)
|
||
|
|
}
|
||
|
|
return a
|
||
|
|
}
|
||
|
|
|
||
|
|
var Tt = {};
|
||
|
|
|
||
|
|
!function(t) {
|
||
|
|
var e, n, r, o = String.fromCharCode;
|
||
|
|
function i(t) {
|
||
|
|
for (var e, n, r = [], o = 0, i = t.length; o < i; )
|
||
|
|
(e = t.charCodeAt(o++)) >= 55296 && e <= 56319 && o < i ? 56320 == (64512 & (n = t.charCodeAt(o++))) ? r.push(((1023 & e) << 10) + (1023 & n) + 65536) : (r.push(e),
|
||
|
|
o--) : r.push(e);
|
||
|
|
return r
|
||
|
|
}
|
||
|
|
function a(t) {
|
||
|
|
if (t >= 55296 && t <= 57343)
|
||
|
|
throw Error("Lone surrogate U+" + t.toString(16).toUpperCase() + " is not a scalar value")
|
||
|
|
}
|
||
|
|
function s(t, e) {
|
||
|
|
return o(t >> e & 63 | 128)
|
||
|
|
}
|
||
|
|
function u(t) {
|
||
|
|
if (0 == (4294967168 & t))
|
||
|
|
return o(t);
|
||
|
|
var e = "";
|
||
|
|
return 0 == (4294965248 & t) ? e = o(t >> 6 & 31 | 192) : 0 == (4294901760 & t) ? (a(t),
|
||
|
|
e = o(t >> 12 & 15 | 224),
|
||
|
|
e += s(t, 6)) : 0 == (4292870144 & t) && (e = o(t >> 18 & 7 | 240),
|
||
|
|
e += s(t, 12),
|
||
|
|
e += s(t, 6)),
|
||
|
|
e += o(63 & t | 128)
|
||
|
|
}
|
||
|
|
function c() {
|
||
|
|
if (r >= n)
|
||
|
|
throw Error("Invalid byte index");
|
||
|
|
var t = 255 & e[r];
|
||
|
|
if (r++,
|
||
|
|
128 == (192 & t))
|
||
|
|
return 63 & t;
|
||
|
|
throw Error("Invalid continuation byte")
|
||
|
|
}
|
||
|
|
function f() {
|
||
|
|
var t, o;
|
||
|
|
if (r > n)
|
||
|
|
throw Error("Invalid byte index");
|
||
|
|
if (r == n)
|
||
|
|
return !1;
|
||
|
|
if (t = 255 & e[r],
|
||
|
|
r++,
|
||
|
|
0 == (128 & t))
|
||
|
|
return t;
|
||
|
|
if (192 == (224 & t)) {
|
||
|
|
if ((o = (31 & t) << 6 | c()) >= 128)
|
||
|
|
return o;
|
||
|
|
throw Error("Invalid continuation byte")
|
||
|
|
}
|
||
|
|
if (224 == (240 & t)) {
|
||
|
|
if ((o = (15 & t) << 12 | c() << 6 | c()) >= 2048)
|
||
|
|
return a(o),
|
||
|
|
o;
|
||
|
|
throw Error("Invalid continuation byte")
|
||
|
|
}
|
||
|
|
if (240 == (248 & t) && (o = (7 & t) << 18 | c() << 12 | c() << 6 | c()) >= 65536 && o <= 1114111)
|
||
|
|
return o;
|
||
|
|
throw Error("Invalid UTF-8 detected")
|
||
|
|
}
|
||
|
|
t.version = "3.0.0",
|
||
|
|
t.encode = function(t) {
|
||
|
|
for (var e = i(t), n = e.length, r = -1, o = ""; ++r < n; )
|
||
|
|
o += u(e[r]);
|
||
|
|
return o
|
||
|
|
}
|
||
|
|
,
|
||
|
|
t.decode = function(t) {
|
||
|
|
e = i(t),
|
||
|
|
n = e.length,
|
||
|
|
r = 0;
|
||
|
|
for (var a, s = []; !1 !== (a = f()); )
|
||
|
|
s.push(a);
|
||
|
|
return function(t) {
|
||
|
|
for (var e, n = t.length, r = -1, i = ""; ++r < n; )
|
||
|
|
(e = t[r]) > 65535 && (i += o((e -= 65536) >>> 10 & 1023 | 55296),
|
||
|
|
e = 56320 | 1023 & e),
|
||
|
|
i += o(e);
|
||
|
|
return i
|
||
|
|
}(s)
|
||
|
|
}
|
||
|
|
}(Tt)
|
||
|
|
|
||
|
|
Qt = function (t, e=!0){
|
||
|
|
const n = t.length;
|
||
|
|
let r = "";
|
||
|
|
for (let e = 0; e < n; e++)
|
||
|
|
r += String.fromCharCode(t[e]);
|
||
|
|
return e && (r = Tt.decode(r),
|
||
|
|
r = r.replace(/\n/g, "\\\\n").replace(/\r/g, "\\\\r").replace(/\t/g, "\\\\t").replace(/\u2028/g, "")),
|
||
|
|
Yt(r, r)
|
||
|
|
}
|
||
|
|
|
||
|
|
Yt = function (t, e){
|
||
|
|
if ("string" != typeof t)
|
||
|
|
return e;
|
||
|
|
let n;
|
||
|
|
try {
|
||
|
|
n = JSON.parse(t) || e
|
||
|
|
} catch (t) {
|
||
|
|
n = e
|
||
|
|
}
|
||
|
|
return n
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function dencode_data(decodedString){
|
||
|
|
var decodedString = atob(decodedString)
|
||
|
|
let uint8Array = [];
|
||
|
|
|
||
|
|
for (let i = 0; i < decodedString.length; i++) {
|
||
|
|
uint8Array[i] = decodedString.charCodeAt(i);
|
||
|
|
};
|
||
|
|
|
||
|
|
let s = new Uint8Array(uint8Array.slice(16));
|
||
|
|
|
||
|
|
var zzz = zdecode(s, undefined, 1)
|
||
|
|
var ccc = window.wang(450).ungzip(zzz["body"].length? zzz["body"]: zzz["extension"])
|
||
|
|
var ddd = zdecode(ccc, undefined, 2)
|
||
|
|
var text = Qt(ddd["payload"])
|
||
|
|
console.log(text)
|
||
|
|
return text
|
||
|
|
}
|
||
|
|
|
||
|
|
//console.log(dencode_data("AAoAZgAAAAAAAAAAAAABQBABUpsCH4sIAAAAAAAAAG2Qz0rDQBDG0SrUgCA5iHiS9SY9ZLPdpMkTePTgPaztGIu7Sc1MkFJyEnwKbwp66jM6G/9QtKdhmO/3zTcTDLNEZ5lU0cn+2fvLzsWxTLWSiY6jVEl9DtNppNOJite7K9EAtpZELup7MfLdoq4QuHfG2gKXSOAKhyUPHSCakmcrcdvUztemtl77JWNJO59xOxbdSFC9IfBm3sF79hIZJSrRahL/Qj+Ze3a5YGocMYHlN7D1BKZnhozf9Ag3BZKhFkUuu87f8tAC0n88ZYpMUwJ5bnsm57D4m6vLT4MDXtHQ9dxBeLjhqeL8KBjyVyqCahbuVa21eRAMECgc4F18+br+eH5SV299+QQzLJ50oQEAAHABMAFomtTgmAQKFHRpdGFuLm5vdGlmeURhdGFMaXRl"))
|