Last active
October 16, 2023 20:04
-
-
Save iGerman00/df6c3b6d56c1df30fb85658a0a96999c to your computer and use it in GitHub Desktop.
Netflix' Cadmium player v6.0042.369.911; modded with 5.1 audio support (tested on Safari), bitrate selection menu re-enabled (Ctrl+Alt+Shift+B) and all audio tracks visible. Modifications are marked with a "// DOLBY-MOD" comment. To use simply make a local override of the cadmium-playercore.js response in your browser.
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
U_XqO[287568] = (function () { | |
var p$m = 2; | |
for (; p$m !== 9; ) { | |
switch (p$m) { | |
case 2: | |
p$m = typeof globalThis === "\x6f\u0062\u006a\u0065\u0063\x74" ? 1 : 5; | |
break; | |
case 1: | |
return globalThis; | |
break; | |
case 5: | |
var Q4l; | |
try { | |
var Y1Y = 2; | |
for (; Y1Y !== 6; ) { | |
switch (Y1Y) { | |
case 2: | |
Object[ | |
"\x64\x65\x66\u0069\u006e\u0065\u0050\x72\x6f\u0070\x65\x72\x74\x79" | |
]( | |
Object["\u0070\u0072\x6f\u0074\u006f\u0074\x79\x70\x65"], | |
"\u0047\u0073\x42\u005a\u0067", | |
{ | |
"\x67\x65\x74": function () { | |
var b_2 = 2; | |
for (; b_2 !== 1; ) { | |
switch (b_2) { | |
case 2: | |
return this; | |
break; | |
} | |
} | |
}, | |
"\x63\x6f\x6e\x66\x69\x67\x75\x72\x61\x62\x6c\x65": true, | |
} | |
); | |
Q4l = GsBZg; | |
Q4l["\u0042\x6b\x6b\u0064\x58"] = Q4l; | |
Y1Y = 4; | |
break; | |
case 4: | |
Y1Y = | |
typeof BkkdX === | |
"\u0075\x6e\x64\u0065\u0066\x69\x6e\u0065\u0064" | |
? 3 | |
: 9; | |
break; | |
case 3: | |
throw ""; | |
Y1Y = 9; | |
break; | |
case 8: | |
var G76 = Object["\x70\x72\x6f\x74\x6f\x74\u0079\x70\x65"]; | |
delete G76["\u0047\u0073\x42\u005a\x67"]; | |
Y1Y = 6; | |
break; | |
case 9: | |
delete Q4l["\u0042\u006b\u006b\u0064\u0058"]; | |
Y1Y = 8; | |
break; | |
} | |
} | |
} catch (K4_) { | |
Q4l = window; | |
} | |
return Q4l; | |
break; | |
} | |
} | |
})(); | |
U_XqO.u_o = function () { | |
return typeof U_XqO[859].e9_DZNl === "function" | |
? U_XqO[859].e9_DZNl.apply(U_XqO[859], arguments) | |
: U_XqO[859].e9_DZNl; | |
}; | |
U_XqO[397002] = 148; | |
U_XqO[268726] = U_XqO[859]; | |
U_XqO[357510] = "hbi"; | |
function U_XqO() {} | |
U_XqO[533845] = true; | |
U_XqO.t_q = function () { | |
return typeof U_XqO[859].S8j4bIS === "function" | |
? U_XqO[859].S8j4bIS.apply(U_XqO[859], arguments) | |
: U_XqO[859].S8j4bIS; | |
}; | |
U_XqO.X32 = function () { | |
return typeof U_XqO[859].S8j4bIS === "function" | |
? U_XqO[859].S8j4bIS.apply(U_XqO[859], arguments) | |
: U_XqO[859].S8j4bIS; | |
}; | |
U_XqO[859] = (function (a1q) { | |
return { | |
S8j4bIS: function () { | |
var G$R, | |
L1_ = arguments; | |
switch (a1q) { | |
case 21: | |
G$R = L1_[0] / L1_[1] - L1_[2]; | |
break; | |
case 2: | |
G$R = L1_[0] + L1_[3] + L1_[1] + L1_[4] + L1_[2]; | |
break; | |
case 14: | |
G$R = L1_[1] * L1_[0]; | |
break; | |
case 15: | |
G$R = ((L1_[3] * L1_[1]) / L1_[2]) * L1_[4] - L1_[0]; | |
break; | |
case 0: | |
G$R = L1_[0] + L1_[2] + L1_[1]; | |
break; | |
case 16: | |
G$R = L1_[0] < L1_[1]; | |
break; | |
case 6: | |
G$R = -L1_[2] - L1_[1] + L1_[0]; | |
break; | |
case 17: | |
G$R = (L1_[0] - L1_[2]) / L1_[4] - L1_[3] + L1_[1]; | |
break; | |
case 12: | |
G$R = (L1_[0] + L1_[2]) / L1_[1] + L1_[3]; | |
break; | |
case 3: | |
G$R = L1_[1] - L1_[0]; | |
break; | |
case 10: | |
G$R = (L1_[1] - L1_[2]) * L1_[0]; | |
break; | |
case 7: | |
G$R = -L1_[1] / L1_[4] + L1_[2] - L1_[0] + L1_[3]; | |
break; | |
case 20: | |
G$R = L1_[1] + (L1_[3] / L1_[2]) * L1_[0]; | |
break; | |
case 8: | |
G$R = L1_[1] !== L1_[0]; | |
break; | |
case 5: | |
G$R = (L1_[0] * L1_[2]) / L1_[1]; | |
break; | |
case 19: | |
G$R = ((L1_[2] / L1_[3]) | L1_[1]) * L1_[0]; | |
break; | |
case 11: | |
G$R = -L1_[0] / L1_[1] + L1_[2]; | |
break; | |
case 13: | |
G$R = L1_[0] + L1_[2] - L1_[1]; | |
break; | |
case 4: | |
G$R = L1_[1] / L1_[0]; | |
break; | |
case 9: | |
G$R = L1_[0] === L1_[1]; | |
break; | |
case 18: | |
G$R = (L1_[0] / L1_[2]) | L1_[1]; | |
break; | |
case 1: | |
G$R = L1_[1] + L1_[0]; | |
break; | |
} | |
return G$R; | |
}, | |
e9_DZNl: function (k1Y) { | |
a1q = k1Y; | |
}, | |
}; | |
})(); | |
U_XqO[165493] = "ioN"; | |
U_XqO[146257] = "H6S"; | |
U_XqO[452761] = U_XqO[859]; | |
U_XqO[287568].A6VV = U_XqO; | |
U_XqO.E5i = function () { | |
return typeof U_XqO[859].e9_DZNl === "function" | |
? U_XqO[859].e9_DZNl.apply(U_XqO[859], arguments) | |
: U_XqO[859].e9_DZNl; | |
}; | |
U_XqO[315244] = true; | |
(function () { | |
(function (ob, Gb) { | |
var qc, | |
Bc, | |
Vb, | |
kd, | |
Kb, | |
Mb, | |
bc, | |
ke, | |
le, | |
Tb, | |
Rb, | |
Kc, | |
me, | |
ld, | |
ne, | |
oe, | |
Ed, | |
Ga, | |
Hb, | |
Zc, | |
pe, | |
Fd, | |
gb, | |
yb, | |
Jb, | |
rc, | |
kc, | |
Zb, | |
Bb, | |
cc, | |
Ub, | |
ad, | |
Nb, | |
Cc, | |
Qb, | |
dc, | |
md, | |
sc, | |
oc, | |
pc, | |
nd, | |
Gd, | |
qe, | |
Dc, | |
Ec, | |
Mc, | |
Hd, | |
bd, | |
tc, | |
od, | |
Jc, | |
Id, | |
re, | |
Sc, | |
Jd, | |
Kd, | |
Ld, | |
Md, | |
uc, | |
Nd, | |
Od, | |
Pd, | |
Uc, | |
vc, | |
wc, | |
Vc, | |
pd, | |
qd, | |
rd, | |
mc, | |
rf, | |
Wb, | |
Lc, | |
se, | |
sd, | |
xc, | |
te, | |
sf, | |
yc, | |
ue, | |
tf, | |
td, | |
ve, | |
uf, | |
Yc, | |
we, | |
qf, | |
vf, | |
Qd, | |
ud, | |
wf, | |
xf, | |
he, | |
yf, | |
ie, | |
xe, | |
lc, | |
cd, | |
ye, | |
dd, | |
ze, | |
nc, | |
Ae, | |
Be, | |
Ce, | |
De, | |
Af, | |
je, | |
Ee, | |
Dd, | |
Fe, | |
zf, | |
Ge, | |
Rd, | |
He, | |
Ie, | |
Je, | |
Sd, | |
Ic, | |
Le, | |
Ke, | |
Bf, | |
fd, | |
Me, | |
Ud, | |
gd, | |
Ne, | |
Td, | |
Oe, | |
Pe, | |
Vd, | |
Re, | |
Se, | |
yd, | |
Nc, | |
Wc, | |
Oc, | |
Te, | |
Ue, | |
Ve, | |
We, | |
Xe, | |
Ye, | |
zd, | |
Cf, | |
Ze, | |
$e, | |
Xd, | |
af, | |
jc, | |
ed, | |
Tc, | |
vd, | |
Fc, | |
zc, | |
wd, | |
Gc, | |
$c, | |
Qe, | |
bf, | |
hd, | |
cf, | |
Df, | |
id, | |
df, | |
Ef, | |
Ff, | |
ef, | |
Wd, | |
xd, | |
ff, | |
Hf, | |
Gf, | |
Xc, | |
jd, | |
If, | |
ge, | |
Jf, | |
Kf; | |
function ec(ib, hb) { | |
if (!hb || "utf-8" === hb) return Ad(ib); | |
throw Error("unsupported encoding"); | |
} | |
function fc(ib, hb) { | |
if (!hb || "utf-8" === hb) return Bd(ib); | |
throw Error("unsupported encoding"); | |
} | |
function Ad(ib) { | |
for (var hb = 0, fb, cb = ib.length, nb = ""; hb < cb; ) { | |
fb = ib[hb++]; | |
if (fb & 128) | |
if (192 === (fb & 224)) fb = ((fb & 31) << 6) + (ib[hb++] & 63); | |
else if (224 === (fb & 240)) | |
fb = ((fb & 15) << 12) + ((ib[hb++] & 63) << 6) + (ib[hb++] & 63); | |
else throw Error("unsupported character"); | |
nb += String.fromCharCode(fb); | |
} | |
return nb; | |
} | |
function Bd(ib) { | |
var hb, fb, cb, nb, xb; | |
hb = ib.length; | |
fb = 0; | |
nb = 0; | |
for (cb = hb; cb--; ) { | |
xb = ib.charCodeAt(cb); | |
128 > xb ? fb++ : (fb = 2048 > xb ? fb + 2 : fb + 3); | |
} | |
fb = new Uint8Array(fb); | |
for (cb = 0; cb < hb; cb++) { | |
xb = ib.charCodeAt(cb); | |
128 > xb | |
? (fb[nb++] = xb) | |
: (2048 > xb | |
? (fb[nb++] = 192 | (xb >>> 6)) | |
: ((fb[nb++] = 224 | (xb >>> 12)), | |
(fb[nb++] = 128 | ((xb >>> 6) & 63))), | |
(fb[nb++] = 128 | (xb & 63))); | |
} | |
return fb; | |
} | |
function gc(ib, hb) { | |
if (ib === hb) return !0; | |
if (!ib || !hb || ib.length != hb.length) return !1; | |
for (var fb = 0; fb < ib.length; ++fb) { | |
if (ib[fb] != hb[fb]) return !1; | |
} | |
return !0; | |
} | |
function hc(ib) { | |
var cb; | |
if (!((ib && ib.constructor == Uint8Array) || Array.isArray(ib))) | |
throw new TypeError("Cannot compute the hash code of " + ib); | |
for (var hb = 1, fb = 0; fb < ib.length; ++fb) { | |
cb = ib[fb]; | |
if ("number" !== typeof cb) | |
throw new TypeError( | |
"Cannot compute the hash code over non-numeric elements: " + cb | |
); | |
hb = (31 * hb + cb) & 4294967295; | |
} | |
return hb; | |
} | |
function be(ib, hb) { | |
var kb; | |
if (ib === hb) return !0; | |
if (!ib || !hb) return !1; | |
hb instanceof Array || (hb = [hb]); | |
for (var fb = 0; fb < hb.length; ++fb) { | |
for (var cb = hb[fb], nb = !1, xb = 0; xb < ib.length; ++xb) { | |
kb = ib[xb]; | |
if ( | |
(cb.equals && "function" === typeof cb.equals && cb.equals(kb)) || | |
cb == kb | |
) { | |
nb = !0; | |
break; | |
} | |
} | |
if (!nb) return !1; | |
} | |
return !0; | |
} | |
function ce(ib, hb) { | |
return be(ib, hb) && (ib.length == hb.length || be(hb, ib)); | |
} | |
function Na(ib, hb, fb) { | |
var cb, nb; | |
fb && (cb = fb); | |
if ( | |
"object" !== typeof ib || | |
"function" !== typeof ib.result || | |
"function" !== typeof ib.error | |
) | |
throw new TypeError( | |
"callback must be an object with function properties 'result' and 'error'." | |
); | |
try { | |
nb = hb.call(cb, ib); | |
nb !== Gb && ib.result(nb); | |
} catch (xb) { | |
try { | |
ib.error(xb); | |
} catch (kb) {} | |
} | |
} | |
function eb(ib, hb, fb) { | |
if ("object" !== typeof ib || "function" !== typeof ib.timeout) | |
throw new TypeError( | |
"callback must be an object with function properties 'result', 'timeout', and 'error'." | |
); | |
Na(ib, hb, fb); | |
} | |
function T(ib, hb, fb) { | |
1e5 > ib && (ib = 1e5 + ib); | |
Object.defineProperties(this, { | |
internalCode: { value: ib, writable: !1, configurable: !1 }, | |
responseCode: { value: hb, writable: !1, configurable: !1 }, | |
message: { value: fb, writable: !1, configurable: !1 }, | |
}); | |
} | |
function Cd(ib) { | |
switch (ib) { | |
case Wb.PSK: | |
case Wb.MGK: | |
return !0; | |
default: | |
return !1; | |
} | |
} | |
function de(ib) { | |
switch (ib) { | |
case Wb.PSK: | |
case Wb.MGK: | |
case Wb.X509: | |
case Wb.RSA: | |
case Wb.NPTICKET: | |
case Wb.ECC: | |
return !0; | |
default: | |
return !1; | |
} | |
} | |
function mf(ib) { | |
return ib.toJSON(); | |
} | |
function ee(ib, hb) { | |
jd | |
? hb.result(jd) | |
: Promise.resolve() | |
.then(function () { | |
return Qb.getKeyByName(ib); | |
}) | |
.catch(function () { | |
return Qb.generateKey({ name: ib }, !1, ["wrapKey", "unwrapKey"]); | |
}) | |
.then(function (fb) { | |
jd = fb; | |
hb.result(jd); | |
}) | |
.catch(function (fb) { | |
hb.error( | |
new gb(T.INTERNAL_EXCEPTION, "Unable to get system key") | |
); | |
}); | |
} | |
function fe(ib, hb) { | |
var fb, cb; | |
fb = hb.masterToken; | |
cb = hb.userIdToken; | |
hb = hb.serviceTokens; | |
return { | |
NccpMethod: ib.method, | |
UserId: ib.userId, | |
UT: cb && cb.serialNumber, | |
MT: fb && fb.serialNumber + ":" + fb.sequenceNumber, | |
STCount: hb && hb.length, | |
}; | |
} | |
function nf(ib) { | |
return ib.uniqueKey(); | |
} | |
function of(ib, hb, fb, cb, nb) { | |
var Qa; | |
function xb(ua, ma) { | |
ua.errorCode === Ga.ENTITY_REAUTH || | |
ua.errorCode === Ga.ENTITYDATA_REAUTH | |
? (cb.clearCryptoContexts(), La()) | |
: (ua.errorCode !== Ga.USER_REAUTH && | |
ua.errorCode !== Ga.USERDATA_REAUTH) || | |
kb(ma); | |
} | |
function kb(ua) { | |
if ((ua = cb.getUserIdToken(ua))) cb.removeUserIdToken(ua), La(); | |
} | |
function Ba(ua, ma, da) { | |
var X; | |
X = []; | |
(function V() { | |
ua.read(-1, ma, { | |
result: function (aa) { | |
Na(da, function () { | |
var W, ha, va, ra, ia; | |
if (aa) X.push(aa), V(); | |
else | |
switch (X.length) { | |
case 0: | |
return new Uint8Array(0); | |
case 1: | |
return X[0]; | |
default: | |
(va = X.length), (ra = 0); | |
for (ha = W = 0; ha < va; ha++) { | |
W += X[ha].length; | |
} | |
W = new Uint8Array(W); | |
for (ha = 0; ha < va; ha++) { | |
ia = X[ha]; | |
W.set(ia, ra); | |
ra += ia.length; | |
} | |
return W; | |
} | |
}); | |
}, | |
timeout: function () { | |
da.timeout(); | |
}, | |
error: function (aa) { | |
da.error(aa); | |
}, | |
}); | |
})(); | |
} | |
function La() { | |
cb.getStoreState({ | |
result: function (ua) { | |
for (var ma = Qa.slice(), da = 0; da < ma.length; da++) { | |
ma[da]({ storeState: ua }); | |
} | |
}, | |
timeout: function () { | |
ib.error("Timeout getting store state", "" + e); | |
}, | |
error: function (ua) { | |
ib.error("Error getting store state", "" + ua); | |
}, | |
}); | |
} | |
Qa = []; | |
this.addEventHandler = function (ua, ma) { | |
switch (ua) { | |
case "shouldpersist": | |
Qa.push(ma); | |
} | |
}; | |
this.send = function (ua) { | |
return new Promise(function (ma, da) { | |
var X, U, V; | |
X = ua.timeout; | |
U = new ge(ib, fb, ua, cb.getKeyRequestData()); | |
V = new he(ua.url); | |
ib.trace("Sending MSL request"); | |
hb.request(fb, U, V, X, { | |
result: function (aa) { | |
var W; | |
ib.trace("Received MSL response", { Method: ua.method }); | |
if (aa) { | |
ua.allowTokenRefresh && La(); | |
W = aa.getErrorHeader(); | |
W | |
? (xb(W, ua.profileGuid || ua.userId), | |
da({ success: !1, error: W })) | |
: Ba(aa, X, { | |
result: function (ha) { | |
ma({ success: !0, body: ec(ha) }); | |
}, | |
timeout: function () { | |
da({ success: !1, subCode: nb.MSL_READ_TIMEOUT }); | |
}, | |
error: function (ha) { | |
da({ success: !1, error: ha }); | |
}, | |
}); | |
} else | |
da({ | |
success: !1, | |
error: new gb(T.INTERNAL_EXCEPTION, "Null response stream"), | |
description: "Null response stream", | |
}); | |
}, | |
timeout: function () { | |
da({ success: !1, subCode: nb.MSL_REQUEST_TIMEOUT }); | |
}, | |
error: function (aa) { | |
da({ success: !1, error: aa }); | |
}, | |
}); | |
}); | |
}; | |
this.hasUserIdToken = function (ua) { | |
return !!cb.getUserIdToken(ua); | |
}; | |
this.getUserIdTokenKeys = function () { | |
return cb.getUserIdTokenKeys(); | |
}; | |
this.removeUserIdToken = kb; | |
this.clearUserIdTokens = function () { | |
cb.clearUserIdTokens(); | |
La(); | |
}; | |
this.isErrorReauth = function (ua) { | |
return ua && ua.errorCode == Ga.USERDATA_REAUTH; | |
}; | |
this.isErrorHeader = function (ua) { | |
return ua instanceof Ic; | |
}; | |
this.getErrorCode = function (ua) { | |
return ua && ua.errorCode; | |
}; | |
this.getStateForMdx = function (ua) { | |
var ma, da; | |
ma = cb.getMasterToken(); | |
ua = cb.getUserIdToken(ua); | |
da = cb.getCryptoContext(ma); | |
return { masterToken: ma, userIdToken: ua, cryptoContext: da }; | |
}; | |
this.buildPlayDataRequest = function (ua, ma) { | |
var da; | |
da = new ie(); | |
hb.request(fb, new ge(ib, fb, ua), da, ua.timeout, { | |
result: function () { | |
ma.result(da.getRequest()); | |
}, | |
error: function () { | |
ma.result(da.getRequest()); | |
}, | |
timeout: function () { | |
ma.timeout(); | |
}, | |
}); | |
}; | |
this.rekeyUserIdToken = function (ua, ma) { | |
cb.rekeyUserIdToken(ua, ma); | |
La(); | |
}; | |
this.getServiceTokens = function (ua) { | |
var ma; | |
ma = cb.getMasterToken(); | |
(ua = cb.getUserIdToken(ua)) && !ua.isBoundTo(ma) && (ua = Gb); | |
return cb.getServiceTokens(ma, ua); | |
}; | |
this.removeServiceToken = function (ua) { | |
var ma; | |
ma = cb.getMasterToken(); | |
cb.getServiceTokens(ma).find(function (da) { | |
return da.name === ua; | |
}) && (cb.removeServiceTokens(ua, ma), La()); | |
}; | |
} | |
function pf(ib, hb, fb) { | |
var xb; | |
function cb() { | |
return Promise.resolve() | |
.then(function () { | |
return Qb.generateKey(hb, !1, ["wrapKey", "unwrapKey"]); | |
}) | |
.then(function (kb) { | |
return nb(kb.publicKey, kb.privateKey); | |
}); | |
} | |
function nb(kb, Ba) { | |
return Promise.all([ | |
new Promise(function (La, Qa) { | |
Jc(kb, { | |
result: La, | |
error: function (ua) { | |
Qa( | |
new gb( | |
T.INTERNAL_EXCEPTION, | |
"Unable to create keyx public key", | |
ua | |
) | |
); | |
}, | |
}); | |
}), | |
new Promise(function (La, Qa) { | |
Sc(Ba, { | |
result: La, | |
error: function (ua) { | |
Qa( | |
new gb( | |
T.INTERNAL_EXCEPTION, | |
"Unable to create keyx private key", | |
ua | |
) | |
); | |
}, | |
}); | |
}), | |
]).then(function (La) { | |
La = new Dd("rsaKeypairId", fb, La[0], La[1]); | |
xb && (La.storeData = { keyxPublicKey: kb, keyxPrivateKey: Ba }); | |
return La; | |
}); | |
} | |
xb = !ib.systemKeyWrapFormat; | |
return Promise.resolve() | |
.then(function () { | |
var kb, Ba; | |
kb = ib.storeState; | |
Ba = kb && kb.keyxPublicKey; | |
kb = kb && kb.keyxPrivateKey; | |
return xb && Ba && kb ? nb(Ba, kb) : cb(); | |
}) | |
.then(function (kb) { | |
var Ba, La, Qa; | |
Ba = {}; | |
Ba[Wb.NONE] = new qf(); | |
La = new Yc(ib.esn); | |
Qa = [new je()]; | |
return { | |
entityAuthFactories: Ba, | |
entityAuthData: La, | |
keyExchangeFactories: Qa, | |
keyRequestData: kb, | |
createKeyRequestData: xb ? cb : Gb, | |
}; | |
}); | |
} | |
Bc = ob.nfCrypto || ob.msCrypto || ob.webkitCrypto || ob.crypto; | |
Vb = Bc && (Bc.webkitSubtle || Bc.subtle); | |
kd = | |
ob.nfCryptokeys || | |
ob.msCryptokeys || | |
ob.webkitCryptokeys || | |
ob.cryptokeys; | |
(function (ib) { | |
var hb, fb; | |
hb = (function () { | |
function cb(nb, xb) { | |
nb instanceof hb | |
? ((this.abv = nb.abv), (this.position = nb.position)) | |
: ((this.abv = nb), (this.position = xb || 0)); | |
} | |
cb.prototype = { | |
readByte: function () { | |
return this.abv[this.position++]; | |
}, | |
writeByte: function (nb) { | |
this.abv[this.position++] = nb; | |
}, | |
peekByte: function (nb) { | |
return this.abv[nb]; | |
}, | |
copyBytes: function (nb, xb, kb) { | |
var Ba; | |
Ba = new Uint8Array(this.abv.buffer, this.position, kb); | |
nb = new Uint8Array(nb.buffer, xb, kb); | |
Ba.set(nb); | |
this.position += kb; | |
}, | |
seek: function (nb) { | |
this.position = nb; | |
}, | |
skip: function (nb) { | |
this.position += nb; | |
}, | |
getPosition: function () { | |
return this.position; | |
}, | |
setPosition: function (nb) { | |
this.position = nb; | |
}, | |
getRemaining: function () { | |
return this.abv.length - this.position; | |
}, | |
getLength: function () { | |
return this.abv.length; | |
}, | |
isEndOfStream: function () { | |
return this.position >= this.abv.length; | |
}, | |
show: function () { | |
return ( | |
"AbvStream: pos " + | |
(this.getPosition().toString() + | |
" of " + | |
this.getLength().toString()) | |
); | |
}, | |
}; | |
return cb; | |
})(); | |
fb = {}; | |
(function () { | |
var aa, W, ha, va, ra, ia, qa, Aa, ka; | |
function cb(Z, ca) { | |
var fa; | |
ca.writeByte((Z.tagClass << 6) | (Z.constructed << 5) | Z.tag); | |
fa = Z.payloadLen; | |
if (128 > fa) ca.writeByte(fa); | |
else { | |
for (var xa = fa, Sa = 0; xa; ) { | |
++Sa; | |
xa >>= 8; | |
} | |
ca.writeByte(128 | Sa); | |
for (xa = 0; xa < Sa; ++xa) { | |
ca.writeByte((fa >> (8 * (Sa - xa - 1))) & 255); | |
} | |
} | |
if (Z.child) | |
for (Z.tag == aa.BIT_STRING && ca.writeByte(0), Z = Z._child; Z; ) { | |
if (!cb(Z, ca)) return !1; | |
Z = Z.next; | |
} | |
else | |
switch (Z.tag) { | |
case aa.INTEGER: | |
Z.backingStore[Z.dataIdx] >> 7 && ca.writeByte(0); | |
ca.copyBytes(Z.backingStore, Z.dataIdx, Z.dataLen); | |
break; | |
case aa.BIT_STRING: | |
ca.writeByte(0); | |
ca.copyBytes(Z.backingStore, Z.dataIdx, Z.dataLen); | |
break; | |
case aa.OCTET_STRING: | |
ca.copyBytes(Z.backingStore, Z.dataIdx, Z.dataLen); | |
break; | |
case aa.OBJECT_IDENTIFIER: | |
ca.copyBytes(Z.backingStore, Z.dataIdx, Z.dataLen); | |
} | |
return !0; | |
} | |
function nb(Z) { | |
var ca, fa; | |
ca = Z.readByte(); | |
fa = ca & 127; | |
if (fa == ca) return fa; | |
if (3 < fa || 0 === fa) return -1; | |
for (var xa = (ca = 0); xa < fa; ++xa) { | |
ca = (ca << 8) | Z.readByte(); | |
} | |
return ca; | |
} | |
function xb(Z, ca, fa) { | |
var xa, Sa, Ma, Ra, Xa, oa, ya; | |
xa = Z.backingStore; | |
Sa = new hb(xa, ca); | |
ca += fa; | |
fa = Z; | |
if (8 < ra++) return Gb; | |
for (; Sa.getPosition() < ca; ) { | |
Sa.getPosition(); | |
Ra = Sa.readByte(); | |
if (31 == (Ra & 31)) { | |
for (Ma = 0; Ra & 128; ) { | |
Ma <<= 8; | |
Ma |= Ra & 127; | |
} | |
Ra = Ma; | |
} | |
Xa = Ra; | |
Ma = Xa & 31; | |
if (0 > Ma || 30 < Ma) return Gb; | |
Ra = nb(Sa); | |
if (0 > Ra || Ra > Sa.getRemaining()) return Gb; | |
fa.constructed = Xa & 32; | |
fa.tagClass = (Xa & 192) >> 6; | |
fa.tag = Ma; | |
fa.dataLen = Ra; | |
fa.dataIdx = Sa.getPosition(); | |
Ma = Sa; | |
oa = Xa; | |
Xa = Ra; | |
if (oa & 32) Ma = !0; | |
else if (oa < aa.BIT_STRING || oa > aa.OCTET_STRING) Ma = !1; | |
else { | |
ya = new hb(Ma); | |
oa == aa.BIT_STRING && ya.skip(1); | |
(ya.readByte() >> 6) & 1 | |
? (Ma = !1) | |
: ((oa = nb(ya)), | |
(Ma = ya.getPosition() - Ma.getPosition() + oa == Xa)); | |
} | |
Ma && | |
((Ma = Sa.getPosition()), | |
(Xa = Ra), | |
fa.tag == aa.BIT_STRING && | |
(fa.dataIdx++, fa.dataLen--, Ma++, Xa--), | |
(fa.child = new W(xa, fa)), | |
xb(fa.child, Ma, Xa)); | |
fa.tag == aa.INTEGER && | |
((Ma = Sa.getPosition()), | |
0 == Sa.peekByte(Ma) && | |
Sa.peekByte(Ma + 1) >> 7 && | |
(fa.dataIdx++, fa.dataLen--)); | |
Sa.skip(Ra); | |
Sa.getPosition() < ca && | |
((fa.next = new W(xa, fa.parent)), (fa = fa.next)); | |
} | |
ra--; | |
return Z; | |
} | |
function kb(Z, ca, fa) { | |
if (9 != fa) return !1; | |
for (fa = 0; 9 > fa; ++fa) { | |
if (Z[ca++] != ia[fa]) return !1; | |
} | |
return !0; | |
} | |
function Ba(Z) { | |
var ca; | |
if ( | |
!( | |
Z && | |
Z.child && | |
Z.child.next && | |
Z.child.child && | |
Z.child.next.child | |
) | |
) | |
return !1; | |
ca = Z.child.child; | |
return kb(ca.backingStore, ca.dataIdx, ca.dataLen) && | |
2 == Z.nChildren && | |
2 == Z.child.nChildren && | |
2 == Z.child.next.child.nChildren | |
? !0 | |
: !1; | |
} | |
function La(Z) { | |
var ca; | |
if ( | |
!( | |
Z && | |
Z.child && | |
Z.child.next && | |
Z.child.next.child && | |
Z.child.next.next && | |
Z.child.next.next.child | |
) | |
) | |
return !1; | |
ca = Z.child.next.child; | |
return kb(ca.backingStore, ca.dataIdx, ca.dataLen) && | |
3 == Z.nChildren && | |
2 == Z.child.next.nChildren && | |
9 == Z.child.next.next.child.nChildren | |
? !0 | |
: !1; | |
} | |
function Qa(Z) { | |
var ca, fa; | |
ca = ha.createSequenceNode(); | |
fa = new va(ca); | |
fa.addChild(ha.createSequenceNode()); | |
fa.addChild(ha.createOidNode(ia)); | |
fa.addSibling(ha.createNullNode()); | |
fa.addToParent(ca, ha.createBitStringNode(null)); | |
fa.addChild(ha.createSequenceNode()); | |
fa.addChild(ha.createIntegerNode(Z.n)); | |
fa.addSibling(ha.createIntegerNode(Z.e)); | |
return ca; | |
} | |
function ua(Z) { | |
var ca; | |
Z = Z.child.next.child.child; | |
ca = Z.data; | |
Z = Z.next; | |
return new qa(ca, Z.data, null, null); | |
} | |
function ma(Z) { | |
var ca, fa; | |
ca = ha.createSequenceNode(); | |
fa = new va(ca); | |
fa.addChild(ha.createIntegerNode(new Uint8Array([0]))); | |
fa.addSibling(ha.createSequenceNode()); | |
fa.addChild(ha.createOidNode(ia)); | |
fa.addSibling(ha.createNullNode()); | |
fa.addToParent(ca, ha.createOctetStringNode(null)); | |
fa.addChild(ha.createSequenceNode()); | |
fa.addChild(ha.createIntegerNode(new Uint8Array([0]))); | |
fa.addSibling(ha.createIntegerNode(Z.n)); | |
fa.addSibling(ha.createIntegerNode(Z.e)); | |
fa.addSibling(ha.createIntegerNode(Z.d)); | |
fa.addSibling(ha.createIntegerNode(Z.p)); | |
fa.addSibling(ha.createIntegerNode(Z.q)); | |
fa.addSibling(ha.createIntegerNode(Z.dp)); | |
fa.addSibling(ha.createIntegerNode(Z.dq)); | |
fa.addSibling(ha.createIntegerNode(Z.qi)); | |
return ca; | |
} | |
function da(Z) { | |
var ca; | |
ca = []; | |
Z = Z.child.next.next.child.child.next; | |
for (var fa = 0; 8 > fa; fa++) { | |
ca.push(Z.data); | |
Z = Z.next; | |
} | |
return new Aa(ca[0], ca[1], ca[2], ca[3], ca[4], ca[5], ca[6], ca[7]); | |
} | |
function X(Z, ca, fa, xa) { | |
if (!(Z instanceof qa || Z instanceof Aa)) return Gb; | |
if (fa) | |
for (var Sa = 0; Sa < fa.length; ++Sa) { | |
if (-1 == ka.indexOf(fa[Sa])) return Gb; | |
} | |
ca = { | |
kty: "RSA", | |
alg: ca, | |
key_ops: fa || [], | |
ext: xa == Gb ? !1 : xa, | |
n: Kb(Z.n, !0), | |
e: Kb(Z.e, !0), | |
}; | |
Z instanceof Aa && | |
((ca.d = Kb(Z.d, !0)), | |
(ca.p = Kb(Z.p, !0)), | |
(ca.q = Kb(Z.q, !0)), | |
(ca.dp = Kb(Z.dp, !0)), | |
(ca.dq = Kb(Z.dq, !0)), | |
(ca.qi = Kb(Z.qi, !0))); | |
return ca; | |
} | |
function U(Z) { | |
var ca, fa, xa, Sa, Ma, Ra, Xa, oa, ya, Ea; | |
if (!Z.kty || "RSA" != Z.kty || !Z.n || !Z.e) return Gb; | |
ca = | |
"RSA1_5 RSA-OAEP RSA-OAEP-256 RSA-OAEP-384 RSA-OAEP-512 RS256 RS384 RS512".split( | |
" " | |
); | |
if (Z.alg && -1 == ca.indexOf(Z.alg)) return Gb; | |
ca = []; | |
Z.use | |
? "enc" == Z.use | |
? (ca = ["encrypt", "decrypt", "wrap", "unwrap"]) | |
: "sig" == Z.use && (ca = ["sign", "verify"]) | |
: (ca = Z.key_ops); | |
fa = Z.ext; | |
xa = Mb(Z.n, !0); | |
Sa = Mb(Z.e, !0); | |
if (Z.d) { | |
Ma = Mb(Z.d, !0); | |
Ra = Mb(Z.p, !0); | |
Xa = Mb(Z.q, !0); | |
oa = Mb(Z.dp, !0); | |
ya = Mb(Z.dq, !0); | |
Ea = Mb(Z.qi, !0); | |
return new Aa(xa, Sa, Ma, Ra, Xa, oa, ya, Ea, Z.alg, ca, fa); | |
} | |
return new qa(xa, Sa, fa, ca); | |
} | |
function V(Z, ca, fa, xa) { | |
this.der = Z; | |
this.type = ca; | |
this.keyOps = fa; | |
this.extractable = xa; | |
} | |
aa = { | |
BER: 0, | |
BOOLEAN: 1, | |
INTEGER: 2, | |
BIT_STRING: 3, | |
OCTET_STRING: 4, | |
NULL: 5, | |
OBJECT_IDENTIFIER: 6, | |
OBJECT_DESCRIPTOR: 7, | |
INSTANCE_OF_EXTERNAL: 8, | |
REAL: 9, | |
ENUMERATED: 10, | |
EMBEDDED_PPV: 11, | |
UTF8_STRING: 12, | |
RELATIVE_OID: 13, | |
SEQUENCE: 16, | |
SET: 17, | |
NUMERIC_STRING: 18, | |
PRINTABLE_STRING: 19, | |
TELETEX_STRING: 20, | |
T61_STRING: 20, | |
VIDEOTEX_STRING: 21, | |
IA5_STRING: 22, | |
UTC_TIME: 23, | |
GENERALIZED_TIME: 24, | |
GRAPHIC_STRING: 25, | |
VISIBLE_STRING: 26, | |
ISO64_STRING: 26, | |
GENERAL_STRING: 27, | |
UNIVERSAL_STRING: 28, | |
CHARACTER_STRING: 29, | |
BMP_STRING: 30, | |
}; | |
W = function (Z, ca, fa, xa, Sa, Ma) { | |
this._data = Z; | |
this._parent = ca || Gb; | |
this._constructed = fa || !1; | |
this._tagClass = 0; | |
this._tag = xa || 0; | |
this._dataIdx = Sa || 0; | |
this._dataLen = Ma || 0; | |
}; | |
W.prototype = { | |
_child: Gb, | |
_next: Gb, | |
get data() { | |
return new Uint8Array( | |
this._data.buffer.slice( | |
this._dataIdx, | |
this._dataIdx + this._dataLen | |
) | |
); | |
}, | |
get backingStore() { | |
return this._data; | |
}, | |
get constructed() { | |
return this._constructed; | |
}, | |
set constructed(Z) { | |
this._constructed = 0 != Z ? !0 : !1; | |
}, | |
get tagClass() { | |
return this._tagClass; | |
}, | |
set tagClass(Z) { | |
this._tagClass = Z; | |
}, | |
get tag() { | |
return this._tag; | |
}, | |
set tag(Z) { | |
this._tag = Z; | |
}, | |
get dataIdx() { | |
return this._dataIdx; | |
}, | |
set dataIdx(Z) { | |
this._dataIdx = Z; | |
}, | |
get dataLen() { | |
return this._dataLen; | |
}, | |
set dataLen(Z) { | |
this._dataLen = Z; | |
}, | |
get child() { | |
return this._child; | |
}, | |
set child(Z) { | |
this._child = Z; | |
this._child.parent = this; | |
}, | |
get next() { | |
return this._next; | |
}, | |
set next(Z) { | |
this._next = Z; | |
}, | |
get parent() { | |
return this._parent; | |
}, | |
set parent(Z) { | |
this._parent = Z; | |
}, | |
get payloadLen() { | |
var Z; | |
Z = 0; | |
if (this._child) { | |
for (var ca = this._child; ca; ) { | |
Z += ca.length; | |
ca = ca.next; | |
} | |
this._tag == aa.BIT_STRING && Z++; | |
} else | |
switch (this._tag) { | |
case aa.INTEGER: | |
Z = this._dataLen; | |
this._data[this._dataIdx] >> 7 && Z++; | |
break; | |
case aa.BIT_STRING: | |
Z = this._dataLen + 1; | |
break; | |
case aa.OCTET_STRING: | |
Z = this._dataLen; | |
break; | |
case aa.NULL: | |
Z = 0; | |
break; | |
case aa.OBJECT_IDENTIFIER: | |
kb(this._data, this._dataIdx, this._dataLen) && (Z = 9); | |
} | |
return Z; | |
}, | |
get length() { | |
var Z, ca; | |
Z = this.payloadLen; | |
if (127 < Z) | |
for (ca = Z; ca; ) { | |
ca >>= 8; | |
++Z; | |
} | |
return Z + 2; | |
}, | |
get der() { | |
var Z, ca; | |
Z = this.length; | |
if (!Z) return Gb; | |
Z = new Uint8Array(Z); | |
ca = new hb(Z); | |
return cb(this, ca) ? Z : Gb; | |
}, | |
get nChildren() { | |
for (var Z = 0, ca = this._child; ca; ) { | |
Z++; | |
ca = ca.next; | |
} | |
return Z; | |
}, | |
}; | |
ha = { | |
createSequenceNode: function () { | |
return new W(null, null, !0, aa.SEQUENCE, null, null); | |
}, | |
createOidNode: function (Z) { | |
return new W( | |
Z, | |
null, | |
!1, | |
aa.OBJECT_IDENTIFIER, | |
0, | |
Z ? Z.length : 0 | |
); | |
}, | |
createNullNode: function () { | |
return new W(null, null, !1, aa.NULL, null, null); | |
}, | |
createBitStringNode: function (Z) { | |
return new W(Z, null, !1, aa.BIT_STRING, 0, Z ? Z.length : 0); | |
}, | |
createIntegerNode: function (Z) { | |
return new W(Z, null, !1, aa.INTEGER, 0, Z ? Z.length : 0); | |
}, | |
createOctetStringNode: function (Z) { | |
return new W(Z, null, !1, aa.OCTET_STRING, 0, Z ? Z.length : 0); | |
}, | |
}; | |
va = function (Z) { | |
this._currentNode = this._rootNode = Z; | |
}; | |
va.prototype = { | |
addChild: function (Z) { | |
this.addTo(this._currentNode, Z); | |
}, | |
addSibling: function (Z) { | |
this.addTo(this._currentNode.parent, Z); | |
}, | |
addTo: function (Z, ca) { | |
this._currentNode = ca; | |
this._currentNode.parent = Z; | |
if (Z.child) { | |
for (Z = Z.child; Z.next; ) { | |
Z = Z.next; | |
} | |
Z.next = ca; | |
} else Z.child = ca; | |
}, | |
addToParent: function (Z, ca) { | |
this.findNode(Z) && this.addTo(Z, ca); | |
}, | |
findNode: function (Z) { | |
for (var ca = this._currentNode; ca; ) { | |
if (Z == ca) return !0; | |
ca = ca.parent; | |
} | |
return !1; | |
}, | |
}; | |
ra = 0; | |
ia = new Uint8Array([42, 134, 72, 134, 247, 13, 1, 1, 1]); | |
qa = function (Z, ca, fa, xa) { | |
this.n = Z; | |
this.e = ca; | |
this.ext = fa; | |
this.keyOps = xa; | |
}; | |
Aa = function (Z, ca, fa, xa, Sa, Ma, Ra, Xa, oa, ya, Ea) { | |
this.n = Z; | |
this.e = ca; | |
this.d = fa; | |
this.p = xa; | |
this.q = Sa; | |
this.dp = Ma; | |
this.dq = Ra; | |
this.qi = Xa; | |
this.alg = oa; | |
this.keyOps = ya; | |
this.ext = Ea; | |
}; | |
ka = | |
"sign verify encrypt decrypt wrapKey unwrapKey deriveKey deriveBits".split( | |
" " | |
); | |
V.prototype.getDer = function () { | |
return this.der; | |
}; | |
V.prototype.getType = function () { | |
return this.type; | |
}; | |
V.prototype.getKeyOps = function () { | |
return this.keyOps; | |
}; | |
V.prototype.getExtractable = function () { | |
return this.extractable; | |
}; | |
fb.parse = function (Z) { | |
ra = 0; | |
return xb(new W(Z), 0, Z.length); | |
}; | |
fb.show = function (Z, ca) {}; | |
fb.isRsaSpki = Ba; | |
fb.isRsaPkcs8 = La; | |
fb.NodeFactory = ha; | |
fb.Builder = va; | |
fb.tagVal = aa; | |
fb.RsaPublicKey = qa; | |
fb.RsaPrivateKey = Aa; | |
fb.buildRsaSpki = Qa; | |
fb.parseRsaSpki = function (Z) { | |
Z = fb.parse(Z); | |
return Ba ? ua(Z) : Gb; | |
}; | |
fb.buildRsaPkcs8 = ma; | |
fb.parseRsaPkcs8 = function (Z) { | |
Z = fb.parse(Z); | |
return La(Z) ? da(Z) : Gb; | |
}; | |
fb.buildRsaJwk = X; | |
fb.parseRsaJwk = U; | |
fb.RsaDer = V; | |
fb.rsaDerToJwk = function (Z, ca, fa, xa) { | |
Z = fb.parse(Z); | |
if (!Z) return Gb; | |
if (Ba(Z)) Z = ua(Z); | |
else if (La(Z)) Z = da(Z); | |
else return Gb; | |
return X(Z, ca, fa, xa); | |
}; | |
fb.jwkToRsaDer = function (Z) { | |
var ca, fa; | |
Z = U(Z); | |
if (!Z) return Gb; | |
if (Z instanceof qa) { | |
ca = "spki"; | |
fa = Qa(Z).der; | |
} else if (Z instanceof Aa) (ca = "pkcs8"), (fa = ma(Z).der); | |
else return Gb; | |
return new V(fa, ca, Z.keyOps, Z.ext); | |
}; | |
fb.webCryptoAlgorithmToJwkAlg = function (Z) { | |
return "RSAES-PKCS1-v1_5" == Z.name | |
? "RSA1_5" | |
: "RSASSA-PKCS1-v1_5" == Z.name | |
? "SHA-256" == Z.hash.name | |
? "RS256" | |
: "SHA-384" == Z.hash.name | |
? "RS384" | |
: "SHA-512" == Z.hash.name | |
? "RS512" | |
: Gb | |
: Gb; | |
}; | |
fb.webCryptoUsageToJwkKeyOps = function (Z) { | |
return Z.map(function (ca) { | |
return "wrapKey" == ca ? "wrap" : "unwrapKey" == ca ? "unwrap" : ca; | |
}); | |
}; | |
})(); | |
ib.ASN1 = fb; | |
})(ob); | |
(function () { | |
for ( | |
var ib = {}, | |
hb = {}, | |
fb = { "=": 0, ".": 0 }, | |
cb = { "=": 0, ".": 0 }, | |
nb = /\s+/g, | |
xb = | |
/^[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/_-]*[=]{0,2}$/, | |
kb = 64; | |
kb--; | |
) { | |
ib[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[kb] | |
] = 262144 * kb; | |
hb[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[kb] | |
] = 4096 * kb; | |
fb[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[kb] | |
] = 64 * kb; | |
cb[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[kb] | |
] = kb; | |
} | |
for ( | |
kb = 64; | |
kb-- && | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[ | |
kb | |
] != | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[ | |
kb | |
]; | |
) { | |
ib[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[kb] | |
] = 262144 * kb; | |
hb[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[kb] | |
] = 4096 * kb; | |
fb[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[kb] | |
] = 64 * kb; | |
cb[ | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[kb] | |
] = kb; | |
} | |
Kb = function (Ba, La) { | |
for ( | |
var Qa = "", | |
ua = 0, | |
ma = Ba.length, | |
da = ma - 2, | |
X = La | |
? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" | |
: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", | |
U = La ? "" : "="; | |
ua < da; | |
) { | |
La = 65536 * Ba[ua++] + 256 * Ba[ua++] + Ba[ua++]; | |
Qa += | |
X[La >>> 18] + | |
X[(La >>> 12) & 63] + | |
X[(La >>> 6) & 63] + | |
X[La & 63]; | |
} | |
ua == da | |
? ((La = 65536 * Ba[ua++] + 256 * Ba[ua++]), | |
(Qa += X[La >>> 18] + X[(La >>> 12) & 63] + X[(La >>> 6) & 63] + U)) | |
: ua == ma - 1 && | |
((La = 65536 * Ba[ua++]), | |
(Qa += X[La >>> 18] + X[(La >>> 12) & 63] + U + U)); | |
return Qa; | |
}; | |
Mb = function (Ba, La) { | |
Ba = Ba.replace(nb, ""); | |
if (La && (La = Ba.length % 4)) { | |
La = 4 - La; | |
for (var Qa = 0; Qa < La; ++Qa) { | |
Ba += "="; | |
} | |
} | |
La = Ba.length; | |
if (0 != La % 4 || !xb.test(Ba)) throw Error("bad base64: " + Ba); | |
for ( | |
var ua = | |
(La / 4) * 3 - | |
("=" == Ba[La - 1] ? 1 : 0) - | |
("=" == Ba[La - 2] ? 1 : 0), | |
ma = new Uint8Array(ua), | |
da = 0, | |
X = 0; | |
da < La; | |
) { | |
Qa = ib[Ba[da++]] + hb[Ba[da++]] + fb[Ba[da++]] + cb[Ba[da++]]; | |
ma[X++] = Qa >>> 16; | |
X < ua && | |
((ma[X++] = (Qa >>> 8) & 255), X < ua && (ma[X++] = Qa & 255)); | |
} | |
return ma; | |
}; | |
})(); | |
bc = {}; | |
(function () { | |
var xb, kb, Ba, Qa; | |
function ib(ua) { | |
if (!(this instanceof ib)) return new ib(ua); | |
for (var ma = 0, da = kb.length; ma < da; ma++) { | |
this[kb[ma]] = ""; | |
} | |
this.bufferCheckPosition = bc.MAX_BUFFER_LENGTH; | |
this.q = this.c = this.p = ""; | |
this.opt = ua || {}; | |
this.closed = this.closedRoot = this.sawRoot = !1; | |
this.tag = this.error = null; | |
this.state = Ba.BEGIN; | |
this.stack = new xb(); | |
this.index = this.position = this.column = 0; | |
this.line = 1; | |
this.slashed = !1; | |
this.unicodeI = 0; | |
this.unicodeS = null; | |
hb(this, "onready"); | |
} | |
function hb(ua, ma, da) { | |
if (ua[ma]) ua[ma](da); | |
} | |
function fb(ua, ma) { | |
var da, X; | |
da = ua.opt; | |
X = ua.textNode; | |
da.trim && (X = X.trim()); | |
da.normalize && (X = X.replace(/\s+/g, " ")); | |
ua.textNode = X; | |
ua.textNode && hb(ua, ma ? ma : "onvalue", ua.textNode); | |
ua.textNode = ""; | |
} | |
function cb(ua, ma) { | |
fb(ua); | |
ma += | |
"\nLine: " + ua.line + "\nColumn: " + ua.column + "\nChar: " + ua.c; | |
ma = Error(ma); | |
ua.error = ma; | |
hb(ua, "onerror", ma); | |
return ua; | |
} | |
function nb(ua) { | |
ua.state !== Ba.VALUE && cb(ua, "Unexpected end"); | |
fb(ua); | |
ua.c = ""; | |
ua.closed = !0; | |
hb(ua, "onend"); | |
ib.call(ua, ua.opt); | |
return ua; | |
} | |
xb = Array; | |
bc.parser = function (ua) { | |
return new ib(ua); | |
}; | |
bc.CParser = ib; | |
bc.MAX_BUFFER_LENGTH = 65536; | |
bc.DEBUG = !1; | |
bc.INFO = !1; | |
bc.EVENTS = | |
"value string key openobject closeobject openarray closearray error end ready".split( | |
" " | |
); | |
kb = ["textNode", "numberNode"]; | |
bc.EVENTS.filter(function (ua) { | |
return "error" !== ua && "end" !== ua; | |
}); | |
Ba = 0; | |
bc.STATE = { | |
BEGIN: Ba++, | |
VALUE: Ba++, | |
OPEN_OBJECT: Ba++, | |
CLOSE_OBJECT: Ba++, | |
OPEN_ARRAY: Ba++, | |
CLOSE_ARRAY: Ba++, | |
TEXT_ESCAPE: Ba++, | |
STRING: Ba++, | |
BACKSLASH: Ba++, | |
END: Ba++, | |
OPEN_KEY: Ba++, | |
CLOSE_KEY: Ba++, | |
TRUE: Ba++, | |
TRUE2: Ba++, | |
TRUE3: Ba++, | |
FALSE: Ba++, | |
FALSE2: Ba++, | |
FALSE3: Ba++, | |
FALSE4: Ba++, | |
NULL: Ba++, | |
NULL2: Ba++, | |
NULL3: Ba++, | |
NUMBER_DECIMAL_POINT: Ba++, | |
NUMBER_DIGIT: Ba++, | |
}; | |
for (var La in bc.STATE) { | |
bc.STATE[bc.STATE[La]] = La; | |
} | |
Ba = bc.STATE; | |
Object.getPrototypeOf || | |
(Object.getPrototypeOf = function (ua) { | |
return ua.__proto__; | |
}); | |
Qa = /[\\"\n]/g; | |
ib.prototype = { | |
end: function () { | |
nb(this); | |
}, | |
write: function (ua) { | |
var X, U, V; | |
if (this.error) throw this.error; | |
if (this.closed) | |
return cb( | |
this, | |
"Cannot write after close. Assign an onready handler." | |
); | |
if (null === ua) return nb(this); | |
for (var ma = ua[0], da; ma; ) { | |
da = ma; | |
this.c = ma = ua.charAt(this.index++); | |
da !== ma ? (this.p = da) : (da = this.p); | |
if (!ma) break; | |
this.position++; | |
"\n" === ma ? (this.line++, (this.column = 0)) : this.column++; | |
switch (this.state) { | |
case Ba.BEGIN: | |
"{" === ma | |
? (this.state = Ba.OPEN_OBJECT) | |
: "[" === ma | |
? (this.state = Ba.OPEN_ARRAY) | |
: "\r" !== ma && | |
"\n" !== ma && | |
" " !== ma && | |
"\t" !== ma && | |
cb(this, "Non-whitespace before {[."); | |
continue; | |
case Ba.OPEN_KEY: | |
case Ba.OPEN_OBJECT: | |
if ("\r" === ma || "\n" === ma || " " === ma || "\t" === ma) | |
continue; | |
if (this.state === Ba.OPEN_KEY) this.stack.push(Ba.CLOSE_KEY); | |
else if ("}" === ma) { | |
hb(this, "onopenobject"); | |
hb(this, "oncloseobject"); | |
this.state = this.stack.pop() || Ba.VALUE; | |
continue; | |
} else this.stack.push(Ba.CLOSE_OBJECT); | |
'"' === ma | |
? (this.state = Ba.STRING) | |
: cb(this, 'Malformed object key should start with "'); | |
continue; | |
case Ba.CLOSE_KEY: | |
case Ba.CLOSE_OBJECT: | |
if ("\r" === ma || "\n" === ma || " " === ma || "\t" === ma) | |
continue; | |
":" === ma | |
? (this.state === Ba.CLOSE_OBJECT | |
? (this.stack.push(Ba.CLOSE_OBJECT), | |
fb(this, "onopenobject")) | |
: fb(this, "onkey"), | |
(this.state = Ba.VALUE)) | |
: "}" === ma | |
? (fb(this), | |
hb(this, "oncloseobject", void 0), | |
(this.state = this.stack.pop() || Ba.VALUE)) | |
: "," === ma | |
? (this.state === Ba.CLOSE_OBJECT && | |
this.stack.push(Ba.CLOSE_OBJECT), | |
fb(this), | |
(this.state = Ba.OPEN_KEY)) | |
: cb(this, "Bad object"); | |
continue; | |
case Ba.OPEN_ARRAY: | |
case Ba.VALUE: | |
if ("\r" === ma || "\n" === ma || " " === ma || "\t" === ma) | |
continue; | |
if (this.state === Ba.OPEN_ARRAY) | |
if ( | |
(hb(this, "onopenarray"), | |
(this.state = Ba.VALUE), | |
"]" === ma) | |
) { | |
hb(this, "onclosearray"); | |
this.state = this.stack.pop() || Ba.VALUE; | |
continue; | |
} else this.stack.push(Ba.CLOSE_ARRAY); | |
'"' === ma | |
? (this.state = Ba.STRING) | |
: "{" === ma | |
? (this.state = Ba.OPEN_OBJECT) | |
: "[" === ma | |
? (this.state = Ba.OPEN_ARRAY) | |
: "t" === ma | |
? (this.state = Ba.TRUE) | |
: "f" === ma | |
? (this.state = Ba.FALSE) | |
: "n" === ma | |
? (this.state = Ba.NULL) | |
: "-" === ma | |
? (this.numberNode += ma) | |
: "0" === ma | |
? ((this.numberNode += ma), (this.state = Ba.NUMBER_DIGIT)) | |
: -1 !== "123456789".indexOf(ma) | |
? ((this.numberNode += ma), (this.state = Ba.NUMBER_DIGIT)) | |
: cb(this, "Bad value"); | |
continue; | |
case Ba.CLOSE_ARRAY: | |
if ("," === ma) | |
this.stack.push(Ba.CLOSE_ARRAY), | |
fb(this, "onvalue"), | |
(this.state = Ba.VALUE); | |
else if ("]" === ma) | |
fb(this), | |
hb(this, "onclosearray", void 0), | |
(this.state = this.stack.pop() || Ba.VALUE); | |
else if ( | |
"\r" === ma || | |
"\n" === ma || | |
" " === ma || | |
"\t" === ma | |
) | |
continue; | |
else cb(this, "Bad array"); | |
continue; | |
case Ba.STRING: | |
da = this.index - 1; | |
(X = this.slashed), (U = this.unicodeI); | |
a: for (;;) { | |
if (bc.DEBUG) | |
for (; 0 < U; ) { | |
if ( | |
((this.unicodeS += ma), | |
(ma = ua.charAt(this.index++)), | |
4 === U | |
? ((this.textNode += String.fromCharCode( | |
parseInt(this.unicodeS, 16) | |
)), | |
(U = 0), | |
(da = this.index - 1)) | |
: U++, | |
!ma) | |
) | |
break a; | |
} | |
if ('"' === ma && !X) { | |
this.state = this.stack.pop() || Ba.VALUE; | |
(this.textNode += ua.substring(da, this.index - 1)) || | |
hb(this, "onvalue", ""); | |
break; | |
} | |
if ( | |
"\\" === ma && | |
!X && | |
((X = !0), | |
(this.textNode += ua.substring(da, this.index - 1)), | |
(ma = ua.charAt(this.index++)), | |
!ma) | |
) | |
break; | |
if (X) | |
if ( | |
((X = !1), | |
"n" === ma | |
? (this.textNode += "\n") | |
: "r" === ma | |
? (this.textNode += "\r") | |
: "t" === ma | |
? (this.textNode += "\t") | |
: "f" === ma | |
? (this.textNode += "\f") | |
: "b" === ma | |
? (this.textNode += "\b") | |
: "u" === ma | |
? ((U = 1), (this.unicodeS = "")) | |
: (this.textNode += ma), | |
(ma = ua.charAt(this.index++)), | |
(da = this.index - 1), | |
ma) | |
) | |
continue; | |
else break; | |
Qa.lastIndex = this.index; | |
V = Qa.exec(ua); | |
if (null === V) { | |
this.index = ua.length + 1; | |
this.textNode += ua.substring(da, this.index - 1); | |
break; | |
} | |
this.index = V.index + 1; | |
ma = ua.charAt(V.index); | |
if (!ma) { | |
this.textNode += ua.substring(da, this.index - 1); | |
break; | |
} | |
} | |
this.slashed = X; | |
this.unicodeI = U; | |
continue; | |
case Ba.TRUE: | |
if ("" === ma) continue; | |
"r" === ma | |
? (this.state = Ba.TRUE2) | |
: cb(this, "Invalid true started with t" + ma); | |
continue; | |
case Ba.TRUE2: | |
if ("" === ma) continue; | |
"u" === ma | |
? (this.state = Ba.TRUE3) | |
: cb(this, "Invalid true started with tr" + ma); | |
continue; | |
case Ba.TRUE3: | |
if ("" === ma) continue; | |
"e" === ma | |
? (hb(this, "onvalue", !0), | |
(this.state = this.stack.pop() || Ba.VALUE)) | |
: cb(this, "Invalid true started with tru" + ma); | |
continue; | |
case Ba.FALSE: | |
if ("" === ma) continue; | |
"a" === ma | |
? (this.state = Ba.FALSE2) | |
: cb(this, "Invalid false started with f" + ma); | |
continue; | |
case Ba.FALSE2: | |
if ("" === ma) continue; | |
"l" === ma | |
? (this.state = Ba.FALSE3) | |
: cb(this, "Invalid false started with fa" + ma); | |
continue; | |
case Ba.FALSE3: | |
if ("" === ma) continue; | |
"s" === ma | |
? (this.state = Ba.FALSE4) | |
: cb(this, "Invalid false started with fal" + ma); | |
continue; | |
case Ba.FALSE4: | |
if ("" === ma) continue; | |
"e" === ma | |
? (hb(this, "onvalue", !1), | |
(this.state = this.stack.pop() || Ba.VALUE)) | |
: cb(this, "Invalid false started with fals" + ma); | |
continue; | |
case Ba.NULL: | |
if ("" === ma) continue; | |
"u" === ma | |
? (this.state = Ba.NULL2) | |
: cb(this, "Invalid null started with n" + ma); | |
continue; | |
case Ba.NULL2: | |
if ("" === ma) continue; | |
"l" === ma | |
? (this.state = Ba.NULL3) | |
: cb(this, "Invalid null started with nu" + ma); | |
continue; | |
case Ba.NULL3: | |
if ("" === ma) continue; | |
"l" === ma | |
? (hb(this, "onvalue", null), | |
(this.state = this.stack.pop() || Ba.VALUE)) | |
: cb(this, "Invalid null started with nul" + ma); | |
continue; | |
case Ba.NUMBER_DECIMAL_POINT: | |
"." === ma | |
? ((this.numberNode += ma), (this.state = Ba.NUMBER_DIGIT)) | |
: cb(this, "Leading zero not followed by ."); | |
continue; | |
case Ba.NUMBER_DIGIT: | |
-1 !== "0123456789".indexOf(ma) | |
? (this.numberNode += ma) | |
: "." === ma | |
? (-1 !== this.numberNode.indexOf(".") && | |
cb(this, "Invalid number has two dots"), | |
(this.numberNode += ma)) | |
: "e" === ma || "E" === ma | |
? ((-1 === this.numberNode.indexOf("e") && | |
-1 === this.numberNode.indexOf("E")) || | |
cb(this, "Invalid number has two exponential"), | |
(this.numberNode += ma)) | |
: "+" === ma || "-" === ma | |
? ("e" !== da && | |
"E" !== da && | |
cb(this, "Invalid symbol in number"), | |
(this.numberNode += ma)) | |
: (this.numberNode && | |
hb(this, "onvalue", parseFloat(this.numberNode)), | |
(this.numberNode = ""), | |
this.index--, | |
(this.state = this.stack.pop() || Ba.VALUE)); | |
continue; | |
default: | |
cb(this, "Unknown state: " + this.state); | |
} | |
} | |
if (this.position >= this.bufferCheckPosition) { | |
ua = Math.max(bc.MAX_BUFFER_LENGTH, 10); | |
da = ma = 0; | |
for (X = kb.length; da < X; da++) { | |
U = this[kb[da]].length; | |
if (U > ua) | |
switch (kb[da]) { | |
case "text": | |
break; | |
default: | |
cb(this, "Max buffer length exceeded: " + kb[da]); | |
} | |
ma = Math.max(ma, U); | |
} | |
this.bufferCheckPosition = | |
bc.MAX_BUFFER_LENGTH - ma + this.position; | |
} | |
return this; | |
}, | |
resume: function () { | |
this.error = null; | |
return this; | |
}, | |
close: function () { | |
return this.write(null); | |
}, | |
}; | |
})(); | |
(function () { | |
var cb, nb, xb; | |
function ib(kb, Ba) { | |
Ba || (Ba = kb.length); | |
return kb.reduce(function (La, Qa, ua) { | |
return ua < Ba ? La + String.fromCharCode(Qa) : La; | |
}, ""); | |
} | |
for (var hb = {}, fb = 0; 256 > fb; ++fb) { | |
cb = ib([fb]); | |
hb[cb] = fb; | |
} | |
nb = Object.keys(hb).length; | |
xb = []; | |
for (fb = 0; 256 > fb; ++fb) { | |
xb[fb] = [fb]; | |
} | |
ke = function (kb, Ba) { | |
var W, ha; | |
function La(va, ra) { | |
var ia; | |
for (; 0 < ra; ) { | |
if (U >= X.length) return !1; | |
if (ra > V) { | |
ia = va; | |
ia >>>= ra - V; | |
X[U] |= ia & 255; | |
ra -= V; | |
V = 8; | |
++U; | |
} else | |
ra <= V && | |
((ia = va), | |
(ia <<= V - ra), | |
(ia &= 255), | |
(ia >>>= 8 - V), | |
(X[U] |= ia & 255), | |
(V -= ra), | |
(ra = 0), | |
0 == V && ((V = 8), ++U)); | |
} | |
return !0; | |
} | |
for (var Qa in hb) { | |
Ba[Qa] = hb[Qa]; | |
} | |
for ( | |
var ua = nb, | |
ma = [], | |
da = 8, | |
X = new Uint8Array(kb.length), | |
U = 0, | |
V = 8, | |
aa = 0; | |
aa < kb.length; | |
++aa | |
) { | |
W = kb[aa]; | |
ma.push(W); | |
Qa = ib(ma); | |
ha = Ba[Qa]; | |
if (!ha) { | |
ma = ib(ma, ma.length - 1); | |
if (!La(Ba[ma], da)) return null; | |
0 != ua >> da && ++da; | |
Ba[Qa] = ua++; | |
ma = [W]; | |
} | |
} | |
return 0 < ma.length && ((Qa = ib(ma)), (ha = Ba[Qa]), !La(ha, da)) | |
? null | |
: X.subarray(0, 8 > V ? U + 1 : U); | |
}; | |
le = function (kb) { | |
var aa, W; | |
for ( | |
var Ba = xb.slice(), | |
La = 0, | |
Qa = 0, | |
ua = 8, | |
ma = new Uint8Array(Math.ceil(1.5 * kb.length)), | |
da = 0, | |
X, | |
U = []; | |
La < kb.length && !(8 * (kb.length - La) - Qa < ua); | |
) { | |
for (var V = (X = 0); V < ua; ) { | |
aa = Math.min(ua - V, 8 - Qa); | |
W = kb[La]; | |
W <<= Qa; | |
W &= 255; | |
W >>>= 8 - aa; | |
V += aa; | |
Qa += aa; | |
8 == Qa && ((Qa = 0), ++La); | |
X |= (W & 255) << (ua - V); | |
} | |
V = Ba[X]; | |
0 == U.length | |
? ++ua | |
: (V ? U.push(V[0]) : U.push(U[0]), | |
(Ba[Ba.length] = U), | |
(U = []), | |
Ba.length == 1 << ua && ++ua, | |
V || (V = Ba[X])); | |
X = da + V.length; | |
X >= ma.length && | |
((aa = new Uint8Array(Math.ceil(1.5 * X))), aa.set(ma), (ma = aa)); | |
ma.set(V, da); | |
da = X; | |
U = U.concat(V); | |
} | |
return ma.subarray(0, da); | |
}; | |
})(); | |
(function () { | |
var ib, hb, fb; | |
Tb = "utf-8"; | |
Rb = 9007199254740992; | |
ib = Kc = { GZIP: "GZIP", LZW: "LZW" }; | |
Object.freeze(Kc); | |
me = function (cb) { | |
for ( | |
var nb = [ib.GZIP, ib.LZW], xb = 0; | |
xb < nb.length && 0 < cb.length; | |
++xb | |
) { | |
for (var kb = nb[xb], Ba = 0; Ba < cb.length; ++Ba) { | |
if (cb[Ba] == kb) return kb; | |
} | |
} | |
return null; | |
}; | |
hb = ld = { | |
AES_CBC_PKCS5Padding: "AES/CBC/PKCS5Padding", | |
AESWrap: "AESWrap", | |
RSA_ECB_PKCS1Padding: "RSA/ECB/PKCS1Padding", | |
}; | |
Object.freeze(ld); | |
ne = function (cb) { | |
return hb.AES_CBC_PKCS5Padding == cb | |
? hb.AES_CBC_PKCS5Padding | |
: hb.RSA_ECB_PKCS1Padding == cb | |
? hb.RSA_ECB_PKCS1Padding | |
: hb[cb]; | |
}; | |
fb = oe = { HmacSHA256: "HmacSHA256", SHA256withRSA: "SHA256withRSA" }; | |
Object.freeze(oe); | |
Ed = function (cb) { | |
return fb[cb]; | |
}; | |
Ga = { | |
FAIL: 1, | |
TRANSIENT_FAILURE: 2, | |
ENTITY_REAUTH: 3, | |
USER_REAUTH: 4, | |
KEYX_REQUIRED: 5, | |
ENTITYDATA_REAUTH: 6, | |
USERDATA_REAUTH: 7, | |
EXPIRED: 8, | |
REPLAYED: 9, | |
SSOTOKEN_REJECTED: 10, | |
}; | |
Object.freeze(Ga); | |
})(); | |
Hb = { | |
isObjectLiteral: function (ib) { | |
return ( | |
null !== ib && "object" === typeof ib && ib.constructor === Object | |
); | |
}, | |
extendDeep: function () { | |
var ib, hb, fb, cb, nb, xb, kb, Ba; | |
ib = arguments[0]; | |
hb = 1; | |
fb = arguments.length; | |
cb = !1; | |
"boolean" === typeof ib && ((cb = ib), (ib = arguments[1]), (hb = 2)); | |
for (; hb < fb; hb++) { | |
if (null != (nb = arguments[hb])) | |
for (xb in nb) { | |
if (!(cb && xb in ib)) { | |
kb = nb[xb]; | |
if (ib !== kb && kb !== Gb) { | |
Ba = ib[xb]; | |
ib[xb] = | |
null !== Ba && | |
null !== kb && | |
"object" === typeof Ba && | |
"object" === typeof kb | |
? Hb.extendDeep(cb, {}, Ba, kb) | |
: kb; | |
} | |
} | |
} | |
} | |
return ib; | |
}, | |
}; | |
(function () { | |
var kb, Ba; | |
function ib(La, Qa) { | |
return function () { | |
var ua, ma; | |
ua = La.base; | |
La.base = Qa; | |
ma = La.apply(this, arguments); | |
La.base = ua; | |
return ma; | |
}; | |
} | |
function hb(La, Qa, ua) { | |
var ma, da, X, U; | |
ua = ua || Ba; | |
da = !!ua.extendAll; | |
for (ma in Qa) { | |
X = Qa.__lookupGetter__(ma); | |
U = Qa.__lookupSetter__(ma); | |
X || U | |
? (X && La.__defineGetter__(ma, X), U && La.__defineSetter__(ma, U)) | |
: ((X = Qa[ma]), | |
(U = La[ma]), | |
"function" === typeof X && "function" === typeof U && X !== U | |
? (X.base !== Function.prototype.base && (X = ib(X, U)), | |
(X.base = U)) | |
: (da || ua[ma]) && | |
Hb.isObjectLiteral(X) && | |
Hb.isObjectLiteral(U) && | |
(X = Hb.extendDeep({}, U, X)), | |
(La[ma] = X)); | |
} | |
} | |
function fb() { | |
var La, Qa; | |
La = Array.prototype.slice; | |
Qa = La.call(arguments, 1); | |
return this.extend({ | |
init: function ma() { | |
var da; | |
da = La.call(arguments, 0); | |
ma.base.apply(this, Qa.concat(da)); | |
}, | |
}); | |
} | |
function cb(La, Qa) { | |
var ua; | |
ua = new this(kb); | |
hb(ua, La, Qa); | |
return xb(ua); | |
} | |
function nb(La, Qa) { | |
hb(this.prototype, La, Qa); | |
return this; | |
} | |
function xb(La) { | |
var Qa; | |
Qa = function () { | |
var ua; | |
ua = this.init; | |
ua && arguments[0] !== kb && ua.apply(this, arguments); | |
}; | |
La && (Qa.prototype = La); | |
Qa.prototype.constructor = Qa; | |
Qa.extend = cb; | |
Qa.bind = fb; | |
Qa.mixin = nb; | |
return Qa; | |
} | |
kb = {}; | |
Ba = { actions: !0 }; | |
Function.prototype.base = function () {}; | |
Hb.Class = { | |
create: xb, | |
mixin: hb, | |
extend: function (La, Qa) { | |
var ua; | |
ua = xb(); | |
ua.prototype = new La(); | |
return ua.extend(Qa); | |
}, | |
}; | |
Hb.mixin = function () { | |
Hb.log && | |
Hb.log.warn( | |
"util.mixin is deprecated. Please change your code to use util.Class.mixin()" | |
); | |
hb.apply(null, arguments); | |
}; | |
})(); | |
(function () { | |
var kb, Ba, La; | |
function ib(Qa, ua) { | |
return function () { | |
var ma, da; | |
ma = Qa.base; | |
Qa.base = ua; | |
da = Qa.apply(this, arguments); | |
Qa.base = ma; | |
return da; | |
}; | |
} | |
function hb(Qa, ua, ma) { | |
var da, X, U, V; | |
ma = ma || Ba; | |
X = !!ma.extendAll; | |
for (da in ua) { | |
U = ua.__lookupGetter__(da); | |
V = ua.__lookupSetter__(da); | |
U || V | |
? (U && Qa.__defineGetter__(da, U), V && Qa.__defineSetter__(da, V)) | |
: ((U = ua[da]), | |
(V = Qa[da]), | |
"function" === typeof U && "function" === typeof V && U !== V | |
? (U.base !== La && (U = ib(U, V)), (U.base = V)) | |
: (X || ma[da]) && | |
Hb.isObjectLiteral(U) && | |
Hb.isObjectLiteral(V) && | |
(U = Hb.extendDeep({}, V, U)), | |
(Qa[da] = U)); | |
} | |
} | |
function fb() { | |
var Qa, ua; | |
Qa = Array.prototype.slice; | |
ua = Qa.call(arguments, 1); | |
return this.extend({ | |
init: function da() { | |
var X; | |
X = Qa.call(arguments, 0); | |
da.base.apply(this, ua.concat(X)); | |
}, | |
}); | |
} | |
function cb(Qa, ua) { | |
var ma; | |
ma = new this(kb); | |
hb(ma, Qa, ua); | |
return xb(ma); | |
} | |
function nb(Qa, ua) { | |
hb(this.prototype, Qa, ua); | |
return this; | |
} | |
function xb(Qa) { | |
var ua; | |
ua = function () { | |
var ma; | |
ma = this.init; | |
ma && arguments[0] !== kb && ma.apply(this, arguments); | |
}; | |
Qa && (ua.prototype = Qa); | |
ua.prototype.constructor = ua; | |
ua.extend = cb; | |
ua.bind = fb; | |
ua.mixin = nb; | |
return ua; | |
} | |
kb = {}; | |
Ba = { actions: !0 }; | |
La = function () {}; | |
Function.prototype.base = La; | |
Hb.Class = { | |
create: xb, | |
mixin: hb, | |
extend: function (Qa, ua) { | |
var ma; | |
ma = xb(); | |
ma.prototype = new Qa(); | |
return ma.extend(ua); | |
}, | |
}; | |
Hb.mixin = function () { | |
Hb.log && | |
Hb.log.warn( | |
"util.mixin is deprecated. Please change your code to use util.Class.mixin()" | |
); | |
hb.apply(null, arguments); | |
}; | |
})(); | |
(function () { | |
function ib(fb) { | |
return fb == Rb ? 1 : fb + 1; | |
} | |
function hb(fb) { | |
if (0 === Object.keys(fb._waiters).length) return 0; | |
for (var cb = ib(fb._nextWaiter); !fb._waiters[cb]; ) { | |
cb = ib(cb); | |
} | |
return cb; | |
} | |
Zc = Hb.Class.create({ | |
init: function () { | |
Object.defineProperties(this, { | |
_queue: { | |
value: [], | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_waiters: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_nextWaiter: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_lastWaiter: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
cancel: function (fb) { | |
var cb; | |
if (this._waiters[fb]) { | |
cb = this._waiters[fb]; | |
delete this._waiters[fb]; | |
fb == this._nextWaiter && (this._nextWaiter = hb(this)); | |
cb.call(this, Gb); | |
} | |
}, | |
cancelAll: function () { | |
for (; 0 !== this._nextWaiter; ) { | |
this.cancel(this._nextWaiter); | |
} | |
}, | |
poll: function (fb, cb) { | |
var nb, xb; | |
nb = this; | |
xb = ib(this._lastWaiter); | |
this._lastWaiter = xb; | |
eb( | |
cb, | |
function () { | |
var kb, Ba; | |
if (0 < this._queue.length) { | |
kb = this._queue.shift(); | |
setTimeout(function () { | |
cb.result(kb); | |
}, 0); | |
} else { | |
-1 != fb && | |
(Ba = setTimeout(function () { | |
delete nb._waiters[xb]; | |
xb == nb._nextWaiter && (nb._nextWaiter = hb(nb)); | |
cb.timeout(); | |
}, fb)); | |
this._waiters[xb] = function (La) { | |
clearTimeout(Ba); | |
setTimeout(function () { | |
cb.result(La); | |
}, 0); | |
}; | |
this._nextWaiter || (this._nextWaiter = xb); | |
} | |
}, | |
nb | |
); | |
return xb; | |
}, | |
add: function (fb) { | |
var cb; | |
if (this._nextWaiter) { | |
cb = this._waiters[this._nextWaiter]; | |
delete this._waiters[this._nextWaiter]; | |
this._nextWaiter = hb(this); | |
cb.call(this, fb); | |
} else this._queue.push(fb); | |
}, | |
}); | |
})(); | |
(function () { | |
var ib; | |
ib = 0 - Rb; | |
pe = Hb.Class.create({ | |
nextBoolean: function () { | |
var hb; | |
hb = new Uint8Array(1); | |
Bc.getRandomValues(hb); | |
return hb[0] & 1 ? !0 : !1; | |
}, | |
nextInt: function (hb) { | |
var fb; | |
if (null !== hb && hb !== Gb) { | |
if ("number" !== typeof hb) | |
throw new TypeError("n must be of type number"); | |
if (1 > hb) throw new RangeError("n must be greater than zero"); | |
--hb; | |
fb = new Uint8Array(4); | |
Bc.getRandomValues(fb); | |
return Math.floor( | |
((((fb[3] & 127) << 24) | (fb[2] << 16) | (fb[1] << 8) | fb[0]) / | |
2147483648) * | |
(hb - 0 + 1) | |
); | |
} | |
hb = new Uint8Array(4); | |
Bc.getRandomValues(hb); | |
fb = ((hb[3] & 127) << 24) | (hb[2] << 16) | (hb[1] << 8) | hb[0]; | |
return hb[3] & 128 ? -fb : fb; | |
}, | |
nextLong: function () { | |
var fb; | |
for (var hb = ib; hb == ib; ) { | |
hb = new Uint8Array(7); | |
Bc.getRandomValues(hb); | |
fb = | |
16777216 * | |
(((hb[6] & 31) << 24) | (hb[5] << 16) | (hb[4] << 8) | hb[3]) + | |
((hb[2] << 16) | (hb[1] << 8) | hb[0]); | |
hb = hb[6] & 128 ? -fb - 1 : fb; | |
} | |
return hb; | |
}, | |
nextBytes: function (hb) { | |
Bc.getRandomValues(hb); | |
}, | |
}); | |
})(); | |
(function () { | |
function ib(cb) { | |
return cb == Rb ? 1 : cb + 1; | |
} | |
function hb(cb) { | |
if (0 === Object.keys(cb._waitingReaders).length) return 0; | |
for (var nb = ib(cb._nextReader); !cb._waitingReaders[nb]; ) { | |
nb = ib(nb); | |
} | |
return nb; | |
} | |
function fb(cb) { | |
if (0 === Object.keys(cb._waitingWriters).length) return 0; | |
for (var nb = ib(cb._nextWriter); !cb._waitingWriters[nb]; ) { | |
nb = ib(nb); | |
} | |
return nb; | |
} | |
Fd = Hb.Class.create({ | |
init: function () { | |
Object.defineProperties(this, { | |
_readers: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_waitingReaders: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_writer: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_waitingWriters: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_nextReader: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_nextWriter: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_lastNumber: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
cancel: function (cb) { | |
var nb; | |
if (this._waitingReaders[cb]) { | |
nb = this._waitingReaders[cb]; | |
delete this._waitingReaders[cb]; | |
cb == this._nextReader && (this._nextReader = hb(this)); | |
nb.call(this, !0); | |
} | |
this._waitingWriters[cb] && | |
((nb = this._waitingWriters[cb]), | |
delete this._waitingWriters[cb], | |
cb == this._nextWriter && (this._nextWriter = fb(this)), | |
nb.call(this, !0)); | |
}, | |
cancelAll: function () { | |
for (; 0 !== this._nextWriter; ) { | |
this.cancel(this._nextWriter); | |
} | |
for (; 0 !== this._nextReader; ) { | |
this.cancel(this._nextReader); | |
} | |
}, | |
readLock: function (cb, nb) { | |
var xb, kb; | |
xb = this; | |
kb = ib(this._lastNumber); | |
this._lastNumber = kb; | |
eb( | |
nb, | |
function () { | |
var Ba; | |
if ( | |
!this._writer && | |
0 === Object.keys(this._waitingWriters).length | |
) | |
return (this._readers[kb] = !0), kb; | |
-1 != cb && | |
(Ba = setTimeout(function () { | |
delete xb._waitingReaders[kb]; | |
kb == xb._nextReader && (xb._nextReader = hb(xb)); | |
nb.timeout(); | |
}, cb)); | |
this._waitingReaders[kb] = function (La) { | |
clearTimeout(Ba); | |
La | |
? setTimeout(function () { | |
nb.result(Gb); | |
}, 0) | |
: ((xb._readers[kb] = !0), | |
setTimeout(function () { | |
nb.result(kb); | |
}, 0)); | |
}; | |
this._nextReader || (this._nextReader = kb); | |
}, | |
xb | |
); | |
return kb; | |
}, | |
writeLock: function (cb, nb) { | |
var xb, kb; | |
xb = this; | |
kb = ib(this._lastNumber); | |
this._lastNumber = kb; | |
eb( | |
nb, | |
function () { | |
var Ba; | |
if ( | |
0 === Object.keys(this._readers).length && | |
0 === Object.keys(this._waitingReaders).length && | |
!this._writer | |
) | |
return (this._writer = kb); | |
-1 != cb && | |
(Ba = setTimeout(function () { | |
delete xb._waitingWriters[kb]; | |
kb == xb._nextWriter && (xb._nextWriter = fb(xb)); | |
nb.timeout(); | |
}, cb)); | |
this._waitingWriters[kb] = function (La) { | |
clearTimeout(Ba); | |
La | |
? setTimeout(function () { | |
nb.result(Gb); | |
}, 0) | |
: ((xb._writer = kb), | |
setTimeout(function () { | |
nb.result(kb); | |
}, 0)); | |
}; | |
this._nextWriter || (this._nextWriter = kb); | |
}, | |
xb | |
); | |
return kb; | |
}, | |
unlock: function (cb) { | |
if (cb == this._writer) this._writer = null; | |
else { | |
if (!this._readers[cb]) | |
throw new Bb( | |
"There is no reader or writer with ticket number " + cb + "." | |
); | |
delete this._readers[cb]; | |
} | |
if (this._nextWriter) | |
0 < Object.keys(this._readers).length || | |
((cb = this._waitingWriters[this._nextWriter]), | |
delete this._waitingWriters[this._nextWriter], | |
(this._nextWriter = fb(this)), | |
cb.call(this, !1)); | |
else { | |
for ( | |
var nb = this._nextReader; | |
0 < Object.keys(this._waitingReaders).length; | |
nb = ib(nb) | |
) { | |
this._waitingReaders[nb] && | |
((cb = this._waitingReaders[nb]), | |
delete this._waitingReaders[nb], | |
cb.call(this, !1)); | |
} | |
this._nextReader = 0; | |
} | |
}, | |
}); | |
})(); | |
Hb.Class.mixin(T, { | |
JSON_PARSE_ERROR: new T(0, Ga.FAIL, "Error parsing JSON."), | |
JSON_ENCODE_ERROR: new T(1, Ga.FAIL, "Error encoding JSON."), | |
ENVELOPE_HASH_MISMATCH: new T( | |
2, | |
Ga.FAIL, | |
"Computed hash does not match envelope hash." | |
), | |
INVALID_PUBLIC_KEY: new T(3, Ga.FAIL, "Invalid public key provided."), | |
INVALID_PRIVATE_KEY: new T(4, Ga.FAIL, "Invalid private key provided."), | |
PLAINTEXT_ILLEGAL_BLOCK_SIZE: new T( | |
5, | |
Ga.FAIL, | |
"Plaintext is not a multiple of the block size." | |
), | |
PLAINTEXT_BAD_PADDING: new T( | |
6, | |
Ga.FAIL, | |
"Plaintext contains incorrect padding." | |
), | |
CIPHERTEXT_ILLEGAL_BLOCK_SIZE: new T( | |
7, | |
Ga.FAIL, | |
"Ciphertext is not a multiple of the block size." | |
), | |
CIPHERTEXT_BAD_PADDING: new T( | |
8, | |
Ga.FAIL, | |
"Ciphertext contains incorrect padding." | |
), | |
ENCRYPT_NOT_SUPPORTED: new T(9, Ga.FAIL, "Encryption not supported."), | |
DECRYPT_NOT_SUPPORTED: new T(10, Ga.FAIL, "Decryption not supported."), | |
ENVELOPE_KEY_ID_MISMATCH: new T( | |
11, | |
Ga.FAIL, | |
"Encryption envelope key ID does not match crypto context key ID." | |
), | |
CIPHERTEXT_ENVELOPE_PARSE_ERROR: new T( | |
12, | |
Ga.FAIL, | |
"Error parsing ciphertext envelope." | |
), | |
CIPHERTEXT_ENVELOPE_ENCODE_ERROR: new T( | |
13, | |
Ga.FAIL, | |
"Error encoding ciphertext envelope." | |
), | |
SIGN_NOT_SUPPORTED: new T(14, Ga.FAIL, "Sign not supported."), | |
VERIFY_NOT_SUPPORTED: new T(15, Ga.FAIL, "Verify not suppoprted."), | |
SIGNATURE_ERROR: new T( | |
16, | |
Ga.FAIL, | |
"Signature not initialized or unable to process data/signature." | |
), | |
HMAC_ERROR: new T(17, Ga.FAIL, "Error computing HMAC."), | |
ENCRYPT_ERROR: new T(18, Ga.FAIL, "Error encrypting plaintext."), | |
DECRYPT_ERROR: new T(19, Ga.FAIL, "Error decrypting ciphertext."), | |
INSUFFICIENT_CIPHERTEXT: new T( | |
20, | |
Ga.FAIL, | |
"Insufficient ciphertext for decryption." | |
), | |
SESSION_KEY_CREATION_FAILURE: new T( | |
21, | |
Ga.FAIL, | |
"Error when creating session keys." | |
), | |
ASN1_PARSE_ERROR: new T(22, Ga.FAIL, "Error parsing ASN.1."), | |
ASN1_ENCODE_ERROR: new T(23, Ga.FAIL, "Error encoding ASN.1."), | |
INVALID_SYMMETRIC_KEY: new T( | |
24, | |
Ga.FAIL, | |
"Invalid symmetric key provided." | |
), | |
INVALID_ENCRYPTION_KEY: new T(25, Ga.FAIL, "Invalid encryption key."), | |
INVALID_HMAC_KEY: new T(26, Ga.FAIL, "Invalid HMAC key."), | |
WRAP_NOT_SUPPORTED: new T(27, Ga.FAIL, "Wrap not supported."), | |
UNWRAP_NOT_SUPPORTED: new T(28, Ga.FAIL, "Unwrap not supported."), | |
UNIDENTIFIED_JWK_TYPE: new T( | |
29, | |
Ga.FAIL, | |
"Unidentified JSON web key type." | |
), | |
UNIDENTIFIED_JWK_USAGE: new T( | |
30, | |
Ga.FAIL, | |
"Unidentified JSON web key usage." | |
), | |
UNIDENTIFIED_JWK_ALGORITHM: new T( | |
31, | |
Ga.FAIL, | |
"Unidentified JSON web key algorithm." | |
), | |
WRAP_ERROR: new T(32, Ga.FAIL, "Error wrapping plaintext."), | |
UNWRAP_ERROR: new T(33, Ga.FAIL, "Error unwrapping ciphertext."), | |
INVALID_JWK: new T(34, Ga.FAIL, "Invalid JSON web key."), | |
INVALID_JWK_KEYDATA: new T(35, Ga.FAIL, "Invalid JSON web key keydata."), | |
UNSUPPORTED_JWK_ALGORITHM: new T( | |
36, | |
Ga.FAIL, | |
"Unsupported JSON web key algorithm." | |
), | |
WRAP_KEY_CREATION_FAILURE: new T( | |
37, | |
Ga.FAIL, | |
"Error when creating wrapping key." | |
), | |
INVALID_WRAP_CIPHERTEXT: new T(38, Ga.FAIL, "Invalid wrap ciphertext."), | |
UNSUPPORTED_JWE_ALGORITHM: new T( | |
39, | |
Ga.FAIL, | |
"Unsupported JSON web encryption algorithm." | |
), | |
JWE_ENCODE_ERROR: new T( | |
40, | |
Ga.FAIL, | |
"Error encoding JSON web encryption header." | |
), | |
JWE_PARSE_ERROR: new T( | |
41, | |
Ga.FAIL, | |
"Error parsing JSON web encryption header." | |
), | |
INVALID_ALGORITHM_PARAMS: new T( | |
42, | |
Ga.FAIL, | |
"Invalid algorithm parameters." | |
), | |
JWE_ALGORITHM_MISMATCH: new T( | |
43, | |
Ga.FAIL, | |
"JSON web encryption header algorithms mismatch." | |
), | |
KEY_IMPORT_ERROR: new T(44, Ga.FAIL, "Error importing key."), | |
KEY_EXPORT_ERROR: new T(45, Ga.FAIL, "Error exporting key."), | |
DIGEST_ERROR: new T(46, Ga.FAIL, "Error in digest."), | |
UNSUPPORTED_KEY: new T(47, Ga.FAIL, "Unsupported key type or algorithm."), | |
UNSUPPORTED_JWE_SERIALIZATION: new T( | |
48, | |
Ga.FAIL, | |
"Unsupported JSON web encryption serialization." | |
), | |
XML_PARSE_ERROR: new T(49, Ga.FAIL, "Error parsing XML."), | |
XML_ENCODE_ERROR: new T(50, Ga.FAIL, "Error encoding XML."), | |
INVALID_WRAPPING_KEY: new T(51, Ga.FAIL, "Invalid wrapping key."), | |
UNIDENTIFIED_CIPHERTEXT_ENVELOPE: new T( | |
52, | |
Ga.FAIL, | |
"Unidentified ciphertext envelope version." | |
), | |
UNIDENTIFIED_SIGNATURE_ENVELOPE: new T( | |
53, | |
Ga.FAIL, | |
"Unidentified signature envelope version." | |
), | |
UNSUPPORTED_CIPHERTEXT_ENVELOPE: new T( | |
54, | |
Ga.FAIL, | |
"Unsupported ciphertext envelope version." | |
), | |
UNSUPPORTED_SIGNATURE_ENVELOPE: new T( | |
55, | |
Ga.FAIL, | |
"Unsupported signature envelope version." | |
), | |
UNIDENTIFIED_CIPHERSPEC: new T( | |
56, | |
Ga.FAIL, | |
"Unidentified cipher specification." | |
), | |
UNIDENTIFIED_ALGORITHM: new T(57, Ga.FAIL, "Unidentified algorithm."), | |
SIGNATURE_ENVELOPE_PARSE_ERROR: new T( | |
58, | |
Ga.FAIL, | |
"Error parsing signature envelope." | |
), | |
SIGNATURE_ENVELOPE_ENCODE_ERROR: new T( | |
59, | |
Ga.FAIL, | |
"Error encoding signature envelope." | |
), | |
INVALID_SIGNATURE: new T(60, Ga.FAIL, "Invalid signature."), | |
WRAPKEY_FINGERPRINT_NOTSUPPORTED: new T( | |
61, | |
Ga.FAIL, | |
"Wrap key fingerprint not supported" | |
), | |
UNIDENTIFIED_JWK_KEYOP: new T( | |
62, | |
Ga.FAIL, | |
"Unidentified JSON web key key operation." | |
), | |
MASTERTOKEN_UNTRUSTED: new T( | |
1e3, | |
Ga.ENTITY_REAUTH, | |
"Master token is not trusted." | |
), | |
MASTERTOKEN_KEY_CREATION_ERROR: new T( | |
1001, | |
Ga.ENTITY_REAUTH, | |
"Unable to construct symmetric keys from master token." | |
), | |
MASTERTOKEN_EXPIRES_BEFORE_RENEWAL: new T( | |
1002, | |
Ga.ENTITY_REAUTH, | |
"Master token expiration timestamp is before the renewal window opens." | |
), | |
MASTERTOKEN_SESSIONDATA_MISSING: new T( | |
1003, | |
Ga.ENTITY_REAUTH, | |
"No master token session data found." | |
), | |
MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE: new T( | |
1004, | |
Ga.ENTITY_REAUTH, | |
"Master token sequence number is out of range." | |
), | |
MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new T( | |
1005, | |
Ga.ENTITY_REAUTH, | |
"Master token serial number is out of range." | |
), | |
MASTERTOKEN_TOKENDATA_INVALID: new T( | |
1006, | |
Ga.ENTITY_REAUTH, | |
"Invalid master token data." | |
), | |
MASTERTOKEN_SIGNATURE_INVALID: new T( | |
1007, | |
Ga.ENTITY_REAUTH, | |
"Invalid master token signature." | |
), | |
MASTERTOKEN_SESSIONDATA_INVALID: new T( | |
1008, | |
Ga.ENTITY_REAUTH, | |
"Invalid master token session data." | |
), | |
MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_SYNC: new T( | |
1009, | |
Ga.ENTITY_REAUTH, | |
"Master token sequence number does not have the expected value." | |
), | |
MASTERTOKEN_TOKENDATA_MISSING: new T( | |
1010, | |
Ga.ENTITY_REAUTH, | |
"No master token data found." | |
), | |
MASTERTOKEN_TOKENDATA_PARSE_ERROR: new T( | |
1011, | |
Ga.ENTITY_REAUTH, | |
"Error parsing master token data." | |
), | |
MASTERTOKEN_SESSIONDATA_PARSE_ERROR: new T( | |
1012, | |
Ga.ENTITY_REAUTH, | |
"Error parsing master token session data." | |
), | |
MASTERTOKEN_IDENTITY_REVOKED: new T( | |
1013, | |
Ga.ENTITY_REAUTH, | |
"Master token entity identity is revoked." | |
), | |
MASTERTOKEN_REJECTED_BY_APP: new T( | |
1014, | |
Ga.ENTITY_REAUTH, | |
"Master token is rejected by the application." | |
), | |
USERIDTOKEN_MASTERTOKEN_MISMATCH: new T( | |
2e3, | |
Ga.USER_REAUTH, | |
"User ID token master token serial number does not match master token serial number." | |
), | |
USERIDTOKEN_NOT_DECRYPTED: new T( | |
2001, | |
Ga.USER_REAUTH, | |
"User ID token is not decrypted or verified." | |
), | |
USERIDTOKEN_MASTERTOKEN_NULL: new T( | |
2002, | |
Ga.USER_REAUTH, | |
"User ID token requires a master token." | |
), | |
USERIDTOKEN_EXPIRES_BEFORE_RENEWAL: new T( | |
2003, | |
Ga.USER_REAUTH, | |
"User ID token expiration timestamp is before the renewal window opens." | |
), | |
USERIDTOKEN_USERDATA_MISSING: new T( | |
2004, | |
Ga.USER_REAUTH, | |
"No user ID token user data found." | |
), | |
USERIDTOKEN_MASTERTOKEN_NOT_FOUND: new T( | |
2005, | |
Ga.USER_REAUTH, | |
"User ID token is bound to an unknown master token." | |
), | |
USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new T( | |
2006, | |
Ga.USER_REAUTH, | |
"User ID token master token serial number is out of range." | |
), | |
USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new T( | |
2007, | |
Ga.USER_REAUTH, | |
"User ID token serial number is out of range." | |
), | |
USERIDTOKEN_TOKENDATA_INVALID: new T( | |
2008, | |
Ga.USER_REAUTH, | |
"Invalid user ID token data." | |
), | |
USERIDTOKEN_SIGNATURE_INVALID: new T( | |
2009, | |
Ga.USER_REAUTH, | |
"Invalid user ID token signature." | |
), | |
USERIDTOKEN_USERDATA_INVALID: new T( | |
2010, | |
Ga.USER_REAUTH, | |
"Invalid user ID token user data." | |
), | |
USERIDTOKEN_IDENTITY_INVALID: new T( | |
2011, | |
Ga.USER_REAUTH, | |
"Invalid user ID token user identity." | |
), | |
RESERVED_2012: new T( | |
2012, | |
Ga.USER_REAUTH, | |
"The entity is not associated with the user." | |
), | |
USERIDTOKEN_IDENTITY_NOT_FOUND: new T( | |
2013, | |
Ga.USER_REAUTH, | |
"The user identity was not found." | |
), | |
USERIDTOKEN_PASSWORD_VERSION_CHANGED: new T( | |
2014, | |
Ga.USER_REAUTH, | |
"The user identity must be reauthenticated because the password version changed." | |
), | |
USERIDTOKEN_USERAUTH_DATA_MISMATCH: new T( | |
2015, | |
Ga.USER_REAUTH, | |
"The user ID token and user authentication data user identities do not match." | |
), | |
USERIDTOKEN_TOKENDATA_MISSING: new T( | |
2016, | |
Ga.USER_REAUTH, | |
"No user ID token data found." | |
), | |
USERIDTOKEN_TOKENDATA_PARSE_ERROR: new T( | |
2017, | |
Ga.USER_REAUTH, | |
"Error parsing user ID token data." | |
), | |
USERIDTOKEN_USERDATA_PARSE_ERROR: new T( | |
2018, | |
Ga.USER_REAUTH, | |
"Error parsing user ID token user data." | |
), | |
USERIDTOKEN_REVOKED: new T( | |
2019, | |
Ga.USER_REAUTH, | |
"User ID token is revoked." | |
), | |
USERIDTOKEN_REJECTED_BY_APP: new T( | |
2020, | |
Ga.USER_REAUTH, | |
"User ID token is rejected by the application." | |
), | |
SERVICETOKEN_MASTERTOKEN_MISMATCH: new T( | |
3e3, | |
Ga.FAIL, | |
"Service token master token serial number does not match master token serial number." | |
), | |
SERVICETOKEN_USERIDTOKEN_MISMATCH: new T( | |
3001, | |
Ga.FAIL, | |
"Service token user ID token serial number does not match user ID token serial number." | |
), | |
SERVICETOKEN_SERVICEDATA_INVALID: new T( | |
3002, | |
Ga.FAIL, | |
"Service token data invalid." | |
), | |
SERVICETOKEN_MASTERTOKEN_NOT_FOUND: new T( | |
3003, | |
Ga.FAIL, | |
"Service token is bound to an unknown master token." | |
), | |
SERVICETOKEN_USERIDTOKEN_NOT_FOUND: new T( | |
3004, | |
Ga.FAIL, | |
"Service token is bound to an unknown user ID token." | |
), | |
SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new T( | |
3005, | |
Ga.FAIL, | |
"Service token master token serial number is out of range." | |
), | |
SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new T( | |
3006, | |
Ga.FAIL, | |
"Service token user ID token serial number is out of range." | |
), | |
SERVICETOKEN_TOKENDATA_INVALID: new T( | |
3007, | |
Ga.FAIL, | |
"Invalid service token data." | |
), | |
SERVICETOKEN_SIGNATURE_INVALID: new T( | |
3008, | |
Ga.FAIL, | |
"Invalid service token signature." | |
), | |
SERVICETOKEN_TOKENDATA_MISSING: new T( | |
3009, | |
Ga.FAIL, | |
"No service token data found." | |
), | |
UNIDENTIFIED_ENTITYAUTH_SCHEME: new T( | |
4e3, | |
Ga.FAIL, | |
"Unable to identify entity authentication scheme." | |
), | |
ENTITYAUTH_FACTORY_NOT_FOUND: new T( | |
4001, | |
Ga.FAIL, | |
"No factory registered for entity authentication scheme." | |
), | |
X509CERT_PARSE_ERROR: new T( | |
4002, | |
Ga.ENTITYDATA_REAUTH, | |
"Error parsing X.509 certificate data." | |
), | |
X509CERT_ENCODE_ERROR: new T( | |
4003, | |
Ga.ENTITYDATA_REAUTH, | |
"Error encoding X.509 certificate data." | |
), | |
X509CERT_VERIFICATION_FAILED: new T( | |
4004, | |
Ga.ENTITYDATA_REAUTH, | |
"X.509 certificate verification failed." | |
), | |
ENTITY_NOT_FOUND: new T(4005, Ga.FAIL, "Entity not recognized."), | |
INCORRECT_ENTITYAUTH_DATA: new T( | |
4006, | |
Ga.FAIL, | |
"Entity used incorrect entity authentication data type." | |
), | |
RSA_PUBLICKEY_NOT_FOUND: new T( | |
4007, | |
Ga.ENTITYDATA_REAUTH, | |
"RSA public key not found." | |
), | |
NPTICKET_GRACE_PERIOD_EXCEEDED: new T( | |
4008, | |
Ga.ENTITYDATA_REAUTH, | |
"Fake NP-Tickets cannot be used after the grace period when the Playstation Network is up." | |
), | |
NPTICKET_SERVICE_ID_MISSING: new T( | |
4009, | |
Ga.ENTITYDATA_REAUTH, | |
"NP-Ticket service ID is missing." | |
), | |
NPTICKET_SERVICE_ID_DISALLOWED: new T( | |
4010, | |
Ga.ENTITYDATA_REAUTH, | |
"NP-Ticket service ID is not allowed." | |
), | |
NPTICKET_NOT_YET_VALID: new T( | |
4011, | |
Ga.ENTITYDATA_REAUTH, | |
"NP-Ticket issuance date is in the future." | |
), | |
NPTICKET_EXPIRED: new T( | |
4012, | |
Ga.ENTITYDATA_REAUTH, | |
"NP-Ticket has expired." | |
), | |
NPTICKET_PRIVATE_KEY_NOT_FOUND: new T( | |
4013, | |
Ga.ENTITYDATA_REAUTH, | |
"No private key found for NP-Ticket GUID." | |
), | |
NPTICKET_COOKIE_VERIFICATION_FAILED: new T( | |
4014, | |
Ga.ENTITYDATA_REAUTH, | |
"NP-Ticket cookie signature verification failed." | |
), | |
NPTICKET_INCORRECT_COOKIE_VERSION: new T( | |
4015, | |
Ga.ENTITYDATA_REAUTH, | |
"Incorrect NP-Ticket cookie version." | |
), | |
NPTICKET_BROKEN: new T(4016, Ga.ENTITYDATA_REAUTH, "NP-Ticket broken."), | |
NPTICKET_VERIFICATION_FAILED: new T( | |
4017, | |
Ga.ENTITYDATA_REAUTH, | |
"NP-Ticket signature verification failed." | |
), | |
NPTICKET_ERROR: new T( | |
4018, | |
Ga.ENTITYDATA_REAUTH, | |
"Unknown NP-Ticket TCM error." | |
), | |
NPTICKET_CIPHER_INFO_NOT_FOUND: new T( | |
4019, | |
Ga.ENTITYDATA_REAUTH, | |
"No cipher information found for NP-Ticket." | |
), | |
NPTICKET_INVALID_CIPHER_INFO: new T( | |
4020, | |
Ga.ENTITYDATA_REAUTH, | |
"Cipher information for NP-Ticket is invalid." | |
), | |
NPTICKET_UNSUPPORTED_VERSION: new T( | |
4021, | |
Ga.ENTITYDATA_REAUTH, | |
"Unsupported NP-Ticket version." | |
), | |
NPTICKET_INCORRECT_KEY_LENGTH: new T( | |
4022, | |
Ga.ENTITYDATA_REAUTH, | |
"Incorrect NP-Ticket public key length." | |
), | |
UNSUPPORTED_ENTITYAUTH_DATA: new T( | |
4023, | |
Ga.FAIL, | |
"Unsupported entity authentication data." | |
), | |
CRYPTEX_RSA_KEY_SET_NOT_FOUND: new T( | |
4024, | |
Ga.FAIL, | |
"Cryptex RSA key set not found." | |
), | |
ENTITY_REVOKED: new T(4025, Ga.FAIL, "Entity is revoked."), | |
ENTITY_REJECTED_BY_APP: new T( | |
4026, | |
Ga.ENTITYDATA_REAUTH, | |
"Entity is rejected by the application." | |
), | |
FORCE_LOGIN: new T(5e3, Ga.USERDATA_REAUTH, "User must login again."), | |
NETFLIXID_COOKIES_EXPIRED: new T( | |
5001, | |
Ga.USERDATA_REAUTH, | |
"Netflix ID cookie identity has expired." | |
), | |
NETFLIXID_COOKIES_BLANK: new T( | |
5002, | |
Ga.USERDATA_REAUTH, | |
"Netflix ID or Secure Netflix ID cookie is blank." | |
), | |
UNIDENTIFIED_USERAUTH_SCHEME: new T( | |
5003, | |
Ga.FAIL, | |
"Unable to identify user authentication scheme." | |
), | |
USERAUTH_FACTORY_NOT_FOUND: new T( | |
5004, | |
Ga.FAIL, | |
"No factory registered for user authentication scheme." | |
), | |
EMAILPASSWORD_BLANK: new T( | |
5005, | |
Ga.USERDATA_REAUTH, | |
"Email or password is blank." | |
), | |
AUTHMGR_COMMS_FAILURE: new T( | |
5006, | |
Ga.TRANSIENT_FAILURE, | |
"Error communicating with authentication manager." | |
), | |
EMAILPASSWORD_INCORRECT: new T( | |
5007, | |
Ga.USERDATA_REAUTH, | |
"Email or password is incorrect." | |
), | |
UNSUPPORTED_USERAUTH_DATA: new T( | |
5008, | |
Ga.FAIL, | |
"Unsupported user authentication data." | |
), | |
SSOTOKEN_BLANK: new T(5009, Ga.SSOTOKEN_REJECTED, "SSO token is blank."), | |
SSOTOKEN_NOT_ASSOCIATED: new T( | |
5010, | |
Ga.USERDATA_REAUTH, | |
"SSO token is not associated with a Netflix user." | |
), | |
USERAUTH_USERIDTOKEN_INVALID: new T( | |
5011, | |
Ga.USERDATA_REAUTH, | |
"User authentication data user ID token is invalid." | |
), | |
PROFILEID_BLANK: new T(5012, Ga.USERDATA_REAUTH, "Profile ID is blank."), | |
UNIDENTIFIED_USERAUTH_MECHANISM: new T( | |
5013, | |
Ga.FAIL, | |
"Unable to identify user authentication mechanism." | |
), | |
UNSUPPORTED_USERAUTH_MECHANISM: new T( | |
5014, | |
Ga.FAIL, | |
"Unsupported user authentication mechanism." | |
), | |
SSOTOKEN_INVALID: new T(5015, Ga.SSOTOKEN_REJECTED, "SSO token invalid."), | |
USERAUTH_MASTERTOKEN_MISSING: new T( | |
5016, | |
Ga.USERDATA_REAUTH, | |
"User authentication required master token is missing." | |
), | |
ACCTMGR_COMMS_FAILURE: new T( | |
5017, | |
Ga.TRANSIENT_FAILURE, | |
"Error communicating with the account manager." | |
), | |
SSO_ASSOCIATION_FAILURE: new T( | |
5018, | |
Ga.TRANSIENT_FAILURE, | |
"SSO user association failed." | |
), | |
SSO_DISASSOCIATION_FAILURE: new T( | |
5019, | |
Ga.TRANSIENT_FAILURE, | |
"SSO user disassociation failed." | |
), | |
MDX_USERAUTH_VERIFICATION_FAILED: new T( | |
5020, | |
Ga.USERDATA_REAUTH, | |
"MDX user authentication data verification failed." | |
), | |
USERAUTH_USERIDTOKEN_NOT_DECRYPTED: new T( | |
5021, | |
Ga.USERDATA_REAUTH, | |
"User authentication data user ID token is not decrypted or verified." | |
), | |
MDX_USERAUTH_ACTION_INVALID: new T( | |
5022, | |
Ga.USERDATA_REAUTH, | |
"MDX user authentication data action is invalid." | |
), | |
CTICKET_DECRYPT_ERROR: new T( | |
5023, | |
Ga.USERDATA_REAUTH, | |
"CTicket decryption failed." | |
), | |
USERAUTH_MASTERTOKEN_INVALID: new T( | |
5024, | |
Ga.USERDATA_REAUTH, | |
"User authentication data master token is invalid." | |
), | |
USERAUTH_MASTERTOKEN_NOT_DECRYPTED: new T( | |
5025, | |
Ga.USERDATA_REAUTH, | |
"User authentication data master token is not decrypted or verified." | |
), | |
CTICKET_CRYPTOCONTEXT_ERROR: new T( | |
5026, | |
Ga.USERDATA_REAUTH, | |
"Error creating CTicket crypto context." | |
), | |
MDX_PIN_BLANK: new T( | |
5027, | |
Ga.USERDATA_REAUTH, | |
"MDX controller or target PIN is blank." | |
), | |
MDX_PIN_MISMATCH: new T( | |
5028, | |
Ga.USERDATA_REAUTH, | |
"MDX controller and target PIN mismatch." | |
), | |
MDX_USER_UNKNOWN: new T( | |
5029, | |
Ga.USERDATA_REAUTH, | |
"MDX controller user ID token or CTicket is not decrypted or verified." | |
), | |
USERAUTH_USERIDTOKEN_MISSING: new T( | |
5030, | |
Ga.USERDATA_REAUTH, | |
"User authentication required user ID token is missing." | |
), | |
MDX_CONTROLLERDATA_INVALID: new T( | |
5031, | |
Ga.USERDATA_REAUTH, | |
"MDX controller authentication data is invalid." | |
), | |
USERAUTH_ENTITY_MISMATCH: new T( | |
5032, | |
Ga.USERDATA_REAUTH, | |
"User authentication data does not match entity identity." | |
), | |
USERAUTH_INCORRECT_DATA: new T( | |
5033, | |
Ga.FAIL, | |
"Entity used incorrect key request data type" | |
), | |
SSO_ASSOCIATION_WITH_NONMEMBER: new T( | |
5034, | |
Ga.USERDATA_REAUTH, | |
"SSO user association failed because the customer is not a member." | |
), | |
SSO_ASSOCIATION_WITH_FORMERMEMBER: new T( | |
5035, | |
Ga.USERDATA_REAUTH, | |
"SSO user association failed because the customer is a former member." | |
), | |
SSO_ASSOCIATION_CONFLICT: new T( | |
5036, | |
Ga.USERDATA_REAUTH, | |
"SSO user association failed because the token identifies a different member." | |
), | |
USER_REJECTED_BY_APP: new T( | |
5037, | |
Ga.USERDATA_REAUTH, | |
"User is rejected by the application." | |
), | |
PROFILE_SWITCH_DISALLOWED: new T( | |
5038, | |
Ga.TRANSIENT_FAILURE, | |
"Unable to switch user profile." | |
), | |
MEMBERSHIPCLIENT_COMMS_FAILURE: new T( | |
5039, | |
Ga.TRANSIENT_FAILURE, | |
"Error communicating with the membership manager." | |
), | |
USERIDTOKEN_IDENTITY_NOT_ASSOCIATED_WITH_ENTITY: new T( | |
5040, | |
Ga.USER_REAUTH, | |
"The entity is not associated with the user." | |
), | |
UNSUPPORTED_COMPRESSION: new T( | |
6e3, | |
Ga.FAIL, | |
"Unsupported compression algorithm." | |
), | |
COMPRESSION_ERROR: new T(6001, Ga.FAIL, "Error compressing data."), | |
UNCOMPRESSION_ERROR: new T(6002, Ga.FAIL, "Error uncompressing data."), | |
MESSAGE_ENTITY_NOT_FOUND: new T( | |
6003, | |
Ga.FAIL, | |
"Message header entity authentication data or master token not found." | |
), | |
PAYLOAD_MESSAGE_ID_MISMATCH: new T( | |
6004, | |
Ga.FAIL, | |
"Payload chunk message ID does not match header message ID ." | |
), | |
PAYLOAD_SEQUENCE_NUMBER_MISMATCH: new T( | |
6005, | |
Ga.FAIL, | |
"Payload chunk sequence number does not match expected sequence number." | |
), | |
PAYLOAD_VERIFICATION_FAILED: new T( | |
6006, | |
Ga.FAIL, | |
"Payload chunk payload signature verification failed." | |
), | |
MESSAGE_DATA_MISSING: new T(6007, Ga.FAIL, "No message data found."), | |
MESSAGE_FORMAT_ERROR: new T(6008, Ga.FAIL, "Malformed message data."), | |
MESSAGE_VERIFICATION_FAILED: new T( | |
6009, | |
Ga.FAIL, | |
"Message header/error data signature verification failed." | |
), | |
HEADER_DATA_MISSING: new T(6010, Ga.FAIL, "No header data found."), | |
PAYLOAD_DATA_MISSING: new T( | |
6011, | |
Ga.FAIL, | |
"No payload data found in non-EOM payload chunk." | |
), | |
PAYLOAD_DATA_CORRUPT: new T( | |
6012, | |
Ga.FAIL, | |
"Corrupt payload data found in non-EOM payload chunk." | |
), | |
UNIDENTIFIED_COMPRESSION: new T( | |
6013, | |
Ga.FAIL, | |
"Unidentified compression algorithm." | |
), | |
MESSAGE_EXPIRED: new T( | |
6014, | |
Ga.EXPIRED, | |
"Message expired and not renewable. Rejected." | |
), | |
MESSAGE_ID_OUT_OF_RANGE: new T( | |
6015, | |
Ga.FAIL, | |
"Message ID is out of range." | |
), | |
INTERNAL_CODE_NEGATIVE: new T( | |
6016, | |
Ga.FAIL, | |
"Error header internal code is negative." | |
), | |
UNEXPECTED_RESPONSE_MESSAGE_ID: new T( | |
6017, | |
Ga.FAIL, | |
"Unexpected response message ID. Possible replay." | |
), | |
RESPONSE_REQUIRES_ENCRYPTION: new T( | |
6018, | |
Ga.KEYX_REQUIRED, | |
"Message response requires encryption." | |
), | |
PAYLOAD_SEQUENCE_NUMBER_OUT_OF_RANGE: new T( | |
6019, | |
Ga.FAIL, | |
"Payload chunk sequence number is out of range." | |
), | |
PAYLOAD_MESSAGE_ID_OUT_OF_RANGE: new T( | |
6020, | |
Ga.FAIL, | |
"Payload chunk message ID is out of range." | |
), | |
MESSAGE_REPLAYED: new T( | |
6021, | |
Ga.REPLAYED, | |
"Non-replayable message replayed." | |
), | |
INCOMPLETE_NONREPLAYABLE_MESSAGE: new T( | |
6022, | |
Ga.FAIL, | |
"Non-replayable message sent non-renewable or without key request data or without a master token." | |
), | |
HEADER_SIGNATURE_INVALID: new T( | |
6023, | |
Ga.FAIL, | |
"Invalid Header signature." | |
), | |
HEADER_DATA_INVALID: new T(6024, Ga.FAIL, "Invalid header data."), | |
PAYLOAD_INVALID: new T(6025, Ga.FAIL, "Invalid payload."), | |
PAYLOAD_SIGNATURE_INVALID: new T( | |
6026, | |
Ga.FAIL, | |
"Invalid payload signature." | |
), | |
RESPONSE_REQUIRES_MASTERTOKEN: new T( | |
6027, | |
Ga.KEYX_REQUIRED, | |
"Message response requires a master token." | |
), | |
RESPONSE_REQUIRES_USERIDTOKEN: new T( | |
6028, | |
Ga.USER_REAUTH, | |
"Message response requires a user ID token." | |
), | |
REQUEST_REQUIRES_USERAUTHDATA: new T( | |
6029, | |
Ga.FAIL, | |
"User-associated message requires user authentication data." | |
), | |
UNEXPECTED_MESSAGE_SENDER: new T( | |
6030, | |
Ga.FAIL, | |
"Message sender is equal to the local entity or not the master token entity." | |
), | |
NONREPLAYABLE_MESSAGE_REQUIRES_MASTERTOKEN: new T( | |
6031, | |
Ga.FAIL, | |
"Non-replayable message requires a master token." | |
), | |
NONREPLAYABLE_ID_OUT_OF_RANGE: new T( | |
6032, | |
Ga.FAIL, | |
"Non-replayable message non-replayable ID is out of range." | |
), | |
MESSAGE_SERVICETOKEN_MISMATCH: new T( | |
6033, | |
Ga.FAIL, | |
"Service token master token or user ID token serial number does not match the message token serial numbers." | |
), | |
MESSAGE_PEER_SERVICETOKEN_MISMATCH: new T( | |
6034, | |
Ga.FAIL, | |
"Peer service token master token or user ID token serial number does not match the message peer token serial numbers." | |
), | |
RESPONSE_REQUIRES_INTEGRITY_PROTECTION: new T( | |
6035, | |
Ga.KEYX_REQUIRED, | |
"Message response requires integrity protection." | |
), | |
HANDSHAKE_DATA_MISSING: new T( | |
6036, | |
Ga.FAIL, | |
"Handshake message is not renewable or does not contain key request data." | |
), | |
MESSAGE_RECIPIENT_MISMATCH: new T( | |
6037, | |
Ga.FAIL, | |
"Message recipient does not match local identity." | |
), | |
UNIDENTIFIED_KEYX_SCHEME: new T( | |
7e3, | |
Ga.FAIL, | |
"Unable to identify key exchange scheme." | |
), | |
KEYX_FACTORY_NOT_FOUND: new T( | |
7001, | |
Ga.FAIL, | |
"No factory registered for key exchange scheme." | |
), | |
KEYX_REQUEST_NOT_FOUND: new T( | |
7002, | |
Ga.FAIL, | |
"No key request found matching header key response data." | |
), | |
UNIDENTIFIED_KEYX_KEY_ID: new T( | |
7003, | |
Ga.FAIL, | |
"Unable to identify key exchange key ID." | |
), | |
UNSUPPORTED_KEYX_KEY_ID: new T( | |
7004, | |
Ga.FAIL, | |
"Unsupported key exchange key ID." | |
), | |
UNIDENTIFIED_KEYX_MECHANISM: new T( | |
7005, | |
Ga.FAIL, | |
"Unable to identify key exchange mechanism." | |
), | |
UNSUPPORTED_KEYX_MECHANISM: new T( | |
7006, | |
Ga.FAIL, | |
"Unsupported key exchange mechanism." | |
), | |
KEYX_RESPONSE_REQUEST_MISMATCH: new T( | |
7007, | |
Ga.FAIL, | |
"Key exchange response does not match request." | |
), | |
KEYX_PRIVATE_KEY_MISSING: new T( | |
7008, | |
Ga.FAIL, | |
"Key exchange private key missing." | |
), | |
UNKNOWN_KEYX_PARAMETERS_ID: new T( | |
7009, | |
Ga.FAIL, | |
"Key exchange parameters ID unknown or invalid." | |
), | |
KEYX_MASTER_TOKEN_MISSING: new T( | |
7010, | |
Ga.FAIL, | |
"Master token required for key exchange is missing." | |
), | |
KEYX_INVALID_PUBLIC_KEY: new T( | |
7011, | |
Ga.FAIL, | |
"Key exchange public key is invalid." | |
), | |
KEYX_PUBLIC_KEY_MISSING: new T( | |
7012, | |
Ga.FAIL, | |
"Key exchange public key missing." | |
), | |
KEYX_WRAPPING_KEY_MISSING: new T( | |
7013, | |
Ga.FAIL, | |
"Key exchange wrapping key missing." | |
), | |
KEYX_WRAPPING_KEY_ID_MISSING: new T( | |
7014, | |
Ga.FAIL, | |
"Key exchange wrapping key ID missing." | |
), | |
KEYX_INVALID_WRAPPING_KEY: new T( | |
7015, | |
Ga.FAIL, | |
"Key exchange wrapping key is invalid." | |
), | |
KEYX_INCORRECT_DATA: new T( | |
7016, | |
Ga.FAIL, | |
"Entity used incorrect wrapping key data type" | |
), | |
CRYPTEX_ENCRYPTION_ERROR: new T( | |
8e3, | |
Ga.FAIL, | |
"Error encrypting data with cryptex." | |
), | |
CRYPTEX_DECRYPTION_ERROR: new T( | |
8001, | |
Ga.FAIL, | |
"Error decrypting data with cryptex." | |
), | |
CRYPTEX_MAC_ERROR: new T( | |
8002, | |
Ga.FAIL, | |
"Error computing MAC with cryptex." | |
), | |
CRYPTEX_VERIFY_ERROR: new T( | |
8003, | |
Ga.FAIL, | |
"Error verifying MAC with cryptex." | |
), | |
CRYPTEX_CONTEXT_CREATION_FAILURE: new T( | |
8004, | |
Ga.FAIL, | |
"Error creating cryptex cipher or MAC context." | |
), | |
DATAMODEL_DEVICE_ACCESS_ERROR: new T( | |
8005, | |
Ga.TRANSIENT_FAILURE, | |
"Error accessing data model device." | |
), | |
DATAMODEL_DEVICETYPE_NOT_FOUND: new T( | |
8006, | |
Ga.FAIL, | |
"Data model device type not found." | |
), | |
CRYPTEX_KEYSET_UNSUPPORTED: new T( | |
8007, | |
Ga.FAIL, | |
"Cryptex key set not supported." | |
), | |
CRYPTEX_PRIVILEGE_EXCEPTION: new T( | |
8008, | |
Ga.FAIL, | |
"Insufficient privileges for cryptex operation." | |
), | |
CRYPTEX_WRAP_ERROR: new T( | |
8009, | |
Ga.FAIL, | |
"Error wrapping data with cryptex." | |
), | |
CRYPTEX_UNWRAP_ERROR: new T( | |
8010, | |
Ga.FAIL, | |
"Error unwrapping data with cryptex." | |
), | |
CRYPTEX_COMMS_FAILURE: new T( | |
8011, | |
Ga.TRANSIENT_FAILURE, | |
"Error comunicating with cryptex." | |
), | |
CRYPTEX_SIGN_ERROR: new T( | |
8012, | |
Ga.FAIL, | |
"Error computing signature with cryptex." | |
), | |
INTERNAL_EXCEPTION: new T( | |
9e3, | |
Ga.TRANSIENT_FAILURE, | |
"Internal exception." | |
), | |
MSL_COMMS_FAILURE: new T( | |
9001, | |
Ga.FAIL, | |
"Error communicating with MSL entity." | |
), | |
NONE: new T(9999, Ga.FAIL, "Special unit test error."), | |
}); | |
Object.freeze(T); | |
(function () { | |
gb = Hb.Class.create(Error()); | |
gb.mixin({ | |
init: function (ib, hb, fb) { | |
var nb, xb, kb; | |
function cb() { | |
return xb | |
? xb | |
: this.cause && this.cause instanceof gb | |
? this.cause.messageId | |
: Gb; | |
} | |
Error.captureStackTrace && | |
Error.captureStackTrace(this, this.constructor); | |
nb = ib.message; | |
hb && (nb += " [" + hb + "]"); | |
kb = this.stack; | |
Object.defineProperties(this, { | |
message: { value: nb, writable: !1, configurable: !0 }, | |
error: { value: ib, writable: !1, configurable: !0 }, | |
cause: { value: fb, writable: !1, configurable: !0 }, | |
name: { value: "MslException", writable: !1, configurable: !0 }, | |
masterToken: { value: null, writable: !0, configurable: !1 }, | |
entityAuthenticationData: { | |
value: null, | |
writable: !0, | |
configurable: !1, | |
}, | |
userIdToken: { value: null, writable: !0, configurable: !1 }, | |
userAuthenticationData: { | |
value: null, | |
writable: !0, | |
configurable: !1, | |
}, | |
messageId: { | |
get: cb, | |
set: function (Ba) { | |
if (0 > Ba || Ba > Rb) | |
throw new RangeError( | |
"Message ID " + Ba + " is outside the valid range." | |
); | |
cb() || (xb = Ba); | |
}, | |
configurable: !0, | |
}, | |
stack: { | |
get: function () { | |
var Ba; | |
Ba = this.toString(); | |
kb && (Ba += "\n" + kb); | |
fb && fb.stack && (Ba += "\nCaused by " + fb.stack); | |
return Ba; | |
}, | |
configurable: !0, | |
}, | |
}); | |
}, | |
setEntity: function (ib) { | |
!ib || | |
this.masterToken || | |
this.entityAuthenticationData || | |
(ib instanceof jc | |
? (this.masterToken = ib) | |
: ib instanceof Lc && (this.entityAuthenticationData = ib)); | |
return this; | |
}, | |
setUser: function (ib) { | |
!ib || | |
this.userIdToken || | |
this.userAuthenticationData || | |
(ib instanceof Tc | |
? (this.userIdToken = ib) | |
: ib instanceof $c && (this.userAuthenticationData = ib)); | |
return this; | |
}, | |
setMessageId: function (ib) { | |
this.messageId = ib; | |
return this; | |
}, | |
toString: function () { | |
return this.name + ": " + this.message; | |
}, | |
}); | |
})(); | |
yb = gb.extend({ | |
init: function nb(hb, fb, cb) { | |
nb.base.call(this, hb, fb, cb); | |
Object.defineProperties(this, { | |
name: { value: "MslCryptoException", writable: !1, configurable: !0 }, | |
}); | |
}, | |
}); | |
Jb = gb.extend({ | |
init: function xb(fb, cb, nb) { | |
xb.base.call(this, fb, cb, nb); | |
Object.defineProperties(this, { | |
name: { | |
value: "MslEncodingException", | |
writable: !1, | |
configurable: !0, | |
}, | |
}); | |
}, | |
}); | |
rc = gb.extend({ | |
init: function kb(cb, nb, xb) { | |
kb.base.call(this, cb, nb, xb); | |
Object.defineProperties(this, { | |
name: { | |
value: "MslEntityAuthException", | |
writable: !1, | |
configurable: !0, | |
}, | |
}); | |
}, | |
}); | |
(function () { | |
kc = Hb.Class.create(Error()); | |
kc.mixin({ | |
init: function (cb, nb, xb) { | |
var kb; | |
Error.captureStackTrace && | |
Error.captureStackTrace(this, this.constructor); | |
kb = this.stack; | |
Object.defineProperties(this, { | |
message: { value: cb, writable: !1, configurable: !1 }, | |
cause: { value: nb, writable: !1, configurable: !1 }, | |
requestCause: { value: xb, writable: !1, configurable: !1 }, | |
name: { | |
value: "MslErrorResponseException", | |
writable: !1, | |
configurable: !0, | |
}, | |
stack: { | |
get: function () { | |
var Ba; | |
Ba = this.toString(); | |
kb && (Ba += "\n" + kb); | |
nb && nb.stack && (Ba += "\nCaused by " + nb.stack); | |
return Ba; | |
}, | |
configurable: !0, | |
}, | |
}); | |
}, | |
toString: function () { | |
return this.name + ": " + this.message; | |
}, | |
}); | |
})(); | |
(function () { | |
Zb = Hb.Class.create(Error()); | |
Zb.mixin({ | |
init: function (cb, nb) { | |
var xb; | |
Error.captureStackTrace && | |
Error.captureStackTrace(this, this.constructor); | |
xb = this.stack; | |
Object.defineProperties(this, { | |
message: { value: cb, writable: !1, configurable: !1 }, | |
cause: { value: nb, writable: !1, configurable: !1 }, | |
name: { value: "MslIoException", writable: !1, configurable: !0 }, | |
stack: { | |
get: function () { | |
var kb; | |
kb = this.toString(); | |
xb && (kb += "\n" + xb); | |
nb && nb.stack && (kb += "\nCaused by " + nb.stack); | |
return kb; | |
}, | |
configurable: !0, | |
}, | |
}); | |
}, | |
toString: function () { | |
return this.name + ": " + this.message; | |
}, | |
}); | |
})(); | |
(function () { | |
Bb = Hb.Class.create(Error()); | |
Bb.mixin({ | |
init: function (cb, nb) { | |
var xb; | |
Error.captureStackTrace && | |
Error.captureStackTrace(this, this.constructor); | |
xb = this.stack; | |
Object.defineProperties(this, { | |
message: { value: cb, writable: !1, configurable: !1 }, | |
cause: { value: nb, writable: !1, configurable: !1 }, | |
name: { | |
value: "MslInternalException", | |
writable: !1, | |
configurable: !0, | |
}, | |
stack: { | |
get: function () { | |
var kb; | |
kb = this.toString(); | |
xb && (kb += "\n" + xb); | |
nb && nb.stack && (kb += "\nCaused by " + nb.stack); | |
return kb; | |
}, | |
configurable: !0, | |
}, | |
}); | |
}, | |
toString: function () { | |
return this.name + ": " + this.message; | |
}, | |
}); | |
})(); | |
(function () { | |
cc = Hb.Class.create(Error()); | |
cc.mixin({ | |
init: function (cb, nb) { | |
var xb; | |
Error.captureStackTrace && | |
Error.captureStackTrace(this, this.constructor); | |
xb = this.stack; | |
Object.defineProperties(this, { | |
message: { value: cb, writable: !1, configurable: !1 }, | |
cause: { value: nb, writable: !1, configurable: !1 }, | |
name: { | |
value: "MslInterruptedException", | |
writable: !1, | |
configurable: !0, | |
}, | |
stack: { | |
get: function () { | |
var kb; | |
kb = this.toString(); | |
xb && (kb += "\n" + xb); | |
nb && nb.stack && (kb += "\nCaused by " + nb.stack); | |
return kb; | |
}, | |
configurable: !0, | |
}, | |
}); | |
}, | |
toString: function () { | |
return this.name + ": " + this.message; | |
}, | |
}); | |
})(); | |
Ub = gb.extend({ | |
init: function Ba(nb, xb, kb) { | |
Ba.base.call(this, nb, xb, kb); | |
Object.defineProperties(this, { | |
name: { | |
value: "MslKeyExchangeException", | |
writable: !1, | |
configurable: !0, | |
}, | |
}); | |
}, | |
}); | |
ad = gb.extend({ | |
init: function Ba(xb, kb) { | |
Ba.base.call(this, xb); | |
Object.defineProperties(this, { | |
masterToken: { value: kb, writable: !1, configurable: !1 }, | |
name: { | |
value: "MslMasterTokenException", | |
writable: !1, | |
configurable: !0, | |
}, | |
}); | |
}, | |
}); | |
Nb = gb.extend({ | |
init: function Qa(kb, Ba, La) { | |
Qa.base.call(this, kb, Ba, La); | |
Object.defineProperties(this, { | |
name: { | |
value: "MslMessageException", | |
writable: !1, | |
configurable: !0, | |
}, | |
}); | |
}, | |
}); | |
Cc = gb.extend({ | |
init: function ua(Ba, La, Qa) { | |
ua.base.call(this, Ba, La, Qa); | |
Object.defineProperties(this, { | |
name: { | |
value: "MslUserAuthException", | |
writable: !1, | |
configurable: !0, | |
}, | |
}); | |
}, | |
}); | |
(function () { | |
var ma; | |
function Ba(da) { | |
return "undefined" === typeof da ? !1 : da; | |
} | |
function La(da) { | |
return da && da.length | |
? (dc === ma.V2014_02 && | |
(da = da.map(function (X) { | |
return "wrap" == X | |
? "wrapKey" | |
: "unwrap" == X | |
? "unwrapKey" | |
: X; | |
})), | |
da) | |
: dc === ma.V2014_02 | |
? "encrypt decrypt sign verify deriveKey wrapKey unwrapKey".split(" ") | |
: "encrypt decrypt sign verify deriveKey wrap unwrap".split(" "); | |
} | |
function Qa(da, X, U, V, aa) { | |
return Promise.resolve() | |
.then(function () { | |
return Vb.importKey(da, X, U, V, aa); | |
}) | |
.catch(function (W) { | |
var ha; | |
if ("spki" !== da && "pkcs8" !== da) throw W; | |
W = ASN1.webCryptoAlgorithmToJwkAlg(U); | |
ha = ASN1.webCryptoUsageToJwkKeyOps(aa); | |
W = ASN1.rsaDerToJwk(X, W, ha, V); | |
if (!W) throw Error("Could not make valid JWK from DER input"); | |
W = JSON.stringify(W); | |
return Vb.importKey("jwk", Bd(W), U, V, aa); | |
}); | |
} | |
function ua(da, X) { | |
return Promise.resolve() | |
.then(function () { | |
return Vb.exportKey(da, X); | |
}) | |
.catch(function (U) { | |
if ("spki" !== da && "pkcs8" !== da) throw U; | |
return Vb.exportKey("jwk", X).then(function (V) { | |
V = JSON.parse(Ad(new Uint8Array(V))); | |
V = ASN1.jwkToRsaDer(V); | |
if (!V) throw Error("Could not make valid DER from JWK input"); | |
return V.getDer().buffer; | |
}); | |
}); | |
} | |
ma = md = { LEGACY: 1, V2014_01: 2, V2014_02: 3, LATEST: 3 }; | |
Object.freeze(md); | |
dc = ma.LATEST; | |
Qb = { | |
encrypt: function (da, X, U) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (V, aa) { | |
var W; | |
W = Vb.encrypt(da, X, U); | |
W.oncomplete = function (ha) { | |
V(ha.target.result); | |
}; | |
W.onerror = function (ha) { | |
aa(ha); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.encrypt(da, X, U).then(function (V) { | |
return new Uint8Array(V); | |
}); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
decrypt: function (da, X, U) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (V, aa) { | |
var W; | |
W = Vb.decrypt(da, X, U); | |
W.oncomplete = function (ha) { | |
V(ha.target.result); | |
}; | |
W.onerror = function (ha) { | |
aa(ha); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.decrypt(da, X, U).then(function (V) { | |
return new Uint8Array(V); | |
}); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
sign: function (da, X, U) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (V, aa) { | |
var W; | |
W = Vb.sign(da, X, U); | |
W.oncomplete = function (ha) { | |
V(ha.target.result); | |
}; | |
W.onerror = function (ha) { | |
aa(ha); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.sign(da, X, U).then(function (V) { | |
return new Uint8Array(V); | |
}); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
verify: function (da, X, U, V) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (aa, W) { | |
var ha; | |
ha = Vb.verify(da, X, U, V); | |
ha.oncomplete = function (va) { | |
aa(va.target.result); | |
}; | |
ha.onerror = function (va) { | |
W(va); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.verify(da, X, U, V); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
digest: function (da, X) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (U, V) { | |
var aa; | |
aa = Vb.digest(da, X); | |
aa.oncomplete = function (W) { | |
U(W.target.result); | |
}; | |
aa.onerror = function (W) { | |
V(W); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.digest(da, X).then(function (U) { | |
return new Uint8Array(U); | |
}); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
generateKey: function (da, X, U) { | |
var V, aa; | |
V = Ba(X); | |
aa = La(U); | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (W, ha) { | |
var va; | |
va = Vb.generateKey(da, V, aa); | |
va.oncomplete = function (ra) { | |
W(ra.target.result); | |
}; | |
va.onerror = function (ra) { | |
ha(ra); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.generateKey(da, V, aa); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
deriveKey: function (da, X, U, V, aa) { | |
var W, ha; | |
W = Ba(V); | |
ha = La(aa); | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (va, ra) { | |
var ia; | |
ia = Vb.deriveKey(da, X, U, W, ha); | |
ia.oncomplete = function (qa) { | |
va(qa.target.result); | |
}; | |
ia.onerror = function (qa) { | |
ra(qa); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.deriveKey(da, X, U, W, ha); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
importKey: function (da, X, U, V, aa) { | |
var W, ha; | |
W = Ba(V); | |
ha = La(aa); | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (va, ra) { | |
var ia; | |
ia = Vb.importKey(da, X, U, W, ha); | |
ia.oncomplete = function (qa) { | |
va(qa.target.result); | |
}; | |
ia.onerror = function (qa) { | |
ra(qa); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Qa(da, X, U, W, ha); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
exportKey: function (da, X) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (U, V) { | |
var aa; | |
aa = Vb.exportKey(da, X); | |
aa.oncomplete = function (W) { | |
U(W.target.result); | |
}; | |
aa.onerror = function (W) { | |
V(W); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return ua(da, X).then(function (U) { | |
return new Uint8Array(U); | |
}); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
wrapKey: function (da, X, U, V) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (aa, W) { | |
var ha; | |
ha = Vb.wrapKey(X, U, V); | |
ha.oncomplete = function (va) { | |
aa(va.target.result); | |
}; | |
ha.onerror = function (va) { | |
W(va); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.wrapKey(da, X, U, V).then(function (aa) { | |
return new Uint8Array(aa); | |
}); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
unwrapKey: function (da, X, U, V, aa, W, ha) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (va, ra) { | |
var ia; | |
ia = Vb.unwrapKey(X, aa, U); | |
ia.oncomplete = function (qa) { | |
va(qa.target.result); | |
}; | |
ia.onerror = function (qa) { | |
ra(qa); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return Vb.unwrapKey(da, X, U, V, aa, Ba(W), La(ha)); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}, | |
}; | |
kd && | |
kd.getKeyByName && | |
(Qb.getKeyByName = function (da) { | |
switch (dc) { | |
case ma.LEGACY: | |
return new Promise(function (X, U) { | |
var V; | |
V = kd.getKeyByName(da); | |
V.oncomplete = function (aa) { | |
X(aa.target.result); | |
}; | |
V.onerror = function (aa) { | |
U(aa); | |
}; | |
}); | |
case ma.V2014_01: | |
case ma.V2014_02: | |
return kd.getKeyByName(da); | |
default: | |
throw Error( | |
"Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "." | |
); | |
} | |
}); | |
ob.netflix = ob.netflix || {}; | |
ob.netflix.crypto = Qb; | |
})(); | |
sc = { name: "AES-KW" }; | |
oc = { name: "AES-CBC" }; | |
pc = { name: "HMAC", hash: { name: "SHA-256" } }; | |
nd = { name: "RSA-OAEP", hash: { name: "SHA-1" } }; | |
Gd = { name: "RSAES-PKCS1-v1_5" }; | |
qe = { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-256" } }; | |
Dc = ["encrypt", "decrypt"]; | |
Ec = ["wrap", "unwrap"]; | |
Mc = ["sign", "verify"]; | |
(function () { | |
Hd = Hb.Class.create({ | |
init: function (Ba, La, Qa) { | |
var ma; | |
function ua(da) { | |
Na( | |
La, | |
function () { | |
var X; | |
X = da ? Kb(da) : Gb; | |
Object.defineProperties(ma, { | |
rawKey: { value: Ba, writable: !1, configurable: !1 }, | |
keyData: { value: da, writable: !1, configurable: !1 }, | |
keyDataB64: { value: X, writable: !1, configurable: !1 }, | |
}); | |
return this; | |
}, | |
ma | |
); | |
} | |
ma = this; | |
Na( | |
La, | |
function () { | |
if (!Ba || "object" != typeof Ba) | |
throw new yb(T.INVALID_SYMMETRIC_KEY); | |
!Qa && Ba.extractable | |
? Qb.exportKey("raw", Ba).then( | |
function (da) { | |
ua(new Uint8Array(da)); | |
}, | |
function (da) { | |
La.error(new yb(T.KEY_EXPORT_ERROR, "raw")); | |
} | |
) | |
: ua(Qa); | |
}, | |
ma | |
); | |
}, | |
size: function () { | |
return this.keyData.length; | |
}, | |
toByteArray: function () { | |
return this.keyData; | |
}, | |
toBase64: function () { | |
return this.keyDataB64; | |
}, | |
}); | |
bd = function (Ba, La) { | |
new Hd(Ba, La); | |
}; | |
tc = function (Ba, La, Qa, ua) { | |
Na(ua, function () { | |
try { | |
Ba = "string" == typeof Ba ? Mb(Ba) : Ba; | |
} catch (ma) { | |
throw new yb(T.INVALID_SYMMETRIC_KEY, "keydata " + Ba, ma); | |
} | |
Qb.importKey("raw", Ba, La, !0, Qa).then( | |
function (ma) { | |
new Hd(ma, ua, Ba); | |
}, | |
function (ma) { | |
ua.error(new yb(T.INVALID_SYMMETRIC_KEY)); | |
} | |
); | |
}); | |
}; | |
})(); | |
(function () { | |
od = Hb.Class.create({ | |
init: function (Ba, La, Qa) { | |
var ma; | |
function ua(da) { | |
Na( | |
La, | |
function () { | |
Object.defineProperties(ma, { | |
rawKey: { value: Ba, writable: !1, configurable: !1 }, | |
encoded: { value: da, writable: !1, configurable: !1 }, | |
}); | |
return this; | |
}, | |
ma | |
); | |
} | |
ma = this; | |
Na(La, function () { | |
if (!Ba || "object" != typeof Ba || "public" != Ba.type) | |
throw new TypeError( | |
"Only original public crypto keys are supported." | |
); | |
!Qa && Ba.extractable | |
? Qb.exportKey("spki", Ba).then( | |
function (da) { | |
ua(new Uint8Array(da)); | |
}, | |
function (da) { | |
La.error(new yb(T.KEY_EXPORT_ERROR, "spki")); | |
} | |
) | |
: ua(Qa); | |
}); | |
}, | |
getEncoded: function () { | |
return this.encoded; | |
}, | |
}); | |
Jc = function (Ba, La) { | |
new od(Ba, La); | |
}; | |
Id = function (Ba, La, Qa, ua) { | |
Na(ua, function () { | |
try { | |
Ba = "string" == typeof Ba ? Mb(Ba) : Ba; | |
} catch (ma) { | |
throw new yb(T.INVALID_PUBLIC_KEY, "spki " + Ba, ma); | |
} | |
Qb.importKey("spki", Ba, La, !0, Qa).then( | |
function (ma) { | |
new od(ma, ua, Ba); | |
}, | |
function (ma) { | |
ua.error(new yb(T.INVALID_PUBLIC_KEY)); | |
} | |
); | |
}); | |
}; | |
})(); | |
(function () { | |
re = Hb.Class.create({ | |
init: function (Ba, La, Qa) { | |
var ma; | |
function ua(da) { | |
Na( | |
La, | |
function () { | |
Object.defineProperties(ma, { | |
rawKey: { value: Ba, writable: !1, configurable: !1 }, | |
encoded: { value: da, writable: !1, configurable: !1 }, | |
}); | |
return this; | |
}, | |
ma | |
); | |
} | |
ma = this; | |
Na(La, function () { | |
if (!Ba || "object" != typeof Ba || "private" != Ba.type) | |
throw new TypeError( | |
"Only original private crypto keys are supported." | |
); | |
!Qa && Ba.extractable | |
? Qb.exportKey("pkcs8", Ba).then( | |
function (da) { | |
ua(new Uint8Array(da)); | |
}, | |
function (da) { | |
La.error(new yb(T.KEY_EXPORT_ERROR, "pkcs8")); | |
} | |
) | |
: ua(Qa); | |
}); | |
}, | |
getEncoded: function () { | |
return this.encoded; | |
}, | |
}); | |
Sc = function (Ba, La) { | |
new re(Ba, La); | |
}; | |
})(); | |
(function () { | |
var Ba; | |
Ba = Md = { V1: 1, V2: 2 }; | |
Jd = Hb.Class.create({ | |
init: function (La, Qa, ua, ma) { | |
Na( | |
ma, | |
function () { | |
var da, X, U, V; | |
da = Ba.V1; | |
X = La; | |
U = null; | |
for (V in ld) { | |
if (ld[V] == La) { | |
da = Ba.V2; | |
X = null; | |
U = La; | |
break; | |
} | |
} | |
Object.defineProperties(this, { | |
version: { | |
value: da, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
keyId: { value: X, writable: !1, configurable: !1 }, | |
cipherSpec: { value: U, writable: !1, configurable: !1 }, | |
iv: { value: Qa, writable: !1, configurable: !1 }, | |
ciphertext: { value: ua, writable: !1, configurable: !1 }, | |
}); | |
return this; | |
}, | |
this | |
); | |
}, | |
toJSON: function () { | |
var La; | |
La = {}; | |
switch (this.version) { | |
case Ba.V1: | |
La.keyid = this.keyId; | |
this.iv && (La.iv = Kb(this.iv)); | |
La.ciphertext = Kb(this.ciphertext); | |
La.sha256 = "AA=="; | |
break; | |
case Ba.V2: | |
La.version = this.version; | |
La.cipherspec = this.cipherSpec; | |
this.iv && (La.iv = Kb(this.iv)); | |
La.ciphertext = Kb(this.ciphertext); | |
break; | |
default: | |
throw new Bb( | |
"Ciphertext envelope version " + | |
this.version + | |
" encoding unsupported." | |
); | |
} | |
return La; | |
}, | |
}); | |
Kd = function (La, Qa, ua, ma) { | |
new Jd(La, Qa, ua, ma); | |
}; | |
Ld = function (La, Qa, ua) { | |
Na(ua, function () { | |
var ma, da, X, U, V, aa, W; | |
ma = La.keyid; | |
da = La.cipherspec; | |
X = La.iv; | |
U = La.ciphertext; | |
V = La.sha256; | |
if (!Qa) | |
if ((Qa = La.version) && "number" === typeof Qa && Qa === Qa) { | |
aa = !1; | |
for (W in Ba) { | |
if (Ba[W] == Qa) { | |
aa = !0; | |
break; | |
} | |
} | |
if (!aa) | |
throw new yb( | |
T.UNIDENTIFIED_CIPHERTEXT_ENVELOPE, | |
"ciphertext envelope " + JSON.stringify(La) | |
); | |
} else Qa = Ba.V1; | |
switch (Qa) { | |
case Ba.V1: | |
if ( | |
"string" !== typeof ma || | |
(X && "string" !== typeof X) || | |
"string" !== typeof U || | |
"string" !== typeof V | |
) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"ciphertext envelope " + JSON.stringify(La) | |
); | |
break; | |
case Ba.V2: | |
W = La.version; | |
if (W != Ba.V2) | |
throw new yb( | |
T.UNIDENTIFIED_CIPHERTEXT_ENVELOPE, | |
"ciphertext envelope " + JSON.stringify(La) | |
); | |
if ( | |
"string" !== typeof da || | |
(X && "string" !== typeof X) || | |
"string" !== typeof U | |
) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"ciphertext envelope " + JSON.stringify(La) | |
); | |
da = ne(da); | |
if (!da) | |
throw new yb( | |
T.UNIDENTIFIED_CIPHERSPEC, | |
"ciphertext envelope " + JSON.stringify(La) | |
); | |
ma = da; | |
break; | |
default: | |
throw new yb( | |
T.UNSUPPORTED_CIPHERTEXT_ENVELOPE, | |
"ciphertext envelope " + JSON.stringify(La) | |
); | |
} | |
try { | |
X && (X = Mb(X)); | |
U = Mb(U); | |
} catch (ha) { | |
throw new yb( | |
T.CIPHERTEXT_ENVELOPE_PARSE_ERROR, | |
"encryption envelope " + JSON.stringify(La), | |
ha | |
); | |
} | |
new Jd(ma, X, U, ua); | |
}); | |
}; | |
})(); | |
(function () { | |
var Ba; | |
Ba = Pd = { V1: 1, V2: 2 }; | |
uc = Hb.Class.create({ | |
init: function (La, Qa, ua) { | |
var ma; | |
switch (La) { | |
case Ba.V1: | |
ma = ua; | |
break; | |
case Ba.V2: | |
ma = {}; | |
ma.version = La; | |
ma.algorithm = Qa; | |
ma.signature = Kb(ua); | |
ma = fc(JSON.stringify(ma), Tb); | |
break; | |
default: | |
throw new Bb( | |
"Signature envelope version " + La + " encoding unsupported." | |
); | |
} | |
Object.defineProperties(this, { | |
version: { | |
value: La, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
algorithm: { value: Qa, writable: !1, configurable: !1 }, | |
signature: { value: ua, writable: !1, configurable: !1 }, | |
bytes: { value: ma, writable: !1, configurable: !1 }, | |
}); | |
}, | |
}); | |
Nd = function () { | |
var La, Qa, ua, ma; | |
if (2 == arguments.length) { | |
La = Ba.V1; | |
Qa = arguments[0]; | |
ua = null; | |
ma = arguments[1]; | |
} else | |
3 == arguments.length && | |
((La = Ba.V2), | |
(ua = arguments[0]), | |
(Qa = arguments[1]), | |
(ma = arguments[2])); | |
Na(ma, function () { | |
return new uc(La, ua, Qa); | |
}); | |
}; | |
Od = function (La, Qa, ua) { | |
Na(ua, function () { | |
var ma, da, X, U, V, aa, W; | |
if (Qa) | |
switch (Qa) { | |
case Ba.V1: | |
return new uc(Ba.V1, null, La); | |
case Ba.V2: | |
try { | |
ma = ec(La, Tb); | |
da = JSON.parse(ma); | |
X = parseInt(da.version); | |
U = da.algorithm; | |
V = da.signature; | |
if ( | |
!X || | |
"number" !== typeof X || | |
X != X || | |
"string" !== typeof U || | |
"string" !== typeof V | |
) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"signature envelope " + Kb(La) | |
); | |
if (Ba.V2 != X) | |
throw new yb( | |
T.UNSUPPORTED_SIGNATURE_ENVELOPE, | |
"signature envelope " + Kb(La) | |
); | |
aa = Ed(U); | |
if (!aa) | |
throw new yb( | |
T.UNIDENTIFIED_ALGORITHM, | |
"signature envelope " + Kb(La) | |
); | |
W = Mb(V); | |
if (!W) | |
throw new yb( | |
T.INVALID_SIGNATURE, | |
"signature envelope " + Base64Util.encode(La) | |
); | |
return new uc(Ba.V2, aa, W); | |
} catch (ha) { | |
if (ha instanceof SyntaxError) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"signature envelope " + Kb(La), | |
ha | |
); | |
throw ha; | |
} | |
default: | |
throw new yb( | |
T.UNSUPPORTED_SIGNATURE_ENVELOPE, | |
"signature envelope " + Kb(La) | |
); | |
} | |
try { | |
ma = ec(La, Tb); | |
da = JSON.parse(ma); | |
} catch (ha) { | |
da = null; | |
} | |
if (da && da.version) { | |
if (((ma = da.version), "number" !== typeof ma || ma !== ma)) | |
ma = Ba.V1; | |
} else ma = Ba.V1; | |
switch (ma) { | |
case Ba.V1: | |
return new uc(ma, null, La); | |
case Ba.V2: | |
aa = da.algorithm; | |
V = da.signature; | |
if ("string" !== typeof aa || "string" !== typeof V) | |
return new uc(Ba.V1, null, La); | |
aa = Ed(aa); | |
if (!aa) return new uc(Ba.V1, null, La); | |
try { | |
W = Mb(V); | |
} catch (ha) { | |
return new uc(Ba.V1, null, La); | |
} | |
return new uc(ma, aa, W); | |
default: | |
throw new yb( | |
T.UNSUPPORTED_SIGNATURE_ENVELOPE, | |
"signature envelope " + La | |
); | |
} | |
}); | |
}; | |
})(); | |
Uc = Hb.Class.create({ | |
encrypt: function (Ba, La) {}, | |
decrypt: function (Ba, La) {}, | |
wrap: function (Ba, La) {}, | |
unwrap: function (Ba, La, Qa, ua) {}, | |
sign: function (Ba, La) {}, | |
verify: function (Ba, La, Qa) {}, | |
}); | |
(function () { | |
var Ba; | |
Ba = wc = { RSA_OAEP: nd.name, A128KW: sc.name }; | |
qc = "A128GCM"; | |
vc = Hb.Class.create({ | |
init: function (La, Qa, ua, ma, da) { | |
switch (Qa) { | |
case Ba.RSA_OAEP: | |
da = da && (da.rawKey || da); | |
ma = ma && (ma.rawKey || ma); | |
break; | |
case Ba.A128KW: | |
da = ma = ma && (ma.rawKey || ma); | |
break; | |
default: | |
throw new Bb("Unsupported algorithm: " + Qa); | |
} | |
Object.defineProperties(this, { | |
_ctx: { value: La, writable: !1, enumerable: !1, configurable: !1 }, | |
_algo: { | |
value: Qa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_enc: { value: ua, writable: !1, enumerable: !1, configurable: !1 }, | |
_wrapKey: { | |
value: da, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_unwrapKey: { | |
value: ma, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
encrypt: function (La, Qa) { | |
Qa.error(new yb(T.ENCRYPT_NOT_SUPPORTED)); | |
}, | |
decrypt: function (La, Qa) { | |
Qa.error(new yb(T.DECRYPT_NOT_SUPPORTED)); | |
}, | |
wrap: function (La, Qa) { | |
Na( | |
Qa, | |
function () { | |
Qb.wrapKey( | |
"jwe+jwk", | |
La.rawKey, | |
this._wrapKey, | |
this._wrapKey.algorithm | |
).then( | |
function (ua) { | |
Qa.result(ua); | |
}, | |
function (ua) { | |
Qa.error(new yb(T.WRAP_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
unwrap: function (La, Qa, ua, ma) { | |
function da(X) { | |
Na(ma, function () { | |
switch (X.type) { | |
case "secret": | |
bd(X, ma); | |
break; | |
case "public": | |
Jc(X, ma); | |
break; | |
case "private": | |
Sc(X, ma); | |
break; | |
default: | |
throw new yb(T.UNSUPPORTED_KEY, "type: " + X.type); | |
} | |
}); | |
} | |
Na( | |
ma, | |
function () { | |
Qb.unwrapKey( | |
"jwe+jwk", | |
La, | |
this._unwrapKey, | |
this._unwrapKey.algorithm, | |
Qa, | |
!1, | |
ua | |
).then( | |
function (X) { | |
da(X); | |
}, | |
function () { | |
ma.error(new yb(T.UNWRAP_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
sign: function (La, Qa) { | |
Qa.error(new yb(T.SIGN_NOT_SUPPORTED)); | |
}, | |
verify: function (La, Qa, ua) { | |
ua.error(new yb(T.VERIFY_NOT_SUPPORTED)); | |
}, | |
}); | |
})(); | |
Vc = Uc.extend({ | |
encrypt: function (Ba, La) { | |
La.result(Ba); | |
}, | |
decrypt: function (Ba, La) { | |
La.result(Ba); | |
}, | |
wrap: function (Ba, La) { | |
La.result(Ba); | |
}, | |
unwrap: function (Ba, La, Qa, ua) { | |
ua.result(Ba); | |
}, | |
sign: function (Ba, La) { | |
La.result(new Uint8Array(0)); | |
}, | |
verify: function (Ba, La, Qa) { | |
Qa.result(!0); | |
}, | |
}); | |
(function () { | |
var Ba; | |
Ba = qd = { | |
ENCRYPT_DECRYPT_OAEP: 1, | |
ENCRYPT_DECRYPT_PKCS1: 2, | |
WRAP_UNWRAP_OAEP: 3, | |
WRAP_UNWRAP_PKCS1: 4, | |
SIGN_VERIFY: 5, | |
}; | |
pd = Uc.extend({ | |
init: function U(Qa, ua, ma, da, X) { | |
U.base.call(this); | |
ma && (ma = ma.rawKey); | |
da && (da = da.rawKey); | |
Object.defineProperties(this, { | |
id: { value: ua, writable: !1, enumerable: !1, configurable: !1 }, | |
privateKey: { | |
value: ma, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
publicKey: { | |
value: da, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
transform: { | |
value: | |
X == Ba.ENCRYPT_DECRYPT_PKCS1 | |
? Gd | |
: X == Ba.ENCRYPT_DECRYPT_OAEP | |
? nd | |
: "nullOp", | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
wrapTransform: { | |
value: | |
X == Ba.WRAP_UNWRAP_PKCS1 | |
? Gd | |
: X == Ba.WRAP_UNWRAP_OAEP | |
? nd | |
: "nullOp", | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
algo: { | |
value: X == Ba.SIGN_VERIFY ? qe : "nullOp", | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
encrypt: function (Qa, ua) { | |
var ma; | |
ma = this; | |
Na( | |
ua, | |
function () { | |
if ("nullOp" == this.transform) return Qa; | |
if (!this.publicKey) | |
throw new yb(T.ENCRYPT_NOT_SUPPORTED, "no public key"); | |
if (0 == Qa.length) return Qa; | |
Qb.encrypt(ma.transform, ma.publicKey, Qa).then( | |
function (da) { | |
Kd(ma.id, null, da, { | |
result: function (X) { | |
var U; | |
try { | |
U = JSON.stringify(X); | |
ua.result(fc(U, Tb)); | |
} catch (V) { | |
ua.error(new yb(T.ENCRYPT_ERROR, null, V)); | |
} | |
}, | |
error: function (X) { | |
X instanceof gb || (X = new yb(T.ENCRYPT_ERROR, null, X)); | |
ua.error(X); | |
}, | |
}); | |
}, | |
function (da) { | |
ua.error(new yb(T.ENCRYPT_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
decrypt: function (Qa, ua) { | |
var ma; | |
ma = this; | |
Na( | |
ua, | |
function () { | |
var da, X; | |
if ("nullOp" == this.transform) return Qa; | |
if (!this.privateKey) | |
throw new yb(T.DECRYPT_NOT_SUPPORTED, "no private key"); | |
if (0 == Qa.length) return Qa; | |
try { | |
da = ec(Qa, Tb); | |
X = JSON.parse(da); | |
} catch (U) { | |
if (U instanceof SyntaxError) | |
throw new yb(T.CIPHERTEXT_ENVELOPE_PARSE_ERROR, null, U); | |
throw new yb(T.DECRYPT_ERROR, null, U); | |
} | |
Ld(X, Md.V1, { | |
result: function (U) { | |
var V; | |
try { | |
if (U.keyId != ma.id) | |
throw new yb(T.ENVELOPE_KEY_ID_MISMATCH); | |
V = ua.result; | |
Qb.decrypt(ma.transform, ma.privateKey, U.ciphertext).then( | |
V, | |
function (aa) { | |
ua.error(new yb(T.DECRYPT_ERROR)); | |
} | |
); | |
} catch (aa) { | |
aa instanceof gb | |
? ua.error(aa) | |
: ua.error(new yb(T.DECRYPT_ERROR, null, aa)); | |
} | |
}, | |
error: function (U) { | |
U instanceof Jb && | |
(U = new yb(T.CIPHERTEXT_ENVELOPE_ENCODE_ERROR, null, U)); | |
U instanceof gb || (U = new yb(T.DECRYPT_ERROR, null, U)); | |
ua.error(U); | |
}, | |
}); | |
}, | |
this | |
); | |
}, | |
wrap: function (Qa, ua) { | |
Na( | |
ua, | |
function () { | |
var ma; | |
if ("nullOp" == this.wrapTransform || !this.publicKey) | |
throw new yb(T.WRAP_NOT_SUPPORTED, "no public key"); | |
ma = ua.result; | |
Qb.wrapKey( | |
"jwk", | |
Qa.rawKey, | |
this.publicKey, | |
this.wrapTransform | |
).then(ma, function (da) { | |
ua.error(new yb(T.WRAP_ERROR)); | |
}); | |
}, | |
this | |
); | |
}, | |
unwrap: function (Qa, ua, ma, da) { | |
function X(U) { | |
Na(da, function () { | |
switch (U.type) { | |
case "secret": | |
bd(U, da); | |
break; | |
case "public": | |
Jc(U, da); | |
break; | |
case "private": | |
Sc(U, da); | |
break; | |
default: | |
throw new yb(T.UNSUPPORTED_KEY, "type: " + U.type); | |
} | |
}); | |
} | |
Na( | |
da, | |
function () { | |
if ("nullOp" == this.wrapTransform || !this.privateKey) | |
throw new yb(T.UNWRAP_NOT_SUPPORTED, "no private key"); | |
Qb.unwrapKey( | |
"jwk", | |
Qa, | |
this.privateKey, | |
{ | |
name: this.privateKey.algorithm.name, | |
hash: { name: "SHA-1" }, | |
}, | |
ua, | |
!1, | |
ma | |
).then(X, function (U) { | |
da.error(new yb(T.UNWRAP_ERROR)); | |
}); | |
}, | |
this | |
); | |
}, | |
sign: function (Qa, ua) { | |
Na( | |
ua, | |
function () { | |
if ("nullOp" == this.algo) return new Uint8Array(0); | |
if (!this.privateKey) | |
throw new yb(T.SIGN_NOT_SUPPORTED, "no private key"); | |
Qb.sign(this.algo, this.privateKey, Qa).then( | |
function (ma) { | |
Nd(ma, { | |
result: function (da) { | |
ua.result(da.bytes); | |
}, | |
error: ua.error, | |
}); | |
}, | |
function (ma) { | |
ua.error(new yb(T.SIGNATURE_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
verify: function (Qa, ua, ma) { | |
var da; | |
da = this; | |
Na( | |
ma, | |
function () { | |
if ("nullOp" == this.algo) return !0; | |
if (!this.publicKey) | |
throw new yb(T.VERIFY_NOT_SUPPORTED, "no public key"); | |
Od(ua, Pd.V1, { | |
result: function (X) { | |
Na( | |
ma, | |
function () { | |
var U; | |
U = ma.result; | |
Qb.verify( | |
this.algo, | |
this.publicKey, | |
X.signature, | |
Qa | |
).then(U, function (V) { | |
ma.error(new yb(T.SIGNATURE_ERROR)); | |
}); | |
}, | |
da | |
); | |
}, | |
error: ma.error, | |
}); | |
}, | |
this | |
); | |
}, | |
}); | |
})(); | |
(function () { | |
rd = Uc.extend({ | |
init: function X(La, Qa, ua, ma, da) { | |
X.base.call(this); | |
ua = ua && ua.rawKey; | |
ma = ma && ma.rawKey; | |
da = da && da.rawKey; | |
Object.defineProperties(this, { | |
ctx: { value: La, writable: !1, enumerable: !1, configurable: !1 }, | |
id: { value: Qa, writable: !1, enumerable: !1, configurable: !1 }, | |
encryptionKey: { | |
value: ua, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
hmacKey: { | |
value: ma, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
wrapKey: { | |
value: da, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
encrypt: function (La, Qa) { | |
var ua; | |
ua = this; | |
Na( | |
Qa, | |
function () { | |
var ma; | |
if (!this.encryptionKey) | |
throw new yb( | |
T.ENCRYPT_NOT_SUPPORTED, | |
"no encryption/decryption key" | |
); | |
if (0 == La.length) return La; | |
ma = new Uint8Array(16); | |
this.ctx.getRandom().nextBytes(ma); | |
Qb.encrypt({ name: oc.name, iv: ma }, ua.encryptionKey, La).then( | |
function (da) { | |
da = new Uint8Array(da); | |
Kd(ua.id, ma, da, { | |
result: function (X) { | |
var U; | |
try { | |
U = JSON.stringify(X); | |
Qa.result(fc(U, Tb)); | |
} catch (V) { | |
Qa.error(new yb(T.ENCRYPT_ERROR, null, V)); | |
} | |
}, | |
error: function (X) { | |
X instanceof gb || (X = new yb(T.ENCRYPT_ERROR, null, X)); | |
Qa.error(X); | |
}, | |
}); | |
}, | |
function (da) { | |
Qa.error(new yb(T.ENCRYPT_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
decrypt: function (La, Qa) { | |
var ua; | |
ua = this; | |
Na( | |
Qa, | |
function () { | |
var ma, da; | |
if (!this.encryptionKey) | |
throw new yb( | |
T.DECRYPT_NOT_SUPPORTED, | |
"no encryption/decryption key" | |
); | |
if (0 == La.length) return La; | |
try { | |
ma = ec(La, Tb); | |
da = JSON.parse(ma); | |
} catch (X) { | |
if (X instanceof SyntaxError) | |
throw new yb(T.CIPHERTEXT_ENVELOPE_PARSE_ERROR, null, X); | |
throw new yb(T.DECRYPT_ERROR, null, X); | |
} | |
Ld(da, Md.V1, { | |
result: function (X) { | |
try { | |
if (X.keyId != ua.id) | |
throw new yb(T.ENVELOPE_KEY_ID_MISMATCH); | |
Qb.decrypt( | |
{ name: oc.name, iv: X.iv }, | |
ua.encryptionKey, | |
X.ciphertext | |
).then( | |
function (U) { | |
U = new Uint8Array(U); | |
Qa.result(U); | |
}, | |
function () { | |
Qa.error(new yb(T.DECRYPT_ERROR)); | |
} | |
); | |
} catch (U) { | |
U instanceof gb | |
? Qa.error(U) | |
: Qa.error(new yb(T.DECRYPT_ERROR, null, U)); | |
} | |
}, | |
error: function (X) { | |
X instanceof Jb && | |
(X = new yb(T.CIPHERTEXT_ENVELOPE_ENCODE_ERROR, null, X)); | |
X instanceof gb || (X = new yb(T.DECRYPT_ERROR, null, X)); | |
Qa.error(X); | |
}, | |
}); | |
}, | |
this | |
); | |
}, | |
wrap: function (La, Qa) { | |
Na( | |
Qa, | |
function () { | |
if (!this.wrapKey) | |
throw new yb(T.WRAP_NOT_SUPPORTED, "no wrap/unwrap key"); | |
Qb.wrapKey( | |
"raw", | |
La.rawKey, | |
this.wrapKey, | |
this.wrapKey.algorithm | |
).then( | |
function (ua) { | |
Qa.result(ua); | |
}, | |
function (ua) { | |
Qa.error(new yb(T.WRAP_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
unwrap: function (La, Qa, ua, ma) { | |
function da(X) { | |
Na(ma, function () { | |
switch (X.type) { | |
case "secret": | |
bd(X, ma); | |
break; | |
case "public": | |
Jc(X, ma); | |
break; | |
case "private": | |
Sc(X, ma); | |
break; | |
default: | |
throw new yb(T.UNSUPPORTED_KEY, "type: " + X.type); | |
} | |
}); | |
} | |
Na( | |
ma, | |
function () { | |
if (!this.wrapKey) | |
throw new yb(T.UNWRAP_NOT_SUPPORTED, "no wrap/unwrap key"); | |
Qb.unwrapKey( | |
"raw", | |
La, | |
this.wrapKey, | |
this.wrapKey.algorithm, | |
Qa, | |
!1, | |
ua | |
).then( | |
function (X) { | |
da(X); | |
}, | |
function (X) { | |
ma.error(new yb(T.UNWRAP_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
sign: function (La, Qa) { | |
var ua; | |
ua = this; | |
Na( | |
Qa, | |
function () { | |
if (!this.hmacKey) | |
throw new yb(T.SIGN_NOT_SUPPORTED, "no HMAC key."); | |
Qb.sign(pc, this.hmacKey, La).then( | |
function (ma) { | |
Na( | |
Qa, | |
function () { | |
var da; | |
da = new Uint8Array(ma); | |
Nd(da, { | |
result: function (X) { | |
Qa.result(X.bytes); | |
}, | |
error: Qa.error, | |
}); | |
}, | |
ua | |
); | |
}, | |
function () { | |
Qa.error(new yb(T.HMAC_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
verify: function (La, Qa, ua) { | |
var ma; | |
ma = this; | |
Na( | |
ua, | |
function () { | |
if (!this.hmacKey) | |
throw new yb(T.VERIFY_NOT_SUPPORTED, "no HMAC key."); | |
Od(Qa, Pd.V1, { | |
result: function (da) { | |
Na( | |
ua, | |
function () { | |
Qb.verify(pc, this.hmacKey, da.signature, La).then( | |
function (X) { | |
ua.result(X); | |
}, | |
function (X) { | |
ua.error(new yb(T.HMAC_ERROR)); | |
} | |
); | |
}, | |
ma | |
); | |
}, | |
error: ua.error, | |
}); | |
}, | |
this | |
); | |
}, | |
}); | |
})(); | |
mc = rd.extend({ | |
init: function X(La, Qa, ua, ma, da) { | |
if (ua || ma || da) | |
X.base.call(this, La, ua + "_" + Qa.sequenceNumber, ma, da, null); | |
else { | |
if (!Qa.isDecrypted()) throw new ad(T.MASTERTOKEN_UNTRUSTED, Qa); | |
X.base.call( | |
this, | |
La, | |
Qa.identity + "_" + Qa.sequenceNumber, | |
Qa.encryptionKey, | |
Qa.hmacKey, | |
null | |
); | |
} | |
}, | |
}); | |
rf = Uc.extend({ | |
encrypt: function (La, Qa) { | |
Qa.result(La); | |
}, | |
decrypt: function (La, Qa) { | |
Qa.result(La); | |
}, | |
wrap: function (La, Qa) { | |
Qa.error( | |
new Bb("Wrap is unsupported by the MSL token crypto context.") | |
); | |
}, | |
unwrap: function (La, Qa, ua, ma) { | |
ma.error( | |
new Bb("Unwrap is unsupported by the MSL token crypto context.") | |
); | |
}, | |
sign: function (La, Qa) { | |
Qa.result(new Uint8Array(0)); | |
}, | |
verify: function (La, Qa, ua) { | |
ua.result(!1); | |
}, | |
}); | |
Wb = { | |
PSK: "PSK", | |
MGK: "MGK", | |
X509: "X509", | |
RSA: "RSA", | |
NPTICKET: "NPTICKET", | |
ECC: "ECC", | |
NONE: "NONE", | |
}; | |
Object.freeze(Wb); | |
(function () { | |
Lc = Hb.Class.create({ | |
init: function (La) { | |
Object.defineProperties(this, { | |
scheme: { value: La, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getIdentity: function () {}, | |
getAuthData: function () {}, | |
equals: function (La) { | |
return this === La | |
? !0 | |
: La instanceof Lc | |
? this.scheme == La.scheme | |
: !1; | |
}, | |
toJSON: function () { | |
var La; | |
La = {}; | |
La.scheme = this.scheme; | |
La.authdata = this.getAuthData(); | |
return La; | |
}, | |
}); | |
se = function (La, Qa) { | |
var ua, ma; | |
ua = Qa.scheme; | |
ma = Qa.authdata; | |
if (!ua || !ma) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"entityauthdata " + JSON.stringify(Qa) | |
); | |
if (!Wb[ua]) throw new rc(T.UNIDENTIFIED_ENTITYAUTH_SCHEME, ua); | |
Qa = La.getEntityAuthenticationFactory(ua); | |
if (!Qa) throw new rc(T.ENTITYAUTH_FACTORY_NOT_FOUND, ua); | |
return Qa.createData(La, ma); | |
}; | |
})(); | |
sd = Hb.Class.create({ | |
init: function (La) { | |
Object.defineProperties(this, { | |
scheme: { value: La, writable: !1, configurable: !1 }, | |
}); | |
}, | |
createData: function (La, Qa) {}, | |
getCryptoContext: function (La, Qa) {}, | |
}); | |
(function () { | |
xc = Lc.extend({ | |
init: function ua(Qa) { | |
ua.base.call(this, Wb.MGK); | |
Object.defineProperties(this, { | |
identity: { value: Qa, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getIdentity: function () { | |
return this.identity; | |
}, | |
getAuthData: function () { | |
var Qa; | |
Qa = {}; | |
Qa.identity = this.identity; | |
return Qa; | |
}, | |
equals: function ma(ua) { | |
return this === ua | |
? !0 | |
: ua instanceof xc | |
? ma.base.call(this, this, ua) && this.identity == ua.identity | |
: !1; | |
}, | |
}); | |
te = function (ua) { | |
var ma; | |
ma = ua.identity; | |
if (!ma) | |
throw new Jb(T.JSON_PARSE_ERROR, "mgk authdata" + JSON.stringify(ua)); | |
return new xc(ma); | |
}; | |
})(); | |
sf = sd.extend({ | |
init: function ua(Qa) { | |
ua.base.call(this, Wb.MGK); | |
Object.defineProperties(this, { | |
localIdentity: { | |
value: Qa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
createData: function (Qa, ua) { | |
return te(ua); | |
}, | |
getCryptoContext: function (Qa, ua) { | |
if (!(ua instanceof xc)) | |
throw new Bb( | |
"Incorrect authentication data type " + JSON.stringify(ua) + "." | |
); | |
if (ua.identity != this.localIdentity) | |
throw new rc(T.ENTITY_NOT_FOUND, "mgk " + ua.identity).setEntity(ua); | |
return new Vc(); | |
}, | |
}); | |
(function () { | |
yc = Lc.extend({ | |
init: function ma(ua) { | |
ma.base.call(this, Wb.PSK); | |
Object.defineProperties(this, { | |
identity: { value: ua, writable: !1 }, | |
}); | |
}, | |
getIdentity: function () { | |
return this.identity; | |
}, | |
getAuthData: function () { | |
var ua; | |
ua = {}; | |
ua.identity = this.identity; | |
return ua; | |
}, | |
equals: function da(ma) { | |
return this === ma | |
? !0 | |
: ma instanceof yc | |
? da.base.call(this, this, ma) && this.identity == ma.identity | |
: !1; | |
}, | |
}); | |
ue = function (ma) { | |
var da; | |
da = ma.identity; | |
if (!da) | |
throw new Jb(T.JSON_PARSE_ERROR, "psk authdata" + JSON.stringify(ma)); | |
return new yc(da); | |
}; | |
})(); | |
tf = sd.extend({ | |
init: function ma(ua) { | |
ma.base.call(this, Wb.PSK); | |
Object.defineProperties(this, { | |
localIdentity: { | |
value: ua, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
createData: function (ua, ma) { | |
return ue(ma); | |
}, | |
getCryptoContext: function (ua, ma) { | |
if (!(ma instanceof yc)) | |
throw new Bb( | |
"Incorrect authentication data type " + JSON.stringify(ma) + "." | |
); | |
if (ma.getIdentity() != this.localIdentity) | |
throw new rc(T.ENTITY_NOT_FOUND, "psk " + ma.identity).setEntity(ma); | |
return new Vc(); | |
}, | |
}); | |
(function () { | |
td = Lc.extend({ | |
init: function X(ma, da) { | |
X.base.call(this, Wb.RSA); | |
Object.defineProperties(this, { | |
identity: { value: ma, writable: !1, configurable: !1 }, | |
publicKeyId: { value: da, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getIdentity: function () { | |
return this.identity; | |
}, | |
getAuthData: function () { | |
var ma; | |
ma = {}; | |
ma.identity = this.identity; | |
ma.pubkeyid = this.publicKeyId; | |
return ma; | |
}, | |
equals: function X(da) { | |
return this === da | |
? !0 | |
: da instanceof td | |
? X.base.call(this, this, da) && | |
this.identity == da.identity && | |
this.publicKeyId == da.publicKeyId | |
: !1; | |
}, | |
}); | |
ve = function (da) { | |
var X, U; | |
X = da.identity; | |
U = da.pubkeyid; | |
if (!X || "string" !== typeof X || !U || "string" !== typeof U) | |
throw new Jb(T.JSON_PARSE_ERROR, "RSA authdata" + JSON.stringify(da)); | |
return new td(X, U); | |
}; | |
})(); | |
uf = sd.extend({ | |
init: function da(ma) { | |
da.base.call(this, Wb.RSA); | |
Object.defineProperties(this, { | |
store: { value: ma, writable: !1, enumerable: !1, configurable: !1 }, | |
}); | |
}, | |
createData: function (ma, da) { | |
return ve(da); | |
}, | |
getCryptoContext: function (ma, da) { | |
var X, U, V; | |
if (!(da instanceof td)) | |
throw new Bb("Incorrect authentication data type " + da + "."); | |
X = da.identity; | |
U = da.publicKeyId; | |
V = this.store.getPublicKey(U); | |
if (!V) throw new rc(T.RSA_PUBLICKEY_NOT_FOUND, U).setEntity(da); | |
return new pd(ma, X, null, V, qd.SIGN_VERIFY); | |
}, | |
}); | |
(function () { | |
Yc = Lc.extend({ | |
init: function X(da) { | |
X.base.call(this, Wb.NONE); | |
Object.defineProperties(this, { | |
identity: { value: da, writable: !1 }, | |
}); | |
}, | |
getIdentity: function () { | |
return this.identity; | |
}, | |
getAuthData: function () { | |
var da; | |
da = {}; | |
da.identity = this.identity; | |
return da; | |
}, | |
equals: function U(X) { | |
return this === X | |
? !0 | |
: X instanceof Yc | |
? U.base.call(this, this, X) && this.identity == X.identity | |
: !1; | |
}, | |
}); | |
we = function (X) { | |
var U; | |
U = X.identity; | |
if (!U) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"Unauthenticated authdata" + JSON.stringify(X) | |
); | |
return new Yc(U); | |
}; | |
})(); | |
qf = sd.extend({ | |
init: function da() { | |
da.base.call(this, Wb.NONE); | |
}, | |
createData: function (da, X) { | |
return we(X); | |
}, | |
getCryptoContext: function (da, X) { | |
if (!(X instanceof Yc)) | |
throw new Bb( | |
"Incorrect authentication data type " + JSON.stringify(X) + "." | |
); | |
return new Vc(); | |
}, | |
}); | |
vf = Hb.Class.create({ | |
init: function () { | |
Object.defineProperties(this, { | |
rsaKeys: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
addPublicKey: function (da, X) { | |
if (!(X instanceof od)) | |
throw new Bb("Incorrect key data type " + X + "."); | |
this.rsaKeys[da] = X; | |
}, | |
getIdentities: function () { | |
return Object.keys(this.rsaKeys); | |
}, | |
removePublicKey: function (da) { | |
delete this.rsaKeys[da]; | |
}, | |
getPublicKey: function (da) { | |
return this.rsaKeys[da]; | |
}, | |
}); | |
Qd = Hb.Class.create({ | |
abort: function () {}, | |
close: function () {}, | |
mark: function () {}, | |
reset: function () {}, | |
markSupported: function () {}, | |
read: function (da, X, U) {}, | |
}); | |
ud = Hb.Class.create({ | |
abort: function () {}, | |
close: function (da, X) {}, | |
write: function (da, X, U, V, aa) {}, | |
flush: function (da, X) {}, | |
}); | |
wf = Hb.Class.create({ | |
init: function (da) { | |
Object.defineProperties(this, { | |
_data: { value: da, writable: !1, enumerable: !1, configurable: !1 }, | |
_closed: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_currentPosition: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_mark: { value: -1, writable: !0, enumerable: !1, configurable: !1 }, | |
}); | |
}, | |
abort: function () {}, | |
close: function () { | |
this._close = !0; | |
}, | |
mark: function () { | |
this._mark = this._currentPosition; | |
}, | |
reset: function () { | |
if (-1 == this._mark) throw new Zb("Stream has not been marked."); | |
this._currentPosition = this._mark; | |
}, | |
markSupported: function () { | |
return !0; | |
}, | |
read: function (da, X, U) { | |
eb( | |
U, | |
function () { | |
var V; | |
if (this._closed) throw new Zb("Stream is already closed."); | |
if (this._currentPosition == this._data.length) return null; | |
-1 == da && (da = this._data.length - this._currentPosition); | |
V = this._data.subarray( | |
this._currentPosition, | |
this._currentPosition + da | |
); | |
this._currentPosition += V.length; | |
return V; | |
}, | |
this | |
); | |
}, | |
}); | |
xf = Hb.Class.create({ | |
init: function () { | |
var da; | |
da = { | |
_closed: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_result: { | |
value: new Uint8Array(0), | |
writable: !0, | |
enuemrable: !1, | |
configurable: !1, | |
}, | |
_buffered: { | |
value: [], | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, da); | |
}, | |
abort: function () {}, | |
close: function (da, X) { | |
this._closed = !0; | |
X.result(!0); | |
}, | |
write: function (da, X, U, V, aa) { | |
eb( | |
aa, | |
function () { | |
var W; | |
if (this._closed) throw new Zb("Stream is already closed."); | |
if (0 > X) throw new RangeError("Offset cannot be negative."); | |
if (0 > U) throw new RangeError("Length cannot be negative."); | |
if (X + U > da.length) | |
throw new RangeError( | |
"Offset plus length cannot be greater than the array length." | |
); | |
W = da.subarray(X, U); | |
this._buffered.push(W); | |
return W.length; | |
}, | |
this | |
); | |
}, | |
flush: function (da, X) { | |
var U; | |
for (; 0 < this._buffered.length; ) { | |
if (((da = this._buffered.shift()), this._result)) { | |
U = new Uint8Array(this._result.length + da.length); | |
U.set(this._result); | |
U.set(da, this._result.length); | |
this._result = U; | |
} else this._result = new Uint8Array(da); | |
} | |
X.result(!0); | |
}, | |
size: function () { | |
this.flush(1, { result: function () {} }); | |
return this._result.length; | |
}, | |
toByteArray: function () { | |
this.flush(1, { result: function () {} }); | |
return this._result; | |
}, | |
}); | |
yf = Hb.Class.create({ getResponse: function (da, X, U) {} }); | |
(function () { | |
var da, X; | |
da = ud.extend({ | |
init: function (U, V) { | |
U = { | |
_httpLocation: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: V, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_buffer: { | |
value: new xf(), | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_response: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_abortToken: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_responseQueue: { | |
value: new Zc(), | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, U); | |
}, | |
setTimeout: function (U) { | |
this._timeout = U; | |
}, | |
getResponse: function (U, V) { | |
var aa; | |
aa = this; | |
this._responseQueue.poll(U, { | |
result: function (W) { | |
eb( | |
V, | |
function () { | |
W && this._responseQueue.add(W); | |
return W; | |
}, | |
aa | |
); | |
}, | |
timeout: function () { | |
eb( | |
V, | |
function () { | |
this._response = { isTimeout: !0 }; | |
this._responseQueue.add(this._response); | |
this.abort(); | |
V.timeout(); | |
}, | |
aa | |
); | |
}, | |
error: function (W) { | |
eb( | |
V, | |
function () { | |
this._response = { isError: !0 }; | |
this._responseQueue.add(this._response); | |
throw W; | |
}, | |
aa | |
); | |
}, | |
}); | |
}, | |
abort: function () { | |
this._abortToken && this._abortToken.abort(); | |
}, | |
close: function (U, V) { | |
var aa; | |
aa = this; | |
eb( | |
V, | |
function () { | |
var W; | |
if (this._response) return !0; | |
W = this._buffer.toByteArray(); | |
0 < W.length && | |
(this._abortToken = this._httpLocation.getResponse( | |
{ body: W }, | |
this._timeout, | |
{ | |
result: function (ha) { | |
aa._response = { response: ha }; | |
aa._responseQueue.add(aa._response); | |
}, | |
timeout: function () { | |
aa._response = { isTimeout: !0 }; | |
aa._responseQueue.add(aa._response); | |
}, | |
error: function (ha) { | |
aa._response = { isError: !0, error: ha }; | |
aa._responseQueue.add(aa._response); | |
}, | |
} | |
)); | |
return !0; | |
}, | |
this | |
); | |
}, | |
write: function (U, V, aa, W, ha) { | |
eb( | |
ha, | |
function () { | |
if (this._response) | |
throw new Zb("HttpOutputStream already closed."); | |
this._buffer.write(U, V, aa, W, ha); | |
}, | |
this | |
); | |
}, | |
flush: function (U, V) { | |
eb( | |
V, | |
function () { | |
if (this._response) return !0; | |
this._buffer.flush(U, V); | |
}, | |
this | |
); | |
}, | |
}); | |
X = Qd.extend({ | |
init: function (U) { | |
Object.defineProperties(this, { | |
_out: { value: U, writable: !1, enumerable: !1, configurable: !1 }, | |
_buffer: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_exception: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timedout: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_json: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
abort: function () { | |
this._out.abort(); | |
}, | |
close: function () { | |
this._buffer && this._buffer.close(); | |
}, | |
mark: function () { | |
this._buffer || this._buffer.mark(); | |
}, | |
reset: function () { | |
this._buffer && this._buffer.reset(); | |
}, | |
markSupported: function () { | |
if (this._buffer) return this._buffer.markSupported(); | |
}, | |
read: function (U, V, aa) { | |
var ha; | |
function W(va) { | |
eb( | |
aa, | |
function () { | |
if (!va) return new Uint8Array(0); | |
this._out.getResponse(V, { | |
result: function (ra) { | |
eb( | |
aa, | |
function () { | |
var ia; | |
if (ra.isTimeout) (this._timedout = !0), aa.timeout(); | |
else { | |
if (ra.isError) | |
throw ( | |
((this._exception = | |
ra.error || new Zb("Unknown HTTP exception.")), | |
this._exception) | |
); | |
if (!ra.response) | |
throw ( | |
((this._exception = new Zb( | |
"Missing HTTP response." | |
)), | |
this._exception) | |
); | |
ra.response.json !== Gb && | |
((this._json = ra.response.json), | |
(this.getJSON = function () { | |
return ha._json; | |
})); | |
ia = | |
ra.response.content || | |
Bd( | |
"string" === typeof ra.response.body | |
? ra.response.body | |
: JSON.stringify(this._json) | |
); | |
this._buffer = new wf(ia); | |
this._buffer.read(U, V, aa); | |
} | |
}, | |
ha | |
); | |
}, | |
timeout: function () { | |
aa.timeout(); | |
}, | |
error: function (ra) { | |
aa.error(ra); | |
}, | |
}); | |
}, | |
ha | |
); | |
} | |
ha = this; | |
eb( | |
aa, | |
function () { | |
if (this._exception) throw this._exception; | |
if (this._timedout) aa.timeout(); | |
else { | |
if (this._aborted) return new Uint8Array(0); | |
this._buffer | |
? this._buffer.read(U, V, aa) | |
: this._out.close(V, { | |
result: function (va) { | |
W(va); | |
}, | |
timeout: function () { | |
aa.timeout(); | |
}, | |
error: function (va) { | |
aa.error(va); | |
}, | |
}); | |
} | |
}, | |
ha | |
); | |
}, | |
}); | |
he = Hb.Class.create({ | |
init: function (U, V) { | |
Object.defineProperties(this, { | |
_httpLocation: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: V, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
setTimeout: function (U) { | |
this._timeout = U; | |
}, | |
openConnection: function () { | |
var U; | |
U = new da(this._httpLocation, this._timeout); | |
return { input: new X(U), output: U }; | |
}, | |
}); | |
})(); | |
(function () { | |
var da, X; | |
da = ud.extend({ | |
init: function () { | |
var U; | |
U = { | |
_buffer: { | |
value: new Uint8Array(), | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, U); | |
}, | |
setTimeout: function () {}, | |
getResponse: function (U, V) { | |
V.result({ | |
success: !1, | |
content: null, | |
errorHttpCode: Gb, | |
errorSubCode: Gb, | |
}); | |
}, | |
abort: function () {}, | |
close: function (U, V) { | |
V.result(!0); | |
}, | |
write: function (U, V, aa, W, ha) { | |
var va, ra; | |
try { | |
if (0 > V) throw new RangeError("Offset cannot be negative."); | |
if (0 > aa) throw new RangeError("Length cannot be negative."); | |
if (V + aa > U.length) | |
throw new RangeError( | |
"Offset plus length cannot be greater than the array length." | |
); | |
va = U.subarray(V, aa); | |
ra = new Uint8Array(this._buffer.length + va.length); | |
ra.set(this._buffer); | |
ra.set(va, this._buffer.length); | |
this._buffer = ra; | |
ha.result(va.length); | |
} catch (ia) { | |
ha.error(ia); | |
} | |
}, | |
flush: function (U, V) { | |
V.result(!0); | |
}, | |
request: function () { | |
return this._buffer; | |
}, | |
}); | |
X = Qd.extend({ | |
init: function () {}, | |
abort: function () {}, | |
close: function () {}, | |
mark: function () {}, | |
reset: function () {}, | |
markSupported: function () {}, | |
read: function (U, V, aa) { | |
aa.result(new Uint8Array(16)); | |
}, | |
}); | |
ie = Hb.Class.create({ | |
init: function () { | |
var U; | |
U = { | |
output: { | |
value: new da(), | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
input: { | |
value: new X(), | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, U); | |
}, | |
setTimeout: function () {}, | |
openConnection: function () { | |
return { input: this.input, output: this.output }; | |
}, | |
getRequest: function () { | |
return Ad(this.output.request()); | |
}, | |
}); | |
})(); | |
xe = function (da, X, U) { | |
(function (V, aa, W) { | |
V.read(-1, aa, { | |
result: function (ha) { | |
ha && ha.length ? W(null, ha) : W(null, null); | |
}, | |
timeout: function () { | |
U.timeout(); | |
}, | |
error: function (ha) { | |
W(ha, null); | |
}, | |
}); | |
})(da, X, function (V, aa) { | |
var W, ha; | |
if (V) U.error(V); | |
else if (aa) { | |
if (da.getJSON !== Gb && "function" === typeof da.getJSON) | |
U.result(da.getJSON()); | |
else { | |
V = U.result; | |
aa = new zf(ec(aa, "utf-8")); | |
W = []; | |
for (ha = aa.nextValue(); ha !== Gb; ) { | |
W.push(ha); | |
ha = aa.nextValue(); | |
} | |
V.call(U, W); | |
} | |
} else U.result(null); | |
}); | |
}; | |
lc = { | |
SYMMETRIC_WRAPPED: "SYMMETRIC_WRAPPED", | |
ASYMMETRIC_WRAPPED: "ASYMMETRIC_WRAPPED", | |
DIFFIE_HELLMAN: "DIFFIE_HELLMAN", | |
JWE_LADDER: "JWE_LADDER", | |
JWK_LADDER: "JWK_LADDER", | |
AUTHENTICATED_DH: "AUTHENTICATED_DH", | |
}; | |
Object.freeze(lc); | |
(function () { | |
cd = Hb.Class.create({ | |
init: function (da) { | |
Object.defineProperties(this, { | |
keyExchangeScheme: { value: da, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () {}, | |
toJSON: function () { | |
var da; | |
da = {}; | |
da.scheme = this.keyExchangeScheme; | |
da.keydata = this.getKeydata(); | |
return da; | |
}, | |
equals: function (da) { | |
return this === da | |
? !0 | |
: da instanceof cd | |
? this.keyExchangeScheme == da.keyExchangeScheme | |
: !1; | |
}, | |
uniqueKey: function () { | |
return this.keyExchangeScheme; | |
}, | |
}); | |
ye = function (da, X, U) { | |
Na(U, function () { | |
var V, aa, W; | |
V = X.scheme; | |
aa = X.keydata; | |
if (!V || !aa || "object" !== typeof aa) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"keyrequestdata " + JSON.stringify(X) | |
); | |
if (!lc[V]) throw new Ub(T.UNIDENTIFIED_KEYX_SCHEME, V); | |
W = da.getKeyExchangeFactory(V); | |
if (!W) throw new Ub(T.KEYX_FACTORY_NOT_FOUND, V); | |
W.createRequestData(da, aa, U); | |
}); | |
}; | |
})(); | |
(function () { | |
dd = Hb.Class.create({ | |
init: function (da, X) { | |
Object.defineProperties(this, { | |
masterToken: { value: da, writable: !1, configurable: !1 }, | |
keyExchangeScheme: { value: X, wrtiable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () {}, | |
toJSON: function () { | |
var da; | |
da = {}; | |
da.mastertoken = this.masterToken; | |
da.scheme = this.keyExchangeScheme; | |
da.keydata = this.getKeydata(); | |
return da; | |
}, | |
equals: function (da) { | |
return this === da | |
? !0 | |
: da instanceof dd | |
? this.masterToken.equals(da.masterToken) && | |
this.keyExchangeScheme == da.keyExchangeScheme | |
: !1; | |
}, | |
uniqueKey: function () { | |
return this.masterToken.uniqueKey() + ":" + this.keyExchangeScheme; | |
}, | |
}); | |
ze = function (da, X, U) { | |
Na(U, function () { | |
var V, aa, W; | |
V = X.mastertoken; | |
aa = X.scheme; | |
W = X.keydata; | |
if (!aa || !V || "object" !== typeof V || !W || "object" !== typeof W) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"keyresponsedata " + JSON.stringify(X) | |
); | |
if (!lc[aa]) throw new Ub(T.UNIDENTIFIED_KEYX_SCHEME, aa); | |
ed(da, V, { | |
result: function (ha) { | |
Na(U, function () { | |
var va; | |
va = da.getKeyExchangeFactory(aa); | |
if (!va) throw new Ub(T.KEYX_FACTORY_NOT_FOUND, aa); | |
return va.createResponseData(da, ha, W); | |
}); | |
}, | |
error: function (ha) { | |
U.error(ha); | |
}, | |
}); | |
}); | |
}; | |
})(); | |
(function () { | |
var da; | |
da = Hb.Class.create({ | |
init: function (X, U) { | |
Object.defineProperties(this, { | |
keyResponseData: { value: X, writable: !1, configurable: !1 }, | |
cryptoContext: { value: U, writable: !1, configurable: !1 }, | |
}); | |
}, | |
}); | |
nc = Hb.Class.create({ | |
init: function (X) { | |
Object.defineProperties(this, { | |
scheme: { value: X, writable: !1, configurable: !1 }, | |
}); | |
}, | |
createRequestData: function (X, U, V) {}, | |
createResponseData: function (X, U, V) {}, | |
generateResponse: function (X, U, V, aa) {}, | |
getCryptoContext: function (X, U, V, aa, W) {}, | |
generateSessionKeys: function (X, U) { | |
Na(U, function () { | |
var V, aa; | |
V = new Uint8Array(16); | |
aa = new Uint8Array(32); | |
X.getRandom().nextBytes(V); | |
X.getRandom().nextBytes(aa); | |
tc(V, oc, Dc, { | |
result: function (W) { | |
tc(aa, pc, Mc, { | |
result: function (ha) { | |
U.result({ encryptionKey: W, hmacKey: ha }); | |
}, | |
error: function (ha) { | |
U.error(new yb(T.SESSION_KEY_CREATION_FAILURE, null, ha)); | |
}, | |
}); | |
}, | |
error: function (W) { | |
U.error(new yb(T.SESSION_KEY_CREATION_FAILURE, null, W)); | |
}, | |
}); | |
}); | |
}, | |
importSessionKeys: function (X, U, V) { | |
tc(X, oc, Dc, { | |
result: function (aa) { | |
tc(U, pc, Mc, { | |
result: function (W) { | |
V.result({ encryptionKey: aa, hmacKey: W }); | |
}, | |
error: function (W) { | |
V.error(W); | |
}, | |
}); | |
}, | |
error: function (aa) { | |
V.error(aa); | |
}, | |
}); | |
}, | |
}); | |
nc.KeyExchangeData = da; | |
})(); | |
(function () { | |
var X, U, V; | |
function da(aa, W, ha, va, ra) { | |
Na(ra, function () { | |
var ia, qa; | |
switch (W) { | |
case X.PSK: | |
(ia = new yc(va)), | |
(qa = aa.getEntityAuthenticationFactory(Wb.PSK)); | |
if (!qa) throw new Ub(T.UNSUPPORTED_KEYX_MECHANISM, W); | |
ia = qa.getCryptoContext(aa, ia); | |
return new vc(aa, wc.A128KW, qc, Gb); | |
case X.MGK: | |
ia = new xc(va); | |
qa = aa.getEntityAuthenticationFactory(Wb.MGK); | |
if (!qa) throw new Ub(T.UNSUPPORTED_KEYX_MECHANISM, W); | |
ia = qa.getCryptoContext(aa, ia); | |
return new vc(aa, wc.A128KW, qc, Gb); | |
case X.WRAP: | |
ia = aa.getMslCryptoContext(); | |
ia.unwrap(ha, sc, Ec, { | |
result: function (Aa) { | |
Na(ra, function () { | |
return new vc(aa, wc.A128KW, qc, Aa); | |
}); | |
}, | |
error: ra.error, | |
}); | |
break; | |
default: | |
throw new Ub(T.UNSUPPORTED_KEYX_MECHANISM, W); | |
} | |
}); | |
} | |
X = { PSK: "PSK", MGK: "MGK", WRAP: "WRAP" }; | |
U = Ae = cd.extend({ | |
init: function va(W, ha) { | |
va.base.call(this, lc.JWE_LADDER); | |
switch (W) { | |
case X.WRAP: | |
if (!ha) | |
throw new Bb( | |
"Previous wrapping key based key exchange requires the previous wrapping key data and ID." | |
); | |
break; | |
default: | |
ha = null; | |
} | |
Object.defineProperties(this, { | |
mechanism: { value: W, writable: !1, configurable: !1 }, | |
wrapdata: { value: ha, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () { | |
var W; | |
W = {}; | |
W.mechanism = this.mechanism; | |
this.wrapdata && (W.wrapdata = Kb(this.wrapdata)); | |
return W; | |
}, | |
equals: function va(ha) { | |
return ha === this | |
? !0 | |
: ha instanceof Ae | |
? va.base.call(this, ha) && | |
this.mechanism == ha.mechanism && | |
gc(this.wrapdata, ha.wrapdata) | |
: !1; | |
}, | |
uniqueKey: function va() { | |
var ra; | |
ra = va.base.call(this) + ":" + this.mechanism; | |
this.wrapdata && (ra += ":" + hc(this.wrapdata)); | |
return ra; | |
}, | |
}); | |
V = Be = dd.extend({ | |
init: function Z(ra, ia, qa, Aa, ka) { | |
Z.base.call(this, ra, lc.JWE_LADDER); | |
Object.defineProperties(this, { | |
wrapKey: { value: ia, writable: !1, configurable: !1 }, | |
wrapdata: { value: qa, writable: !1, configurable: !1 }, | |
encryptionKey: { value: Aa, writable: !1, configurable: !1 }, | |
hmacKey: { value: ka, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () { | |
var ra; | |
ra = {}; | |
ra.wrapkey = Kb(this.wrapKey); | |
ra.wrapdata = Kb(this.wrapdata); | |
ra.encryptionkey = Kb(this.encryptionKey); | |
ra.hmackey = Kb(this.hmacKey); | |
return ra; | |
}, | |
equals: function qa(ia) { | |
return this === ia | |
? !0 | |
: ia instanceof Be | |
? qa.base.call(this, ia) && | |
gc(this.wrapKey, ia.wrapKey) && | |
gc(this.wrapdata, ia.wrapdata) && | |
gc(this.encryptionKey, ia.encryptionKey) && | |
gc(this.hmacKey, ia.hmacKey) | |
: !1; | |
}, | |
uniqueKey: function qa() { | |
return ( | |
qa.base.call(this) + | |
":" + | |
hc(this.wrapKey) + | |
":" + | |
hc(this.wrapdata) + | |
":" + | |
hc(this.encryptionKey) + | |
":" + | |
hc(this.hmacKey) | |
); | |
}, | |
}); | |
nc.extend({ | |
init: function ka(Aa) { | |
ka.base.call(this, lc.JWE_LADDER); | |
Object.defineProperties(this, { | |
repository: { | |
value: Aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
createRequestData: function (Aa, ka, Z) { | |
Na(Z, function () { | |
var ca, fa, xa; | |
ca = ka.mechanism; | |
fa = ka.wrapdata; | |
if (!ca || (ca == X.WRAP && (!fa || "string" !== typeof fa))) | |
throw new Jb(T.JSON_PARSE_ERROR, "keydata " + JSON.stringify(ka)); | |
if (!X[ca]) throw new Ub(T.UNIDENTIFIED_KEYX_MECHANISM, ca); | |
switch (ca) { | |
case X.WRAP: | |
try { | |
xa = Mb(fa); | |
} catch (Sa) { | |
throw new Ub( | |
T.KEYX_WRAPPING_KEY_MISSING, | |
"keydata " + ka.toString() | |
); | |
} | |
if (null == xa || 0 == xa.length) | |
throw new Ub( | |
T.KEYX_WRAPPING_KEY_MISSING, | |
"keydata " + ka.toString() | |
); | |
break; | |
default: | |
xa = null; | |
} | |
return new U(ca, xa); | |
}); | |
}, | |
createResponseData: function (Aa, ka, Z) { | |
var ca, fa, xa, Sa, Ma, Ra, Xa; | |
Aa = Z.wrapkey; | |
ca = Z.wrapdata; | |
fa = Z.encryptionkey; | |
xa = Z.hmackey; | |
if ( | |
!( | |
Aa && | |
"string" === typeof Aa && | |
ca && | |
"string" === typeof ca && | |
fa && | |
"string" === typeof fa && | |
xa | |
) || | |
"string" !== typeof xa | |
) | |
throw new Jb(T.JSON_PARSE_ERROR, "keydata " + JSON.stringify(Z)); | |
try { | |
Sa = Mb(Aa); | |
Ma = Mb(ca); | |
} catch (oa) { | |
throw new yb( | |
T.INVALID_SYMMETRIC_KEY, | |
"keydata " + JSON.stringify(Z), | |
oa | |
); | |
} | |
try { | |
Ra = Mb(fa); | |
} catch (oa) { | |
throw new yb( | |
T.INVALID_ENCRYPTION_KEY, | |
"keydata " + JSON.stringify(Z), | |
oa | |
); | |
} | |
try { | |
Xa = Mb(xa); | |
} catch (oa) { | |
throw new yb( | |
T.INVALID_HMAC_KEY, | |
"keydata " + JSON.stringify(Z), | |
oa | |
); | |
} | |
return new V(ka, Sa, Ma, Ra, Xa); | |
}, | |
generateResponse: function (Aa, ka, Z, ca) { | |
var Ra, Xa; | |
function fa(oa, ya, Ea) { | |
Ra.generateSessionKeys(Aa, { | |
result: function (Ja) { | |
Na( | |
ca, | |
function () { | |
xa(oa, ya, Ea, Ja.encryptionKey, Ja.hmacKey); | |
}, | |
Ra | |
); | |
}, | |
error: function (Ja) { | |
Na(ca, function () { | |
Ja instanceof gb && Ja.setEntity(Xa); | |
throw Ja; | |
}); | |
}, | |
}); | |
} | |
function xa(oa, ya, Ea, Ja, Da) { | |
Na( | |
ca, | |
function () { | |
da(Aa, ka.mechanism, ka.wrapdata, oa, { | |
result: function (Va) { | |
Va.wrap(ya, { | |
result: function (Ha) { | |
Sa(ya, Ea, Ja, Da, Ha); | |
}, | |
error: function (Ha) { | |
Na(ca, function () { | |
Ha instanceof gb && Ha.setEntity(Xa); | |
throw Ha; | |
}); | |
}, | |
}); | |
}, | |
error: function (Va) { | |
Na(ca, function () { | |
Va instanceof gb && Va.setEntity(Xa); | |
throw Va; | |
}); | |
}, | |
}); | |
}, | |
Ra | |
); | |
} | |
function Sa(oa, ya, Ea, Ja, Da) { | |
Na( | |
ca, | |
function () { | |
var Va; | |
Va = new vc(Aa, wc.A128KW, qc, oa); | |
Va.wrap(Ea, { | |
result: function (Ha) { | |
Va.wrap(Ja, { | |
result: function (ab) { | |
Ma(ya, Da, Ea, Ha, Ja, ab); | |
}, | |
error: function (ab) { | |
Na(ca, function () { | |
ab instanceof gb && ab.setEntity(Xa); | |
throw ab; | |
}); | |
}, | |
}); | |
}, | |
error: function (Ha) { | |
Na(ca, function () { | |
Ha instanceof gb && Ha.setEntity(Xa); | |
throw Ha; | |
}); | |
}, | |
}); | |
}, | |
Ra | |
); | |
} | |
function Ma(oa, ya, Ea, Ja, Da, Va) { | |
Na( | |
ca, | |
function () { | |
var Ha; | |
Ha = Aa.getTokenFactory(); | |
Xa | |
? Ha.renewMasterToken(Aa, Xa, Ea, Da, { | |
result: function (ab) { | |
Na( | |
ca, | |
function () { | |
var db, Ya; | |
db = new mc(Aa, ab); | |
Ya = new V(ab, ya, oa, Ja, Va); | |
return new nc.KeyExchangeData(Ya, db, ca); | |
}, | |
Ra | |
); | |
}, | |
error: function (ab) { | |
Na(ca, function () { | |
ab instanceof gb && ab.setEntity(Xa); | |
throw ab; | |
}); | |
}, | |
}) | |
: Ha.createMasterToken(Aa, Z, Ea, Da, { | |
result: function (ab) { | |
Na( | |
ca, | |
function () { | |
var db, Ya; | |
db = new mc(Aa, ab); | |
Ya = new V(ab, ya, oa, Ja, Va); | |
return new nc.KeyExchangeData(Ya, db, ca); | |
}, | |
Ra | |
); | |
}, | |
error: ca.error, | |
}); | |
}, | |
Ra | |
); | |
} | |
Ra = this; | |
Na( | |
ca, | |
function () { | |
var oa, ya; | |
if (!(ka instanceof U)) | |
throw new Bb( | |
"Key request data " + | |
JSON.stringify(ka) + | |
" was not created by this factory." | |
); | |
oa = Z; | |
if (Z instanceof jc) { | |
if (!Z.isVerified()) throw new ad(T.MASTERTOKEN_UNTRUSTED, Z); | |
Xa = Z; | |
oa = Z.identity; | |
} | |
ya = new Uint8Array(16); | |
Aa.getRandom().nextBytes(ya); | |
tc(ya, sc, Ec, { | |
result: function (Ea) { | |
Na( | |
ca, | |
function () { | |
Aa.getMslCryptoContext().wrap(Ea, { | |
result: function (Ja) { | |
fa(oa, Ea, Ja); | |
}, | |
error: function (Ja) { | |
Na( | |
ca, | |
function () { | |
Ja instanceof gb && Ja.setEntity(Xa); | |
throw Ja; | |
}, | |
Ra | |
); | |
}, | |
}); | |
}, | |
Ra | |
); | |
}, | |
error: function (Ea) { | |
Na( | |
ca, | |
function () { | |
throw new yb( | |
T.WRAP_KEY_CREATION_FAILURE, | |
null, | |
Ea | |
).setEntity(Xa); | |
}, | |
Ra | |
); | |
}, | |
}); | |
}, | |
Ra | |
); | |
}, | |
getCryptoContext: function (Aa, ka, Z, ca, fa) { | |
var Sa; | |
function xa(Ma, Ra, Xa, oa, ya) { | |
Na( | |
fa, | |
function () { | |
var Ea; | |
Ea = new vc(Aa, wc.A128KW, qc, ya); | |
Ea.unwrap(Ra.encryptionKey, oc, Dc, { | |
result: function (Ja) { | |
Ea.unwrap(Ra.hmacKey, pc, Mc, { | |
result: function (Da) { | |
Na( | |
fa, | |
function () { | |
this.repository.addCryptoContext(Ra.wrapdata, Ea); | |
this.repository.removeCryptoContext(Xa); | |
return new mc(Aa, Ra.masterToken, oa, Ja, Da); | |
}, | |
Sa | |
); | |
}, | |
error: function (Da) { | |
Na(fa, function () { | |
Da instanceof gb && Da.setEntity(Ma); | |
throw Da; | |
}); | |
}, | |
}); | |
}, | |
error: function (Ja) { | |
Na(fa, function () { | |
Ja instanceof gb && Ja.setEntity(Ma); | |
throw Ja; | |
}); | |
}, | |
}); | |
}, | |
Sa | |
); | |
} | |
Sa = this; | |
Na( | |
fa, | |
function () { | |
var Ma, Ra; | |
if (!(ka instanceof U)) | |
throw new Bb( | |
"Key request data " + | |
JSON.stringify(ka) + | |
" was not created by this factory." | |
); | |
if (!(Z instanceof V)) | |
throw new Bb( | |
"Key response data " + | |
JSON.stringify(Z) + | |
" was not created by this factory." | |
); | |
Ma = ka.mechanism; | |
Ra = ka.wrapdata; | |
Aa.getEntityAuthenticationData(null, { | |
result: function (Xa) { | |
Na( | |
fa, | |
function () { | |
var oa, ya, Ea; | |
oa = Xa.getIdentity(); | |
switch (Ma) { | |
case X.PSK: | |
ya = new yc(oa); | |
Ea = Aa.getEntityAuthenticationFactory(Wb.PSK); | |
if (!Ea) | |
throw new Ub( | |
T.UNSUPPORTED_KEYX_MECHANISM, | |
Ma | |
).setEntity(Xa); | |
ya = Ea.getCryptoContext(Aa, ya); | |
ya = new vc(Aa, wc.A128KW, qc, Gb); | |
break; | |
case X.MGK: | |
ya = new xc(oa); | |
Ea = Aa.getEntityAuthenticationFactory(Wb.MGK); | |
if (!Ea) | |
throw new Ub( | |
T.UNSUPPORTED_KEYX_MECHANISM, | |
Ma | |
).setEntity(Xa); | |
ya = Ea.getCryptoContext(Aa, ya); | |
ya = new vc(Aa, wc.A128KW, qc, ya.wrapKey); | |
break; | |
case X.WRAP: | |
ya = this.repository.getCryptoContext(Ra); | |
if (!ya) | |
throw new Ub( | |
T.KEYX_WRAPPING_KEY_MISSING, | |
Kb(Ra) | |
).setEntity(Xa); | |
break; | |
default: | |
throw new Ub( | |
T.UNSUPPORTED_KEYX_MECHANISM, | |
Ma | |
).setEntity(Xa); | |
} | |
ya.unwrap(Z.wrapKey, sc, Ec, { | |
result: function (Ja) { | |
xa(Xa, Z, Ra, oa, Ja); | |
}, | |
error: function (Ja) { | |
Na(fa, function () { | |
Ja instanceof gb && Ja.setEntity(Xa); | |
throw Ja; | |
}); | |
}, | |
}); | |
}, | |
Sa | |
); | |
}, | |
error: fa.error, | |
}); | |
}, | |
Sa | |
); | |
}, | |
}); | |
})(); | |
(function () { | |
var X, U, V, aa; | |
function da(W, ha, va, ra, ia) { | |
Na(ia, function () { | |
var qa, Aa; | |
switch (ha) { | |
case X.PSK: | |
(qa = new yc(ra)), | |
(Aa = W.getEntityAuthenticationFactory(Wb.PSK)); | |
if (!Aa) throw new Ub(T.UNSUPPORTED_KEYX_MECHANISM, ha); | |
qa = Aa.getCryptoContext(W, qa); | |
return new aa(Gb); | |
case X.MGK: | |
qa = new xc(ra); | |
Aa = W.getEntityAuthenticationFactory(Wb.MGK); | |
if (!Aa) throw new Ub(T.UNSUPPORTED_KEYX_MECHANISM, ha); | |
qa = Aa.getCryptoContext(W, qa); | |
return new aa(Gb); | |
case X.WRAP: | |
qa = W.getMslCryptoContext(); | |
qa.unwrap(va, sc, Ec, { | |
result: function (ka) { | |
Na(ia, function () { | |
return new aa(ka); | |
}); | |
}, | |
error: ia.error, | |
}); | |
break; | |
default: | |
throw new Ub(T.UNSUPPORTED_KEYX_MECHANISM, ha); | |
} | |
}); | |
} | |
X = { PSK: "PSK", MGK: "MGK", WRAP: "WRAP" }; | |
U = Ce = cd.extend({ | |
init: function ra(ha, va) { | |
ra.base.call(this, lc.JWK_LADDER); | |
switch (ha) { | |
case X.WRAP: | |
if (!va) | |
throw new Bb( | |
"Previous wrapping key based key exchange requires the previous wrapping key data and ID." | |
); | |
break; | |
default: | |
va = null; | |
} | |
Object.defineProperties(this, { | |
mechanism: { value: ha, writable: !1, configurable: !1 }, | |
wrapdata: { value: va, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () { | |
var ha; | |
ha = {}; | |
ha.mechanism = this.mechanism; | |
this.wrapdata && (ha.wrapdata = Kb(this.wrapdata)); | |
return ha; | |
}, | |
equals: function ra(va) { | |
return va === this | |
? !0 | |
: va instanceof Ce | |
? ra.base.call(this, va) && | |
this.mechanism == va.mechanism && | |
gc(this.wrapdata, va.wrapdata) | |
: !1; | |
}, | |
uniqueKey: function ra() { | |
var ia; | |
ia = ra.base.call(this) + ":" + this.mechanism; | |
this.wrapdata && (ia += ":" + hc(this.wrapdata)); | |
return ia; | |
}, | |
}); | |
V = De = dd.extend({ | |
init: function ca(ia, qa, Aa, ka, Z) { | |
ca.base.call(this, ia, lc.JWK_LADDER); | |
Object.defineProperties(this, { | |
wrapKey: { value: qa, writable: !1, configurable: !1 }, | |
wrapdata: { value: Aa, writable: !1, configurable: !1 }, | |
encryptionKey: { value: ka, writable: !1, configurable: !1 }, | |
hmacKey: { value: Z, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () { | |
var ia; | |
ia = {}; | |
ia.wrapkey = Kb(this.wrapKey); | |
ia.wrapdata = Kb(this.wrapdata); | |
ia.encryptionkey = Kb(this.encryptionKey); | |
ia.hmackey = Kb(this.hmacKey); | |
return ia; | |
}, | |
equals: function Aa(qa) { | |
return this === qa | |
? !0 | |
: qa instanceof De | |
? Aa.base.call(this, qa) && | |
gc(this.wrapKey, qa.wrapKey) && | |
gc(this.wrapdata, qa.wrapdata) && | |
gc(this.encryptionKey, qa.encryptionKey) && | |
gc(this.hmacKey, qa.hmacKey) | |
: !1; | |
}, | |
uniqueKey: function Aa() { | |
return ( | |
Aa.base.call(this) + | |
":" + | |
hc(this.wrapKey) + | |
":" + | |
hc(this.wrapdata) + | |
":" + | |
hc(this.encryptionKey) + | |
":" + | |
hc(this.hmacKey) | |
); | |
}, | |
}); | |
aa = Uc.extend({ | |
init: function (Aa) { | |
Aa && Aa.rawKey && (Aa = Aa.rawKey); | |
Object.defineProperties(this, { | |
_wrapKey: { | |
value: Aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
encrypt: function (Aa, ka) { | |
ka.error(new yb(T.ENCRYPT_NOT_SUPPORTED)); | |
}, | |
decrypt: function (Aa, ka) { | |
ka.error(new yb(T.DECRYPT_NOT_SUPPORTED)); | |
}, | |
wrap: function (Aa, ka) { | |
Na( | |
ka, | |
function () { | |
Qb.wrapKey("jwk", Aa.rawKey, this._wrapKey, sc).then( | |
function (Z) { | |
ka.result(Z); | |
}, | |
function (Z) { | |
ka.error(new yb(T.WRAP_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
unwrap: function (Aa, ka, Z, ca) { | |
function fa(xa) { | |
Na(ca, function () { | |
switch (xa.type) { | |
case "secret": | |
bd(xa, ca); | |
break; | |
case "public": | |
Jc(xa, ca); | |
break; | |
case "private": | |
Sc(xa, ca); | |
break; | |
default: | |
throw new yb(T.UNSUPPORTED_KEY, "type: " + xa.type); | |
} | |
}); | |
} | |
Na( | |
ca, | |
function () { | |
Qb.unwrapKey("jwk", Aa, this._wrapKey, sc, ka, !1, Z).then( | |
function (xa) { | |
fa(xa); | |
}, | |
function (xa) { | |
ca.error(new yb(T.UNWRAP_ERROR)); | |
} | |
); | |
}, | |
this | |
); | |
}, | |
sign: function (Aa, ka) { | |
ka.error(new yb(T.SIGN_NOT_SUPPORTED)); | |
}, | |
verify: function (Aa, ka, Z) { | |
Z.error(new yb(T.VERIFY_NOT_SUPPORTED)); | |
}, | |
}); | |
nc.extend({ | |
init: function Z(ka) { | |
Z.base.call(this, lc.JWK_LADDER); | |
Object.defineProperties(this, { | |
repository: { | |
value: ka, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
createRequestData: function (ka, Z, ca) { | |
Na(ca, function () { | |
var fa, xa, Sa; | |
fa = Z.mechanism; | |
xa = Z.wrapdata; | |
if (!fa || (fa == X.WRAP && (!xa || "string" !== typeof xa))) | |
throw new Jb(T.JSON_PARSE_ERROR, "keydata " + JSON.stringify(Z)); | |
if (!X[fa]) throw new Ub(T.UNIDENTIFIED_KEYX_MECHANISM, fa); | |
switch (fa) { | |
case X.WRAP: | |
try { | |
Sa = Mb(xa); | |
} catch (Ma) { | |
throw new Ub( | |
T.KEYX_WRAPPING_KEY_MISSING, | |
"keydata " + Z.toString() | |
); | |
} | |
if (null == Sa || 0 == Sa.length) | |
throw new Ub( | |
T.KEYX_WRAPPING_KEY_MISSING, | |
"keydata " + Z.toString() | |
); | |
break; | |
default: | |
Sa = null; | |
} | |
return new U(fa, Sa); | |
}); | |
}, | |
createResponseData: function (ka, Z, ca) { | |
var fa, xa, Sa, Ma, Ra, Xa, oa; | |
ka = ca.wrapkey; | |
fa = ca.wrapdata; | |
xa = ca.encryptionkey; | |
Sa = ca.hmackey; | |
if ( | |
!( | |
ka && | |
"string" === typeof ka && | |
fa && | |
"string" === typeof fa && | |
xa && | |
"string" === typeof xa && | |
Sa | |
) || | |
"string" !== typeof Sa | |
) | |
throw new Jb(T.JSON_PARSE_ERROR, "keydata " + JSON.stringify(ca)); | |
try { | |
Ma = Mb(ka); | |
Ra = Mb(fa); | |
} catch (ya) { | |
throw new yb( | |
T.INVALID_SYMMETRIC_KEY, | |
"keydata " + JSON.stringify(ca), | |
ya | |
); | |
} | |
try { | |
Xa = Mb(xa); | |
} catch (ya) { | |
throw new yb( | |
T.INVALID_ENCRYPTION_KEY, | |
"keydata " + JSON.stringify(ca), | |
ya | |
); | |
} | |
try { | |
oa = Mb(Sa); | |
} catch (ya) { | |
throw new yb( | |
T.INVALID_HMAC_KEY, | |
"keydata " + JSON.stringify(ca), | |
ya | |
); | |
} | |
return new V(Z, Ma, Ra, Xa, oa); | |
}, | |
generateResponse: function (ka, Z, ca, fa) { | |
var Xa, oa; | |
function xa(ya, Ea, Ja) { | |
Xa.generateSessionKeys(ka, { | |
result: function (Da) { | |
Na( | |
fa, | |
function () { | |
Sa(ya, Ea, Ja, Da.encryptionKey, Da.hmacKey); | |
}, | |
Xa | |
); | |
}, | |
error: function (Da) { | |
Na(fa, function () { | |
Da instanceof gb && Da.setEntity(oa); | |
throw Da; | |
}); | |
}, | |
}); | |
} | |
function Sa(ya, Ea, Ja, Da, Va) { | |
Na( | |
fa, | |
function () { | |
da(ka, Z.mechanism, Z.wrapdata, ya, { | |
result: function (Ha) { | |
Ha.wrap(Ea, { | |
result: function (ab) { | |
Ma(Ea, Ja, Da, Va, ab); | |
}, | |
error: function (ab) { | |
Na(fa, function () { | |
ab instanceof gb && ab.setEntity(oa); | |
throw ab; | |
}); | |
}, | |
}); | |
}, | |
error: function (Ha) { | |
Na(fa, function () { | |
Ha instanceof gb && Ha.setEntity(oa); | |
throw Ha; | |
}); | |
}, | |
}); | |
}, | |
Xa | |
); | |
} | |
function Ma(ya, Ea, Ja, Da, Va) { | |
Na( | |
fa, | |
function () { | |
var Ha; | |
Ha = new aa(ya); | |
Ha.wrap(Ja, { | |
result: function (ab) { | |
Ha.wrap(Da, { | |
result: function (db) { | |
Ra(Ea, Va, Ja, ab, Da, db); | |
}, | |
error: function (db) { | |
Na(fa, function () { | |
db instanceof gb && db.setEntity(oa); | |
throw db; | |
}); | |
}, | |
}); | |
}, | |
error: function (ab) { | |
Na(fa, function () { | |
ab instanceof gb && ab.setEntity(oa); | |
throw ab; | |
}); | |
}, | |
}); | |
}, | |
Xa | |
); | |
} | |
function Ra(ya, Ea, Ja, Da, Va, Ha) { | |
Na( | |
fa, | |
function () { | |
var ab; | |
ab = ka.getTokenFactory(); | |
oa | |
? ab.renewMasterToken(ka, oa, Ja, Va, { | |
result: function (db) { | |
Na( | |
fa, | |
function () { | |
var Ya, mb; | |
Ya = new mc(ka, db); | |
mb = new V(db, Ea, ya, Da, Ha); | |
return new nc.KeyExchangeData(mb, Ya, fa); | |
}, | |
Xa | |
); | |
}, | |
error: function (db) { | |
Na(fa, function () { | |
db instanceof gb && db.setEntity(oa); | |
throw db; | |
}); | |
}, | |
}) | |
: ab.createMasterToken(ka, ca, Ja, Va, { | |
result: function (db) { | |
Na( | |
fa, | |
function () { | |
var Ya, mb; | |
Ya = new mc(ka, db); | |
mb = new V(db, Ea, ya, Da, Ha); | |
return new nc.KeyExchangeData(mb, Ya, fa); | |
}, | |
Xa | |
); | |
}, | |
error: fa.error, | |
}); | |
}, | |
Xa | |
); | |
} | |
Xa = this; | |
Na( | |
fa, | |
function () { | |
var ya, Ea; | |
if (!(Z instanceof U)) | |
throw new Bb( | |
"Key request data " + | |
JSON.stringify(Z) + | |
" was not created by this factory." | |
); | |
ya = ca; | |
if (ca instanceof jc) { | |
if (!ca.isVerified()) throw new ad(T.MASTERTOKEN_UNTRUSTED, ca); | |
oa = ca; | |
ya = ca.identity; | |
} | |
Ea = new Uint8Array(16); | |
ka.getRandom().nextBytes(Ea); | |
tc(Ea, sc, Ec, { | |
result: function (Ja) { | |
Na( | |
fa, | |
function () { | |
ka.getMslCryptoContext().wrap(Ja, { | |
result: function (Da) { | |
xa(ya, Ja, Da); | |
}, | |
error: function (Da) { | |
Na( | |
fa, | |
function () { | |
Da instanceof gb && Da.setEntity(oa); | |
throw Da; | |
}, | |
Xa | |
); | |
}, | |
}); | |
}, | |
Xa | |
); | |
}, | |
error: function (Ja) { | |
Na( | |
fa, | |
function () { | |
throw new yb( | |
T.WRAP_KEY_CREATION_FAILURE, | |
null, | |
Ja | |
).setEntity(oa); | |
}, | |
Xa | |
); | |
}, | |
}); | |
}, | |
Xa | |
); | |
}, | |
getCryptoContext: function (ka, Z, ca, fa, xa) { | |
var Ma; | |
function Sa(Ra, Xa, oa, ya, Ea) { | |
Na( | |
xa, | |
function () { | |
var Ja; | |
Ja = new aa(Ea); | |
Ja.unwrap(Xa.encryptionKey, oc, Dc, { | |
result: function (Da) { | |
Ja.unwrap(Xa.hmacKey, pc, Mc, { | |
result: function (Va) { | |
Na( | |
xa, | |
function () { | |
this.repository.addCryptoContext(Xa.wrapdata, Ja); | |
this.repository.removeCryptoContext(oa); | |
return new mc(ka, Xa.masterToken, ya, Da, Va); | |
}, | |
Ma | |
); | |
}, | |
error: function (Va) { | |
Na(xa, function () { | |
Va instanceof gb && Va.setEntity(Ra); | |
throw Va; | |
}); | |
}, | |
}); | |
}, | |
error: function (Da) { | |
Na(xa, function () { | |
Da instanceof gb && Da.setEntity(Ra); | |
throw Da; | |
}); | |
}, | |
}); | |
}, | |
Ma | |
); | |
} | |
Ma = this; | |
Na( | |
xa, | |
function () { | |
var Ra, Xa; | |
if (!(Z instanceof U)) | |
throw new Bb( | |
"Key request data " + | |
JSON.stringify(Z) + | |
" was not created by this factory." | |
); | |
if (!(ca instanceof V)) | |
throw new Bb( | |
"Key response data " + | |
JSON.stringify(ca) + | |
" was not created by this factory." | |
); | |
Ra = Z.mechanism; | |
Xa = Z.wrapdata; | |
ka.getEntityAuthenticationData(null, { | |
result: function (oa) { | |
Na( | |
xa, | |
function () { | |
var ya, Ea, Ja; | |
ya = oa.getIdentity(); | |
switch (Ra) { | |
case X.PSK: | |
Ea = new yc(ya); | |
Ja = ka.getEntityAuthenticationFactory(Wb.PSK); | |
if (!Ja) | |
throw new Ub( | |
T.UNSUPPORTED_KEYX_MECHANISM, | |
Ra | |
).setEntity(oa); | |
Ea = Ja.getCryptoContext(ka, Ea); | |
Ea = new aa(Ea.wrapKey); | |
break; | |
case X.MGK: | |
Ea = new xc(ya); | |
Ja = ka.getEntityAuthenticationFactory(Wb.MGK); | |
if (!Ja) | |
throw new Ub( | |
T.UNSUPPORTED_KEYX_MECHANISM, | |
Ra | |
).setEntity(oa); | |
Ea = Ja.getCryptoContext(ka, Ea); | |
Ea = new aa(Ea.wrapKey); | |
break; | |
case X.WRAP: | |
Ea = this.repository.getCryptoContext(Xa); | |
if (!Ea) | |
throw new Ub( | |
T.KEYX_WRAPPING_KEY_MISSING, | |
Kb(Xa) | |
).setEntity(oa); | |
break; | |
default: | |
throw new Ub( | |
T.UNSUPPORTED_KEYX_MECHANISM, | |
Ra | |
).setEntity(oa); | |
} | |
Ea.unwrap(ca.wrapKey, sc, Ec, { | |
result: function (Da) { | |
Sa(oa, ca, Xa, ya, Da); | |
}, | |
error: function (Da) { | |
Na(xa, function () { | |
Da instanceof gb && Da.setEntity(oa); | |
throw Da; | |
}); | |
}, | |
}); | |
}, | |
Ma | |
); | |
}, | |
error: xa.error, | |
}); | |
}, | |
Ma | |
); | |
}, | |
}); | |
})(); | |
Af = Hb.Class.create({ | |
addCryptoContext: function (da, X) {}, | |
getCryptoContext: function (da) {}, | |
removeCryptoContext: function (da) {}, | |
}); | |
(function () { | |
var X, U, V, aa; | |
function da(W, ha, va, ra, ia) { | |
switch (va) { | |
case X.JWE_RSA: | |
case X.JWEJS_RSA: | |
return new vc(W, wc.RSA_OAEP, qc, ra, ia); | |
case X.JWK_RSA: | |
return new pd(W, ha, ra, ia, qd.WRAP_UNWRAP_OAEP); | |
case X.JWK_RSAES: | |
return new pd(W, ha, ra, ia, qd.WRAP_UNWRAP_PKCS1); | |
default: | |
throw new yb(T.UNSUPPORTED_KEYX_MECHANISM, va); | |
} | |
} | |
X = Ee = { | |
RSA: "RSA", | |
ECC: "ECC", | |
JWE_RSA: "JWE_RSA", | |
JWEJS_RSA: "JWEJS_RSA", | |
JWK_RSA: "JWK_RSA", | |
JWK_RSAES: "JWK_RSAES", | |
}; | |
U = Dd = cd.extend({ | |
init: function qa(ha, va, ra, ia) { | |
qa.base.call(this, lc.ASYMMETRIC_WRAPPED); | |
Object.defineProperties(this, { | |
keyPairId: { value: ha, writable: !1, configurable: !1 }, | |
mechanism: { value: va, writable: !1, configurable: !1 }, | |
publicKey: { value: ra, writable: !1, configurable: !1 }, | |
privateKey: { value: ia, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () { | |
var ha; | |
ha = {}; | |
ha.keypairid = this.keyPairId; | |
ha.mechanism = this.mechanism; | |
ha.publickey = Kb(this.publicKey.getEncoded()); | |
return ha; | |
}, | |
equals: function ra(va) { | |
var ia; | |
if (va === this) return !0; | |
if (!(va instanceof Dd)) return !1; | |
ia = | |
this.privateKey === va.privateKey || | |
(this.privateKey && | |
va.privateKey && | |
gc(this.privateKey.getEncoded(), va.privateKey.getEncoded())); | |
return ( | |
ra.base.call(this, va) && | |
this.keyPairId == va.keyPairId && | |
this.mechanism == va.mechanism && | |
gc(this.publicKey.getEncoded(), va.publicKey.getEncoded()) && | |
ia | |
); | |
}, | |
uniqueKey: function ra() { | |
var ia, qa; | |
ia = this.publicKey.getEncoded(); | |
qa = this.privateKey && this.privateKey.getEncoded(); | |
ia = | |
ra.base.call(this) + | |
":" + | |
this.keyPairId + | |
":" + | |
this.mechanism + | |
":" + | |
hc(ia); | |
qa && (ia += ":" + hc(qa)); | |
return ia; | |
}, | |
}); | |
V = function (ra, ia) { | |
Na(ia, function () { | |
var qa, Aa, ka, Z; | |
qa = ra.keypairid; | |
Aa = ra.mechanism; | |
ka = ra.publickey; | |
if ( | |
!qa || | |
"string" !== typeof qa || | |
!Aa || | |
!ka || | |
"string" !== typeof ka | |
) | |
throw new Jb(T.JSON_PARSE_ERROR, "keydata " + JSON.stringify(ra)); | |
if (!X[Aa]) throw new Ub(T.UNIDENTIFIED_KEYX_MECHANISM, Aa); | |
try { | |
Z = Mb(ka); | |
switch (Aa) { | |
case X.JWE_RSA: | |
case X.JWEJS_RSA: | |
case X.JWK_RSA: | |
Id(Z, nd, Ec, { | |
result: function (ca) { | |
ia.result(new U(qa, Aa, ca, null)); | |
}, | |
error: function (ca) { | |
ia.error(ca); | |
}, | |
}); | |
break; | |
case X.JWK_RSAES: | |
Id(Z, Gd, Ec, { | |
result: function (ca) { | |
ia.result(new U(qa, Aa, ca, null)); | |
}, | |
error: function (ca) { | |
ia.error(ca); | |
}, | |
}); | |
break; | |
default: | |
throw new yb(T.UNSUPPORTED_KEYX_MECHANISM, Aa); | |
} | |
} catch (ca) { | |
if (!(ca instanceof gb)) | |
throw new yb( | |
T.INVALID_PUBLIC_KEY, | |
"keydata " + JSON.stringify(ra), | |
ca | |
); | |
throw ca; | |
} | |
}); | |
}; | |
aa = Fe = dd.extend({ | |
init: function Z(ia, qa, Aa, ka) { | |
Z.base.call(this, ia, lc.ASYMMETRIC_WRAPPED); | |
Object.defineProperties(this, { | |
keyPairId: { value: qa, writable: !1, configurable: !1 }, | |
encryptionKey: { value: Aa, writable: !1, configurable: !1 }, | |
hmacKey: { value: ka, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getKeydata: function () { | |
var ia; | |
ia = {}; | |
ia.keypairid = this.keyPairId; | |
ia.encryptionkey = Kb(this.encryptionKey); | |
ia.hmackey = Kb(this.hmacKey); | |
return ia; | |
}, | |
equals: function Aa(qa) { | |
return this === qa | |
? !0 | |
: qa instanceof Fe | |
? Aa.base.call(this, qa) && | |
this.keyPairId == qa.keyPairId && | |
gc(this.encryptionKey, qa.encryptionKey) && | |
gc(this.hmacKey, qa.hmacKey) | |
: !1; | |
}, | |
uniqueKey: function Aa() { | |
return ( | |
Aa.base.call(this) + | |
":" + | |
this.keyPairId + | |
":" + | |
hc(this.encryptionKey) + | |
":" + | |
hc(this.hmacKey) | |
); | |
}, | |
}); | |
je = nc.extend({ | |
init: function ka() { | |
ka.base.call(this, lc.ASYMMETRIC_WRAPPED); | |
}, | |
createRequestData: function (ka, Z, ca) { | |
V(Z, ca); | |
}, | |
createResponseData: function (ka, Z, ca) { | |
var fa, xa, Sa, Ma; | |
ka = ca.keypairid; | |
fa = ca.encryptionkey; | |
xa = ca.hmackey; | |
if ( | |
!ka || | |
"string" !== typeof ka || | |
!fa || | |
"string" !== typeof fa || | |
!xa || | |
"string" !== typeof xa | |
) | |
throw new Jb(T.JSON_PARSE_ERROR, "keydata " + JSON.stringify(ca)); | |
try { | |
Sa = Mb(fa); | |
} catch (Ra) { | |
throw new yb( | |
T.INVALID_ENCRYPTION_KEY, | |
"keydata " + JSON.stringify(ca), | |
Ra | |
); | |
} | |
try { | |
Ma = Mb(xa); | |
} catch (Ra) { | |
throw new yb( | |
T.INVALID_HMAC_KEY, | |
"keydata " + JSON.stringify(ca), | |
Ra | |
); | |
} | |
return new aa(Z, ka, Sa, Ma); | |
}, | |
generateResponse: function (ka, Z, ca, fa) { | |
var Ma; | |
function xa(Ra, Xa) { | |
Na( | |
fa, | |
function () { | |
var oa; | |
oa = da(ka, Z.keyPairId, Z.mechanism, null, Z.publicKey); | |
oa.wrap(Ra, { | |
result: function (ya) { | |
Na( | |
fa, | |
function () { | |
oa.wrap(Xa, { | |
result: function (Ea) { | |
Sa(Ra, ya, Xa, Ea); | |
}, | |
error: function (Ea) { | |
Na( | |
fa, | |
function () { | |
Ea instanceof gb && | |
ca instanceof jc && | |
Ea.setEntity(ca); | |
throw Ea; | |
}, | |
Ma | |
); | |
}, | |
}); | |
}, | |
Ma | |
); | |
}, | |
error: function (ya) { | |
Na( | |
fa, | |
function () { | |
ya instanceof gb && | |
ca instanceof jc && | |
ya.setEntity(ca); | |
throw ya; | |
}, | |
Ma | |
); | |
}, | |
}); | |
}, | |
Ma | |
); | |
} | |
function Sa(Ra, Xa, oa, ya) { | |
Na( | |
fa, | |
function () { | |
var Ea; | |
Ea = ka.getTokenFactory(); | |
ca instanceof jc | |
? Ea.renewMasterToken(ka, ca, Ra, oa, { | |
result: function (Ja) { | |
Na( | |
fa, | |
function () { | |
var Da, Va; | |
Da = new mc(ka, Ja); | |
Va = new aa(Ja, Z.keyPairId, Xa, ya); | |
return new nc.KeyExchangeData(Va, Da, fa); | |
}, | |
Ma | |
); | |
}, | |
error: function (Ja) { | |
Na( | |
fa, | |
function () { | |
Ja instanceof gb && Ja.setEntity(ca); | |
throw Ja; | |
}, | |
Ma | |
); | |
}, | |
}) | |
: Ea.createMasterToken(ka, ca, Ra, oa, { | |
result: function (Ja) { | |
Na( | |
fa, | |
function () { | |
var Da, Va; | |
Da = new mc(ka, Ja); | |
Va = new aa(Ja, Z.keyPairId, Xa, ya); | |
return new nc.KeyExchangeData(Va, Da, fa); | |
}, | |
Ma | |
); | |
}, | |
error: fa.error, | |
}); | |
}, | |
Ma | |
); | |
} | |
Ma = this; | |
Na( | |
fa, | |
function () { | |
if (!(Z instanceof U)) | |
throw new Bb( | |
"Key request data " + | |
JSON.stringify(Z) + | |
" was not created by this factory." | |
); | |
this.generateSessionKeys(ka, { | |
result: function (Ra) { | |
xa(Ra.encryptionKey, Ra.hmacKey); | |
}, | |
error: function (Ra) { | |
Na( | |
fa, | |
function () { | |
Ra instanceof gb && ca instanceof jc && Ra.setEntity(ca); | |
throw Ra; | |
}, | |
Ma | |
); | |
}, | |
}); | |
}, | |
Ma | |
); | |
}, | |
getCryptoContext: function (ka, Z, ca, fa, xa) { | |
var Sa; | |
Sa = this; | |
Na( | |
xa, | |
function () { | |
var Ma, Ra, Xa; | |
if (!(Z instanceof U)) | |
throw new Bb( | |
"Key request data " + | |
JSON.stringify(Z) + | |
" was not created by this factory." | |
); | |
if (!(ca instanceof aa)) | |
throw new Bb( | |
"Key response data " + | |
JSON.stringify(ca) + | |
" was not created by this factory." | |
); | |
Ma = Z.keyPairId; | |
Ra = ca.keyPairId; | |
if (Ma != Ra) | |
throw new Ub( | |
T.KEYX_RESPONSE_REQUEST_MISMATCH, | |
"request " + Ma + "; response " + Ra | |
).setEntity(fa); | |
Ra = Z.privateKey; | |
if (!Ra) | |
throw new Ub( | |
T.KEYX_PRIVATE_KEY_MISSING, | |
"request Asymmetric private key" | |
).setEntity(fa); | |
Xa = da(ka, Ma, Z.mechanism, Ra, null); | |
Xa.unwrap(ca.encryptionKey, oc, Dc, { | |
result: function (oa) { | |
Xa.unwrap(ca.hmacKey, pc, Mc, { | |
result: function (ya) { | |
ka.getEntityAuthenticationData(null, { | |
result: function (Ea) { | |
Na( | |
xa, | |
function () { | |
var Ja; | |
Ja = Ea.getIdentity(); | |
return new mc(ka, ca.masterToken, Ja, oa, ya); | |
}, | |
Sa | |
); | |
}, | |
error: function (Ea) { | |
Na( | |
xa, | |
function () { | |
Ea instanceof gb && Ea.setEntity(fa); | |
throw Ea; | |
}, | |
Sa | |
); | |
}, | |
}); | |
}, | |
error: function (ya) { | |
Na( | |
xa, | |
function () { | |
ya instanceof gb && ya.setEntity(fa); | |
throw ya; | |
}, | |
Sa | |
); | |
}, | |
}); | |
}, | |
error: function (oa) { | |
Na( | |
xa, | |
function () { | |
oa instanceof gb && oa.setEntity(fa); | |
throw oa; | |
}, | |
Sa | |
); | |
}, | |
}); | |
}, | |
Sa | |
); | |
}, | |
}); | |
})(); | |
zf = Hb.Class.create({ | |
init: function (da) { | |
var X, U, V, aa, W, ha, va, ra; | |
X = bc.parser(); | |
U = []; | |
V = []; | |
va = 0; | |
ra = !1; | |
X.onerror = function (ia) { | |
ra || ((ra = !0), X.end()); | |
}; | |
X.onopenobject = function (ia) { | |
var qa; | |
if (aa) (aa[ha] = {}), V.push(aa), (aa = aa[ha]); | |
else if (W) { | |
qa = {}; | |
V.push(W); | |
W.push(qa); | |
aa = qa; | |
W = Gb; | |
} else aa = {}; | |
ha = ia; | |
}; | |
X.oncloseobject = function () { | |
var ia; | |
ia = V.pop(); | |
ia | |
? "object" === typeof ia | |
? (aa = ia) | |
: ((aa = Gb), (W = ia)) | |
: (U.push(aa), (va = X.index), (aa = Gb)); | |
}; | |
X.onopenarray = function () { | |
var ia; | |
if (aa) (aa[ha] = []), V.push(aa), (W = aa[ha]), (aa = Gb); | |
else if (W) { | |
ia = []; | |
V.push(W); | |
W.push(ia); | |
W = ia; | |
} else W = []; | |
}; | |
X.onclosearray = function () { | |
var ia; | |
ia = V.pop(); | |
ia | |
? "object" === typeof ia | |
? ((aa = ia), (W = Gb)) | |
: (W = ia) | |
: (U.push(W), (va = X.index), (W = Gb)); | |
}; | |
X.onkey = function (ia) { | |
ha = ia; | |
}; | |
X.onvalue = function (ia) { | |
aa ? (aa[ha] = ia) : W ? W.push(ia) : (U.push(ia), (va = X.index)); | |
}; | |
X.write(da).close(); | |
Object.defineProperties(this, { | |
_values: { value: U, writable: !1, enumerable: !1, configurable: !1 }, | |
_lastIndex: { | |
value: va, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
more: function () { | |
return 0 < this._values.length; | |
}, | |
nextValue: function () { | |
return 0 == this._values.length ? Gb : this._values.shift(); | |
}, | |
lastIndex: function () { | |
return this._lastIndex; | |
}, | |
}); | |
(function () { | |
var da, X, U, V, aa; | |
da = Rd = "entityauthdata"; | |
X = He = "mastertoken"; | |
U = Ie = "headerdata"; | |
V = Je = "errordata"; | |
aa = Sd = "signature"; | |
Ge = function (W, ha, va, ra) { | |
Na(ra, function () { | |
var ia, qa, Aa, ka, Z, ca; | |
ia = ha[da]; | |
qa = ha[X]; | |
Aa = ha[aa]; | |
if ( | |
(ia && "object" !== typeof ia) || | |
(qa && "object" !== typeof qa) || | |
"string" !== typeof Aa | |
) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"header/errormsg " + JSON.stringify(ha) | |
); | |
try { | |
ka = Mb(Aa); | |
} catch (fa) { | |
throw new Nb( | |
T.HEADER_SIGNATURE_INVALID, | |
"header/errormsg " + JSON.stringify(ha), | |
fa | |
); | |
} | |
Z = null; | |
ia && (Z = se(W, ia)); | |
ca = ha[U]; | |
if (ca != Gb && null != ca) { | |
if ("string" !== typeof ca) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"header/errormsg " + JSON.stringify(ha) | |
); | |
qa | |
? ed(W, qa, { | |
result: function (fa) { | |
Td(W, ca, Z, fa, ka, va, ra); | |
}, | |
error: function (fa) { | |
ra.error(fa); | |
}, | |
}) | |
: Td(W, ca, Z, null, ka, va, ra); | |
} else if (((ia = ha[V]), ia != Gb && null != ia)) { | |
if ("string" !== typeof ia) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"header/errormsg " + JSON.stringify(ha) | |
); | |
Ke(W, ia, Z, ka, ra); | |
} else throw new Jb(T.JSON_PARSE_ERROR, JSON.stringify(ha)); | |
}); | |
}; | |
})(); | |
(function () { | |
function da(X, U) { | |
this.errordata = X; | |
this.signature = U; | |
} | |
Ic = Hb.Class.create({ | |
init: function (X, U, V, aa, W, ha, va, ra, ia, qa) { | |
var Aa; | |
Aa = this; | |
Na( | |
qa, | |
function () { | |
var ka, Z; | |
0 > ha && (ha = -1); | |
if (0 > aa || aa > Rb) | |
throw new Bb("Message ID " + aa + " is out of range."); | |
if (!U) throw new Nb(T.MESSAGE_ENTITY_NOT_FOUND); | |
if (ia) | |
return ( | |
Object.defineProperties(this, { | |
entityAuthenticationData: { | |
value: U, | |
writable: !1, | |
configurable: !1, | |
}, | |
recipient: { value: V, writable: !1, configurable: !1 }, | |
messageId: { value: aa, writable: !1, configurable: !1 }, | |
errorCode: { value: W, writable: !1, configurable: !1 }, | |
internalCode: { value: ha, writable: !1, configurable: !1 }, | |
errorMessage: { value: va, writable: !1, configurable: !1 }, | |
userMessage: { value: ra, writable: !1, configurable: !1 }, | |
errordata: { | |
value: ia.errordata, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: ia.signature, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}), | |
this | |
); | |
ka = {}; | |
V && (ka.recipient = V); | |
ka.messageid = aa; | |
ka.errorcode = W; | |
0 < ha && (ka.internalcode = ha); | |
va && (ka.errormsg = va); | |
ra && (ka.usermsg = ra); | |
try { | |
Z = X.getEntityAuthenticationFactory(U.scheme).getCryptoContext( | |
X, | |
U | |
); | |
} catch (ca) { | |
throw ( | |
(ca instanceof gb && (ca.setEntity(U), ca.setMessageId(aa)), | |
ca) | |
); | |
} | |
ka = fc(JSON.stringify(ka), Tb); | |
Z.encrypt(ka, { | |
result: function (ca) { | |
Na( | |
qa, | |
function () { | |
Z.sign(ca, { | |
result: function (fa) { | |
Na( | |
qa, | |
function () { | |
Object.defineProperties(this, { | |
entityAuthenticationData: { | |
value: U, | |
writable: !1, | |
configurable: !1, | |
}, | |
recipient: { | |
value: V, | |
writable: !1, | |
configurable: !1, | |
}, | |
messageId: { | |
value: aa, | |
writable: !1, | |
configurable: !1, | |
}, | |
errorCode: { | |
value: W, | |
writable: !1, | |
configurable: !1, | |
}, | |
internalCode: { | |
value: ha, | |
writable: !1, | |
configurable: !1, | |
}, | |
errorMessage: { | |
value: va, | |
writable: !1, | |
configurable: !1, | |
}, | |
userMessage: { | |
value: ra, | |
writable: !1, | |
configurable: !1, | |
}, | |
errordata: { | |
value: ca, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: fa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
}, | |
Aa | |
); | |
}, | |
error: function (fa) { | |
Na( | |
qa, | |
function () { | |
fa instanceof gb && | |
(fa.setEntity(U), fa.setMessageId(aa)); | |
throw fa; | |
}, | |
Aa | |
); | |
}, | |
}); | |
}, | |
Aa | |
); | |
}, | |
error: function (ca) { | |
Na( | |
qa, | |
function () { | |
ca instanceof gb && | |
(ca.setEntity(U), ca.setMessageId(aa)); | |
throw ca; | |
}, | |
Aa | |
); | |
}, | |
}); | |
}, | |
Aa | |
); | |
}, | |
toJSON: function () { | |
var X; | |
X = {}; | |
X[Rd] = this.entityAuthenticationData; | |
X[Je] = Kb(this.errordata); | |
X[Sd] = Kb(this.signature); | |
return X; | |
}, | |
}); | |
Le = function (X, U, V, aa, W, ha, va, ra, ia) { | |
new Ic(X, U, V, aa, W, ha, va, ra, null, ia); | |
}; | |
Ke = function (X, U, V, aa, W) { | |
Na(W, function () { | |
var ha, va, ra; | |
if (!V) throw new Nb(T.MESSAGE_ENTITY_NOT_FOUND); | |
try { | |
ha = V.scheme; | |
va = X.getEntityAuthenticationFactory(ha); | |
if (!va) throw new rc(T.ENTITYAUTH_FACTORY_NOT_FOUND, ha); | |
ra = va.getCryptoContext(X, V); | |
} catch (ia) { | |
throw (ia instanceof gb && ia.setEntity(V), ia); | |
} | |
try { | |
U = Mb(U); | |
} catch (ia) { | |
throw new Nb(T.HEADER_DATA_INVALID, U, ia).setEntity(V); | |
} | |
if (!U || 0 == U.length) | |
throw new Nb(T.HEADER_DATA_MISSING, U).setEntity(V); | |
ra.verify(U, aa, { | |
result: function (ia) { | |
Na(W, function () { | |
if (!ia) | |
throw new yb(T.MESSAGE_VERIFICATION_FAILED).setEntity(V); | |
ra.decrypt(U, { | |
result: function (qa) { | |
Na(W, function () { | |
var Aa, ka, Z, ca, fa, xa, Sa, Ma; | |
Aa = ec(qa, Tb); | |
try { | |
ka = JSON.parse(Aa); | |
} catch (Xa) { | |
if (Xa instanceof SyntaxError) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"errordata " + Aa, | |
Xa | |
).setEntity(V); | |
throw Xa; | |
} | |
Z = ka.recipient !== Gb ? ka.recipient : null; | |
ca = parseInt(ka.messageid); | |
fa = parseInt(ka.errorcode); | |
xa = parseInt(ka.internalcode); | |
Sa = ka.errormsg; | |
Ma = ka.usermsg; | |
if ( | |
(Z && "string" !== typeof Z) || | |
!ca || | |
ca != ca || | |
!fa || | |
fa != fa || | |
(ka.internalcode && xa != xa) || | |
(Sa && "string" !== typeof Sa) || | |
(Ma && "string" !== typeof Ma) | |
) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"errordata " + Aa | |
).setEntity(V); | |
if (0 > ca || ca > Rb) | |
throw new Nb( | |
T.MESSAGE_ID_OUT_OF_RANGE, | |
"errordata " + Aa | |
).setEntity(V); | |
ka = !1; | |
for (var Ra in Ga) { | |
if (Ga[Ra] == fa) { | |
ka = !0; | |
break; | |
} | |
} | |
ka || (fa = Ga.FAIL); | |
if (xa) { | |
if (0 > xa) | |
throw new Nb( | |
T.INTERNAL_CODE_NEGATIVE, | |
"errordata " + Aa | |
) | |
.setEntity(V) | |
.setMessageId(ca); | |
} else xa = -1; | |
Aa = new da(U, aa); | |
new Ic(X, V, Z, ca, fa, xa, Sa, Ma, Aa, W); | |
}); | |
}, | |
error: function (qa) { | |
Na(W, function () { | |
qa instanceof gb && qa.setEntity(V); | |
throw qa; | |
}); | |
}, | |
}); | |
}); | |
}, | |
error: function (ia) { | |
Na(W, function () { | |
ia instanceof gb && ia.setEntity(V); | |
throw ia; | |
}); | |
}, | |
}); | |
}); | |
}; | |
})(); | |
Bf = Hb.Class.create({ getUserMessage: function (da, X) {} }); | |
(function () { | |
Ud = function (da, X) { | |
var U; | |
if (!da || !X) return null; | |
U = da.compressionAlgorithms.filter(function (V) { | |
for (var aa = 0; aa < X.compressionAlgorithms.length; ++aa) { | |
if (V == X.compressionAlgorithms[aa]) return !0; | |
} | |
return !1; | |
}); | |
da = da.languages.filter(function (V) { | |
for (var aa = 0; aa < X.languages.length; ++aa) { | |
if (V == X.languages[aa]) return !0; | |
} | |
return !1; | |
}); | |
return new fd(U, da); | |
}; | |
fd = Hb.Class.create({ | |
init: function (da, X) { | |
da || (da = []); | |
X || (X = []); | |
da.sort(); | |
Object.defineProperties(this, { | |
compressionAlgorithms: { | |
value: da, | |
writable: !1, | |
enumerable: !0, | |
configurable: !1, | |
}, | |
languages: { | |
value: X, | |
writable: !1, | |
enumerable: !0, | |
configurable: !1, | |
}, | |
}); | |
}, | |
toJSON: function () { | |
var da; | |
da = {}; | |
da.compressionalgos = this.compressionAlgorithms; | |
da.languages = this.languages; | |
return da; | |
}, | |
equals: function (da) { | |
return this === da | |
? !0 | |
: da instanceof fd | |
? ce(this.compressionAlgorithms, da.compressionAlgorithms) && | |
ce(this.languages, da.languages) | |
: !1; | |
}, | |
uniqueKey: function () { | |
return ( | |
this.compressionAlgorithms.join(":") + | |
"|" + | |
this.languages.join(":") | |
); | |
}, | |
}); | |
Me = function (da) { | |
var X, U, aa; | |
X = da.compressionalgos; | |
U = da.languages; | |
if ((X && !(X instanceof Array)) || (U && !(U instanceof Array))) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"capabilities " + JSON.stringify(da) | |
); | |
da = []; | |
for (var V = 0; X && V < X.length; ++V) { | |
aa = X[V]; | |
Kc[aa] && da.push(aa); | |
} | |
return new fd(da, U); | |
}; | |
})(); | |
(function () { | |
var qa, Aa; | |
function da(ka, Z, ca, fa, xa) { | |
this.customer = ka; | |
this.sender = Z; | |
this.messageCryptoContext = ca; | |
this.headerdata = fa; | |
this.signature = xa; | |
} | |
function X( | |
ka, | |
Z, | |
ca, | |
fa, | |
xa, | |
Sa, | |
Ma, | |
Ra, | |
Xa, | |
oa, | |
ya, | |
Ea, | |
Ja, | |
Da, | |
Va, | |
Ha, | |
ab, | |
db, | |
Ya, | |
mb | |
) { | |
return { | |
cryptoContext: { value: Z, writable: !1, configurable: !1 }, | |
customer: { value: ca, writable: !1, configurable: !1 }, | |
entityAuthenticationData: { | |
value: fa, | |
writable: !1, | |
configurable: !1, | |
}, | |
masterToken: { value: xa, writable: !1, configurable: !1 }, | |
sender: { value: Sa, writable: !1, configurable: !1 }, | |
messageId: { value: Ma, writable: !1, configurable: !1 }, | |
nonReplayableId: { value: Ha, writable: !1, configurable: !1 }, | |
keyRequestData: { value: Ra, writable: !1, configurable: !1 }, | |
keyResponseData: { value: Xa, writable: !1, configurable: !1 }, | |
userAuthenticationData: { value: oa, writable: !1, configurable: !1 }, | |
userIdToken: { value: ya, writable: !1, configurable: !1 }, | |
serviceTokens: { value: Ea, writable: !1, configurable: !1 }, | |
peerMasterToken: { value: Ja, writable: !1, configurable: !1 }, | |
peerUserIdToken: { value: Da, writable: !1, configurable: !1 }, | |
peerServiceTokens: { value: Va, writable: !1, configurable: !1 }, | |
messageCapabilities: { value: db, writable: !1, configurable: !1 }, | |
renewable: { | |
value: ab, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
headerdata: { | |
value: Ya, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: mb, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
} | |
function U(ka, Z, ca) { | |
var fa; | |
if (ca) { | |
if ((Z = ka.getMslStore().getCryptoContext(ca))) return Z; | |
if (!ca.isVerified() || !ca.isDecrypted()) | |
throw new ad(T.MASTERTOKEN_UNTRUSTED, ca); | |
return new mc(ka, ca); | |
} | |
ca = Z.scheme; | |
fa = ka.getEntityAuthenticationFactory(ca); | |
if (!fa) throw new rc(T.ENTITYAUTH_FACTORY_NOT_FOUND, ca); | |
return fa.getCryptoContext(ka, Z); | |
} | |
function V(ka, Z, ca, fa, xa) { | |
Na(xa, function () { | |
Z.verify(ca, fa, { | |
result: function (Sa) { | |
Na(xa, function () { | |
if (!Sa) throw new yb(T.MESSAGE_VERIFICATION_FAILED); | |
Z.decrypt(ca, { | |
result: function (Ma) { | |
Na(xa, function () { | |
return ec(Ma, Tb); | |
}); | |
}, | |
error: function (Ma) { | |
xa.error(Ma); | |
}, | |
}); | |
}); | |
}, | |
error: function (Sa) { | |
xa.error(Sa); | |
}, | |
}); | |
}); | |
} | |
function aa(ka, Z, ca) { | |
Na(ca, function () { | |
if (Z) ze(ka, Z, ca); | |
else return null; | |
}); | |
} | |
function W(ka, Z, ca, fa) { | |
Na(fa, function () { | |
if (Z) vd(ka, Z, ca, fa); | |
else return null; | |
}); | |
} | |
function ha(ka, Z, ca, fa) { | |
Na(fa, function () { | |
if (ca) Qe(ka, Z, ca, fa); | |
else return null; | |
}); | |
} | |
function va(ka, Z, ca, fa, xa, Sa, Ma) { | |
var Xa; | |
function Ra(oa, ya, Ea) { | |
var Ja, Da; | |
if (ya >= oa.length) { | |
Ja = []; | |
for (Da in Xa) { | |
Ja.push(Xa[Da]); | |
} | |
Ea.result(Ja); | |
} else { | |
Ja = oa[ya]; | |
if ("object" !== typeof Ja) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + Sa); | |
wd(ka, Ja, ca, fa, xa, { | |
result: function (Va) { | |
Na(Ea, function () { | |
Xa[Va.uniqueKey()] = Va; | |
Ra(oa, ya + 1, Ea); | |
}); | |
}, | |
error: function (Va) { | |
Ea.error(Va); | |
}, | |
}); | |
} | |
} | |
Xa = {}; | |
Na(Ma, function () { | |
if (Z) { | |
if (!(Z instanceof Array)) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + Sa); | |
Ra(Z, 0, Ma); | |
} else return []; | |
}); | |
} | |
function ra(ka, Z, ca, fa, xa, Sa) { | |
function Ma(Xa, oa, ya) { | |
Na(ya, function () { | |
var Ea; | |
Ea = oa.peermastertoken; | |
if (Ea && "object" !== typeof Ea) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + xa); | |
if (!Ea) return null; | |
ed(Xa, Ea, ya); | |
}); | |
} | |
function Ra(Xa, oa, ya, Ea) { | |
Na(Ea, function () { | |
var Ja; | |
Ja = oa.peeruseridtoken; | |
if (Ja && "object" !== typeof Ja) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + xa); | |
if (!Ja) return null; | |
vd(Xa, Ja, ya, Ea); | |
}); | |
} | |
Na(Sa, function () { | |
if (!ka.isPeerToPeer()) | |
return { | |
peerMasterToken: null, | |
peerUserIdToken: null, | |
peerServiceTokens: [], | |
}; | |
Ma(ka, Z, { | |
result: function (Xa) { | |
Na(Sa, function () { | |
var oa; | |
oa = ca ? ca.masterToken : Xa; | |
Ra(ka, Z, oa, { | |
result: function (ya) { | |
Na(Sa, function () { | |
va(ka, Z.peerservicetokens, oa, ya, fa, xa, { | |
result: function (Ea) { | |
Na(Sa, function () { | |
return { | |
peerMasterToken: Xa, | |
peerUserIdToken: ya, | |
peerServiceTokens: Ea, | |
}; | |
}); | |
}, | |
error: function (Ea) { | |
Na(Sa, function () { | |
Ea instanceof gb && | |
(Ea.setEntity(oa), Ea.setUser(ya)); | |
throw Ea; | |
}); | |
}, | |
}); | |
}); | |
}, | |
error: function (ya) { | |
Na(Sa, function () { | |
ya instanceof gb && ya.setEntity(oa); | |
throw ya; | |
}); | |
}, | |
}); | |
}); | |
}, | |
error: Sa.error, | |
}); | |
}); | |
} | |
function ia(ka, Z, ca, fa) { | |
var Sa; | |
function xa(Ma, Ra) { | |
Na(fa, function () { | |
if (Ra >= Ma.length) return Sa; | |
ye(ka, Ma[Ra], { | |
result: function (Xa) { | |
Na(fa, function () { | |
Sa.push(Xa); | |
xa(Ma, Ra + 1); | |
}); | |
}, | |
error: function (Xa) { | |
fa.error(Xa); | |
}, | |
}); | |
}); | |
} | |
Sa = []; | |
Na(fa, function () { | |
var Ma; | |
Ma = Z.keyrequestdata; | |
if (!Ma) return Sa; | |
if (!(Ma instanceof Array)) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + ca); | |
xa(Ma, 0); | |
}); | |
} | |
qa = Oe = Hb.Class.create({ | |
init: function (ka, Z, ca, fa, xa, Sa, Ma, Ra, Xa) { | |
Object.defineProperties(this, { | |
messageId: { value: ka, writable: !1, configurable: !1 }, | |
nonReplayableId: { value: Z, writable: !1, configurable: !1 }, | |
renewable: { value: ca, writable: !1, configurable: !1 }, | |
capabilities: { value: fa, writable: !1, configurable: !1 }, | |
keyRequestData: { value: xa, writable: !1, configurable: !1 }, | |
keyResponseData: { value: Sa, writable: !1, configurable: !1 }, | |
userAuthData: { value: Ma, writable: !1, configurable: !1 }, | |
userIdToken: { value: Ra, writable: !1, configurable: !1 }, | |
serviceTokens: { value: Xa, writable: !1, configurable: !1 }, | |
}); | |
}, | |
}); | |
Aa = Pe = Hb.Class.create({ | |
init: function (ka, Z, ca) { | |
Object.defineProperties(this, { | |
peerMasterToken: { value: ka, writable: !1, configurable: !1 }, | |
peerUserIdToken: { value: Z, writable: !1, configurable: !1 }, | |
peerServiceTokens: { value: ca, writable: !1, configurable: !1 }, | |
}); | |
}, | |
}); | |
gd = Hb.Class.create({ | |
init: function (ka, Z, ca, fa, xa, Sa, Ma) { | |
var Xa; | |
function Ra(oa) { | |
Na( | |
Ma, | |
function () { | |
var ya, | |
Ea, | |
Ja, | |
Da, | |
Va, | |
Ha, | |
ab, | |
db, | |
Ya, | |
mb, | |
qb, | |
sb, | |
ub, | |
vb, | |
Eb, | |
Db, | |
pa; | |
Z = ca ? null : Z; | |
ya = fa.nonReplayableId; | |
Ea = fa.renewable; | |
Ja = fa.capabilities; | |
Da = fa.messageId; | |
Va = fa.keyRequestData ? fa.keyRequestData : []; | |
Ha = fa.keyResponseData; | |
ab = fa.userAuthData; | |
db = fa.userIdToken; | |
Ya = fa.serviceTokens ? fa.serviceTokens : []; | |
if (ka.isPeerToPeer()) { | |
mb = xa.peerMasterToken; | |
qb = xa.peerUserIdToken; | |
sb = xa.peerServiceTokens ? xa.peerServiceTokens : []; | |
} else (qb = mb = null), (sb = []); | |
if (0 > Da || Da > Rb) | |
throw new Bb("Message ID " + Da + " is out of range."); | |
if (!Z && !ca) | |
throw new Bb( | |
"Message entity authentication data or master token must be provided." | |
); | |
if (Ha) { | |
if (ka.isPeerToPeer()) { | |
ub = ca; | |
vb = Ha.masterToken; | |
} else (ub = Ha.masterToken), (vb = mb); | |
} else (ub = ca), (vb = mb); | |
if (db && (!ub || !db.isBoundTo(ub))) | |
throw new Bb( | |
"User ID token must be bound to a master token." | |
); | |
if (qb && (!vb || !qb.isBoundTo(vb))) | |
throw new Bb( | |
"Peer user ID token must be bound to a peer master token." | |
); | |
Ya.forEach(function (Fa) { | |
if (Fa.isMasterTokenBound() && (!ub || !Fa.isBoundTo(ub))) | |
throw new Bb( | |
"Master token bound service tokens must be bound to the provided master token." | |
); | |
if (Fa.isUserIdTokenBound() && (!db || !Fa.isBoundTo(db))) | |
throw new Bb( | |
"User ID token bound service tokens must be bound to the provided user ID token." | |
); | |
}, this); | |
sb.forEach(function (Fa) { | |
if (Fa.isMasterTokenBound() && (!vb || !Fa.isBoundTo(vb))) | |
throw new Bb( | |
"Master token bound peer service tokens must be bound to the provided peer master token." | |
); | |
if (Fa.isUserIdTokenBound() && (!qb || !Fa.isBoundTo(qb))) | |
throw new Bb( | |
"User ID token bound peer service tokens must be bound to the provided peer user ID token." | |
); | |
}, this); | |
if (Sa) { | |
pa = Sa.customer; | |
Eb = Sa.messageCryptoContext; | |
Db = X( | |
ka, | |
Eb, | |
pa, | |
Z, | |
ca, | |
oa, | |
Da, | |
Va, | |
Ha, | |
ab, | |
db, | |
Ya, | |
mb, | |
qb, | |
sb, | |
ya, | |
Ea, | |
Ja, | |
Sa.headerdata, | |
Sa.signature | |
); | |
Object.defineProperties(this, Db); | |
return this; | |
} | |
pa = db ? db.customer : null; | |
Db = {}; | |
oa && (Db.sender = oa); | |
Db.messageid = Da; | |
"number" === typeof ya && (Db.nonreplayableid = ya); | |
Db.renewable = Ea; | |
Ja && (Db.capabilities = Ja); | |
0 < Va.length && (Db.keyrequestdata = Va); | |
Ha && (Db.keyresponsedata = Ha); | |
ab && (Db.userauthdata = ab); | |
db && (Db.useridtoken = db); | |
0 < Ya.length && (Db.servicetokens = Ya); | |
mb && (Db.peermastertoken = mb); | |
qb && (Db.peeruseridtoken = qb); | |
0 < sb.length && (Db.peerservicetokens = sb); | |
try { | |
Eb = U(ka, Z, ca); | |
} catch (Fa) { | |
throw ( | |
(Fa instanceof gb && | |
(Fa.setEntity(ca), | |
Fa.setEntity(Z), | |
Fa.setUser(db), | |
Fa.setUser(ab), | |
Fa.setMessageId(Da)), | |
Fa) | |
); | |
} | |
Db = fc(JSON.stringify(Db), Tb); | |
Eb.encrypt(Db, { | |
result: function (Fa) { | |
Na( | |
Ma, | |
function () { | |
Eb.sign(Fa, { | |
result: function (Pa) { | |
Na( | |
Ma, | |
function () { | |
var r; | |
r = X( | |
ka, | |
Eb, | |
pa, | |
Z, | |
ca, | |
oa, | |
Da, | |
Va, | |
Ha, | |
ab, | |
db, | |
Ya, | |
mb, | |
qb, | |
sb, | |
ya, | |
Ea, | |
Ja, | |
Fa, | |
Pa | |
); | |
Object.defineProperties(this, r); | |
return this; | |
}, | |
Xa | |
); | |
}, | |
error: function (Pa) { | |
Na( | |
Ma, | |
function () { | |
Pa instanceof gb && | |
(Pa.setEntity(ca), | |
Pa.setEntity(Z), | |
Pa.setUser(db), | |
Pa.setUser(ab), | |
Pa.setMessageId(Da)); | |
throw Pa; | |
}, | |
Xa | |
); | |
}, | |
}); | |
}, | |
Xa | |
); | |
}, | |
error: function (Fa) { | |
Na( | |
Ma, | |
function () { | |
Fa instanceof gb && | |
(Fa.setEntity(ca), | |
Fa.setEntity(Z), | |
Fa.setUser(db), | |
Fa.setUser(ab), | |
Fa.setMessageId(Da)); | |
throw Fa; | |
}, | |
Xa | |
); | |
}, | |
}); | |
}, | |
Xa | |
); | |
} | |
Xa = this; | |
Na( | |
Ma, | |
function () { | |
Sa | |
? Ra(Sa.sender) | |
: ca | |
? ka.getEntityAuthenticationData(null, { | |
result: function (oa) { | |
oa = oa.getIdentity(); | |
Ra(oa); | |
}, | |
error: Ma.error, | |
}) | |
: Ra(null); | |
}, | |
Xa | |
); | |
}, | |
isEncrypting: function () { | |
return this.masterToken || Cd(this.entityAuthenticationData.scheme); | |
}, | |
isRenewable: function () { | |
return this.renewable; | |
}, | |
toJSON: function () { | |
var ka; | |
ka = {}; | |
this.masterToken | |
? (ka[He] = this.masterToken) | |
: (ka[Rd] = this.entityAuthenticationData); | |
ka[Ie] = Kb(this.headerdata); | |
ka[Sd] = Kb(this.signature); | |
return ka; | |
}, | |
}); | |
Ne = function (ka, Z, ca, fa, xa, Sa) { | |
new gd(ka, Z, ca, fa, xa, null, Sa); | |
}; | |
Td = function (ka, Z, ca, fa, xa, Sa, Ma) { | |
Na(Ma, function () { | |
var Ra, Xa; | |
ca = fa ? null : ca; | |
if (!ca && !fa) throw new Nb(T.MESSAGE_ENTITY_NOT_FOUND); | |
Ra = Z; | |
try { | |
Z = Mb(Ra); | |
} catch (oa) { | |
throw new Nb(T.HEADER_DATA_INVALID, Ra, oa); | |
} | |
if (!Z || 0 == Z.length) throw new Nb(T.HEADER_DATA_MISSING, Ra); | |
try { | |
Xa = U(ka, ca, fa); | |
} catch (oa) { | |
throw ( | |
(oa instanceof gb && (oa.setEntity(fa), oa.setEntity(ca)), oa) | |
); | |
} | |
V(ka, Xa, Z, xa, { | |
result: function (oa) { | |
Na(Ma, function () { | |
var ya, Ea, Ja, Da, Va; | |
try { | |
ya = JSON.parse(oa); | |
} catch (Ha) { | |
if (Ha instanceof SyntaxError) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + oa, Ha) | |
.setEntity(fa) | |
.setEntity(ca); | |
throw Ha; | |
} | |
Ea = parseInt(ya.messageid); | |
if (!Ea || Ea != Ea) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + oa) | |
.setEntity(fa) | |
.setEntity(ca); | |
if (0 > Ea || Ea > Rb) | |
throw new Nb(T.MESSAGE_ID_OUT_OF_RANGE, "headerdata " + oa) | |
.setEntity(fa) | |
.setEntity(ca); | |
Ja = fa ? ya.sender : null; | |
if (fa && (!Ja || "string" !== typeof Ja)) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + oa) | |
.setEntity(fa) | |
.setEntity(ca) | |
.setMessageId(Ea); | |
Da = ya.keyresponsedata; | |
if (Da && "object" !== typeof Da) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + oa) | |
.setEntity(fa) | |
.setEntity(ca) | |
.setMessageId(Ea); | |
Va = Ma; | |
Ma = { | |
result: function (Ha) { | |
Va.result(Ha); | |
}, | |
error: function (Ha) { | |
Ha instanceof gb && | |
(Ha.setEntity(fa), Ha.setEntity(ca), Ha.setMessageId(Ea)); | |
Va.error(Ha); | |
}, | |
}; | |
aa(ka, Da, { | |
result: function (Ha) { | |
Na(Ma, function () { | |
var ab, db; | |
ab = !ka.isPeerToPeer() && Ha ? Ha.masterToken : fa; | |
db = ya.useridtoken; | |
if (db && "object" !== typeof db) | |
throw new Jb(T.JSON_PARSE_ERROR, "headerdata " + oa); | |
W(ka, db, ab, { | |
result: function (Ya) { | |
Na(Ma, function () { | |
var mb; | |
mb = ya.userauthdata; | |
if (mb && "object" !== typeof mb) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"headerdata " + oa | |
); | |
ha(ka, ab, mb, { | |
result: function (qb) { | |
Na(Ma, function () { | |
var sb, ub, vb; | |
if (qb) { | |
sb = qb.scheme; | |
ub = ka.getUserAuthenticationFactory(sb); | |
if (!ub) | |
throw new Cc( | |
T.USERAUTH_FACTORY_NOT_FOUND, | |
sb | |
) | |
.setUser(Ya) | |
.setUser(qb); | |
sb = fa ? fa.identity : ca.getIdentity(); | |
vb = ub.authenticate(ka, sb, qb, Ya); | |
} else vb = Ya ? Ya.customer : null; | |
va(ka, ya.servicetokens, ab, Ya, Sa, oa, { | |
result: function (Eb) { | |
Na(Ma, function () { | |
var Db, pa, Fa, Pa; | |
Db = | |
ya.nonreplayableid !== Gb | |
? parseInt(ya.nonreplayableid) | |
: null; | |
pa = ya.renewable; | |
if (Db != Db || "boolean" !== typeof pa) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"headerdata " + oa | |
); | |
if (0 > Db || Db > Rb) | |
throw new Nb( | |
T.NONREPLAYABLE_ID_OUT_OF_RANGE, | |
"headerdata " + oa | |
); | |
Fa = null; | |
Pa = ya.capabilities; | |
if (Pa) { | |
if ("object" !== typeof Pa) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"headerdata " + oa | |
); | |
Fa = Me(Pa); | |
} | |
ia(ka, ya, oa, { | |
result: function (r) { | |
ra(ka, ya, Ha, Sa, oa, { | |
result: function (b) { | |
Na(Ma, function () { | |
var a, c, l, g; | |
a = b.peerMasterToken; | |
c = b.peerUserIdToken; | |
l = b.peerServiceTokens; | |
g = new qa( | |
Ea, | |
Db, | |
pa, | |
Fa, | |
r, | |
Ha, | |
qb, | |
Ya, | |
Eb | |
); | |
a = new Aa(a, c, l); | |
c = new da(vb, Ja, Xa, Z, xa); | |
new gd( | |
ka, | |
ca, | |
fa, | |
g, | |
a, | |
c, | |
Ma | |
); | |
}); | |
}, | |
error: Ma.error, | |
}); | |
}, | |
error: function (r) { | |
Na(Ma, function () { | |
r instanceof gb && | |
(r.setUser(Ya), r.setUser(qb)); | |
throw r; | |
}); | |
}, | |
}); | |
}); | |
}, | |
error: function (Eb) { | |
Na(Ma, function () { | |
Eb instanceof gb && | |
(Eb.setEntity(ab), | |
Eb.setUser(Ya), | |
Eb.setUser(qb)); | |
throw Eb; | |
}); | |
}, | |
}); | |
}); | |
}, | |
error: Ma.error, | |
}); | |
}); | |
}, | |
error: Ma.error, | |
}); | |
}); | |
}, | |
error: Ma.error, | |
}); | |
}); | |
}, | |
error: Ma.error, | |
}); | |
}); | |
}; | |
})(); | |
(function () { | |
function da(X, U) { | |
this.payload = X; | |
this.signature = U; | |
} | |
Vd = Hb.Class.create({ | |
init: function (X, U, V, aa, W, ha, va, ra) { | |
var ia; | |
ia = this; | |
Na( | |
ra, | |
function () { | |
var qa, Aa; | |
if (0 > X || X > Rb) | |
throw new Bb( | |
"Sequence number " + X + " is outside the valid range." | |
); | |
if (0 > U || U > Rb) | |
throw new Bb( | |
"Message ID " + U + " is outside the valid range." | |
); | |
if (va) | |
return ( | |
Object.defineProperties(this, { | |
sequenceNumber: { | |
value: X, | |
writable: !1, | |
configurable: !1, | |
}, | |
messageId: { value: U, writable: !1, configurable: !1 }, | |
compressionAlgo: { | |
value: aa, | |
writable: !1, | |
configurable: !1, | |
}, | |
data: { value: W, writable: !1, configurable: !1 }, | |
endofmsg: { | |
value: V, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
payload: { | |
value: va.payload, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: va.signature, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}), | |
this | |
); | |
if (aa) { | |
qa = Wd(aa, W); | |
qa || ((aa = null), (qa = W)); | |
} else (aa = null), (qa = W); | |
Aa = {}; | |
Aa.sequencenumber = X; | |
Aa.messageid = U; | |
V && (Aa.endofmsg = V); | |
aa && (Aa.compressionalgo = aa); | |
Aa.data = Kb(qa); | |
qa = fc(JSON.stringify(Aa), Tb); | |
ha.encrypt(qa, { | |
result: function (ka) { | |
Na( | |
ra, | |
function () { | |
ha.sign(ka, { | |
result: function (Z) { | |
Na( | |
ra, | |
function () { | |
Object.defineProperties(this, { | |
sequenceNumber: { | |
value: X, | |
writable: !1, | |
configurable: !1, | |
}, | |
messageId: { | |
value: U, | |
writable: !1, | |
configurable: !1, | |
}, | |
compressionAlgo: { | |
value: aa, | |
writable: !1, | |
configurable: !1, | |
}, | |
data: { | |
value: W, | |
writable: !1, | |
configurable: !1, | |
}, | |
endofmsg: { | |
value: V, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
payload: { | |
value: ka, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: Z, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
}, | |
ia | |
); | |
}, | |
error: function (Z) { | |
ra.error(Z); | |
}, | |
}); | |
}, | |
ia | |
); | |
}, | |
error: function (ka) { | |
ra.error(ka); | |
}, | |
}); | |
}, | |
ia | |
); | |
}, | |
isEndOfMessage: function () { | |
return this.endofmsg; | |
}, | |
toJSON: function () { | |
var X; | |
X = {}; | |
X.payload = Kb(this.payload); | |
X.signature = Kb(this.signature); | |
return X; | |
}, | |
}); | |
Re = function (X, U, V, aa, W, ha, va) { | |
new Vd(X, U, V, aa, W, ha, null, va); | |
}; | |
Se = function (X, U, V) { | |
Na(V, function () { | |
var aa, W, ha, va; | |
aa = X.payload; | |
W = X.signature; | |
if (!aa || "string" !== typeof aa || "string" !== typeof W) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"payload chunk " + JSON.stringify(X) | |
); | |
try { | |
ha = Mb(aa); | |
} catch (ra) { | |
throw new Nb( | |
T.PAYLOAD_INVALID, | |
"payload chunk " + JSON.stringify(X), | |
ra | |
); | |
} | |
try { | |
va = Mb(W); | |
} catch (ra) { | |
throw new Nb( | |
T.PAYLOAD_SIGNATURE_INVALID, | |
"payload chunk " + JSON.stringify(X), | |
ra | |
); | |
} | |
U.verify(ha, va, { | |
result: function (ra) { | |
Na(V, function () { | |
if (!ra) throw new yb(T.PAYLOAD_VERIFICATION_FAILED); | |
U.decrypt(ha, { | |
result: function (ia) { | |
Na(V, function () { | |
var qa, Aa, ka, Z, ca, fa, xa; | |
qa = ec(ia, Tb); | |
try { | |
Aa = JSON.parse(qa); | |
} catch (Sa) { | |
if (Sa instanceof SyntaxError) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"payload chunk payload " + qa, | |
Sa | |
); | |
throw Sa; | |
} | |
ka = parseInt(Aa.sequencenumber); | |
Z = parseInt(Aa.messageid); | |
ca = Aa.endofmsg; | |
fa = Aa.compressionalgo; | |
Aa = Aa.data; | |
if ( | |
!ka || | |
ka != ka || | |
!Z || | |
Z != Z || | |
(ca && "boolean" !== typeof ca) || | |
(fa && "string" !== typeof fa) || | |
"string" !== typeof Aa | |
) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"payload chunk payload " + qa | |
); | |
if (0 > ka || ka > Rb) | |
throw new gb( | |
T.PAYLOAD_SEQUENCE_NUMBER_OUT_OF_RANGE, | |
"payload chunk payload " + qa | |
); | |
if (0 > Z || Z > Rb) | |
throw new gb( | |
T.PAYLOAD_MESSAGE_ID_OUT_OF_RANGE, | |
"payload chunk payload " + qa | |
); | |
ca || (ca = !1); | |
if (fa && !Kc[fa]) | |
throw new Nb(T.UNIDENTIFIED_COMPRESSION, fa); | |
try { | |
xa = Mb(Aa); | |
} catch (Sa) { | |
throw new Nb(T.PAYLOAD_DATA_CORRUPT, Aa, Sa); | |
} | |
if (xa && 0 != xa.length) qa = fa ? xd(fa, xa) : xa; | |
else { | |
if (0 < Aa.length) | |
throw new Nb(T.PAYLOAD_DATA_CORRUPT, Aa); | |
if (ca) qa = new Uint8Array(0); | |
else throw new Nb(T.PAYLOAD_DATA_MISSING, Aa); | |
} | |
xa = new da(ha, va); | |
new Vd(ka, Z, ca, fa, qa, U, xa, V); | |
}); | |
}, | |
error: function (ia) { | |
V.error(ia); | |
}, | |
}); | |
}); | |
}, | |
error: function (ra) { | |
V.error(ra); | |
}, | |
}); | |
}); | |
}; | |
})(); | |
(function () { | |
var V, aa; | |
function da(W, ha, va, ra, ia) { | |
var Aa, ka, Z, ca, fa; | |
function qa() { | |
Na(ia, function () { | |
var xa, Sa; | |
ka >= ha.length && ((ka = 0), ++Aa); | |
if (Aa >= Z.length) { | |
if (ca) throw ca; | |
throw new Ub(T.KEYX_FACTORY_NOT_FOUND, JSON.stringify(ha)); | |
} | |
xa = Z[Aa]; | |
Sa = ha[ka]; | |
xa.scheme != Sa.keyExchangeScheme | |
? (++ka, qa()) | |
: xa.generateResponse(W, Sa, fa, { | |
result: function (Ma) { | |
ia.result(Ma); | |
}, | |
error: function (Ma) { | |
Na(ia, function () { | |
if (!(Ma instanceof gb)) throw Ma; | |
ca = Ma; | |
++ka; | |
qa(); | |
}); | |
}, | |
}); | |
}); | |
} | |
Aa = 0; | |
ka = 0; | |
Z = W.getKeyExchangeFactories(); | |
fa = va ? va : ra; | |
qa(); | |
} | |
function X(W, ha, va, ra, ia) { | |
Na(ia, function () { | |
var qa; | |
qa = ha.keyRequestData; | |
if (ha.isRenewable() && 0 < qa.length) | |
ra | |
? ra.isRenewable() || ra.isExpired() | |
? da(W, qa, ra, null, ia) | |
: W.getTokenFactory().isNewestMasterToken(W, ra, { | |
result: function (Aa) { | |
Na(ia, function () { | |
if (Aa) return null; | |
da(W, qa, ra, null, ia); | |
}); | |
}, | |
error: ia.error, | |
}) | |
: da(W, qa, null, va.getIdentity(), ia); | |
else return null; | |
}); | |
} | |
function U(W, ha, va, ra) { | |
Na(ra, function () { | |
var ia, qa, Aa, ka; | |
ia = ha.userIdToken; | |
qa = ha.userAuthenticationData; | |
Aa = ha.messageId; | |
if (ia && ia.isVerified()) { | |
if ( | |
(ia.isRenewable() && ha.isRenewable()) || | |
ia.isExpired() || | |
!ia.isBoundTo(va) | |
) { | |
qa = W.getTokenFactory(); | |
qa.renewUserIdToken(W, ia, va, ra); | |
return; | |
} | |
} else if (ha.isRenewable() && va && qa) { | |
ia = ha.customer; | |
if (!ia) { | |
ia = qa.scheme; | |
ka = W.getUserAuthenticationFactory(ia); | |
if (!ka) | |
throw new Cc(T.USERAUTH_FACTORY_NOT_FOUND, ia) | |
.setEntity(va) | |
.setUser(qa) | |
.setMessageId(Aa); | |
ia = ka.authenticate(W, va.identity, qa, null); | |
} | |
qa = W.getTokenFactory(); | |
qa.createUserIdToken(W, ia, va, ra); | |
return; | |
} | |
return ia; | |
}); | |
} | |
V = new Uint8Array(0); | |
aa = Nc = function (W) { | |
if (0 > W || W > Rb) | |
throw new Bb("Message ID " + W + " is outside the valid range."); | |
return W == Rb ? 0 : W + 1; | |
}; | |
Wc = function (W) { | |
if (0 > W || W > Rb) | |
throw new Bb("Message ID " + W + " is outside the valid range."); | |
return 0 == W ? Rb : W - 1; | |
}; | |
Oc = function (W, ha, va, ra, ia) { | |
Na(ia, function () { | |
var qa; | |
if (ra == Gb || null == ra) { | |
qa = W.getRandom(); | |
do { | |
ra = qa.nextLong(); | |
} while (0 > ra || ra > Rb); | |
} else if (0 > ra || ra > Rb) throw new Bb("Message ID " + ra + " is outside the valid range."); | |
W.getEntityAuthenticationData(null, { | |
result: function (Aa) { | |
Na(ia, function () { | |
var ka; | |
ka = W.getMessageCapabilities(); | |
return new yd( | |
W, | |
ra, | |
ka, | |
Aa, | |
ha, | |
va, | |
null, | |
null, | |
null, | |
null, | |
null | |
); | |
}); | |
}, | |
error: function (Aa) { | |
ia.error(Aa); | |
}, | |
}); | |
}); | |
}; | |
Te = function (W, ha, va) { | |
Na(va, function () { | |
var ia, qa, Aa, ka, Z, ca; | |
function ra(fa) { | |
Na(va, function () { | |
fa instanceof gb && | |
(fa.setEntity(ia), | |
fa.setEntity(qa), | |
fa.setUser(Aa), | |
fa.setUser(ka), | |
fa.setMessageId(Z)); | |
throw fa; | |
}); | |
} | |
ia = ha.masterToken; | |
qa = ha.entityAuthenticationData; | |
Aa = ha.userIdToken; | |
ka = ha.userAuthenticationData; | |
Z = ha.messageId; | |
ca = aa(Z); | |
X(W, ha, qa, ia, { | |
result: function (fa) { | |
Na(va, function () { | |
var xa; | |
xa = fa ? fa.keyResponseData.masterToken : (xa = ia); | |
W.getEntityAuthenticationData(null, { | |
result: function (Sa) { | |
Na(va, function () { | |
U(W, ha, xa, { | |
result: function (Ma) { | |
Na(va, function () { | |
var Ra, Xa, oa; | |
Aa = Ma; | |
Ra = Ud( | |
ha.messageCapabilities, | |
W.getMessageCapabilities() | |
); | |
Xa = ha.keyResponseData; | |
oa = ha.serviceTokens; | |
return W.isPeerToPeer() | |
? new yd( | |
W, | |
ca, | |
Ra, | |
Sa, | |
Xa ? Xa.masterToken : ha.peerMasterToken, | |
ha.peerUserIdToken, | |
ha.peerServiceTokens, | |
ia, | |
Aa, | |
oa, | |
fa | |
) | |
: new yd( | |
W, | |
ca, | |
Ra, | |
Sa, | |
Xa ? Xa.masterToken : ia, | |
Aa, | |
oa, | |
null, | |
null, | |
null, | |
fa | |
); | |
}); | |
}, | |
error: ra, | |
}); | |
}); | |
}, | |
error: ra, | |
}); | |
}); | |
}, | |
error: ra, | |
}); | |
}); | |
}; | |
Ue = function (W, ha, va, ra, ia) { | |
Na(ia, function () { | |
W.getEntityAuthenticationData(null, { | |
result: function (qa) { | |
Na(ia, function () { | |
var Aa, ka; | |
if (ha != Gb && null != ha) Aa = aa(ha); | |
else { | |
ka = W.getRandom(); | |
do { | |
Aa = ka.nextInt(); | |
} while (0 > Aa || Aa > Rb); | |
} | |
Le( | |
W, | |
qa, | |
Aa, | |
va.responseCode, | |
va.internalCode, | |
va.message, | |
ra, | |
ia | |
); | |
}); | |
}, | |
error: function (qa) { | |
ia.error(qa); | |
}, | |
}); | |
}); | |
}; | |
yd = Hb.Class.create({ | |
init: function (W, ha, va, ra, ia, qa, Aa, ka, Z, ca, fa) { | |
var xa, Sa, Ma, Ra, Xa; | |
if (!W.isPeerToPeer() && (ka || Z)) | |
throw new Bb( | |
"Cannot set peer master token or peer user ID token when not in peer-to-peer mode." | |
); | |
xa = fa && !W.isPeerToPeer() ? fa.keyResponseData.masterToken : ia; | |
Sa = []; | |
xa = W.getMslStore().getServiceTokens(xa, qa); | |
Sa.push.apply(Sa, xa); | |
Aa && | |
Aa.forEach(function (oa) { | |
Sa.push(oa); | |
}, this); | |
Ma = []; | |
if (W.isPeerToPeer()) { | |
Ra = ka; | |
Xa = Z; | |
Aa = fa ? fa.keyResponseData.masterToken : ka; | |
Z = W.getMslStore().getServiceTokens(Aa, Z); | |
Ma.push.apply(Ma, Z); | |
ca && | |
ca.forEach(function (oa) { | |
Ma.push(oa); | |
}, this); | |
} | |
Object.defineProperties(this, { | |
_ctx: { value: W, writable: !1, enumerable: !1, configurable: !1 }, | |
_entityAuthData: { | |
value: ra, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_masterToken: { | |
value: ia, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_messageId: { | |
value: ha, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_capabilities: { | |
value: va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_keyExchangeData: { | |
value: fa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_nonReplayable: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_renewable: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_keyRequestData: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_userAuthData: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_userIdToken: { | |
value: qa, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_serviceTokens: { | |
value: Sa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_peerMasterToken: { | |
value: Ra, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_peerUserIdToken: { | |
value: Xa, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_peerServiceTokens: { | |
value: Ma, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
getMessageId: function () { | |
return this._messageId; | |
}, | |
getMasterToken: function () { | |
return this._masterToken; | |
}, | |
getUserIdToken: function () { | |
return this._userIdToken; | |
}, | |
getKeyExchangeData: function () { | |
return this._keyExchangeData; | |
}, | |
willEncryptHeader: function () { | |
return this._masterToken || Cd(this._entityAuthData.scheme); | |
}, | |
willEncryptPayloads: function () { | |
return ( | |
this._masterToken || | |
(!this._ctx.isPeerToPeer() && this._keyExchangeData) || | |
Cd(this._entityAuthData.scheme) | |
); | |
}, | |
willIntegrityProtectHeader: function () { | |
return this._masterToken || de(this._entityAuthData.scheme); | |
}, | |
willIntegrityProtectPayloads: function () { | |
return ( | |
this._masterToken || | |
(!this._ctx.isPeerToPeer() && this._keyExchangeData) || | |
de(this._entityAuthData.scheme) | |
); | |
}, | |
getHeader: function (W) { | |
Na( | |
W, | |
function () { | |
var ha, va, ra; | |
ha = this._keyExchangeData | |
? this._keyExchangeData.keyResponseData | |
: null; | |
va = []; | |
for (ra in this._keyRequestData) { | |
va.push(this._keyRequestData[ra]); | |
} | |
if (this._nonReplayable) { | |
if (!this._masterToken) | |
throw new Nb(T.NONREPLAYABLE_MESSAGE_REQUIRES_MASTERTOKEN); | |
ra = this._ctx | |
.getMslStore() | |
.getNonReplayableId(this._masterToken); | |
} else ra = null; | |
ha = new Oe( | |
this._messageId, | |
ra, | |
this._renewable, | |
this._capabilities, | |
va, | |
ha, | |
this._userAuthData, | |
this._userIdToken, | |
this._serviceTokens | |
); | |
va = new Pe( | |
this._peerMasterToken, | |
this._peerUserIdToken, | |
this._peerServiceTokens | |
); | |
Ne(this._ctx, this._entityAuthData, this._masterToken, ha, va, W); | |
}, | |
this | |
); | |
}, | |
isNonReplayable: function () { | |
return this._nonReplayable; | |
}, | |
setNonReplayable: function (W) { | |
this._nonReplayable = W; | |
return this; | |
}, | |
isRenewable: function () { | |
return this._renewable; | |
}, | |
setRenewable: function (W) { | |
this._renewable = W; | |
return this; | |
}, | |
setAuthTokens: function (W, ha) { | |
var va, ia; | |
if (ha && !ha.isBoundTo(W)) | |
throw new Bb("User ID token must be bound to master token."); | |
if (this._keyExchangeData && !this._ctx.isPeerToPeer()) | |
throw new Bb( | |
"Attempt to set message builder master token when key exchange data exists as a trusted network server." | |
); | |
try { | |
va = this._ctx.getMslStore().getServiceTokens(W, ha); | |
} catch (qa) { | |
if (qa instanceof gb) | |
throw new Bb( | |
"Invalid master token and user ID token combination despite checking above.", | |
qa | |
); | |
throw qa; | |
} | |
for (var ra = this._serviceTokens.length - 1; 0 <= ra; --ra) { | |
ia = this._serviceTokens[ra]; | |
((ia.isUserIdTokenBound() && !ia.isBoundTo(ha)) || | |
(ia.isMasterTokenBound() && !ia.isBoundTo(W))) && | |
this._serviceTokens.splice(ra, 1); | |
} | |
va.forEach(function (qa) { | |
this.excludeServiceToken( | |
qa.name, | |
qa.isMasterTokenBound(), | |
qa.isUserIdTokenBound() | |
); | |
this._serviceTokens.push(qa); | |
}, this); | |
this._masterToken = W; | |
this._userIdToken = ha; | |
}, | |
setUserAuthenticationData: function (W) { | |
this._userAuthData = W; | |
return this; | |
}, | |
setCustomer: function (W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra; | |
if ( | |
(!this._ctx.isPeerToPeer() && null != this._userIdToken) || | |
(this._ctx.isPeerToPeer() && null != this._peerUserIdToken) | |
) | |
throw new Bb( | |
"User ID token or peer user ID token already exists for the remote user." | |
); | |
ra = this._keyExchangeData | |
? this._keyExchangeData.keyResponseData.masterToken | |
: this._ctx.isPeerToPeer() | |
? this._peerMasterToken | |
: this._masterToken; | |
if (!ra) | |
throw new Bb( | |
"User ID token or peer user ID token cannot be created because no corresponding master token exists." | |
); | |
this._ctx.getTokenFactory().createUserIdToken(this._ctx, W, ra, { | |
result: function (ia) { | |
Na( | |
ha, | |
function () { | |
this._ctx.isPeerToPeer() | |
? (this._peerUserIdToken = ia) | |
: ((this._userIdToken = ia), | |
(this._userAuthData = null)); | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (ia) { | |
ha.error(ia); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
addKeyRequestData: function (W) { | |
this._keyRequestData[W.uniqueKey()] = W; | |
return this; | |
}, | |
removeKeyRequestData: function (W) { | |
delete this._keyRequestData[W.uniqueKey()]; | |
return this; | |
}, | |
addServiceToken: function (W) { | |
var ha; | |
ha = | |
this._keyExchangeData && !this._ctx.isPeerToPeer() | |
? this._keyExchangeData.keyResponseData.masterToken | |
: this._masterToken; | |
if (W.isMasterTokenBound() && !W.isBoundTo(ha)) | |
throw new Nb( | |
T.SERVICETOKEN_MASTERTOKEN_MISMATCH, | |
"st " + JSON.stringify(W) + "; mt " + JSON.stringify(ha) | |
).setEntity(ha); | |
if (W.isUserIdTokenBound() && !W.isBoundTo(this._userIdToken)) | |
throw new Nb( | |
T.SERVICETOKEN_USERIDTOKEN_MISMATCH, | |
"st " + | |
JSON.stringify(W) + | |
"; uit " + | |
JSON.stringify(this._userIdToken) | |
) | |
.setEntity(ha) | |
.setUser(this._userIdToken); | |
this.excludeServiceToken( | |
W.name, | |
W.isMasterTokenBound(), | |
W.isUserIdTokenBound() | |
); | |
this._serviceTokens.push(W); | |
return this; | |
}, | |
addServiceTokenIfAbsent: function (W) { | |
var va; | |
for (var ha = this._serviceTokens.length - 1; 0 <= ha; --ha) { | |
va = this._serviceTokens[ha]; | |
if ( | |
va.name == W.name && | |
va.isMasterTokenBound() == W.isMasterTokenBound() && | |
va.isUserIdTokenBound() == W.isUserIdTokenBound() | |
) | |
return this; | |
} | |
this.addServiceToken(W); | |
return this; | |
}, | |
excludeServiceToken: function () { | |
var W, ha, va, ia; | |
if (1 == arguments.length) { | |
W = arguments[0]; | |
ha = W.name; | |
va = W.isMasterTokenBound(); | |
W = W.isUserIdTokenBound(); | |
} else | |
(arguments.length = 3), | |
(ha = arguments[0]), | |
(va = arguments[1]), | |
(W = arguments[2]); | |
for (var ra = this._serviceTokens.length - 1; 0 <= ra; --ra) { | |
ia = this._serviceTokens[ra]; | |
ia.name == ha && | |
ia.isMasterTokenBound() == va && | |
ia.isUserIdTokenBound() == W && | |
this._serviceTokens.splice(ra, 1); | |
} | |
return this; | |
}, | |
deleteServiceToken: function () { | |
var W, ha, va, ra; | |
if (2 == arguments.length) { | |
W = arguments[0]; | |
ha = W.name; | |
W.isMasterTokenBound(); | |
W.isUserIdTokenBound(); | |
va = arguments[1]; | |
} else | |
(arguments.length = 4), (ha = arguments[0]), (va = arguments[3]); | |
ra = this; | |
Na( | |
va, | |
function () { | |
var ia, qa; | |
ia = originalToken.isMasterTokenBound() | |
? this._masterToken | |
: null; | |
qa = originalToken.isUserIdTokenBound() | |
? this._userIdToken | |
: null; | |
zc(this._ctx, ha, V, ia, qa, !1, null, new Vc(), { | |
result: function (Aa) { | |
Na( | |
va, | |
function () { | |
return this.addServiceToken(Aa); | |
}, | |
ra | |
); | |
}, | |
error: function (Aa) { | |
Aa instanceof gb && | |
(Aa = new Bb( | |
"Failed to create and add empty service token to message.", | |
Aa | |
)); | |
va.error(Aa); | |
}, | |
}); | |
}, | |
ra | |
); | |
}, | |
getServiceTokens: function () { | |
var W; | |
W = []; | |
W.push.apply(W, this._serviceTokens); | |
return W; | |
}, | |
getPeerMasterToken: function () { | |
return this._peerMasterToken; | |
}, | |
getPeerUserIdToken: function () { | |
return this._peerUserIdToken; | |
}, | |
setPeerAuthTokens: function (W, ha) { | |
var va, ia; | |
if (!this._ctx.isPeerToPeer()) | |
throw new Bb( | |
"Cannot set peer master token or peer user ID token when not in peer-to-peer mode." | |
); | |
if (ha && !W) | |
throw new Bb( | |
"Peer master token cannot be null when setting peer user ID token." | |
); | |
if (ha && !ha.isBoundTo(W)) | |
throw new Nb( | |
T.USERIDTOKEN_MASTERTOKEN_MISMATCH, | |
"uit " + ha + "; mt " + W | |
) | |
.setEntity(W) | |
.setUser(ha); | |
try { | |
va = this._ctx.getMslStore().getServiceTokens(W, ha); | |
} catch (qa) { | |
if (qa instanceof gb) | |
throw new Bb( | |
"Invalid peer master token and user ID token combination despite proper check.", | |
qa | |
); | |
throw qa; | |
} | |
for (var ra = this._peerServiceTokens.length - 1; 0 <= ra; --ra) { | |
ia = this._peerServiceTokens[ra]; | |
((ia.isUserIdTokenBound() && !ia.isBoundTo(ha)) || | |
(ia.isMasterTokenBound() && !ia.isBoundTo(W))) && | |
this._peerServiceTokens.slice(ra, 1); | |
} | |
va.forEach(function (qa) { | |
this.excludePeerServiceToken( | |
qa.name, | |
qa.isMasterTokenBound(), | |
qa.isUserIdTokenBound() | |
); | |
this._peerServiceTokens.push(qa); | |
}, this); | |
this._peerUserIdToken = ha; | |
this._peerMasterToken = W; | |
return this; | |
}, | |
addPeerServiceToken: function (W) { | |
if (!this._ctx.isPeerToPeer()) | |
throw new Bb( | |
"Cannot set peer service tokens when not in peer-to-peer mode." | |
); | |
if (W.isMasterTokenBound() && !W.isBoundTo(this._peerMasterToken)) | |
throw new Nb( | |
T.SERVICETOKEN_MASTERTOKEN_MISMATCH, | |
"st " + | |
JSON.stringify(W) + | |
"; mt " + | |
JSON.stringify(this._peerMasterToken) | |
).setEntity(this._peerMasterToken); | |
if (W.isUserIdTokenBound() && !W.isBoundTo(this._peerUserIdToken)) | |
throw new Nb( | |
T.SERVICETOKEN_USERIDTOKEN_MISMATCH, | |
"st " + | |
JSON.stringify(W) + | |
"; uit " + | |
JSON.stringify(this._peerUserIdToken) | |
) | |
.setEntity(this._peerMasterToken) | |
.setUser(this._peerUserIdToken); | |
this.excludePeerServiceToken( | |
W.name, | |
W.isMasterTokenBound(), | |
W.isUserIdTokenBound() | |
); | |
this._peerServiceTokens.push(W); | |
return this; | |
}, | |
addPeerServiceTokenIfAbsent: function (W) { | |
var va; | |
for (var ha = this._peerServiceTokens.length - 1; 0 <= ha; --ha) { | |
va = this._peerServiceTokens[ha]; | |
if ( | |
va.name == W.name && | |
va.isMasterTokenBound() == W.isMasterTokenBound() && | |
va.isUserIdTokenBound() == W.isUserIdTokenBound() | |
) | |
return this; | |
} | |
this.addPeerServiceToken(W); | |
return this; | |
}, | |
excludePeerServiceToken: function () { | |
var W, ha, va, ia; | |
if (1 == arguments.length) { | |
W = arguments[0]; | |
ha = W.name; | |
va = W.isMasterTokenBound(); | |
W = W.isUserIdTokenBound(); | |
} else | |
(arguments.length = 3), | |
(ha = arguments[0]), | |
(va = arguments[1]), | |
(W = arguments[2]); | |
for (var ra = this._peerServiceTokens.length - 1; 0 <= ra; --ra) { | |
ia = this._peerServiceTokens[ra]; | |
ia.name == ha && | |
ia.isMasterTokenBound() == va && | |
ia.isUserIdTokenBound() == W && | |
this._peerServiceTokens.splice(ra, 1); | |
} | |
return this; | |
}, | |
deletePeerServiceToken: function () { | |
var W, ha, va, ra, ia, qa; | |
if (2 == arguments.length) { | |
W = arguments[0]; | |
ha = W.name; | |
va = W.isMasterTokenBound(); | |
ra = W.isUserIdTokenBound(); | |
ia = arguments[1]; | |
} else | |
(arguments.length = 4), | |
(ha = arguments[0]), | |
(va = arguments[1]), | |
(ra = arguments[2]), | |
(ia = arguments[3]); | |
qa = this; | |
Na( | |
ia, | |
function () { | |
zc( | |
this._ctx, | |
ha, | |
V, | |
va ? this._peerMasterToken : null, | |
ra ? this._peerUserIdToken : null, | |
!1, | |
null, | |
new Vc(), | |
{ | |
result: function (Aa) { | |
Na( | |
ia, | |
function () { | |
return this.addPeerServiceToken(Aa); | |
}, | |
qa | |
); | |
}, | |
error: function (Aa) { | |
Aa instanceof gb && | |
(Aa = new Bb( | |
"Failed to create and add empty peer service token to message.", | |
Aa | |
)); | |
ia.error(Aa); | |
}, | |
} | |
); | |
}, | |
qa | |
); | |
}, | |
getPeerServiceTokens: function () { | |
var W; | |
W = []; | |
W.push.apply(W, this._peerServiceTokens); | |
return W; | |
}, | |
}); | |
})(); | |
(function () { | |
function da(U, V) { | |
return V[U] ? V[U] : V[""]; | |
} | |
function X(U) { | |
var V; | |
V = U.builder.getKeyExchangeData(); | |
return V && !U.ctx.isPeerToPeer() | |
? V.keyResponseData.masterToken | |
: U.builder.getMasterToken(); | |
} | |
Ve = Hb.Class.create({ | |
init: function (U, V, aa) { | |
U = { | |
ctx: { value: U, writable: !1, enumerable: !1, configurable: !1 }, | |
cryptoContexts: { | |
value: V.getCryptoContexts(), | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
builder: { | |
value: aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, U); | |
}, | |
isPrimaryMasterTokenAvailable: function () { | |
return X(this) ? !0 : !1; | |
}, | |
isPrimaryUserIdTokenAvailable: function () { | |
return this.builder.getUserIdToken() ? !0 : !1; | |
}, | |
isPeerMasterTokenAvailable: function () { | |
return this.builder.getPeerMasterToken() ? !0 : !1; | |
}, | |
isPeerUserIdTokenAvailable: function () { | |
return this.builder.getPeerUserIdToken() ? !0 : !1; | |
}, | |
getPrimaryServiceTokens: function () { | |
return this.builder.getServiceTokens(); | |
}, | |
getPeerServiceTokens: function () { | |
return this.builder.getPeerServiceTokens(); | |
}, | |
addPrimaryServiceToken: function (U) { | |
try { | |
return this.builder.addServiceToken(U), !0; | |
} catch (V) { | |
if (V instanceof Nb) return !1; | |
throw V; | |
} | |
}, | |
addPeerServiceToken: function (U) { | |
try { | |
return this.builder.addPeerServiceToken(U), !0; | |
} catch (V) { | |
if (V instanceof Nb) return !1; | |
throw V; | |
} | |
}, | |
addUnboundPrimaryServiceToken: function (U, V, aa, W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra; | |
ra = da(U, this.cryptoContexts); | |
if (!ra) return !1; | |
zc(this.ctx, U, V, null, null, aa, W, ra, { | |
result: function (ia) { | |
Na( | |
ha, | |
function () { | |
try { | |
this.builder.addServiceToken(ia); | |
} catch (qa) { | |
if (qa instanceof Nb) | |
throw new Bb( | |
"Service token bound to incorrect authentication tokens despite being unbound.", | |
qa | |
); | |
throw qa; | |
} | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (ia) { | |
ha.error(ia); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
addUnboundPeerServiceToken: function (U, V, aa, W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra; | |
ra = da(U, this.cryptoContexts); | |
if (!ra) return !1; | |
zc(this.ctx, U, V, null, null, aa, W, ra, { | |
result: function (ia) { | |
Na( | |
ha, | |
function () { | |
try { | |
this.builder.addPeerServiceToken(ia); | |
} catch (qa) { | |
if (qa instanceof Nb) | |
throw new Bb( | |
"Service token bound to incorrect authentication tokens despite being unbound.", | |
qa | |
); | |
throw qa; | |
} | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (ia) { | |
ha.error(ia); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
addMasterBoundPrimaryServiceToken: function (U, V, aa, W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra, ia; | |
ra = X(this); | |
if (!ra) return !1; | |
ia = da(U, this.cryptoContexts); | |
if (!ia) return !1; | |
zc(this.ctx, U, V, ra, null, aa, W, ia, { | |
result: function (qa) { | |
Na( | |
ha, | |
function () { | |
try { | |
this.builder.addServiceToken(qa); | |
} catch (Aa) { | |
if (Aa instanceof Nb) | |
throw new Bb( | |
"Service token bound to incorrect authentication tokens despite setting correct master token.", | |
Aa | |
); | |
throw Aa; | |
} | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (qa) { | |
ha.error(qa); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
addMasterBoundPeerServiceToken: function (U, V, aa, W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra, ia; | |
ra = this.builder.getPeerMasterToken(); | |
if (!ra) return !1; | |
ia = da(U, this.cryptoContexts); | |
if (!ia) return !1; | |
zc(this.ctx, U, V, ra, null, aa, W, ia, { | |
result: function (qa) { | |
Na( | |
ha, | |
function () { | |
try { | |
this.builder.addPeerServiceToken(qa); | |
} catch (Aa) { | |
if (Aa instanceof Nb) | |
throw new Bb( | |
"Service token bound to incorrect authentication tokens despite setting correct master token.", | |
Aa | |
); | |
throw Aa; | |
} | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (qa) { | |
ha.error(qa); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
addUserBoundPrimaryServiceToken: function (U, V, aa, W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra, ia, qa; | |
ra = X(this); | |
if (!ra) return !1; | |
ia = this.builder.getUserIdToken(); | |
if (!ia) return !1; | |
qa = da(U, this.cryptoContexts); | |
if (!qa) return !1; | |
zc(this.ctx, U, V, ra, ia, aa, W, qa, { | |
result: function (Aa) { | |
Na( | |
ha, | |
function () { | |
try { | |
this.builder.addServiceToken(Aa); | |
} catch (ka) { | |
if (ka instanceof Nb) | |
throw new Bb( | |
"Service token bound to incorrect authentication tokens despite setting correct master token and user ID token.", | |
ka | |
); | |
throw ka; | |
} | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (Aa) { | |
ha.error(Aa); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
addUserBoundPeerServiceToken: function (U, V, aa, W, ha) { | |
var va; | |
va = this; | |
Na( | |
ha, | |
function () { | |
var ra, ia, qa; | |
ra = this.builder.getPeerMasterToken(); | |
if (!ra) return !1; | |
ia = this.builder.getPeerUserIdToken(); | |
if (!ia) return !1; | |
qa = da(U, this.cryptoContexts); | |
if (!qa) return !1; | |
zc(this.ctx, U, V, ra, ia, aa, W, qa, { | |
result: function (Aa) { | |
Na( | |
ha, | |
function () { | |
try { | |
this.builder.addPeerServiceToken(Aa); | |
} catch (ka) { | |
if (ka instanceof Nb) | |
throw new Bb( | |
"Service token bound to incorrect authentication tokens despite setting correct master token and user ID token.", | |
ka | |
); | |
throw ka; | |
} | |
return !0; | |
}, | |
va | |
); | |
}, | |
error: function (Aa) { | |
ha.error(Aa); | |
}, | |
}); | |
}, | |
va | |
); | |
}, | |
excludePrimaryServiceToken: function () { | |
var U, V, aa, W; | |
if (1 == arguments.length) { | |
U = arguments[0]; | |
V = U.name; | |
aa = U.isMasterTokenBound(); | |
W = U.isUserIdTokenBound(); | |
} else | |
(arguments.length = 3), | |
(V = arguments[0]), | |
(aa = arguments[1]), | |
(W = arguments[2]); | |
for ( | |
var ha = this.builder.getServiceTokens(), va = 0; | |
va < ha.length; | |
++va | |
) { | |
if ( | |
((U = ha[va]), | |
U.name == V && | |
U.isMasterTokenBound() == aa && | |
U.isUserIdTokenBound() == W) | |
) | |
return this.builder.excludeServiceToken(V, aa, W), !0; | |
} | |
return !1; | |
}, | |
excludePeerServiceToken: function () { | |
var U, V, aa, W; | |
if (1 == arguments.length) { | |
U = arguments[0]; | |
V = U.name; | |
aa = U.isMasterTokenBound(); | |
W = U.isUserIdTokenBound(); | |
} else | |
(arguments.length = 3), | |
(V = arguments[0]), | |
(aa = arguments[1]), | |
(W = arguments[2]); | |
for ( | |
var ha = this.builder.getPeerServiceTokens(), va = 0; | |
va < ha.length; | |
++va | |
) { | |
if ( | |
((U = ha[va]), | |
U.name == V && | |
U.isMasterTokenBound() == aa && | |
U.isUserIdTokenBound() == W) | |
) | |
return this.builder.excludePeerServiceToken(V, aa, W), !0; | |
} | |
return !1; | |
}, | |
deletePrimaryServiceToken: function () { | |
var U, V, aa, W, ha; | |
if (2 == arguments.length) { | |
U = arguments[0]; | |
V = U.name; | |
aa = U.isMasterTokenBound(); | |
W = U.isUserIdTokenBound(); | |
ha = arguments[1]; | |
} else | |
4 == arguments.length && | |
((V = arguments[0]), | |
(aa = arguments[1]), | |
(W = arguments[2]), | |
(ha = arguments[3])); | |
Na( | |
ha, | |
function () { | |
var ia; | |
for ( | |
var va = this.builder.getServiceTokens(), ra = 0; | |
ra < va.length; | |
++ra | |
) { | |
ia = va[ra]; | |
if ( | |
ia.name == V && | |
ia.isMasterTokenBound() == aa && | |
ia.isUserIdTokenBound() == W | |
) { | |
this.builder.deleteServiceToken(V, aa, W, { | |
result: function () { | |
ha.result(!0); | |
}, | |
error: function (qa) { | |
ha.error(qa); | |
}, | |
}); | |
return; | |
} | |
} | |
return !1; | |
}, | |
this | |
); | |
}, | |
deletePeerServiceToken: function () { | |
var U, V, aa, W, ha; | |
if (2 == arguments.length) { | |
U = arguments[0]; | |
V = U.name; | |
aa = U.isMasterTokenBound(); | |
W = U.isUserIdTokenBound(); | |
ha = arguments[1]; | |
} else | |
4 == arguments.length && | |
((V = arguments[0]), | |
(aa = arguments[1]), | |
(W = arguments[2]), | |
(ha = arguments[3])); | |
Na( | |
ha, | |
function () { | |
var ia; | |
for ( | |
var va = this.builder.getPeerServiceTokens(), ra = 0; | |
ra < va.length; | |
++ra | |
) { | |
ia = va[ra]; | |
if ( | |
ia.name == V && | |
ia.isMasterTokenBound() == aa && | |
ia.isUserIdTokenBound() == W | |
) { | |
this.builder.deletePeerServiceToken(V, aa, W, { | |
result: function () { | |
ha.result(!0); | |
}, | |
error: function (qa) { | |
ha.error(qa); | |
}, | |
}); | |
return; | |
} | |
} | |
return !1; | |
}, | |
this | |
); | |
}, | |
}); | |
})(); | |
(function () { | |
function da(X, U, V, aa) { | |
Na(aa, function () { | |
var ha, va, ra, ia, qa, Aa; | |
function W() { | |
Na(aa, function () { | |
var ka; | |
if (Aa >= V.length) { | |
if (qa) throw qa; | |
throw new Ub( | |
T.KEYX_RESPONSE_REQUEST_MISMATCH, | |
JSON.stringify(V) | |
); | |
} | |
ka = V[Aa]; | |
ra != ka.keyExchangeScheme | |
? (++Aa, W()) | |
: ia.getCryptoContext(X, ka, va, ha, { | |
result: aa.result, | |
error: function (Z) { | |
Na(aa, function () { | |
if (!(Z instanceof gb)) throw Z; | |
qa = Z; | |
++Aa; | |
W(); | |
}); | |
}, | |
}); | |
}); | |
} | |
ha = U.masterToken; | |
va = U.keyResponseData; | |
if (!va) return null; | |
ra = va.keyExchangeScheme; | |
ia = X.getKeyExchangeFactory(ra); | |
if (!ia) throw new Ub(T.KEYX_FACTORY_NOT_FOUND, ra); | |
Aa = 0; | |
W(); | |
}); | |
} | |
We = Qd.extend({ | |
init: function (X, U, V, aa, W, ha, va) { | |
var ra; | |
ra = this; | |
eb( | |
va, | |
function () { | |
var ca; | |
function ia() { | |
ra._ready = !0; | |
ra._readyQueue.add(!0); | |
} | |
function qa(fa, xa) { | |
var Sa; | |
try { | |
Sa = xa.masterToken; | |
fa.getTokenFactory().isMasterTokenRevoked(fa, Sa, { | |
result: function (Ma) { | |
Ma | |
? ((ra._errored = new ad(Ma, Sa) | |
.setUser(xa.userIdToken) | |
.setUser(xa.userAuthenticationData) | |
.setMessageId(xa.messageId)), | |
ia()) | |
: Aa(fa, xa); | |
}, | |
error: function (Ma) { | |
Ma instanceof gb && | |
(Ma.setEntity(xa.masterToken), | |
Ma.setUser(xa.userIdToken), | |
Ma.setUser(xa.userAuthenticationData), | |
Ma.setMessageId(xa.messageId)); | |
ra._errored = Ma; | |
ia(); | |
}, | |
}); | |
} catch (Ma) { | |
Ma instanceof gb && | |
(Ma.setEntity(xa.masterToken), | |
Ma.setUser(xa.userIdToken), | |
Ma.setUser(xa.userAuthenticationData), | |
Ma.setMessageId(xa.messageId)); | |
ra._errored = Ma; | |
ia(); | |
} | |
} | |
function Aa(fa, xa) { | |
var Sa, Ma; | |
try { | |
Sa = xa.masterToken; | |
Ma = xa.userIdToken; | |
Ma | |
? fa.getTokenFactory().isUserIdTokenRevoked(fa, Sa, Ma, { | |
result: function (Ra) { | |
Ra | |
? ((ra._errored = new MslUserIdTokenException( | |
Ra, | |
Ma | |
) | |
.setEntity(Sa) | |
.setUser(Ma) | |
.setMessageId(xa.messageId)), | |
ia()) | |
: ka(fa, xa); | |
}, | |
error: function (Ra) { | |
Ra instanceof gb && | |
(Ra.setEntity(xa.masterToken), | |
Ra.setUser(xa.userIdToken), | |
Ra.setUser(xa.userAuthenticationData), | |
Ra.setMessageId(xa.messageId)); | |
ra._errored = Ra; | |
ia(); | |
}, | |
}) | |
: ka(fa, xa); | |
} catch (Ra) { | |
Ra instanceof gb && | |
(Ra.setEntity(xa.masterToken), | |
Ra.setUser(xa.userIdToken), | |
Ra.setUser(xa.userAuthenticationData), | |
Ra.setMessageId(xa.messageId)); | |
ra._errored = Ra; | |
ia(); | |
} | |
} | |
function ka(fa, xa) { | |
var Sa; | |
try { | |
Sa = xa.masterToken; | |
Sa.isExpired() | |
? xa.isRenewable() && 0 != xa.keyRequestData.length | |
? fa.getTokenFactory().isMasterTokenRenewable(fa, Sa, { | |
result: function (Ma) { | |
Ma | |
? ((ra._errored = new Nb( | |
Ma, | |
"Master token is expired and not renewable." | |
) | |
.setEntity(Sa) | |
.setUser(xa.userIdToken) | |
.setUser(xa.userAuthenticationData) | |
.setMessageId(xa.messageId)), | |
ia()) | |
: Z(fa, xa); | |
}, | |
error: function (Ma) { | |
Ma instanceof gb && | |
(Ma.setEntity(xa.masterToken), | |
Ma.setUser(xa.userIdToken), | |
Ma.setUser(xa.userAuthenticationData), | |
Ma.setMessageId(xa.messageId)); | |
ra._errored = Ma; | |
ia(); | |
}, | |
}) | |
: ((ra._errored = new Nb( | |
T.MESSAGE_EXPIRED, | |
JSON.stringify(xa) | |
) | |
.setEntity(Sa) | |
.setUser(xa.userIdToken) | |
.setUser(xa.userAuthenticationData) | |
.setMessageId(xa.messageId)), | |
ia()) | |
: Z(fa, xa); | |
} catch (Ma) { | |
Ma instanceof gb && | |
(Ma.setEntity(xa.masterToken), | |
Ma.setUser(xa.userIdToken), | |
Ma.setUser(xa.userAuthenticationData), | |
Ma.setMessageId(xa.messageId)); | |
ra._errored = Ma; | |
ia(); | |
} | |
} | |
function Z(fa, xa) { | |
var Sa, Ma; | |
try { | |
Sa = xa.masterToken; | |
Ma = xa.nonReplayableId; | |
"number" === typeof Ma | |
? Sa | |
? fa.getTokenFactory().acceptNonReplayableId(fa, Sa, Ma, { | |
result: function (Ra) { | |
Ra || | |
(ra._errored = new Nb( | |
T.MESSAGE_REPLAYED, | |
JSON.stringify(xa) | |
) | |
.setEntity(Sa) | |
.setUser(xa.userIdToken) | |
.setUser(xa.userAuthenticationData) | |
.setMessageId(xa.messageId)); | |
ia(); | |
}, | |
error: function (Ra) { | |
Ra instanceof gb && | |
(Ra.setEntity(Sa), | |
Ra.setUser(xa.userIdToken), | |
Ra.setUser(xa.userAuthenticationData), | |
Ra.setMessageId(xa.messageId)); | |
ra._errored = Ra; | |
ia(); | |
}, | |
}) | |
: ((ra._errored = new Nb( | |
T.INCOMPLETE_NONREPLAYABLE_MESSAGE, | |
JSON.stringify(xa) | |
) | |
.setEntity(xa.entityAuthenticationData) | |
.setUser(xa.userIdToken) | |
.setUser(xa.userAuthenticationData) | |
.setMessageId(xa.messageId)), | |
ia()) | |
: ia(); | |
} catch (Ra) { | |
Ra instanceof gb && | |
(Ra.setEntity(xa.masterToken), | |
Ra.setEntity(xa.entityAuthenticationData), | |
Ra.setUser(xa.userIdToken), | |
Ra.setUser(xa.userAuthenticationData), | |
Ra.setMessageId(xa.messageId)); | |
ra._errored = Ra; | |
ia(); | |
} | |
} | |
ca = { | |
_source: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_parser: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_charset: { | |
value: V, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_remainingData: { | |
value: "", | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: ha, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_header: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_cryptoContext: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_keyxCryptoContext: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_payloadSequenceNumber: { | |
value: 1, | |
writable: !0, | |
enuemrable: !1, | |
configurable: !1, | |
}, | |
_eom: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_closeSource: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_payloads: { | |
value: [], | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_payloadIndex: { | |
value: -1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_payloadOffset: { | |
value: 0, | |
writable: !0, | |
enuemrable: !1, | |
configurable: !1, | |
}, | |
_markOffset: { | |
value: 0, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_currentPayload: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_readException: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_ready: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_readyQueue: { | |
value: new Zc(), | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timedout: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_errored: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, ca); | |
xe(ra._source, ha, { | |
result: function (fa) { | |
ra._json = fa; | |
ra._jsonIndex = 0; | |
null === ra._json | |
? ((ra._errored = new Jb(T.MESSAGE_DATA_MISSING)), ia()) | |
: Ge(X, ra._json[ra._jsonIndex++], W, { | |
result: function (xa) { | |
var Sa; | |
ra._header = xa; | |
if (ra._header instanceof Ic) | |
(ra._keyxCryptoContext = null), | |
(ra._cryptoContext = null), | |
ia(); | |
else { | |
Sa = ra._header; | |
da(X, Sa, aa, { | |
result: function (Ma) { | |
var Ra; | |
try { | |
ra._keyxCryptoContext = Ma; | |
X.isPeerToPeer() || !ra._keyxCryptoContext | |
? (ra._cryptoContext = Sa.cryptoContext) | |
: (ra._cryptoContext = | |
ra._keyxCryptoContext); | |
try { | |
Ra = Sa.masterToken; | |
Ra && (X.isPeerToPeer() || Ra.isVerified()) | |
? qa(X, Sa) | |
: Z(X, Sa); | |
} catch (Xa) { | |
Xa instanceof gb && | |
(Xa.setEntity(Sa.masterToken), | |
Xa.setUser(Sa.userIdToken), | |
Xa.setUser(Sa.userAuthenticationData), | |
Xa.setMessageId(Sa.messageId)); | |
ra._errored = Xa; | |
ia(); | |
} | |
} catch (Xa) { | |
Xa instanceof gb && | |
(Xa.setEntity(Sa.masterToken), | |
Xa.setEntity(Sa.entityAuthenticationData), | |
Xa.setUser(Sa.userIdToken), | |
Xa.setUser(Sa.userAuthenticationData), | |
Xa.setMessageId(Sa.messageId)); | |
ra._errored = Xa; | |
ia(); | |
} | |
}, | |
error: function (Ma) { | |
Ma instanceof gb && | |
(Ma.setEntity(Sa.masterToken), | |
Ma.setEntity(Sa.entityAuthenticationData), | |
Ma.setUser(Sa.userIdToken), | |
Ma.setUser(Sa.userAuthenticationData), | |
Ma.setMessageId(Sa.messageId)); | |
ra._errored = Ma; | |
ia(); | |
}, | |
}); | |
} | |
}, | |
error: function (xa) { | |
ra._errored = xa; | |
ia(); | |
}, | |
}); | |
}, | |
timeout: function () { | |
ra._timedout = !0; | |
ia(); | |
}, | |
error: function (fa) { | |
ra._errored = fa; | |
ia(); | |
}, | |
}); | |
return this; | |
}, | |
ra | |
); | |
}, | |
nextData: function (X, U) { | |
var V; | |
V = this; | |
eb( | |
U, | |
function () { | |
var W; | |
function aa(ha) { | |
eb( | |
ha, | |
function () { | |
var va; | |
if (this._jsonIndex < this._json.length) | |
return (va = this._json[this._jsonIndex++]); | |
xe(this._source, this._timeout, { | |
result: function (ra) { | |
ra && ra.length && 0 < ra.length | |
? (ra.forEach(function (ia) { | |
this._json.push(ia); | |
}), | |
aa(ha)) | |
: ((this._eom = !0), ha.result(null)); | |
}, | |
timeout: function () { | |
ha.timeout(); | |
}, | |
error: function (ra) { | |
ha.error(ra); | |
}, | |
}); | |
}, | |
V | |
); | |
} | |
W = this.getMessageHeader(); | |
if (!W) throw new Bb("Read attempted with error message."); | |
if ( | |
-1 != this._payloadIndex && | |
this._payloadIndex < this._payloads.length | |
) | |
return this._payloads[this._payloadIndex++]; | |
if (this._eom) return null; | |
aa({ | |
result: function (ha) { | |
eb( | |
U, | |
function () { | |
if (!ha) return null; | |
if ("object" !== typeof ha) | |
throw new Jb(T.MESSAGE_FORMAT_ERROR); | |
Se(ha, this._cryptoContext, { | |
result: function (va) { | |
eb( | |
U, | |
function () { | |
var ra, ia, qa, Aa; | |
ra = W.masterToken; | |
ia = W.entityAuthenticationData; | |
qa = W.userIdToken; | |
Aa = W.getUserAuthenticationData; | |
if (va.messageId != W.messageId) | |
throw new Nb( | |
T.PAYLOAD_MESSAGE_ID_MISMATCH, | |
"payload mid " + | |
va.messageId + | |
" header mid " + | |
W.messageId | |
) | |
.setEntity(ra) | |
.setEntity(ia) | |
.setUser(qa) | |
.setUser(Aa); | |
if ( | |
va.sequenceNumber != this._payloadSequenceNumber | |
) | |
throw new Nb( | |
T.PAYLOAD_SEQUENCE_NUMBER_MISMATCH, | |
"payload seqno " + | |
va.sequenceNumber + | |
" expected seqno " + | |
this._payloadSequenceNumber | |
) | |
.setEntity(ra) | |
.setEntity(ia) | |
.setUser(qa) | |
.setUser(Aa); | |
++this._payloadSequenceNumber; | |
va.isEndOfMessage() && (this._eom = !0); | |
ra = va.data; | |
this._payloads.push(ra); | |
this._payloadIndex = -1; | |
return ra; | |
}, | |
V | |
); | |
}, | |
error: function (va) { | |
va instanceof SyntaxError && | |
(va = new Jb( | |
T.JSON_PARSE_ERROR, | |
"payloadchunk", | |
va | |
)); | |
U.error(va); | |
}, | |
}); | |
}, | |
V | |
); | |
}, | |
timeout: function () { | |
U.timeout(); | |
}, | |
error: function (ha) { | |
U.error(ha); | |
}, | |
}); | |
}, | |
V | |
); | |
}, | |
isReady: function (X, U) { | |
var aa; | |
function V() { | |
eb( | |
U, | |
function () { | |
if (this._aborted) return !1; | |
if (this._timedout) U.timeout(); | |
else { | |
if (this._errored) throw this._errored; | |
return !0; | |
} | |
}, | |
aa | |
); | |
} | |
aa = this; | |
eb( | |
U, | |
function () { | |
this._ready | |
? V() | |
: this._readyQueue.poll(X, { | |
result: function (W) { | |
eb( | |
U, | |
function () { | |
if (W === Gb) return !1; | |
V(); | |
}, | |
aa | |
); | |
}, | |
timeout: function () { | |
U.timeout(); | |
}, | |
error: function (W) { | |
U.error(W); | |
}, | |
}); | |
}, | |
aa | |
); | |
}, | |
getMessageHeader: function () { | |
return this._header instanceof gd ? this._header : null; | |
}, | |
getErrorHeader: function () { | |
return this._header instanceof Ic ? this._header : null; | |
}, | |
getIdentity: function () { | |
var X, U; | |
X = this.getMessageHeader(); | |
if (X) { | |
U = X.masterToken; | |
return U ? U.identity : X.entityAuthenticationData.getIdentity(); | |
} | |
return this.getErrorHeader().entityAuthenticationData.getIdentity(); | |
}, | |
getCustomer: function () { | |
var X; | |
X = this.getMessageHeader(); | |
return X ? X.customer : null; | |
}, | |
getPayloadCryptoContext: function () { | |
return this._cryptoContext; | |
}, | |
getKeyExchangeCryptoContext: function () { | |
return this._keyxCryptoContext; | |
}, | |
closeSource: function (X) { | |
this._closeSource = X; | |
}, | |
abort: function () { | |
this._aborted = !0; | |
this._source.abort(); | |
this._readyQueue.cancelAll(); | |
}, | |
close: function () { | |
this._closeSource && this._source.close(); | |
}, | |
mark: function () { | |
if (this._currentPayload) { | |
for ( | |
; | |
0 < this._payloads.length && | |
this._payloads[0] !== this._currentPayload; | |
) { | |
this._payloads.shift(); | |
} | |
this._payloadIndex = 0; | |
this._currentPayload = this._payloads[this._payloadIndex++]; | |
this._markOffset = this._payloadOffset; | |
} else (this._payloadIndex = -1), (this._payloads = []); | |
}, | |
markSupported: function () { | |
return !0; | |
}, | |
read: function (X, U, V) { | |
var W; | |
function aa() { | |
eb( | |
V, | |
function () { | |
var va, ra, ia, qa; | |
function ha(Aa) { | |
eb( | |
Aa, | |
function () { | |
var ka, Z, ca; | |
if (ra && qa >= ra.length) return ra.subarray(0, qa); | |
ka = -1; | |
if (this._currentPayload) { | |
Z = this._currentPayload.length - this._payloadOffset; | |
if (!ra) { | |
ca = Z; | |
if (-1 != this._payloadIndex) | |
for ( | |
var fa = this._payloadIndex; | |
fa < this._payloads.length; | |
++fa | |
) { | |
ca += this._payloads[fa].length; | |
} | |
0 < ca && (ra = new Uint8Array(ca)); | |
} | |
Z = Math.min(Z, ra ? ra.length - qa : 0); | |
0 < Z && | |
((ka = this._currentPayload.subarray( | |
this._payloadOffset, | |
this._payloadOffset + Z | |
)), | |
ra.set(ka, ia), | |
(ka = Z), | |
(ia += Z), | |
(this._payloadOffset += Z)); | |
} | |
-1 != ka | |
? ((qa += ka), ha(Aa)) | |
: this.nextData(U, { | |
result: function (xa) { | |
eb( | |
Aa, | |
function () { | |
if (this._aborted) | |
return ra | |
? ra.subarray(0, qa) | |
: new Uint8Array(0); | |
this._currentPayload = xa; | |
this._payloadOffset = 0; | |
if (this._currentPayload) ha(Aa); | |
else | |
return 0 == qa && 0 != X | |
? null | |
: ra | |
? ra.subarray(0, qa) | |
: new Uint8Array(0); | |
}, | |
W | |
); | |
}, | |
timeout: function () { | |
Aa.timeout( | |
ra ? ra.subarray(0, qa) : new Uint8Array(0) | |
); | |
}, | |
error: function (xa) { | |
eb( | |
Aa, | |
function () { | |
xa instanceof gb && | |
(xa = new Zb( | |
"Error reading the payload chunk.", | |
xa | |
)); | |
if (0 < qa) | |
return ( | |
(W._readException = xa), | |
ra.subarray(0, qa) | |
); | |
throw xa; | |
}, | |
W | |
); | |
}, | |
}); | |
}, | |
W | |
); | |
} | |
if (this._aborted) return new Uint8Array(0); | |
if (this._timedout) V.timeout(new Uint8Array(0)); | |
else { | |
if (this._errored) throw this._errored; | |
if (null != this._readException) { | |
va = this._readException; | |
this._readException = null; | |
throw va; | |
} | |
ra = -1 != X ? new Uint8Array(X) : Gb; | |
ia = 0; | |
qa = 0; | |
ha(V); | |
} | |
}, | |
W | |
); | |
} | |
W = this; | |
eb( | |
V, | |
function () { | |
if (-1 > X) | |
throw new RangeError("read requested with illegal length " + X); | |
this._ready | |
? aa() | |
: this._readyQueue.poll(U, { | |
result: function (ha) { | |
ha === Gb ? V.result(!1) : aa(); | |
}, | |
timeout: function () { | |
V.timeout(new Uint8Array(0)); | |
}, | |
error: function (ha) { | |
V.error(ha); | |
}, | |
}); | |
}, | |
W | |
); | |
}, | |
reset: function () { | |
this._payloadIndex = 0; | |
0 < this._payloads.length | |
? ((this._currentPayload = this._payloads[this._payloadIndex++]), | |
(this._payloadOffset = this._markOffset)) | |
: (this._currentPayload = null); | |
}, | |
}); | |
Xe = function (X, U, V, aa, W, ha, va) { | |
new We(X, U, V, aa, W, ha, va); | |
}; | |
})(); | |
(function () { | |
Ye = ud.extend({ | |
init: function (da, X, U, V, aa, W, ha) { | |
var va; | |
va = this; | |
eb( | |
ha, | |
function () { | |
var ia, qa, Aa; | |
function ra() { | |
va._ready = !0; | |
va._readyQueue.add(!0); | |
} | |
ia = Ud(da.getMessageCapabilities(), V.messageCapabilities); | |
qa = null; | |
ia && (qa = me(ia.compressionAlgorithms)); | |
ia = { | |
_destination: { | |
value: X, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_charset: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_capabilities: { | |
value: ia, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_header: { | |
value: V, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_compressionAlgo: { | |
value: qa, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_cryptoContext: { | |
value: aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_payloadSequenceNumber: { | |
value: 1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_currentPayload: { | |
value: [], | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_closed: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_payloads: { | |
value: [], | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_ready: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_readyQueue: { | |
value: new Zc(), | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timedout: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_errored: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, ia); | |
Aa = fc(JSON.stringify(V), U); | |
X.write(Aa, 0, Aa.length, W, { | |
result: function (ka) { | |
try { | |
va._aborted | |
? ra() | |
: ka < Aa.length | |
? ((va._timedout = !0), ra()) | |
: X.flush(W, { | |
result: function (Z) { | |
va._aborted || (va._timedout = !Z); | |
ra(); | |
}, | |
timeout: function () { | |
va._timedout = !0; | |
ra(); | |
}, | |
error: function (Z) { | |
va._errored = Z; | |
ra(); | |
}, | |
}); | |
} catch (Z) { | |
va._errored = Z; | |
ra(); | |
} | |
}, | |
timeout: function () { | |
va._timedout = !0; | |
ra(); | |
}, | |
error: function (ka) { | |
va._errored = ka; | |
ra(); | |
}, | |
}); | |
return this; | |
}, | |
va | |
); | |
}, | |
setCompressionAlgorithm: function (da, X, U) { | |
var aa; | |
function V() { | |
aa.flush(X, { | |
result: function (W) { | |
eb( | |
U, | |
function () { | |
if (!W) throw new Zb("flush() aborted"); | |
this._compressionAlgo = da; | |
return !0; | |
}, | |
aa | |
); | |
}, | |
timeout: function () { | |
U.timeout(); | |
}, | |
error: function (W) { | |
U.error(W); | |
}, | |
}); | |
} | |
aa = this; | |
eb( | |
U, | |
function () { | |
if (!this.getMessageHeader()) | |
throw new Bb("Cannot write payload data for an error message."); | |
if (this._compressionAlgo == da) return !0; | |
if (da) { | |
if (!this._capabilities) return !1; | |
for ( | |
var W = this._capabilities.compressionAlgorithms, ha = 0; | |
ha < W.length; | |
++ha | |
) { | |
if (W[ha] == da) { | |
V(); | |
return; | |
} | |
} | |
return !1; | |
} | |
V(); | |
}, | |
aa | |
); | |
}, | |
getMessageHeader: function () { | |
return this._header instanceof gd ? this._header : null; | |
}, | |
getErrorMessage: function () { | |
return this._header instanceof Ic ? this._header : null; | |
}, | |
getPayloads: function () { | |
return this._payloads; | |
}, | |
abort: function () { | |
this._aborted = !0; | |
this._destination.abort(); | |
this._readyQueue.cancelAll(); | |
}, | |
close: function (da, X) { | |
var U; | |
U = this; | |
eb( | |
X, | |
function () { | |
if (this._aborted) return !1; | |
if (this._timedout) X.timeout(); | |
else { | |
if (this._errored) throw this._errored; | |
if (this._closed) return !0; | |
this._closed = !0; | |
this.flush(da, { | |
result: function (V) { | |
eb( | |
X, | |
function () { | |
V && (this._currentPayload = null); | |
return V; | |
}, | |
U | |
); | |
}, | |
timeout: function () { | |
X.timeout(); | |
}, | |
error: function (V) { | |
X.error(V); | |
}, | |
}); | |
} | |
}, | |
U | |
); | |
}, | |
flush: function (da, X) { | |
var V; | |
function U() { | |
eb( | |
X, | |
function () { | |
var aa, W, ia; | |
if (this._aborted) return !1; | |
if (this._timedout) X.timeout(); | |
else { | |
if (this._errored) throw this._errored; | |
if ( | |
!this._currentPayload || | |
(!this._closed && 0 == this._currentPayload.length) | |
) | |
return !0; | |
aa = this.getMessageHeader(); | |
if (!aa) return !0; | |
W = 0; | |
this._currentPayload && | |
this._currentPayload.forEach(function (qa) { | |
W += qa.length; | |
}); | |
for ( | |
var ha = new Uint8Array(W), va = 0, ra = 0; | |
this._currentPayload && ra < this._currentPayload.length; | |
++ra | |
) { | |
ia = this._currentPayload[ra]; | |
ha.set(ia, va); | |
va += ia.length; | |
} | |
Re( | |
this._payloadSequenceNumber, | |
aa.messageId, | |
this._closed, | |
this._compressionAlgo, | |
ha, | |
this._cryptoContext, | |
{ | |
result: function (qa) { | |
eb( | |
X, | |
function () { | |
var Aa; | |
this._payloads.push(qa); | |
Aa = fc(JSON.stringify(qa), this._charset); | |
this._destination.write(Aa, 0, Aa.length, da, { | |
result: function (ka) { | |
eb( | |
X, | |
function () { | |
if (this._aborted) return !1; | |
ka < qa.length | |
? X.timeout() | |
: this._destination.flush(da, { | |
result: function (Z) { | |
eb( | |
X, | |
function () { | |
if (this._aborted) return !1; | |
if (Z) | |
return ( | |
++this | |
._payloadSequenceNumber, | |
(this._currentPayload = this | |
._closed | |
? null | |
: []), | |
!0 | |
); | |
X.timeout(); | |
}, | |
V | |
); | |
}, | |
timeout: function () { | |
X.timeout(); | |
}, | |
error: function (Z) { | |
Z instanceof gb && | |
(Z = new Zb( | |
"Error encoding payload chunk [sequence number " + | |
V._payloadSequenceNumber + | |
"].", | |
Z | |
)); | |
X.error(Z); | |
}, | |
}); | |
}, | |
V | |
); | |
}, | |
timeout: function (ka) { | |
X.timeout(); | |
}, | |
error: function (ka) { | |
ka instanceof gb && | |
(ka = new Zb( | |
"Error encoding payload chunk [sequence number " + | |
V._payloadSequenceNumber + | |
"].", | |
ka | |
)); | |
X.error(ka); | |
}, | |
}); | |
}, | |
V | |
); | |
}, | |
error: function (qa) { | |
qa instanceof gb && | |
(qa = new Zb( | |
"Error encoding payload chunk [sequence number " + | |
V._payloadSequenceNumber + | |
"].", | |
qa | |
)); | |
X.error(qa); | |
}, | |
} | |
); | |
} | |
}, | |
V | |
); | |
} | |
V = this; | |
eb( | |
X, | |
function () { | |
this._ready | |
? U() | |
: this._readyQueue.poll(da, { | |
result: function (aa) { | |
aa === Gb ? X.result(!1) : U(); | |
}, | |
timeout: function () { | |
X.timeout(); | |
}, | |
error: function (aa) { | |
X.error(aa); | |
}, | |
}); | |
}, | |
V | |
); | |
}, | |
write: function (da, X, U, V, aa) { | |
eb( | |
aa, | |
function () { | |
var W; | |
if (this._aborted) return !1; | |
if (this._timedout) aa.timeout(); | |
else { | |
if (this._errored) throw this._errored; | |
if (this._closed) | |
throw new Zb("Message output stream already closed."); | |
if (0 > X) throw new RangeError("Offset cannot be negative."); | |
if (0 > U) throw new RangeError("Length cannot be negative."); | |
if (X + U > da.length) | |
throw new RangeError( | |
"Offset plus length cannot be greater than the array length." | |
); | |
if (!this.getMessageHeader()) | |
throw new Bb( | |
"Cannot write payload data for an error message." | |
); | |
W = da.subarray(X, X + U); | |
this._currentPayload.push(W); | |
return W.length; | |
} | |
}, | |
this | |
); | |
}, | |
}); | |
zd = function (da, X, U, V, aa, W, ha) { | |
new Ye(da, X, U, V, aa, W, ha); | |
}; | |
})(); | |
Cf = Hb.Class.create({ | |
sentHeader: function (da) {}, | |
receivedHeader: function (da) {}, | |
}); | |
Object.freeze({ | |
USERDATA_REAUTH: Ga.USERDATA_REAUTH, | |
SSOTOKEN_REJECTED: Ga.SSOTOKEN_REJECTED, | |
}); | |
Ze = Hb.Class.create({ | |
getCryptoContexts: function () {}, | |
getRecipient: function () {}, | |
isEncrypted: function () {}, | |
isIntegrityProtected: function () {}, | |
isNonReplayable: function () {}, | |
isRequestingTokens: function () {}, | |
getUserId: function () {}, | |
getUserAuthData: function (da, X, U, V) {}, | |
getCustomer: function () {}, | |
getKeyRequestData: function (da) {}, | |
updateServiceTokens: function (da, X, U) {}, | |
write: function (da, X, U) {}, | |
getDebugContext: function () {}, | |
}); | |
Hb.Class.create({ | |
getInputStream: function (da) {}, | |
getOutputStream: function (da) {}, | |
}); | |
(function () { | |
var va, ra, ia, qa, Aa, ka, Z, ca, fa, xa, Sa, Ma; | |
function da(Ra) { | |
return function () { | |
Ra.abort(); | |
}; | |
} | |
function X(Ra, Xa) { | |
Object.defineProperties(this, { | |
masterToken: { value: Ra, writable: !1, configurable: !1 }, | |
ticket: { value: Xa, writable: !1, configurable: !1 }, | |
}); | |
} | |
function U(Ra, Xa) { | |
Object.defineProperties(this, { | |
builder: { value: Ra, writable: !1, configurable: !1 }, | |
msgCtx: { value: Xa, writable: !1, configurable: !1 }, | |
}); | |
} | |
function V(Ra, Xa, oa) { | |
Object.defineProperties(this, { | |
requestHeader: { value: Ra, writable: !1, configurable: !1 }, | |
payloads: { value: Xa, writable: !1, configurable: !1 }, | |
handshake: { value: oa, writable: !1, configurable: !1 }, | |
}); | |
} | |
function aa(Ra, Xa) { | |
Object.defineProperties(this, { | |
requestHeader: { | |
value: Xa.requestHeader, | |
writable: !1, | |
configurable: !1, | |
}, | |
payloads: { value: Xa.payloads, writable: !1, configurable: !1 }, | |
handshake: { value: Xa.handshake, writable: !1, configurable: !1 }, | |
response: { value: Ra, writable: !1, configurable: !1 }, | |
}); | |
} | |
function W(Ra) { | |
for (; Ra; ) { | |
if (Ra instanceof cc) return !0; | |
Ra = Ra instanceof gb ? Ra.cause : Gb; | |
} | |
return !1; | |
} | |
function ha(Ra, Xa, oa, ya, Ea, Ja, Da, Va, Ha) { | |
Ue(Xa, ya, Ea, Ja, { | |
result: function (ab) { | |
oa && oa.sentHeader(ab); | |
zd(Xa, Da, Tb, ab, null, null, Va, { | |
result: function (db) { | |
Ra.setAbort(function () { | |
db.abort(); | |
}); | |
db.close(Va, { | |
result: function (Ya) { | |
eb(Ha, function () { | |
if (!Ya) throw new cc("sendError aborted."); | |
return Ya; | |
}); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (Ya) { | |
Ha.error(Ya); | |
}, | |
}); | |
}, | |
timeout: function () {}, | |
error: function (db) { | |
Ha.error(db); | |
}, | |
}); | |
}, | |
error: function (ab) { | |
Ha.error(ab); | |
}, | |
}); | |
} | |
va = ud.extend({ | |
close: function (Ra, Xa) { | |
Xa.result(!0); | |
}, | |
write: function (Ra, Xa, oa, ya, Ea) { | |
Na(Ea, function () { | |
return Math.min(Ra.length - Xa, oa); | |
}); | |
}, | |
flush: function (Ra, Xa) { | |
Xa.result(!0); | |
}, | |
}); | |
ra = Bf.extend({ | |
getUserMessage: function (Ra, Xa) { | |
return null; | |
}, | |
}); | |
ia = Ze.extend({ | |
init: function (Ra) { | |
Object.defineProperties(this, { | |
_appCtx: { | |
value: Ra, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
getCryptoContexts: function () { | |
return this._appCtx.getCryptoContexts(); | |
}, | |
isEncrypted: function () { | |
return this._appCtx.isEncrypted(); | |
}, | |
isIntegrityProtected: function () { | |
return this._appCtx.isIntegrityProtected(); | |
}, | |
isNonReplayable: function () { | |
return this._appCtx.isNonReplayable(); | |
}, | |
isRequestingTokens: function () { | |
return this._appCtx.isRequestingTokens(); | |
}, | |
getUserId: function () { | |
return this._appCtx.getUserId(); | |
}, | |
getUserAuthData: function (Ra, Xa, oa, ya) { | |
this._appCtx.getUserAuthData(Ra, Xa, oa, ya); | |
}, | |
getCustomer: function () { | |
return this._appCtx.getCustomer(); | |
}, | |
getKeyRequestData: function (Ra) { | |
this._appCtx.getKeyRequestData(Ra); | |
}, | |
updateServiceTokens: function (Ra, Xa, oa) { | |
this._appCtx.updateServiceTokens(Ra, Xa, oa); | |
}, | |
write: function (Ra, Xa, oa) { | |
this._appCtx.write(Ra, Xa, oa); | |
}, | |
getDebugContext: function () { | |
return this._appCtx.getDebugContext(); | |
}, | |
}); | |
qa = ia.extend({ | |
init: function ya(Xa, oa) { | |
ya.base.call(this, oa); | |
Object.defineProperties(this, { | |
_payloads: { | |
value: Xa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
write: function (Xa, oa, ya) { | |
var Ja; | |
function Ea(Da, Va) { | |
var Ha; | |
if (Da == Ja._payloads.length) ya.result(!0); | |
else { | |
Ha = Ja._payloads[Da]; | |
Xa.setCompressionAlgorithm(Ha.compressionAlgo, oa, { | |
result: function (ab) { | |
Xa.write(Ha.data, 0, Ha.data.length, oa, { | |
result: function (db) { | |
eb( | |
ya, | |
function () { | |
Ha.isEndOfMessage() | |
? Ea(Da + 1, Va) | |
: Xa.flush(oa, { | |
result: function (Ya) { | |
ya.result(Ya); | |
}, | |
timeout: function () { | |
ya.timeout(); | |
}, | |
error: function (Ya) { | |
ya.error(Ya); | |
}, | |
}); | |
}, | |
Ja | |
); | |
}, | |
timeout: function (db) { | |
ya.timeout(db); | |
}, | |
error: function (db) { | |
ya.error(db); | |
}, | |
}); | |
}, | |
timeout: function () {}, | |
error: function (ab) { | |
ya.error(ab); | |
}, | |
}); | |
} | |
} | |
Ja = this; | |
Ea(0); | |
}, | |
}); | |
Aa = ia.extend({ | |
init: function ya(oa) { | |
ya.base.call(this, oa); | |
}, | |
isEncrypted: function () { | |
return !1; | |
}, | |
isNonReplayable: function () { | |
return !1; | |
}, | |
write: function (oa, ya, Ea) { | |
Ea.result(!0); | |
}, | |
}); | |
ka = {}; | |
Z = Hb.Class.create({ | |
init: function (oa) { | |
oa || (oa = new ra()); | |
Object.defineProperties(this, { | |
_filterFactory: { | |
value: null, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_renewingContexts: { | |
value: [], | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_masterTokenLocks: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_messageRegistry: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
setFilterFactory: function (oa) { | |
this._filterFactory = oa; | |
}, | |
getNewestMasterToken: function (oa, ya, Ea, Ja) { | |
var Da; | |
Da = this; | |
eb( | |
Ja, | |
function () { | |
var Va, Ha, ab, db, Ya; | |
Va = ya.getMslStore(); | |
Ha = Va.getMasterToken(); | |
if (!Ha) return null; | |
ab = Ha.uniqueKey(); | |
db = this._masterTokenLocks[ab]; | |
db || ((db = new Fd()), (this._masterTokenLocks[ab] = db)); | |
Ya = db.readLock(Ea, { | |
result: function (mb) { | |
eb( | |
Ja, | |
function () { | |
var qb; | |
if (mb === Gb) | |
throw new cc("getNewestMasterToken aborted."); | |
qb = Va.getMasterToken(); | |
if (Ha.equals(qb)) return new X(Ha, mb); | |
db.unlock(mb); | |
db.writeLock(Ea, { | |
result: function (sb) { | |
eb( | |
Ja, | |
function () { | |
if (sb === Gb) | |
throw new cc("getNewestMasterToken aborted."); | |
delete this._masterTokenLocks[ab]; | |
db.unlock(sb); | |
return this.getNewestMasterToken(oa, ya, Ea, Ja); | |
}, | |
Da | |
); | |
}, | |
timeout: function () { | |
Ja.timeout(); | |
}, | |
error: function (sb) { | |
Ja.error(sb); | |
}, | |
}); | |
}, | |
Da | |
); | |
}, | |
timeout: function () { | |
Ja.timeout(); | |
}, | |
error: function (mb) { | |
Ja.error(mb); | |
}, | |
}); | |
oa.setAbort(function () { | |
Ya && (db.cancel(Ya), (Ya = Gb)); | |
}); | |
}, | |
Da | |
); | |
}, | |
deleteMasterToken: function (oa, ya) { | |
var Ea; | |
if (ya) { | |
Ea = this; | |
setTimeout(function () { | |
var Ja, Da; | |
Ja = ya.uniqueKey(); | |
Da = Ea._masterTokenLocks[Ja]; | |
Da || ((Da = new Fd()), (Ea._masterTokenLocks[Ja] = Da)); | |
Da.writeLock(-1, { | |
result: function (Va) { | |
oa.getMslStore().removeCryptoContext(ya); | |
delete Ea._masterTokenLocks[Ja]; | |
Da.unlock(Va); | |
}, | |
timeout: function () { | |
throw new Bb("Unexpected timeout received."); | |
}, | |
error: function (Va) { | |
throw Va; | |
}, | |
}); | |
}, 0); | |
} | |
}, | |
releaseMasterToken: function (oa) { | |
var ya; | |
if (oa && oa.masterToken) { | |
ya = oa.masterToken.uniqueKey(); | |
ya = this._masterTokenLocks[ya]; | |
if (!ya) | |
throw new Bb( | |
"Master token read/write lock does not exist when it should." | |
); | |
ya.unlock(oa.ticket); | |
} | |
}, | |
updateOutgoingCryptoContexts: function (oa, ya, Ea) { | |
var Ja; | |
Ja = oa.getMslStore(); | |
!oa.isPeerToPeer() && | |
Ea && | |
(Ja.setCryptoContext( | |
Ea.keyResponseData.masterToken, | |
Ea.cryptoContext | |
), | |
this.deleteMasterToken(oa, ya.masterToken)); | |
}, | |
updateIncomingCryptoContexts: function (oa, ya, Ea) { | |
var Ja, Da; | |
Ja = Ea.getMessageHeader(); | |
if (Ja) { | |
Da = oa.getMslStore(); | |
if ((Ja = Ja.keyResponseData)) | |
Da.setCryptoContext( | |
Ja.masterToken, | |
Ea.getKeyExchangeCryptoContext() | |
), | |
this.deleteMasterToken(oa, ya.masterToken); | |
} | |
}, | |
storeServiceTokens: function (oa, ya, Ea, Ja) { | |
var Ha, ab; | |
oa = oa.getMslStore(); | |
for (var Da = [], Va = 0; Va < Ja.length; ++Va) { | |
Ha = Ja[Va]; | |
if (!Ha.isBoundTo(ya) || !ya.isVerified()) { | |
ab = Ha.data; | |
ab && 0 == ab.length | |
? oa.removeServiceTokens( | |
Ha.name, | |
Ha.isMasterTokenBound() ? ya : null, | |
Ha.isUserIdTokenBound() ? Ea : null | |
) | |
: Da.push(Ha); | |
} | |
} | |
0 < Da.length && oa.addServiceTokens(Da); | |
}, | |
buildRequest: function (oa, ya, Ea, Ja, Da) { | |
var Va; | |
Va = this; | |
this.getNewestMasterToken(oa, ya, Ja, { | |
result: function (Ha) { | |
Na( | |
Da, | |
function () { | |
var ab, db, Ya; | |
ab = Ha && Ha.masterToken; | |
if (ab) { | |
db = Ea.getUserId(); | |
Ya = ya.getMslStore(); | |
db = | |
(db = db ? Ya.getUserIdToken(db) : null) && | |
db.isBoundTo(ab) | |
? db | |
: null; | |
} else db = null; | |
Oc(ya, ab, db, null, { | |
result: function (mb) { | |
Na(Da, function () { | |
mb.setNonReplayable(Ea.isNonReplayable()); | |
return { builder: mb, tokenTicket: Ha }; | |
}); | |
}, | |
error: function (mb) { | |
Na( | |
Da, | |
function () { | |
this.releaseMasterToken(Ha); | |
mb instanceof gb && | |
(mb = new Bb( | |
"User ID token not bound to master token despite internal check.", | |
mb | |
)); | |
throw mb; | |
}, | |
Va | |
); | |
}, | |
}); | |
}, | |
Va | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (Ha) { | |
Da.error(Ha); | |
}, | |
}); | |
}, | |
buildResponse: function (oa, ya, Ea, Ja, Da, Va) { | |
var Ha; | |
Ha = this; | |
Te(ya, Ja, { | |
result: function (ab) { | |
eb( | |
Va, | |
function () { | |
ab.setNonReplayable(Ea.isNonReplayable()); | |
if (!ya.isPeerToPeer() && !Ja.keyResponseData) | |
return { builder: ab, tokenTicket: null }; | |
this.getNewestMasterToken(oa, ya, Da, { | |
result: function (db) { | |
eb( | |
Va, | |
function () { | |
var Ya, mb, qb; | |
Ya = db && db.masterToken; | |
if (Ya) { | |
mb = Ea.getUserId(); | |
qb = ya.getMslStore(); | |
mb = | |
(mb = mb ? qb.getUserIdToken(mb) : null) && | |
mb.isBoundTo(Ya) | |
? mb | |
: null; | |
} else mb = null; | |
ab.setAuthTokens(Ya, mb); | |
return { builder: ab, tokenTicket: db }; | |
}, | |
Ha | |
); | |
}, | |
timeout: function () { | |
Va.timeout(); | |
}, | |
error: function (db) { | |
Va.error(db); | |
}, | |
}); | |
}, | |
Ha | |
); | |
}, | |
error: function (ab) { | |
Va.error(ab); | |
}, | |
}); | |
}, | |
buildErrorResponse: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
var Ya; | |
function ab(mb, qb) { | |
eb( | |
Ha, | |
function () { | |
var sb, ub; | |
sb = Nc(Da.messageId); | |
ub = new qa(qb, Ea); | |
Oc(ya, null, null, sb, { | |
result: function (vb) { | |
eb( | |
Ha, | |
function () { | |
ya.isPeerToPeer() && | |
vb.setPeerAuthTokens( | |
mb.peerMasterToken, | |
mb.peerUserIdToken | |
); | |
vb.setNonReplayable(ub.isNonReplayable()); | |
return { | |
errorResult: new U(vb, ub), | |
tokenTicket: null, | |
}; | |
}, | |
Ya | |
); | |
}, | |
error: function (vb) { | |
Ha.error(vb); | |
}, | |
}); | |
}, | |
Ya | |
); | |
} | |
function db(mb, qb) { | |
Ya.getNewestMasterToken(oa, ya, Va, { | |
result: function (sb) { | |
eb( | |
Ha, | |
function () { | |
var ub, vb, Eb; | |
ub = sb && sb.masterToken; | |
vb = Nc(Da.messageId); | |
Eb = new qa(qb, Ea); | |
Oc(ya, ub, null, vb, { | |
result: function (Db) { | |
eb( | |
Ha, | |
function () { | |
ya.isPeerToPeer() && | |
Db.setPeerAuthTokens( | |
mb.peerMasterToken, | |
mb.peerUserIdToken | |
); | |
Db.setNonReplayable(Eb.isNonReplayable()); | |
return { | |
errorResult: new U(Db, Eb), | |
tokenTicket: sb, | |
}; | |
}, | |
Ya | |
); | |
}, | |
error: function (Db) { | |
Ha.error(Db); | |
}, | |
}); | |
}, | |
Ya | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (sb) { | |
Ha.error(sb); | |
}, | |
}); | |
} | |
Ya = this; | |
eb( | |
Ha, | |
function () { | |
var mb, qb, sb, ub; | |
mb = Ja.requestHeader; | |
qb = Ja.payloads; | |
sb = Da.errorCode; | |
switch (sb) { | |
case Ga.ENTITYDATA_REAUTH: | |
case Ga.ENTITY_REAUTH: | |
ya.getEntityAuthenticationData(sb, { | |
result: function (vb) { | |
eb( | |
Ha, | |
function () { | |
if (!vb) return null; | |
ab(mb, qb); | |
}, | |
Ya | |
); | |
}, | |
error: function (vb) { | |
Ha.error(vb); | |
}, | |
}); | |
break; | |
case Ga.USERDATA_REAUTH: | |
case Ga.SSOTOKEN_REJECTED: | |
Ea.getUserAuthData(sb, !1, !0, { | |
result: function (vb) { | |
eb( | |
Ha, | |
function () { | |
if (!vb) return null; | |
db(mb, qb); | |
}, | |
Ya | |
); | |
}, | |
error: function (vb) { | |
Ha.error(vb); | |
}, | |
}); | |
break; | |
case Ga.USER_REAUTH: | |
db(mb, qb); | |
break; | |
case Ga.KEYX_REQUIRED: | |
sb = Nc(Da.messageId); | |
ub = new qa(qb, Ea); | |
Oc(ya, null, null, sb, { | |
result: function (vb) { | |
eb( | |
Ha, | |
function () { | |
ya.isPeerToPeer() && | |
vb.setPeerAuthTokens( | |
mb.peerMasterToken, | |
mb.peerUserIdToken | |
); | |
vb.setRenewable(!0); | |
vb.setNonReplayable(ub.isNonReplayable()); | |
return { | |
errorResult: new U(vb, ub), | |
tokenTicket: null, | |
}; | |
}, | |
Ya | |
); | |
}, | |
error: function (vb) { | |
Ha.error(vb); | |
}, | |
}); | |
break; | |
case Ga.EXPIRED: | |
this.getNewestMasterToken(oa, ya, Va, { | |
result: function (vb) { | |
eb( | |
Ha, | |
function () { | |
var Eb, Db, pa, Fa; | |
Eb = vb && vb.masterToken; | |
Db = mb.userIdToken; | |
pa = Nc(Da.messageId); | |
Fa = new qa(qb, Ea); | |
Oc( | |
ya, | |
Eb, | |
Db, | |
pa, | |
{ | |
result: function (Pa) { | |
eb( | |
Ha, | |
function () { | |
ya.isPeerToPeer() && | |
Pa.setPeerAuthTokens( | |
mb.peerMasterToken, | |
mb.peerUserIdToken | |
); | |
mb.masterToken.equals(Eb) && | |
Pa.setRenewable(!0); | |
Pa.setNonReplayable(Fa.isNonReplayable()); | |
return { | |
errorResult: new U(Pa, Fa), | |
tokenTicket: vb, | |
}; | |
}, | |
Ya | |
); | |
}, | |
error: function (Pa) { | |
Ha.error(Pa); | |
}, | |
}, | |
Ya | |
); | |
}, | |
Ya | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (vb) { | |
Ha.error(vb); | |
}, | |
}); | |
break; | |
case Ga.REPLAYED: | |
this.getNewestMasterToken(oa, ya, Va, { | |
result: function (vb) { | |
eb( | |
Ha, | |
function () { | |
var Eb, Db, pa, Fa; | |
Eb = vb && vb.masterToken; | |
Db = mb.userIdToken; | |
pa = Nc(Da.messageId); | |
Fa = new qa(qb, Ea); | |
Oc(ya, Eb, Db, pa, { | |
result: function (Pa) { | |
eb( | |
Ha, | |
function () { | |
ya.isPeerToPeer() && | |
Pa.setPeerAuthTokens( | |
mb.peerMasterToken, | |
mb.peerUserIdToken | |
); | |
mb.masterToken.equals(Eb) | |
? (Pa.setRenewable(!0), | |
Pa.setNonReplayable(!1)) | |
: Pa.setNonReplayable(Fa.isNonReplayable()); | |
return { | |
errorResult: new U(Pa, Fa), | |
tokenTicket: vb, | |
}; | |
}, | |
Ya | |
); | |
}, | |
error: function (Pa) { | |
Ha.error(Pa); | |
}, | |
}); | |
}, | |
Ya | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (vb) { | |
Ha.error(vb); | |
}, | |
}); | |
break; | |
default: | |
return null; | |
} | |
}, | |
Ya | |
); | |
}, | |
cleanupContext: function (oa, ya, Ea) { | |
switch (Ea.errorCode) { | |
case Ga.ENTITY_REAUTH: | |
this.deleteMasterToken(oa, ya.masterToken); | |
break; | |
case Ga.USER_REAUTH: | |
(Ea = ya.userIdToken), | |
ya.masterToken && Ea && oa.getMslStore().removeUserIdToken(Ea); | |
} | |
}, | |
send: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
var sb; | |
function ab(ub, vb, Eb) { | |
eb( | |
Ha, | |
function () { | |
var Db; | |
Db = Da.getPeerUserIdToken(); | |
(!ya.isPeerToPeer() && !vb) || (ya.isPeerToPeer() && !Db) | |
? (Db = Ea.getCustomer()) | |
? Da.setCustomer(Db, { | |
result: function (pa) { | |
eb( | |
Ha, | |
function () { | |
vb = Da.getUserIdToken(); | |
db(ub, vb, Eb); | |
}, | |
sb | |
); | |
}, | |
error: function (pa) { | |
Ha.error(pa); | |
}, | |
}) | |
: db(ub, vb, Eb) | |
: db(ub, vb, Eb); | |
}, | |
sb | |
); | |
} | |
function db(ub, vb, Eb) { | |
eb( | |
Ha, | |
function () { | |
var Db, pa; | |
Db = | |
!Eb && | |
(!Ea.isEncrypted() || Da.willEncryptPayloads()) && | |
(!Ea.isIntegrityProtected() || | |
Da.willIntegrityProtectPayloads()) && | |
(!Ea.isNonReplayable() || (Da.isNonReplayable() && ub)); | |
Db || Da.setNonReplayable(!1); | |
pa = []; | |
Da.isRenewable() && | |
(!ub || ub.isRenewable() || Ea.isNonReplayable()) | |
? Ea.getKeyRequestData({ | |
result: function (Fa) { | |
eb( | |
Ha, | |
function () { | |
var r; | |
for (var Pa = 0; Pa < Fa.length; ++Pa) { | |
r = Fa[Pa]; | |
pa.push(r); | |
Da.addKeyRequestData(r); | |
} | |
Ya(ub, vb, Db, pa); | |
}, | |
sb | |
); | |
}, | |
error: function (Fa) { | |
Ha.error(Fa); | |
}, | |
}) | |
: Ya(ub, vb, Db, pa); | |
}, | |
sb | |
); | |
} | |
function Ya(ub, vb, Eb, Db) { | |
eb( | |
Ha, | |
function () { | |
var pa; | |
pa = new Ve(ya, Ea, Da); | |
Ea.updateServiceTokens(pa, !Eb, { | |
result: function (Fa) { | |
Da.getHeader({ | |
result: function (Pa) { | |
eb( | |
Ha, | |
function () { | |
var r, b; | |
r = Ea.getDebugContext(); | |
r && r.sentHeader(Pa); | |
r = Da.getKeyExchangeData(); | |
this.updateOutgoingCryptoContexts(ya, Pa, r); | |
this.storeServiceTokens( | |
ya, | |
ub, | |
vb, | |
Pa.serviceTokens | |
); | |
r = | |
!ya.isPeerToPeer() && r | |
? r.cryptoContext | |
: Pa.cryptoContext; | |
if (oa.isAborted()) throw new cc("send aborted."); | |
b = | |
null != this._filterFactory | |
? this._filterFactory.getOutputStream(Ja) | |
: Ja; | |
zd(ya, b, Tb, Pa, r, Va, { | |
result: function (a) { | |
oa.setAbort(function () { | |
a.abort(); | |
}); | |
mb(a, Pa, Eb); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (a) { | |
Ha.error(a); | |
}, | |
}); | |
}, | |
sb | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (Pa) { | |
Ha.error(Pa); | |
}, | |
}); | |
}, | |
error: function (Fa) { | |
Ha.error(Fa); | |
}, | |
}); | |
}, | |
sb | |
); | |
} | |
function mb(ub, vb, Eb) { | |
var Db, pa; | |
if (Eb) | |
Ea.write(ub, Va, { | |
result: function (Fa) { | |
eb( | |
Ha, | |
function () { | |
if (oa.isAborted()) | |
throw new cc("MessageOutputStream write aborted."); | |
qb(ub, vb, Eb); | |
}, | |
sb | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (Fa) { | |
Ha.error(Fa); | |
}, | |
}); | |
else { | |
Db = new va(); | |
pa = new Vc(); | |
zd(ya, Db, Tb, vb, pa, Va, { | |
result: function (Fa) { | |
Ea.write(Fa, Va, { | |
result: function (Pa) { | |
eb( | |
Ha, | |
function () { | |
if (oa.isAborted()) | |
throw new cc( | |
"MessageOutputStream proxy write aborted." | |
); | |
Fa.close(Va, { | |
result: function (r) { | |
eb( | |
Ha, | |
function () { | |
var b; | |
if (!r) | |
throw new cc( | |
"MessageOutputStream proxy close aborted." | |
); | |
b = Fa.getPayloads(); | |
qb(ub, vb, Eb, b); | |
}, | |
sb | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (r) { | |
Ha.error(r); | |
}, | |
}); | |
}, | |
sb | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (Pa) { | |
Ha.error(Pa); | |
}, | |
}); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (Fa) { | |
Ha.error(Fa); | |
}, | |
}); | |
} | |
} | |
function qb(ub, vb, Eb, Db) { | |
ub.close(Va, { | |
result: function (pa) { | |
eb( | |
Ha, | |
function () { | |
if (!pa) throw new cc("MessageOutputStream close aborted."); | |
Db || (Db = ub.getPayloads()); | |
return new V(vb, Db, !Eb); | |
}, | |
sb | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (pa) { | |
Ha.error(pa); | |
}, | |
}); | |
} | |
sb = this; | |
eb( | |
Ha, | |
function () { | |
var ub, vb, Eb, Db; | |
ub = Da.getMasterToken(); | |
vb = Da.getUserIdToken(); | |
Eb = !1; | |
if (Ea.getUserId()) { | |
Db = !vb; | |
Ea.getUserAuthData(null, Da.isRenewable(), Db, { | |
result: function (pa) { | |
eb( | |
Ha, | |
function () { | |
pa && | |
(Da.willEncryptHeader() && | |
Da.willIntegrityProtectHeader() | |
? Da.setUserAuthenticationData(pa) | |
: (Eb = !0)); | |
ab(ub, vb, Eb); | |
}, | |
sb | |
); | |
}, | |
error: function (pa) { | |
Ha.error(pa); | |
}, | |
}); | |
} else ab(ub, vb, Eb); | |
}, | |
sb | |
); | |
}, | |
receive: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
var ab; | |
ab = this; | |
eb( | |
Ha, | |
function () { | |
var db, Ya, mb; | |
if (oa.isAborted()) throw new cc("receive aborted."); | |
db = []; | |
Da && | |
(db = Da.keyRequestData.filter(function () { | |
return !0; | |
})); | |
Ya = Ea.getCryptoContexts(); | |
mb = this._filterFactory | |
? this._filterFactory.getInputStream(Ja) | |
: Ja; | |
Xe(ya, mb, Tb, db, Ya, Va, { | |
result: function (qb) { | |
oa.setAbort(function () { | |
qb.abort(); | |
}); | |
qb.isReady(Va, { | |
result: function (sb) { | |
eb( | |
Ha, | |
function () { | |
var ub, vb, Eb, Db; | |
if (!sb) throw new cc("MessageInputStream aborted."); | |
ub = qb.getMessageHeader(); | |
vb = qb.getErrorHeader(); | |
Eb = Ea.getDebugContext(); | |
Eb && Eb.receivedHeader(ub ? ub : vb); | |
if ( | |
Da && | |
((Eb = vb ? vb.errorCode : null), | |
ub || | |
(Eb != Ga.FAIL && | |
Eb != Ga.TRANSIENT_FAILURE && | |
Eb != Ga.ENTITY_REAUTH && | |
Eb != Ga.ENTITYDATA_REAUTH)) | |
) { | |
Eb = ub ? ub.messageId : vb.messageId; | |
Db = Nc(Da.messageId); | |
if (Eb != Db) | |
throw new Nb( | |
T.UNEXPECTED_RESPONSE_MESSAGE_ID, | |
"expected " + Db + "; received " + Eb | |
); | |
} | |
ya.getEntityAuthenticationData(null, { | |
result: function (pa) { | |
eb( | |
Ha, | |
function () { | |
var Fa, Pa, r, b; | |
Fa = pa.getIdentity(); | |
if (ub) { | |
Pa = ub.entityAuthenticationData; | |
r = ub.masterToken; | |
Pa = r ? ub.sender : Pa.getIdentity(); | |
if ( | |
(r && | |
r.isDecrypted() && | |
r.identity != Pa) || | |
Fa == Pa | |
) | |
throw new Nb( | |
T.UNEXPECTED_MESSAGE_SENDER, | |
Pa | |
); | |
Da && | |
this.updateIncomingCryptoContexts( | |
ya, | |
Da, | |
qb | |
); | |
Fa = ub.keyResponseData; | |
ya.isPeerToPeer() | |
? ((Fa = Fa | |
? Fa.masterToken | |
: ub.peerMasterToken), | |
(r = ub.peerUserIdToken), | |
(Pa = ub.peerServiceTokens)) | |
: ((Fa = Fa | |
? Fa.masterToken | |
: ub.masterToken), | |
(r = ub.userIdToken), | |
(Pa = ub.serviceTokens)); | |
b = Ea.getUserId(); | |
b && | |
r && | |
!r.isVerified() && | |
ya.getMslStore().addUserIdToken(b, r); | |
this.storeServiceTokens(ya, Fa, r, Pa); | |
} else if ( | |
((Pa = | |
vb.entityAuthenticationData.getIdentity()), | |
Fa == Pa) | |
) | |
throw new Nb( | |
T.UNEXPECTED_MESSAGE_SENDER, | |
Pa | |
); | |
return qb; | |
}, | |
ab | |
); | |
}, | |
error: Ha.error, | |
}); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (sb) { | |
Ha.error(sb); | |
}, | |
}); | |
}, | |
timeout: function () { | |
Ha.timeout(); | |
}, | |
error: function (qb) { | |
Ha.error(qb); | |
}, | |
}); | |
}, | |
ab | |
); | |
}, | |
sendReceive: function (oa, ya, Ea, Ja, Da, Va, Ha, ab, db) { | |
var mb; | |
function Ya(qb, sb) { | |
eb( | |
db, | |
function () { | |
Va.setRenewable(sb); | |
this.send(oa, ya, Ea, Da, Va, Ha, { | |
result: function (ub) { | |
eb( | |
db, | |
function () { | |
var vb; | |
vb = ub.requestHeader.keyRequestData; | |
ab || ub.handshake || !vb.isEmpty() | |
? this.receive(oa, ya, Ea, Ja, ub.requestHeader, Ha, { | |
result: function (Eb) { | |
eb( | |
db, | |
function () { | |
sb && this.releaseRenewalLock(ya, qb, Eb); | |
return new aa(Eb, ub); | |
}, | |
mb | |
); | |
}, | |
timeout: function () { | |
eb( | |
db, | |
function () { | |
sb && this.releaseRenewalLock(ya, qb, null); | |
db.timeout(); | |
}, | |
mb | |
); | |
}, | |
error: function (Eb) { | |
eb( | |
db, | |
function () { | |
sb && this.releaseRenewalLock(ya, qb, null); | |
throw Eb; | |
}, | |
mb | |
); | |
}, | |
}) | |
: eb( | |
db, | |
function () { | |
sb && this.releaseRenewalLock(ya, qb, null); | |
return new aa(null, ub); | |
}, | |
mb | |
); | |
}, | |
mb | |
); | |
}, | |
timeout: function () { | |
eb( | |
db, | |
function () { | |
sb && this.releaseRenewalLock(ya, qb, null); | |
db.timeout(); | |
}, | |
mb | |
); | |
}, | |
error: function (ub) { | |
eb( | |
db, | |
function () { | |
sb && this.releaseRenewalLock(ya, qb, null); | |
throw ub; | |
}, | |
mb | |
); | |
}, | |
}); | |
}, | |
mb | |
); | |
} | |
mb = this; | |
eb( | |
db, | |
function () { | |
var qb; | |
qb = new Zc(); | |
this.acquireRenewalLock(oa, ya, Ea, qb, Va, Ha, { | |
result: function (sb) { | |
Ya(qb, sb); | |
}, | |
timeout: function () { | |
db.timeout(); | |
}, | |
error: function (sb) { | |
sb instanceof cc ? db.result(null) : db.error(sb); | |
}, | |
}); | |
}, | |
mb | |
); | |
}, | |
acquireRenewalLock: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
var Ya; | |
function ab(mb, qb, sb) { | |
eb( | |
Ha, | |
function () { | |
var Eb, Db; | |
if (oa.isAborted()) throw new cc("acquireRenewalLock aborted."); | |
for ( | |
var ub = null, vb = 0; | |
vb < this._renewingContexts.length; | |
++vb | |
) { | |
Eb = this._renewingContexts[vb]; | |
if (Eb.ctx === ya) { | |
ub = Eb.queue; | |
break; | |
} | |
} | |
if (!ub) | |
return ( | |
this._renewingContexts.push({ ctx: ya, queue: Ja }), !0 | |
); | |
Db = ub.poll(Va, { | |
result: function (pa) { | |
eb( | |
Ha, | |
function () { | |
var Fa; | |
if (pa === Gb) | |
throw new cc("acquireRenewalLock aborted."); | |
ub.add(pa); | |
if (pa === ka || pa.isExpired()) ab(pa, qb, sb); | |
else { | |
if ((sb && !qb) || (qb && !qb.isBoundTo(pa))) { | |
Fa = ya.getMslStore().getUserIdToken(sb); | |
qb = Fa && Fa.isBoundTo(pa) ? Fa : null; | |
} | |
Da.setAuthTokens(pa, qb); | |
Da.isRenewable() && pa.equals(mb) | |
? ab(pa, qb, sb) | |
: Ea.isRequestingTokens() && !qb | |
? ab(pa, qb, sb) | |
: db(pa, qb); | |
} | |
}, | |
Ya | |
); | |
}, | |
timeout: function () {}, | |
error: function (pa) {}, | |
}); | |
oa.setAbort(function () { | |
Db && (ub.cancel(Db), (Db = Gb)); | |
}); | |
}, | |
Ya | |
); | |
} | |
function db(mb, qb) { | |
eb( | |
Ha, | |
function () { | |
var vb; | |
if (oa.isAborted()) throw new cc("acquireRenewalLock aborted."); | |
if ( | |
!mb || | |
mb.isRenewable() || | |
(!qb && Ea.getUserId()) || | |
(qb && qb.isRenewable()) | |
) { | |
for ( | |
var sb = null, ub = 0; | |
ub < this._renewingContexts.length; | |
++ub | |
) { | |
vb = this._renewingContexts[ub]; | |
if (vb.ctx === ya) { | |
sb = vb.queue; | |
break; | |
} | |
} | |
if (!sb) | |
return ( | |
this._renewingContexts.push({ ctx: ya, queue: Ja }), !0 | |
); | |
} | |
return !1; | |
}, | |
Ya | |
); | |
} | |
Ya = this; | |
eb( | |
Ha, | |
function () { | |
var mb, qb, sb; | |
mb = Da.getMasterToken(); | |
qb = Da.getUserIdToken(); | |
sb = Ea.getUserId(); | |
(Ea.isEncrypted() && !Da.willEncryptPayloads()) || | |
(Ea.isIntegrityProtected() && | |
!Da.willIntegrityProtectPayloads()) || | |
Da.isRenewable() || | |
(!mb && Ea.isNonReplayable()) || | |
(mb && mb.isExpired()) || | |
!( | |
qb || | |
!sb || | |
(Da.willEncryptHeader() && Da.willIntegrityProtectHeader()) | |
) || | |
(Ea.isRequestingTokens() && (!mb || (sb && !qb))) | |
? ab(mb, qb, sb) | |
: db(mb, qb); | |
}, | |
Ya | |
); | |
}, | |
releaseRenewalLock: function (oa, ya, Ea) { | |
var Ha; | |
for (var Ja, Da, Va = 0; Va < this._renewingContexts.length; ++Va) { | |
Ha = this._renewingContexts[Va]; | |
if (Ha.ctx === oa) { | |
Ja = Va; | |
Da = Ha.queue; | |
break; | |
} | |
} | |
if (Da !== ya) | |
throw new Bb( | |
"Attempt to release renewal lock that is not owned by this queue." | |
); | |
Ea | |
? (Ea = Ea.messageHeader) | |
? (Da = Ea.keyResponseData) | |
? ya.add(Da.masterToken) | |
: (oa = oa.isPeerToPeer() ? Ea.peerMasterToken : Ea.masterToken) | |
? ya.add(oa) | |
: ya.add(ka) | |
: ya.add(ka) | |
: ya.add(ka); | |
this._renewingContexts.splice(Ja, 1); | |
}, | |
}); | |
$e = Hb.Class.create({ | |
init: function () { | |
var oa; | |
oa = { | |
_impl: { | |
value: new Z(), | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_shutdown: { | |
value: !1, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}; | |
Object.defineProperties(this, oa); | |
}, | |
setFilterFactory: function (oa) { | |
this._impl.setFilterFactory(oa); | |
}, | |
shutdown: function () { | |
this._shutdown = !0; | |
}, | |
receive: function (oa, ya, Ea, Ja, Da, Va) { | |
var Ha; | |
if (this._shutdown) throw new gb("MslControl is shutdown."); | |
Ha = new ca(this._impl, oa, ya, Ea, Ja, Da); | |
setTimeout(function () { | |
Ha.call(Va); | |
}, 0); | |
return da(Ha); | |
}, | |
respond: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
var ab; | |
if (this._shutdown) throw new gb("MslControl is shutdown."); | |
ab = new fa(this._impl, oa, ya, Ea, Ja, Da, Va); | |
setTimeout(function () { | |
ab.call(Ha); | |
}, 0); | |
return da(ab); | |
}, | |
error: function Ea(oa, ya, Ea, Ja, Da, Va, Ha) { | |
var ab; | |
if (this._shutdown) throw new gb("MslControl is shutdown."); | |
ab = new xa(this._impl, oa, ya, Ea, Ja, Da, Va); | |
setTimeout(function () { | |
ab.call(Ha); | |
}, 0); | |
return da(ab); | |
}, | |
request: function (oa, ya) { | |
var Ea, Ja, Da, Va, Ha, ab; | |
if (this._shutdown) throw new gb("MslControl is shutdown."); | |
if (5 == arguments.length) { | |
Ja = arguments[2]; | |
Da = Ea = null; | |
Va = arguments[3]; | |
Ha = arguments[4]; | |
if (oa.isPeerToPeer()) { | |
Ha.error( | |
new Bb("This method cannot be used in peer-to-peer mode.") | |
); | |
return; | |
} | |
} else if ( | |
6 == arguments.length && | |
((Ja = null), | |
(Ea = arguments[2]), | |
(Da = arguments[3]), | |
(Va = arguments[4]), | |
(Ha = arguments[5]), | |
!oa.isPeerToPeer()) | |
) { | |
Ha.error( | |
new Bb("This method cannot be used in trusted network mode.") | |
); | |
return; | |
} | |
ab = new Ma(this._impl, oa, ya, Ja, Ea, Da, null, 0, Va); | |
setTimeout(function () { | |
ab.call(Ha); | |
}, 0); | |
return da(ab); | |
}, | |
}); | |
ca = Hb.Class.create({ | |
init: function (oa, ya, Ea, Ja, Da, Va) { | |
Object.defineProperties(this, { | |
_ctrl: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_ctx: { value: ya, writable: !1, enumerable: !1, configurable: !1 }, | |
_msgCtx: { | |
value: Ea, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_input: { | |
value: Ja, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_output: { | |
value: Da, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: Va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_abortFunc: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
isAborted: function () { | |
return this._aborted; | |
}, | |
abort: function () { | |
this._aborted = !0; | |
this._abortFunc && this._abortFunc.call(this); | |
}, | |
setAbort: function (oa) { | |
this._abortFunc = oa; | |
}, | |
call: function (oa) { | |
var Da; | |
function ya(Va) { | |
eb( | |
oa, | |
function () { | |
var Ha; | |
Ha = Va.messageHeader; | |
if (!Ha) return Va; | |
this.setAbort(function () { | |
Va.abort(); | |
}); | |
Va.mark(Number.MAX_VALUE); | |
Va.read(1, Da._timeout, { | |
result: function (ab) { | |
eb( | |
oa, | |
function () { | |
if (ab && 0 == ab.length) return null; | |
if (ab) return Va.reset(), Va; | |
Ea(Va); | |
}, | |
Da | |
); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (ab) { | |
eb( | |
oa, | |
function () { | |
var db, Ya, mb; | |
if (W(ab)) return null; | |
db = Ha ? Ha.messageId : null; | |
if (ab instanceof Zb) { | |
Ya = T.MSL_COMMS_FAILURE; | |
mb = ab; | |
} else | |
(Ya = T.INTERNAL_EXCEPTION), | |
(mb = new Bb( | |
"Error peeking into the message payloads." | |
)); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
db, | |
Ya, | |
null, | |
this._output, | |
this._timeout, | |
{ | |
result: function (qb) { | |
oa.error(mb); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (qb) { | |
eb( | |
oa, | |
function () { | |
if (W(qb)) return null; | |
throw new kc( | |
"Error peeking into the message payloads.", | |
qb, | |
ab | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
}, | |
}); | |
}, | |
Da | |
); | |
} | |
function Ea(Va) { | |
eb( | |
oa, | |
function () { | |
Va.close(); | |
this._ctrl.buildResponse( | |
this, | |
this._ctx, | |
this._msgCtx, | |
Va.messageHeader, | |
this._timeout, | |
{ | |
result: function (Ha) { | |
eb( | |
oa, | |
function () { | |
var ab, db, Ya, mb, qb; | |
ab = Ha.builder; | |
db = Ha.tokenTicket; | |
Ya = Va.messageHeader; | |
mb = new Aa(this._msgCtx); | |
if ( | |
!this._ctx.isPeerToPeer() || | |
Ya.isEncrypting() || | |
Ya.keyResponseData | |
) | |
Ja(Ya, ab, mb, db); | |
else { | |
qb = new Ma( | |
this._ctrl, | |
this._ctx, | |
mb, | |
null, | |
this._input, | |
this._output, | |
Ha, | |
1, | |
this._timeout | |
); | |
this.setAbort(function () { | |
qb.abort(); | |
}); | |
qb.call(oa); | |
} | |
}, | |
Da | |
); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (Ha) { | |
eb( | |
oa, | |
function () { | |
var ab, db, Ya, mb; | |
if (W(Ha)) return null; | |
if (Ha instanceof gb) { | |
ab = Ha.messageId; | |
db = Ha.error; | |
Ya = Va.messageHeader.messageCapabilities; | |
Ya = this._ctrl.messageRegistry.getUserMessage( | |
db, | |
Ya ? Ya.languages : null | |
); | |
mb = Ha; | |
} else | |
(ab = requestHeader | |
? requestHeader.messageId | |
: null), | |
(db = T.INTERNAL_EXCEPTION), | |
(Ya = null), | |
(mb = new Bb( | |
"Error creating an automatic handshake response.", | |
Ha | |
)); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
ab, | |
db, | |
Ya, | |
this._output, | |
this._timeout, | |
{ | |
result: function (qb) { | |
oa.error(mb); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (qb) { | |
eb( | |
oa, | |
function () { | |
if (W(qb)) return null; | |
throw new kc( | |
"Error creating an automatic handshake response.", | |
qb, | |
Ha | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
} | |
function Ja(Va, Ha, ab, db) { | |
eb( | |
oa, | |
function () { | |
Ha.setRenewable(!1); | |
this._ctrl.send( | |
this._ctx, | |
ab, | |
this._output, | |
Ha, | |
this._timeout, | |
{ | |
result: function (Ya) { | |
eb( | |
oa, | |
function () { | |
this._ctx.isPeerToPeer() && | |
this._ctrl.releaseMasterToken(db); | |
return null; | |
}, | |
Da | |
); | |
}, | |
timeout: function () { | |
eb( | |
oa, | |
function () { | |
this._ctx.isPeerToPeer() && | |
this._ctrl.releaseMasterToken(db); | |
oa.timeout(); | |
}, | |
Da | |
); | |
}, | |
error: function (Ya) { | |
eb( | |
oa, | |
function () { | |
var mb, qb, sb, ub; | |
this._ctx.isPeerToPeer() && | |
this._ctrl.releaseMasterToken(db); | |
if (W(Ya)) return null; | |
if (Ya instanceof gb) { | |
mb = Ya.messageId; | |
qb = Ya.error; | |
sb = Va ? Va.messageCapabilities : null; | |
sb = this._ctrl.messageRegistry.getUserMessage( | |
qb, | |
sb ? sb.languages : null | |
); | |
ub = Ya; | |
} else | |
Ya instanceof Zb | |
? ((mb = Va ? Va.messageId : null), | |
(qb = T.MSL_COMMS_FAILURE), | |
(sb = null), | |
(ub = Ya)) | |
: ((mb = Va ? Va.messageId : null), | |
(qb = T.INTERNAL_EXCEPTION), | |
(sb = null), | |
(ub = new Bb( | |
"Error sending an automatic handshake response.", | |
Ya | |
))); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
mb, | |
qb, | |
sb, | |
this._output, | |
this._timeout, | |
{ | |
result: function (vb) { | |
oa.error(ub); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (vb) { | |
eb( | |
oa, | |
function () { | |
if (W(vb)) return null; | |
throw new kc( | |
"Error sending an automatic handshake response.", | |
vb, | |
Ya | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
} | |
Da = this; | |
eb( | |
oa, | |
function () { | |
this._ctrl.receive( | |
this, | |
this._ctx, | |
this._msgCtx, | |
this._input, | |
null, | |
this._timeout, | |
{ | |
result: function (Va) { | |
ya(Va); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (Va) { | |
eb( | |
oa, | |
function () { | |
var Ha, ab, db, Ya; | |
if (W(Va)) return null; | |
if (Va instanceof gb) { | |
Ha = Va.messageId; | |
ab = Va.error; | |
db = this._ctrl.messageRegistry.getUserMessage( | |
ab, | |
null | |
); | |
Ya = Va; | |
} else | |
(Ha = null), | |
(ab = T.INTERNAL_EXCEPTION), | |
(db = null), | |
(Ya = new Bb( | |
"Error receiving the message header.", | |
Va | |
)); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
Ha, | |
ab, | |
db, | |
this._output, | |
this._timeout, | |
{ | |
result: function (mb) { | |
oa.error(Ya); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (mb) { | |
eb( | |
oa, | |
function () { | |
if (W(mb)) return null; | |
throw new kc( | |
"Error receiving the message header.", | |
mb, | |
Va | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
}, | |
} | |
); | |
}, | |
Da | |
); | |
}, | |
}); | |
fa = Hb.Class.create({ | |
init: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
Object.defineProperties(this, { | |
_ctrl: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_ctx: { value: ya, writable: !1, enumerable: !1, configurable: !1 }, | |
_msgCtx: { | |
value: Ea, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_input: { | |
value: Ja, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_output: { | |
value: Da, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_request: { | |
value: Va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: Ha, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_abortFunc: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
isAborted: function () { | |
return this._aborted; | |
}, | |
abort: function () { | |
this._aborted = !0; | |
this._abortFunc && this._abortFunc.call(this); | |
}, | |
setAbort: function (oa) { | |
this._abortFunc = oa; | |
}, | |
trustedNetworkExecute: function (oa, ya, Ea) { | |
var Ja; | |
Ja = this; | |
eb( | |
Ea, | |
function () { | |
var Da, Va; | |
if (12 < ya + 1) return !1; | |
if ( | |
(Da = | |
this._msgCtx.isIntegrityProtected() && | |
!oa.willIntegrityProtectHeader() | |
? T.RESPONSE_REQUIRES_INTEGRITY_PROTECTION | |
: this._msgCtx.isEncrypted() && !oa.willEncryptPayloads() | |
? T.RESPONSE_REQUIRES_ENCRYPTION | |
: null) | |
) { | |
Va = Wc(oa.getMessageId()); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
Va, | |
Da, | |
null, | |
this._output, | |
this._timeout, | |
{ | |
result: function (Ha) { | |
Ea.result(!1); | |
}, | |
timeout: function () { | |
Ea.timeout(); | |
}, | |
error: function (Ha) { | |
eb( | |
Ea, | |
function () { | |
if (W(Ha)) return !1; | |
throw new kc( | |
"Response requires encryption or integrity protection but cannot be protected: " + | |
Da, | |
Ha, | |
null | |
); | |
}, | |
Ja | |
); | |
}, | |
} | |
); | |
} else | |
!this._msgCtx.getCustomer() || | |
oa.getMasterToken() || | |
oa.getKeyExchangeData() | |
? (oa.setRenewable(!1), | |
this._ctrl.send( | |
this._ctx, | |
this._msgCtx, | |
this._output, | |
oa, | |
this._timeout, | |
{ | |
result: function (Ha) { | |
Ea.result(!0); | |
}, | |
timeout: function () { | |
Ea.timeout(); | |
}, | |
error: function (Ha) { | |
Ea.error(Ha); | |
}, | |
} | |
)) | |
: ((Va = Wc(oa.getMessageId())), | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
Va, | |
T.RESPONSE_REQUIRES_MASTERTOKEN, | |
null, | |
this._output, | |
this._timeout, | |
{ | |
result: function (Ha) { | |
Ea.result(!1); | |
}, | |
timeout: function () { | |
Ea.timeout(); | |
}, | |
error: function (Ha) { | |
eb( | |
Ea, | |
function () { | |
if (W(Ha)) return !1; | |
throw new kc( | |
"Response wishes to attach a user ID token but there is no master token.", | |
Ha, | |
null | |
); | |
}, | |
Ja | |
); | |
}, | |
} | |
)); | |
}, | |
Ja | |
); | |
}, | |
peerToPeerExecute: function (oa, ya, Ea, Ja) { | |
var Va; | |
function Da(Ha) { | |
eb( | |
Ja, | |
function () { | |
var ab; | |
ab = Ha.response; | |
ab.close(); | |
ab = ab.getErrorHeader(); | |
this._ctrl.cleanupContext(this._ctx, Ha.requestHeader, ab); | |
this._ctrl.buildErrorResponse(this, this._ctx, oa, Ha, ab, { | |
result: function (db) { | |
eb( | |
Ja, | |
function () { | |
var Ya, mb; | |
if (!db) return !1; | |
Ya = db.errorResult; | |
mb = db.tokenTicket; | |
this.peerToPeerExecute(Ya.msgCtx, Ya.builder, Ea, { | |
result: function (qb) { | |
eb( | |
Ja, | |
function () { | |
this._ctrl.releaseMasterToken(mb); | |
return qb; | |
}, | |
Va | |
); | |
}, | |
timeout: function () { | |
eb( | |
Ja, | |
function () { | |
this._ctrl.releaseMasterToken(mb); | |
Ja.timeout(); | |
}, | |
Va | |
); | |
}, | |
error: function (qb) { | |
eb( | |
Ja, | |
function () { | |
this._ctrl.releaseMasterToken(mb); | |
throw qb; | |
}, | |
Va | |
); | |
}, | |
}); | |
}, | |
Va | |
); | |
}, | |
}); | |
}, | |
Va | |
); | |
} | |
Va = this; | |
eb( | |
Ja, | |
function () { | |
var Ha; | |
if (12 < Ea + 2) return !1; | |
if ( | |
null != oa.getCustomer() && | |
null == ya.getPeerMasterToken() && | |
null == ya.getKeyExchangeData() | |
) { | |
Ha = Wc(ya.getMessageId()); | |
ha( | |
this, | |
this._ctx, | |
oa.getDebugContext(), | |
Ha, | |
T.RESPONSE_REQUIRES_MASTERTOKEN, | |
null, | |
this._output, | |
this._timeout, | |
{ | |
result: function (ab) { | |
Ja.result(!1); | |
}, | |
timeout: function () { | |
Ja.timeout(); | |
}, | |
error: function (ab) { | |
eb( | |
Ja, | |
function () { | |
if (W(ab)) return !1; | |
throw new kc( | |
"Response wishes to attach a user ID token but there is no master token.", | |
ab, | |
null | |
); | |
}, | |
Va | |
); | |
}, | |
} | |
); | |
} else | |
this._ctrl.sendReceive( | |
this._ctx, | |
oa, | |
this._input, | |
this._output, | |
ya, | |
this._timeout, | |
!1, | |
{ | |
result: function (ab) { | |
eb( | |
Ja, | |
function () { | |
var mb, qb, sb; | |
function db() { | |
mb.read(32768, Va._timeout, { | |
result: function (ub) { | |
eb( | |
Ja, | |
function () { | |
ub ? db() : Ya(); | |
}, | |
Va | |
); | |
}, | |
timeout: function () { | |
Ja.timeout(); | |
}, | |
error: function (ub) { | |
Ja.error(ub); | |
}, | |
}); | |
} | |
function Ya() { | |
eb( | |
Ja, | |
function () { | |
var ub; | |
ub = new qa(ab.payloads, oa); | |
this._ctrl.buildResponse( | |
this, | |
this._ctx, | |
ub, | |
qb, | |
this._timeout, | |
{ | |
result: function (vb) { | |
eb( | |
Ja, | |
function () { | |
var Eb; | |
Eb = vb.tokenTicket; | |
this.peerToPeerExecute( | |
ub, | |
vb.builder, | |
Ea, | |
{ | |
result: function (Db) { | |
eb( | |
Ja, | |
function () { | |
this._ctrl.releaseMasterToken( | |
Eb | |
); | |
return Db; | |
}, | |
Va | |
); | |
}, | |
timeout: function () { | |
eb( | |
Ja, | |
function () { | |
this._ctrl.releaseMasterToken( | |
Eb | |
); | |
Ja.timeout(); | |
}, | |
Va | |
); | |
}, | |
error: function (Db) { | |
eb( | |
Ja, | |
function () { | |
this._ctrl.releaseMasterToken( | |
Eb | |
); | |
throw Db; | |
}, | |
Va | |
); | |
}, | |
} | |
); | |
}, | |
Va | |
); | |
}, | |
timeout: function () { | |
Ja.timeout(); | |
}, | |
error: function (vb) { | |
Ja.error(vb); | |
}, | |
} | |
); | |
}, | |
Va | |
); | |
} | |
mb = ab.response; | |
Ea += 2; | |
if (!mb) return !0; | |
qb = mb.getMessageHeader(); | |
if (qb) { | |
sb = ab.payloads; | |
sb = 0 < sb.length && 0 < sb[0].data.length; | |
if (ab.handshake && sb) db(); | |
else return !0; | |
} else Da(ab); | |
}, | |
Va | |
); | |
}, | |
timeout: function () { | |
Ja.timeout(); | |
}, | |
error: function (ab) { | |
Ja.error(ab); | |
}, | |
} | |
); | |
}, | |
Va | |
); | |
}, | |
call: function (oa) { | |
var ya; | |
ya = this; | |
this._ctrl.buildResponse( | |
this, | |
this._ctx, | |
this._msgCtx, | |
this._request, | |
this._timeout, | |
{ | |
result: function (Ea) { | |
eb( | |
oa, | |
function () { | |
var Ja, Da; | |
Ja = Ea.builder; | |
Da = Ea.tokenTicket; | |
this._ctx.isPeerToPeer() | |
? this.peerToPeerExecute(this._msgCtx, Ja, 3, { | |
result: function (Va) { | |
eb( | |
oa, | |
function () { | |
this._ctx.isPeerToPeer() && | |
this.releaseMasterToken(Da); | |
return Va; | |
}, | |
ya | |
); | |
}, | |
timeout: function () { | |
eb( | |
oa, | |
function () { | |
this._ctx.isPeerToPeer() && | |
this.releaseMasterToken(Da); | |
oa.timeout(); | |
}, | |
ya | |
); | |
}, | |
error: function (Va) { | |
eb( | |
oa, | |
function () { | |
var Ha, ab, db, Ya; | |
this._ctx.isPeerToPeer() && | |
this.releaseMasterToken(Da); | |
if (W(Va)) return !1; | |
Ha = Wc(Ja.getMessageId()); | |
if (Va instanceof gb) { | |
ab = Va.error; | |
db = this._request.messageCapabilities; | |
db = | |
this._ctrl.messageRegistry.getUserMessage( | |
ab, | |
db ? db.languages : null | |
); | |
Ya = Va; | |
} else | |
Va instanceof Zb | |
? ((ab = T.MSL_COMMS_FAILURE), | |
(db = null), | |
(Ya = Va)) | |
: ((ab = T.INTERNAL_EXCEPTION), | |
(db = null), | |
(Ya = new Bb( | |
"Error sending the response.", | |
Va | |
))); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
Ha, | |
ab, | |
db, | |
this._output, | |
this._timeout, | |
{ | |
result: function (mb) { | |
oa.error(Ya); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (mb) { | |
eb( | |
oa, | |
function () { | |
if (W(mb)) return !1; | |
throw new kc( | |
"Error sending the response.", | |
mb, | |
null | |
); | |
}, | |
ya | |
); | |
}, | |
} | |
); | |
}, | |
ya | |
); | |
}, | |
}) | |
: this.trustedNetworkExecute(Ja, 3, { | |
result: function (Va) { | |
eb( | |
oa, | |
function () { | |
this._ctx.isPeerToPeer() && | |
this.releaseMasterToken(Da); | |
return Va; | |
}, | |
ya | |
); | |
}, | |
timeout: function () { | |
eb( | |
oa, | |
function () { | |
this._ctx.isPeerToPeer() && | |
this.releaseMasterToken(Da); | |
oa.timeout(); | |
}, | |
ya | |
); | |
}, | |
error: function (Va) { | |
eb( | |
oa, | |
function () { | |
var Ha, ab, db, Ya; | |
this._ctx.isPeerToPeer() && | |
this.releaseMasterToken(Da); | |
if (W(Va)) return !1; | |
Ha = Wc(Ja.getMessageId()); | |
if (Va instanceof gb) { | |
ab = Va.error; | |
db = this._request.messageCapabilities; | |
db = | |
this._ctrl.messageRegistry.getUserMessage( | |
ab, | |
db ? db.languages : null | |
); | |
Ya = Va; | |
} else | |
Va instanceof Zb | |
? ((ab = T.MSL_COMMS_FAILURE), | |
(db = null), | |
(Ya = Va)) | |
: ((ab = T.INTERNAL_EXCEPTION), | |
(db = null), | |
(Ya = new Bb( | |
"Error sending the response.", | |
Va | |
))); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
Ha, | |
ab, | |
db, | |
this._output, | |
this._timeout, | |
{ | |
result: function (mb) { | |
oa.error(Ya); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (mb) { | |
eb( | |
oa, | |
function () { | |
if (W(mb)) return !1; | |
throw new kc( | |
"Error sending the response.", | |
mb, | |
null | |
); | |
}, | |
ya | |
); | |
}, | |
} | |
); | |
}, | |
ya | |
); | |
}, | |
}); | |
}, | |
ya | |
); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (Ea) { | |
eb( | |
oa, | |
function () { | |
var Ja, Da, Va, Ha; | |
if (W(Ea)) return !1; | |
if (Ea instanceof gb) { | |
Ja = Ea.messageId; | |
Da = Ea.error; | |
Va = this._request.messageCapabilities; | |
Va = this._ctrl.messageRegistry.getUserMessage( | |
Da, | |
Va ? Va.languages : null | |
); | |
Ha = Ea; | |
} else | |
(Ja = null), | |
(Da = T.INTERNAL_EXCEPTION), | |
(Va = null), | |
(Ha = new Bb("Error building the response.", Ea)); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
Ja, | |
Da, | |
Va, | |
this._output, | |
this._timeout, | |
{ | |
result: function (ab) { | |
oa.error(Ha); | |
}, | |
timeout: function () { | |
oa.timeout(); | |
}, | |
error: function (ab) { | |
eb( | |
oa, | |
function () { | |
if (W(ab)) return null; | |
throw new kc( | |
"Error building the response.", | |
ab, | |
Ea | |
); | |
}, | |
ya | |
); | |
}, | |
} | |
); | |
}, | |
ya | |
); | |
}, | |
} | |
); | |
}, | |
}); | |
xa = Hb.Class.create({ | |
init: function (oa, ya, Ea, Ja, Da, Va, Ha) { | |
Object.defineProperties(this, { | |
_ctrl: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_ctx: { value: ya, writable: !1, enumerable: !1, configurable: !1 }, | |
_msgCtx: { | |
value: Ea, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_appError: { | |
value: Ja, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_output: { | |
value: output, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_request: { | |
value: Va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: Ha, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_abortFunc: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
isAborted: function () { | |
return this._aborted; | |
}, | |
abort: function () { | |
this._aborted = !0; | |
this._abortFunc && this._abortFunc.call(this); | |
}, | |
setAbort: function (oa) { | |
this._abortFunc = oa; | |
}, | |
call: function (oa) { | |
var ya; | |
ya = this; | |
eb( | |
oa, | |
function () { | |
var Ea, Ja; | |
if (this._appError == ENTITY_REJECTED) | |
Ea = this._request.masterToken | |
? T.MASTERTOKEN_REJECTED_BY_APP | |
: T.ENTITY_REJECTED_BY_APP; | |
else if (this._appError == USER_REJECTED) | |
Ea = this._request.userIdToken | |
? T.USERIDTOKEN_REJECTED_BY_APP | |
: T.USER_REJECTED_BY_APP; | |
else | |
throw new Bb( | |
"Unhandled application error " + this._appError + "." | |
); | |
Ja = this._request.messageCapabilities; | |
Ja = this._ctrl.messageRegistry.getUserMessage( | |
Ea, | |
Ja ? Ja.languages : null | |
); | |
ha( | |
this, | |
this._ctx, | |
this._msgCtx.getDebugContext(), | |
this._request.messageId, | |
Ea, | |
Ja, | |
this._output, | |
this._timeout, | |
{ | |
result: function (Da) { | |
oa.result(Da); | |
}, | |
timeout: oa.timeout, | |
error: function (Da) { | |
eb( | |
oa, | |
function () { | |
if (W(Da)) return !1; | |
if (Da instanceof gb) throw Da; | |
throw new Bb("Error building the error response.", Da); | |
}, | |
ya | |
); | |
}, | |
} | |
); | |
}, | |
ya | |
); | |
}, | |
}); | |
Sa = { | |
result: function () {}, | |
timeout: function () {}, | |
error: function () {}, | |
}; | |
Ma = Hb.Class.create({ | |
init: function (oa, ya, Ea, Ja, Da, Va, Ha, ab, db) { | |
var Ya; | |
if (Ha) { | |
Ya = Ha.builder; | |
Ha = Ha.tokenTicket; | |
} else Ha = Ya = null; | |
Object.defineProperties(this, { | |
_ctrl: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_ctx: { value: ya, writable: !1, enumerable: !1, configurable: !1 }, | |
_msgCtx: { | |
value: Ea, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_remoteEntity: { | |
value: Ja, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_input: { | |
value: Da, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_output: { | |
value: Va, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_openedStreams: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_builder: { | |
value: Ya, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_tokenTicket: { | |
value: Ha, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_timeout: { | |
value: db, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_msgCount: { | |
value: ab, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_aborted: { | |
value: !1, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_abortFunc: { | |
value: Gb, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
isAborted: function () { | |
return this._aborted; | |
}, | |
abort: function () { | |
this._aborted = !0; | |
this._abortFunc && this._abortFunc.call(this); | |
}, | |
setAbort: function (oa) { | |
this._abortFunc = oa; | |
}, | |
execute: function (oa, ya, Ea, Ja, Da) { | |
var ab; | |
function Va(db) { | |
function Ya(mb) { | |
eb( | |
Da, | |
function () { | |
var qb; | |
qb = db.response; | |
return mb ? mb : qb; | |
}, | |
ab | |
); | |
} | |
eb( | |
Da, | |
function () { | |
var mb, qb; | |
mb = db.response; | |
mb.close(); | |
qb = mb.getErrorHeader(); | |
this._ctrl.cleanupContext(this._ctx, db.requestHeader, qb); | |
this._ctrl.buildErrorResponse(this, this._ctx, oa, db, qb, Ea, { | |
result: function (sb) { | |
eb( | |
Da, | |
function () { | |
var ub, vb, Eb, Db; | |
if (!sb) return mb; | |
ub = sb.errorResult; | |
vb = sb.tokenTicket; | |
Eb = ub.builder; | |
ub = ub.msgCtx; | |
if (this._ctx.isPeerToPeer()) | |
this.execute(ub, Eb, this._timeout, Ja, { | |
result: function (pa) { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(vb); | |
Ya(pa); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(vb); | |
Da.timeout(); | |
}, | |
ab | |
); | |
}, | |
error: function (pa) { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(vb); | |
Da.error(pa); | |
}, | |
ab | |
); | |
}, | |
}); | |
else { | |
this._openedStreams && | |
(this._input.close(), this._output.close(Ea, Sa)); | |
Db = new Ma( | |
this._ctrl, | |
this._ctx, | |
ub, | |
this._remoteEntity, | |
null, | |
null, | |
{ builder: Eb, tokenTicket: vb }, | |
Ja, | |
this._timeout | |
); | |
this.setAbort(function () { | |
Db.abort(); | |
}); | |
Db.call({ | |
result: function (pa) { | |
Ya(pa); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (pa) { | |
Da.error(pa); | |
}, | |
}); | |
} | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (sb) { | |
Da.error(sb); | |
}, | |
}); | |
}, | |
ab | |
); | |
} | |
function Ha(db) { | |
eb( | |
Da, | |
function () { | |
var qb, sb, ub, vb, Eb; | |
function Ya() { | |
qb.read(32768, ab._timeout, { | |
result: function (Db) { | |
Db ? Ya() : mb(); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (Db) { | |
Da.error(Db); | |
}, | |
}); | |
} | |
function mb() { | |
eb( | |
Da, | |
function () { | |
var Db; | |
Db = new qa(db.payloads, oa); | |
this._ctrl.buildResponse(this, this._ctx, oa, sb, Ea, { | |
result: function (pa) { | |
eb( | |
Da, | |
function () { | |
var Fa; | |
Fa = pa.tokenTicket; | |
this.execute(Db, pa.builder, this._timeout, Ja, { | |
result: function (Pa) { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(Fa); | |
return Pa; | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(Fa); | |
Da.timeout(); | |
}, | |
ab | |
); | |
}, | |
error: function (Pa) { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(Fa); | |
throw Pa; | |
}, | |
ab | |
); | |
}, | |
}); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (pa) { | |
Da.error(pa); | |
}, | |
}); | |
}, | |
ab | |
); | |
} | |
qb = db.response; | |
sb = qb.getMessageHeader(); | |
ub = db.payloads; | |
ub = 0 < ub.length && 0 < ub[0].data.length; | |
if (!this._ctx.isPeerToPeer()) { | |
if (!db.handshake || !ub) return qb; | |
this._openedStreams && | |
(this._input.close(), this._output.close(Ea, Sa)); | |
vb = new qa(db.payloads, oa); | |
this._ctrl.buildResponse(this, this._ctx, oa, sb, Ea, { | |
result: function (Db) { | |
eb( | |
Da, | |
function () { | |
var pa; | |
pa = new Ma( | |
this._ctrl, | |
this._ctx, | |
vb, | |
this._remoteEntity, | |
null, | |
null, | |
Db, | |
Ja, | |
this._timeout | |
); | |
this.setAbort(function () { | |
pa.abort(); | |
}); | |
pa.call(Da); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (Db) { | |
Da.error(Db); | |
}, | |
}); | |
} else if (db.handshake && ub) Ya(); | |
else if (0 < sb.keyRequestData.length) { | |
Eb = new Aa(oa); | |
this._ctrl.buildResponse(this, this._ctx, Eb, sb, Ea, { | |
result: function (Db) { | |
eb( | |
Da, | |
function () { | |
var pa, Fa; | |
pa = Db.builder; | |
Fa = Db.tokenTicket; | |
qb.mark(); | |
qb.read(1, this._timeout, { | |
result: function (Pa) { | |
eb( | |
Da, | |
function () { | |
function r() { | |
qb.read(32768, ab._timeout, { | |
result: function (a) { | |
a ? r() : b(); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (a) { | |
Da.error(a); | |
}, | |
}); | |
} | |
function b() { | |
ab.execute(Eb, pa, ab._timeout, Ja, { | |
result: function (a) { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(Fa); | |
return a; | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(Fa); | |
Da.timeout(); | |
}, | |
ab | |
); | |
}, | |
error: function (a) { | |
eb( | |
Da, | |
function () { | |
this._ctrl.releaseMasterToken(Fa); | |
throw a; | |
}, | |
ab | |
); | |
}, | |
}); | |
} | |
if (Pa) { | |
if ((qb.reset(), 12 >= Ja + 1)) | |
pa.setRenewable(!1), | |
this._ctrl.send( | |
this, | |
this._ctx, | |
Eb, | |
this._output, | |
pa, | |
this._timeout, | |
{ | |
result: function (a) { | |
eb( | |
Da, | |
function () { | |
this.releaseMasterToken(Fa); | |
return qb; | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (a) { | |
Da.error(a); | |
}, | |
} | |
); | |
else return this.releaseMasterToken(Fa), qb; | |
} else r(); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
eb( | |
Da, | |
function () { | |
this.releaseMasterToken(Fa); | |
Da.timeout(); | |
}, | |
ab | |
); | |
}, | |
error: function (Pa) { | |
eb( | |
Da, | |
function () { | |
this.releaseMasterToken(Fa); | |
throw Pa; | |
}, | |
ab | |
); | |
}, | |
}); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (Db) { | |
Da.error(Db); | |
}, | |
}); | |
} | |
}, | |
ab | |
); | |
} | |
ab = this; | |
eb( | |
Da, | |
function () { | |
if (12 < Ja + 2) return null; | |
this._ctrl.sendReceive( | |
this, | |
this._ctx, | |
oa, | |
this._input, | |
this._output, | |
ya, | |
Ea, | |
!0, | |
{ | |
result: function (db) { | |
eb( | |
Da, | |
function () { | |
var Ya; | |
if (!db) return null; | |
Ya = db.response; | |
Ja += 2; | |
Ya.getMessageHeader() ? Ha(db) : Va(db); | |
}, | |
ab | |
); | |
}, | |
timeout: function () { | |
Da.timeout(); | |
}, | |
error: function (db) { | |
Da.error(db); | |
}, | |
} | |
); | |
}, | |
ab | |
); | |
}, | |
call: function (oa) { | |
var Ea; | |
function ya(Ja, Da, Va) { | |
eb( | |
oa, | |
function () { | |
this.execute(this._msgCtx, Ja, Va, this._msgCount, { | |
result: function (Ha) { | |
eb( | |
oa, | |
function () { | |
this._ctrl.releaseMasterToken(Da); | |
this._openedStreams && this._output.close(Va, Sa); | |
Ha && Ha.closeSource(this._openedStreams); | |
return Ha; | |
}, | |
Ea | |
); | |
}, | |
timeout: function () { | |
eb( | |
oa, | |
function () { | |
this._ctrl.releaseMasterToken(Da); | |
this._openedStreams && | |
(this._output.close(Va, Sa), this._input.close()); | |
oa.timeout(); | |
}, | |
Ea | |
); | |
}, | |
error: function (Ha) { | |
eb( | |
oa, | |
function () { | |
this._ctrl.releaseMasterToken(Da); | |
this._openedStreams && | |
(this._output.close(Va, Sa), this._input.close()); | |
if (W(Ha)) return null; | |
throw Ha; | |
}, | |
Ea | |
); | |
}, | |
}); | |
}, | |
Ea | |
); | |
} | |
Ea = this; | |
eb( | |
oa, | |
function () { | |
var Ja, Da, Va; | |
Ja = this._timeout; | |
if (!this._input || !this._output) | |
try { | |
this._remoteEntity.setTimeout(this._timeout); | |
Da = Date.now(); | |
Va = this._remoteEntity.openConnection(); | |
this._output = Va.output; | |
this._input = Va.input; | |
-1 != Ja && (Ja = this._timeout - (Date.now() - Da)); | |
this._openedStreams = !0; | |
} catch (Ha) { | |
this._builder && | |
this._ctrl.releaseMasterToken(this._tokenTicket); | |
this._output && this._output.close(this._timeout, Sa); | |
this._input && this._input.close(); | |
if (W(Ha)) return null; | |
throw Ha; | |
} | |
this._builder | |
? ya(this._builder, this._tokenTicket, Ja) | |
: this._ctrl.buildRequest( | |
this, | |
this._ctx, | |
this._msgCtx, | |
this._timeout, | |
{ | |
result: function (Ha) { | |
eb( | |
oa, | |
function () { | |
ya(Ha.builder, Ha.tokenTicket, Ja); | |
}, | |
Ea | |
); | |
}, | |
timeout: function () { | |
eb( | |
oa, | |
function () { | |
this._openedStreams && | |
(this._output.close(this._timeout, Sa), | |
this._input.close()); | |
oa.timeout(); | |
}, | |
Ea | |
); | |
}, | |
error: function (Ha) { | |
eb( | |
oa, | |
function () { | |
this._openedStreams && | |
(this._output.close(this._timeout, Sa), | |
this._input.close()); | |
if (W(Ha)) return null; | |
throw Ha; | |
}, | |
Ea | |
); | |
}, | |
} | |
); | |
}, | |
Ea | |
); | |
}, | |
}); | |
})(); | |
(function () { | |
Xd = Hb.Class.create({ | |
init: function (da) { | |
Object.defineProperties(this, { | |
id: { value: da, writable: !1, configurable: !1 }, | |
}); | |
}, | |
toJSON: function () { | |
var da; | |
da = {}; | |
da.id = this.id; | |
return da; | |
}, | |
equals: function (da) { | |
return this === da ? !0 : da instanceof Xd ? this.id == da.id : !1; | |
}, | |
uniqueKey: function () { | |
return this.id; | |
}, | |
}); | |
af = function (da) { | |
var X; | |
X = da.id; | |
if (!X) throw new Jb(T.JSON_PARSE_ERROR, JSON.stringify(da)); | |
return new Xd(X); | |
}; | |
})(); | |
Hb.Class.create({ | |
isNewestMasterToken: function (da, X, U) {}, | |
isMasterTokenRevoked: function (da, X) {}, | |
acceptNonReplayableId: function (da, X, U, V) {}, | |
createMasterToken: function (da, X, U, V, aa) {}, | |
isMasterTokenRenewable: function (da, X, U) {}, | |
renewMasterToken: function (da, X, U, V, aa) {}, | |
isUserIdTokenRevoked: function (da, X, U, V) {}, | |
createUserIdToken: function (da, X, U, V) {}, | |
renewUserIdToken: function (da, X, U, V) {}, | |
}); | |
(function () { | |
function da(X, U, V, aa) { | |
this.sessiondata = X; | |
this.tokendata = U; | |
this.signature = V; | |
this.verified = aa; | |
} | |
jc = Hb.Class.create({ | |
init: function (X, U, V, aa, W, ha, va, ra, ia, qa, Aa) { | |
var ka; | |
ka = this; | |
Na( | |
Aa, | |
function () { | |
var Z, ca, fa, xa, Sa; | |
if (V.getTime() < U.getTime()) | |
throw new Bb( | |
"Cannot construct a master token that expires before its renewal window opens." | |
); | |
if (0 > aa || aa > Rb) | |
throw new Bb( | |
"Sequence number " + aa + " is outside the valid range." | |
); | |
if (0 > W || W > Rb) | |
throw new Bb( | |
"Serial number " + W + " is outside the valid range." | |
); | |
Z = Math.floor(U.getTime() / 1e3); | |
ca = Math.floor(V.getTime() / 1e3); | |
if (qa) fa = qa.sessiondata; | |
else { | |
xa = {}; | |
ha && (xa.issuerdata = ha); | |
xa.identity = va; | |
xa.encryptionkey = Kb(ra.toByteArray()); | |
xa.hmackey = Kb(ia.toByteArray()); | |
fa = fc(JSON.stringify(xa), Tb); | |
} | |
if (qa) | |
return ( | |
Object.defineProperties(this, { | |
ctx: { | |
value: X, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
renewalWindowSeconds: { | |
value: Z, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
expirationSeconds: { | |
value: ca, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
sequenceNumber: { | |
value: aa, | |
writable: !1, | |
configurable: !1, | |
}, | |
serialNumber: { value: W, writable: !1, configurable: !1 }, | |
issuerData: { value: ha, writable: !1, configurable: !1 }, | |
identity: { value: va, writable: !1, configurable: !1 }, | |
encryptionKey: { | |
value: ra, | |
writable: !1, | |
configurable: !1, | |
}, | |
hmacKey: { value: ia, writable: !1, configurable: !1 }, | |
sessiondata: { | |
value: fa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
verified: { | |
value: qa.verified, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: qa.tokendata, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: qa.signature, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}), | |
this | |
); | |
Sa = X.getMslCryptoContext(); | |
Sa.encrypt(fa, { | |
result: function (Ma) { | |
Na( | |
Aa, | |
function () { | |
var Ra, Xa; | |
Ra = {}; | |
Ra.renewalwindow = Z; | |
Ra.expiration = ca; | |
Ra.sequencenumber = aa; | |
Ra.serialnumber = W; | |
Ra.sessiondata = Kb(Ma); | |
Xa = fc(JSON.stringify(Ra), Tb); | |
Sa.sign(Xa, { | |
result: function (oa) { | |
Na( | |
Aa, | |
function () { | |
Object.defineProperties(this, { | |
ctx: { | |
value: X, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
renewalWindowSeconds: { | |
value: Z, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
expirationSeconds: { | |
value: ca, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
sequenceNumber: { | |
value: aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
serialNumber: { | |
value: W, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
issuerData: { | |
value: ha, | |
writable: !1, | |
configurable: !1, | |
}, | |
identity: { | |
value: va, | |
writable: !1, | |
configurable: !1, | |
}, | |
encryptionKey: { | |
value: ra, | |
writable: !1, | |
configurable: !1, | |
}, | |
hmacKey: { | |
value: ia, | |
writable: !1, | |
configurable: !1, | |
}, | |
sessiondata: { | |
value: fa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
verified: { | |
value: !0, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: Xa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
}, | |
ka | |
); | |
}, | |
error: function (oa) { | |
Aa.error(oa); | |
}, | |
}); | |
}, | |
ka | |
); | |
}, | |
error: function (Ma) { | |
Aa.error(Ma); | |
}, | |
}); | |
}, | |
this | |
); | |
}, | |
get renewalWindow() { | |
return new Date(1e3 * this.renewalWindowSeconds); | |
}, | |
get expiration() { | |
return new Date(1e3 * this.expirationSeconds); | |
}, | |
isDecrypted: function () { | |
return this.sessiondata ? !0 : !1; | |
}, | |
isVerified: function () { | |
return this.verified; | |
}, | |
isRenewable: function (X) { | |
return this.isVerified() | |
? this.renewalWindow.getTime() <= this.ctx.getTime() | |
: !0; | |
}, | |
isExpired: function (X) { | |
return this.isVerified() | |
? this.expiration.getTime() <= this.ctx.getTime() | |
: !1; | |
}, | |
isNewerThan: function (X) { | |
var U; | |
if (this.sequenceNumber == X.sequenceNumber) | |
return this.expiration > X.expiration; | |
if (this.sequenceNumber > X.sequenceNumber) { | |
U = this.sequenceNumber - Rb + 127; | |
return X.sequenceNumber >= U; | |
} | |
U = X.sequenceNumber - Rb + 127; | |
return this.sequenceNumber < U; | |
}, | |
toJSON: function () { | |
var X; | |
X = {}; | |
X.tokendata = Kb(this.tokendata); | |
X.signature = Kb(this.signature); | |
return X; | |
}, | |
equals: function (X) { | |
return this === X | |
? !0 | |
: X instanceof jc | |
? this.serialNumber == X.serialNumber && | |
this.sequenceNumber == X.sequenceNumber && | |
this.expiration.getTime() == X.expiration.getTime() | |
: !1; | |
}, | |
uniqueKey: function () { | |
return ( | |
this.serialNumber + | |
":" + | |
this.sequenceNumber + | |
this.expiration.getTime() | |
); | |
}, | |
}); | |
ed = function (X, U, V) { | |
Na(V, function () { | |
var aa, W, ha, va, ra; | |
aa = X.getMslCryptoContext(); | |
W = U.tokendata; | |
ha = U.signature; | |
if ("string" !== typeof W || "string" !== typeof ha) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"mastertoken " + JSON.stringify(U) | |
); | |
try { | |
va = Mb(W); | |
} catch (ia) { | |
throw new gb( | |
T.MASTERTOKEN_TOKENDATA_INVALID, | |
"mastertoken " + JSON.stringify(U), | |
ia | |
); | |
} | |
if (!va || 0 == va.length) | |
throw new Jb( | |
T.MASTERTOKEN_TOKENDATA_MISSING, | |
"mastertoken " + JSON.stringify(U) | |
); | |
try { | |
ra = Mb(ha); | |
} catch (ia) { | |
throw new gb( | |
T.MASTERTOKEN_SIGNATURE_INVALID, | |
"mastertoken " + JSON.stringify(U), | |
ia | |
); | |
} | |
aa.verify(va, ra, { | |
result: function (ia) { | |
Na(V, function () { | |
var qa, Aa, ka, Z, ca, fa, xa, Sa, Ma, Ra; | |
qa = ec(va, Tb); | |
try { | |
Aa = JSON.parse(qa); | |
ka = parseInt(Aa.renewalwindow); | |
Z = parseInt(Aa.expiration); | |
ca = parseInt(Aa.sequencenumber); | |
fa = parseInt(Aa.serialnumber); | |
xa = Aa.sessiondata; | |
} catch (Xa) { | |
if (Xa instanceof SyntaxError) | |
throw new Jb( | |
T.MASTERTOKEN_TOKENDATA_PARSE_ERROR, | |
"mastertokendata " + qa, | |
Xa | |
); | |
throw Xa; | |
} | |
if ( | |
!ka || | |
ka != ka || | |
!Z || | |
Z != Z || | |
"number" !== typeof ca || | |
ca != ca || | |
"number" !== typeof fa || | |
fa != fa || | |
"string" !== typeof xa | |
) | |
throw new Jb( | |
T.MASTERTOKEN_TOKENDATA_PARSE_ERROR, | |
"mastertokendata " + qa | |
); | |
if (Z < ka) | |
throw new gb( | |
T.MASTERTOKEN_EXPIRES_BEFORE_RENEWAL, | |
"mastertokendata " + qa | |
); | |
if (0 > ca || ca > Rb) | |
throw new gb( | |
T.MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE, | |
"mastertokendata " + qa | |
); | |
if (0 > fa || fa > Rb) | |
throw new gb( | |
T.MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, | |
"mastertokendata " + qa | |
); | |
Sa = new Date(1e3 * ka); | |
Ma = new Date(1e3 * Z); | |
try { | |
Ra = Mb(xa); | |
} catch (Xa) { | |
throw new gb(T.MASTERTOKEN_SESSIONDATA_INVALID, xa, Xa); | |
} | |
if (!Ra || 0 == Ra.length) | |
throw new gb(T.MASTERTOKEN_SESSIONDATA_MISSING, xa); | |
ia | |
? aa.decrypt(Ra, { | |
result: function (Xa) { | |
Na(V, function () { | |
var oa, ya, Ea, Ja, Da, Va; | |
oa = ec(Xa, Tb); | |
try { | |
ya = JSON.parse(oa); | |
Ea = ya.issuerdata; | |
Ja = ya.identity; | |
Da = ya.encryptionkey; | |
Va = ya.hmackey; | |
} catch (Ha) { | |
if (Ha instanceof SyntaxError) | |
throw new Jb( | |
T.MASTERTOKEN_SESSIONDATA_PARSE_ERROR, | |
"sessiondata " + oa, | |
Ha | |
); | |
throw Ha; | |
} | |
if ( | |
(Ea && "object" !== typeof Ea) || | |
!Ja || | |
"string" !== typeof Da || | |
"string" !== typeof Va | |
) | |
throw new Jb( | |
T.MASTERTOKEN_SESSIONDATA_PARSE_ERROR, | |
"sessiondata " + oa | |
); | |
tc(Da, oc, Dc, { | |
result: function (Ha) { | |
tc(Va, pc, Mc, { | |
result: function (ab) { | |
Na(V, function () { | |
var db; | |
db = new da(Xa, va, ra, ia); | |
new jc( | |
X, | |
Sa, | |
Ma, | |
ca, | |
fa, | |
Ea, | |
Ja, | |
Ha, | |
ab, | |
db, | |
V | |
); | |
}); | |
}, | |
error: function (ab) { | |
V.error( | |
new yb(T.MASTERTOKEN_KEY_CREATION_ERROR, ab) | |
); | |
}, | |
}); | |
}, | |
error: function (Ha) { | |
V.error( | |
new yb(T.MASTERTOKEN_KEY_CREATION_ERROR, Ha) | |
); | |
}, | |
}); | |
}); | |
}, | |
error: function (Xa) { | |
V.error(Xa); | |
}, | |
}) | |
: ((ka = new da(null, va, ra, ia)), | |
new jc(X, Sa, Ma, ca, fa, null, null, null, null, ka, V)); | |
}); | |
}, | |
error: function (ia) { | |
V.error(ia); | |
}, | |
}); | |
}); | |
}; | |
})(); | |
(function () { | |
function da(X, U, V) { | |
this.tokendata = X; | |
this.signature = U; | |
this.verified = V; | |
} | |
Tc = Hb.Class.create({ | |
init: function (X, U, V, aa, W, ha, va, ra, ia) { | |
var qa; | |
qa = this; | |
Na( | |
ia, | |
function () { | |
var Aa, ka, Z, ca, fa, xa, Sa; | |
if (V.getTime() < U.getTime()) | |
throw new Bb( | |
"Cannot construct a user ID token that expires before its renewal window opens." | |
); | |
if (!aa) | |
throw new Bb( | |
"Cannot construct a user ID token without a master token." | |
); | |
if (0 > W || W > Rb) | |
throw new Bb( | |
"Serial number " + W + " is outside the valid range." | |
); | |
Aa = Math.floor(U.getTime() / 1e3); | |
ka = Math.floor(V.getTime() / 1e3); | |
Z = aa.serialNumber; | |
if (ra) { | |
ca = ra.tokendata; | |
fa = ra.signature; | |
xa = ra.verified; | |
Z = aa.serialNumber; | |
Object.defineProperties(this, { | |
ctx: { | |
value: X, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
renewalWindowSeconds: { | |
value: Aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
expirationSeconds: { | |
value: ka, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
mtSerialNumber: { value: Z, writable: !1, configurable: !1 }, | |
serialNumber: { value: W, writable: !1, configurable: !1 }, | |
issuerData: { value: ha, writable: !1, configurable: !1 }, | |
customer: { value: va, writable: !1, configurable: !1 }, | |
verified: { | |
value: xa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: ca, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: fa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
} | |
ca = {}; | |
ha && (ca.issuerdata = ha); | |
ca.identity = va; | |
ca = fc(JSON.stringify(ca), Tb); | |
Sa = X.getMslCryptoContext(); | |
Sa.encrypt(ca, { | |
result: function (Ma) { | |
Na( | |
ia, | |
function () { | |
var Ra, Xa; | |
Ra = {}; | |
Ra.renewalwindow = Aa; | |
Ra.expiration = ka; | |
Ra.mtserialnumber = Z; | |
Ra.serialnumber = W; | |
Ra.userdata = Kb(Ma); | |
Xa = fc(JSON.stringify(Ra), Tb); | |
Sa.sign(Xa, { | |
result: function (oa) { | |
Na( | |
ia, | |
function () { | |
Object.defineProperties(this, { | |
ctx: { | |
value: X, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
renewalWindowSeconds: { | |
value: Aa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
expirationSeconds: { | |
value: ka, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
mtSerialNumber: { | |
value: aa.serialNumber, | |
writable: !1, | |
configurable: !1, | |
}, | |
serialNumber: { | |
value: W, | |
writable: !1, | |
configurable: !1, | |
}, | |
issuerData: { | |
value: ha, | |
writable: !1, | |
configurable: !1, | |
}, | |
customer: { | |
value: va, | |
writable: !1, | |
configurable: !1, | |
}, | |
verified: { | |
value: !0, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: Xa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: oa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
}, | |
qa | |
); | |
}, | |
error: function (oa) { | |
Na( | |
ia, | |
function () { | |
oa instanceof gb && oa.setEntity(aa); | |
throw oa; | |
}, | |
qa | |
); | |
}, | |
}); | |
}, | |
qa | |
); | |
}, | |
error: function (Ma) { | |
Na( | |
ia, | |
function () { | |
Ma instanceof gb && Ma.setEntity(aa); | |
throw Ma; | |
}, | |
qa | |
); | |
}, | |
}); | |
}, | |
this | |
); | |
}, | |
get renewalWindow() { | |
return new Date(1e3 * this.renewalWindowSeconds); | |
}, | |
get expiration() { | |
return new Date(1e3 * this.expirationSeconds); | |
}, | |
isVerified: function () { | |
return this.verified; | |
}, | |
isDecrypted: function () { | |
return this.customer ? !0 : !1; | |
}, | |
isRenewable: function () { | |
return this.renewalWindow.getTime() <= this.ctx.getTime(); | |
}, | |
isExpired: function () { | |
return this.expiration.getTime() <= this.ctx.getTime(); | |
}, | |
isBoundTo: function (X) { | |
return X && X.serialNumber == this.mtSerialNumber; | |
}, | |
toJSON: function () { | |
var X; | |
X = {}; | |
X.tokendata = Kb(this.tokendata); | |
X.signature = Kb(this.signature); | |
return X; | |
}, | |
equals: function (X) { | |
return this === X | |
? !0 | |
: X instanceof Tc | |
? this.serialNumber == X.serialNumber && | |
this.mtSerialNumber == X.mtSerialNumber | |
: !1; | |
}, | |
uniqueKey: function () { | |
return this.serialNumber + ":" + this.mtSerialNumber; | |
}, | |
}); | |
vd = function (X, U, V, aa) { | |
Na(aa, function () { | |
var W, ha, va, ra, ia; | |
W = X.getMslCryptoContext(); | |
ha = U.tokendata; | |
va = U.signature; | |
if ("string" !== typeof ha || "string" !== typeof va) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"useridtoken " + JSON.stringify(U) | |
).setEntity(V); | |
try { | |
ra = Mb(ha); | |
} catch (qa) { | |
throw new gb( | |
T.USERIDTOKEN_TOKENDATA_INVALID, | |
"useridtoken " + JSON.stringify(U), | |
qa | |
).setEntity(V); | |
} | |
if (!ra || 0 == ra.length) | |
throw new Jb( | |
T.USERIDTOKEN_TOKENDATA_MISSING, | |
"useridtoken " + JSON.stringify(U) | |
).setEntity(V); | |
try { | |
ia = Mb(va); | |
} catch (qa) { | |
throw new gb( | |
T.USERIDTOKEN_TOKENDATA_INVALID, | |
"useridtoken " + JSON.stringify(U), | |
qa | |
).setEntity(V); | |
} | |
W.verify(ra, ia, { | |
result: function (qa) { | |
Na(aa, function () { | |
var Aa, ka, Z, ca, fa, xa, Sa, Ma, Ra, Xa; | |
Aa = ec(ra, Tb); | |
try { | |
ka = JSON.parse(Aa); | |
Z = parseInt(ka.renewalwindow); | |
ca = parseInt(ka.expiration); | |
fa = parseInt(ka.mtserialnumber); | |
xa = parseInt(ka.serialnumber); | |
Sa = ka.userdata; | |
} catch (oa) { | |
if (oa instanceof SyntaxError) | |
throw new Jb( | |
T.USERIDTOKEN_TOKENDATA_PARSE_ERROR, | |
"usertokendata " + Aa, | |
oa | |
).setEntity(V); | |
throw oa; | |
} | |
if ( | |
!Z || | |
Z != Z || | |
!ca || | |
ca != ca || | |
"number" !== typeof fa || | |
fa != fa || | |
"number" !== typeof xa || | |
xa != xa || | |
"string" !== typeof Sa | |
) | |
throw new Jb( | |
T.USERIDTOKEN_TOKENDATA_PARSE_ERROR, | |
"usertokendata " + Aa | |
).setEntity(V); | |
if (ca < Z) | |
throw new gb( | |
T.USERIDTOKEN_EXPIRES_BEFORE_RENEWAL, | |
"mastertokendata " + Aa | |
).setEntity(V); | |
if (0 > fa || fa > Rb) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, | |
"usertokendata " + Aa | |
).setEntity(V); | |
if (0 > xa || xa > Rb) | |
throw new gb( | |
T.USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, | |
"usertokendata " + Aa | |
).setEntity(V); | |
Ma = new Date(1e3 * Z); | |
Ra = new Date(1e3 * ca); | |
if (!V || fa != V.serialNumber) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_MISMATCH, | |
"uit mtserialnumber " + fa + "; mt " + JSON.stringify(V) | |
).setEntity(V); | |
try { | |
Xa = Mb(Sa); | |
} catch (oa) { | |
throw new gb( | |
T.USERIDTOKEN_USERDATA_INVALID, | |
Sa, | |
oa | |
).setEntity(V); | |
} | |
if (!Xa || 0 == Xa.length) | |
throw new gb(T.USERIDTOKEN_USERDATA_MISSING, Sa).setEntity(V); | |
qa | |
? W.decrypt(Xa, { | |
result: function (oa) { | |
Na(aa, function () { | |
var ya, Ea, Ja, Da, Va; | |
ya = ec(oa, Tb); | |
try { | |
Ea = JSON.parse(ya); | |
Ja = Ea.issuerdata; | |
Da = Ea.identity; | |
} catch (Ha) { | |
if (Ha instanceof SyntaxError) | |
throw new Jb( | |
T.USERIDTOKEN_USERDATA_PARSE_ERROR, | |
"userdata " + ya | |
).setEntity(V); | |
throw Ha; | |
} | |
if ( | |
(Ja && "object" !== typeof Ja) || | |
"object" !== typeof Da | |
) | |
throw new Jb( | |
T.USERIDTOKEN_USERDATA_PARSE_ERROR, | |
"userdata " + ya | |
).setEntity(V); | |
try { | |
Va = af(Da); | |
} catch (Ha) { | |
throw new gb( | |
T.USERIDTOKEN_IDENTITY_INVALID, | |
"userdata " + ya, | |
Ha | |
).setEntity(V); | |
} | |
Da = new da(ra, ia, qa); | |
new Tc(X, Ma, Ra, V, xa, Ja, Va, Da, aa); | |
}); | |
}, | |
error: function (oa) { | |
Na(aa, function () { | |
oa instanceof gb && oa.setEntity(V); | |
throw oa; | |
}); | |
}, | |
}) | |
: ((Z = new da(ra, ia, qa)), | |
new Tc(X, Ma, Ra, V, xa, null, null, Z, aa)); | |
}); | |
}, | |
error: function (qa) { | |
Na(aa, function () { | |
qa instanceof gb && qa.setEntity(V); | |
throw qa; | |
}); | |
}, | |
}); | |
}); | |
}; | |
})(); | |
(function () { | |
function da(U, V) { | |
var aa, W, ha; | |
aa = U.tokendata; | |
if ("string" !== typeof aa) | |
throw new Jb(T.JSON_PARSE_ERROR, "servicetoken " + JSON.stringify(U)); | |
try { | |
W = Mb(aa); | |
} catch (va) { | |
throw new gb( | |
T.SERVICETOKEN_TOKENDATA_INVALID, | |
"servicetoken " + JSON.stringify(U), | |
va | |
); | |
} | |
if (!W || 0 == W.length) | |
throw new Jb( | |
T.SERVICETOKEN_TOKENDATA_MISSING, | |
"servicetoken " + JSON.stringify(U) | |
); | |
try { | |
ha = JSON.parse(ec(W, Tb)).name; | |
} catch (va) { | |
if (va instanceof SyntaxError) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"servicetoken " + JSON.stringify(U), | |
va | |
); | |
throw va; | |
} | |
if (!ha) | |
throw new Jb(T.JSON_PARSE_ERROR, "servicetoken " + JSON.stringify(U)); | |
return V[ha] ? V[ha] : V[""]; | |
} | |
function X(U, V, aa) { | |
this.tokendata = U; | |
this.signature = V; | |
this.verified = aa; | |
} | |
Fc = Hb.Class.create({ | |
init: function (U, V, aa, W, ha, va, ra, ia, qa, Aa) { | |
var ka; | |
ka = this; | |
Na( | |
Aa, | |
function () { | |
var Z, ca, fa, xa, Sa; | |
if (W && ha && !ha.isBoundTo(W)) | |
throw new Bb( | |
"Cannot construct a service token bound to a master token and user ID token where the user ID token is not bound to the same master token." | |
); | |
Z = W ? W.serialNumber : -1; | |
ca = ha ? ha.serialNumber : -1; | |
if (qa) | |
return ( | |
(Sa = qa.tokendata), | |
Object.defineProperties(this, { | |
ctx: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
name: { value: V, writable: !1, configurable: !1 }, | |
mtSerialNumber: { | |
value: Z, | |
writable: !1, | |
configurable: !1, | |
}, | |
uitSerialNumber: { | |
value: ca, | |
writable: !1, | |
configurable: !1, | |
}, | |
data: { value: aa, writable: !1, configurable: !1 }, | |
encrypted: { | |
value: va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
compressionAlgo: { | |
value: ra, | |
writable: !1, | |
configurable: !1, | |
}, | |
verified: { | |
value: qa.verified, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: Sa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: qa.signature, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}), | |
this | |
); | |
if (ra) { | |
fa = Wd(ra, aa); | |
fa.length < aa.length || ((ra = null), (fa = aa)); | |
} else (ra = null), (fa = aa); | |
xa = {}; | |
xa.name = V; | |
-1 != Z && (xa.mtserialnumber = Z); | |
-1 != ca && (xa.uitserialnumber = ca); | |
xa.encrypted = va; | |
ra && (xa.compressionalgo = ra); | |
if (va && 0 < fa.length) | |
ia.encrypt(fa, { | |
result: function (Ma) { | |
Na( | |
Aa, | |
function () { | |
var Ra; | |
xa.servicedata = Kb(Ma); | |
Ra = fc(JSON.stringify(xa), Tb); | |
ia.sign(Ra, { | |
result: function (Xa) { | |
Na( | |
Aa, | |
function () { | |
Object.defineProperties(this, { | |
ctx: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
name: { | |
value: V, | |
writable: !1, | |
configurable: !1, | |
}, | |
mtSerialNumber: { | |
value: Z, | |
writable: !1, | |
configurable: !1, | |
}, | |
uitSerialNumber: { | |
value: ca, | |
writable: !1, | |
configurable: !1, | |
}, | |
data: { | |
value: aa, | |
writable: !1, | |
configurable: !1, | |
}, | |
encrypted: { | |
value: va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
compressionAlgo: { | |
value: ra, | |
writable: !1, | |
configurable: !1, | |
}, | |
verified: { | |
value: !0, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: Ra, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: Xa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
}, | |
ka | |
); | |
}, | |
error: function (Xa) { | |
Na(Aa, function () { | |
Xa instanceof gb && | |
(Xa.setEntity(W), Xa.setUser(ha)); | |
throw Xa; | |
}); | |
}, | |
}); | |
}, | |
ka | |
); | |
}, | |
error: function (Ma) { | |
Na(Aa, function () { | |
Ma instanceof gb && (Ma.setEntity(W), Ma.setUser(ha)); | |
throw Ma; | |
}); | |
}, | |
}); | |
else { | |
xa.servicedata = Kb(fa); | |
Sa = fc(JSON.stringify(xa), Tb); | |
ia.sign(Sa, { | |
result: function (Ma) { | |
Na( | |
Aa, | |
function () { | |
Object.defineProperties(this, { | |
ctx: { | |
value: U, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
name: { value: V, writable: !1, configurable: !1 }, | |
mtSerialNumber: { | |
value: Z, | |
writable: !1, | |
configurable: !1, | |
}, | |
uitSerialNumber: { | |
value: ca, | |
writable: !1, | |
configurable: !1, | |
}, | |
data: { value: aa, writable: !1, configurable: !1 }, | |
encrypted: { | |
value: va, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
compressionAlgo: { | |
value: ra, | |
writable: !1, | |
configurable: !1, | |
}, | |
verified: { | |
value: !0, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
tokendata: { | |
value: Sa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
signature: { | |
value: Ma, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
return this; | |
}, | |
ka | |
); | |
}, | |
error: function (Ma) { | |
Na(Aa, function () { | |
Ma instanceof gb && (Ma.setEntity(W), Ma.setUser(ha)); | |
throw Ma; | |
}); | |
}, | |
}); | |
} | |
}, | |
this | |
); | |
}, | |
isEncrypted: function () { | |
return this.encrypted; | |
}, | |
isVerified: function () { | |
return this.verified; | |
}, | |
isDecrypted: function () { | |
return this.data ? !0 : !1; | |
}, | |
isDeleted: function () { | |
return this.data && 0 == this.data.length; | |
}, | |
isMasterTokenBound: function () { | |
return -1 != this.mtSerialNumber; | |
}, | |
isBoundTo: function (U) { | |
return U | |
? U instanceof jc | |
? U.serialNumber == this.mtSerialNumber | |
: U instanceof Tc | |
? U.serialNumber == this.uitSerialNumber | |
: !1 | |
: !1; | |
}, | |
isUserIdTokenBound: function () { | |
return -1 != this.uitSerialNumber; | |
}, | |
isUnbound: function () { | |
return -1 == this.mtSerialNumber && -1 == this.uitSerialNumber; | |
}, | |
toJSON: function () { | |
var U; | |
U = {}; | |
U.tokendata = Kb(this.tokendata); | |
U.signature = Kb(this.signature); | |
return U; | |
}, | |
equals: function (U) { | |
return this === U | |
? !0 | |
: U instanceof Fc | |
? this.name == U.name && | |
this.mtSerialNumber == U.mtSerialNumber && | |
this.uitSerialNumber == U.uitSerialNumber | |
: !1; | |
}, | |
uniqueKey: function () { | |
return ( | |
this.name + ":" + this.mtSerialNumber + ":" + this.uitSerialNumber | |
); | |
}, | |
}); | |
zc = function (U, V, aa, W, ha, va, ra, ia, qa) { | |
new Fc(U, V, aa, W, ha, va, ra, ia, null, qa); | |
}; | |
wd = function (U, V, aa, W, ha, va) { | |
Na(va, function () { | |
var ra, ia, qa, Aa, ka, Z, ca, fa, xa, Sa, Ma, Ra, Xa; | |
!ha || ha instanceof Uc || (ha = da(V, ha)); | |
ra = V.tokendata; | |
ia = V.signature; | |
if ("string" !== typeof ra || "string" !== typeof ia) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"servicetoken " + JSON.stringify(V) | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
try { | |
qa = Mb(ra); | |
} catch (oa) { | |
throw new gb( | |
T.SERVICETOKEN_TOKENDATA_INVALID, | |
"servicetoken " + JSON.stringify(V), | |
oa | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
} | |
if (!qa || 0 == qa.length) | |
throw new Jb( | |
T.SERVICETOKEN_TOKENDATA_MISSING, | |
"servicetoken " + JSON.stringify(V) | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
try { | |
Aa = Mb(ia); | |
} catch (oa) { | |
throw new gb( | |
T.SERVICETOKEN_SIGNATURE_INVALID, | |
"servicetoken " + JSON.stringify(V), | |
oa | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
} | |
ka = ec(qa, Tb); | |
try { | |
Z = JSON.parse(ka); | |
ca = Z.name; | |
fa = Z.mtserialnumber ? parseInt(Z.mtserialnumber) : -1; | |
xa = Z.uitserialnumber ? parseInt(Z.uitserialnumber) : -1; | |
Sa = Z.encrypted; | |
Ma = Z.compressionalgo; | |
Ra = Z.servicedata; | |
} catch (oa) { | |
if (oa instanceof SyntaxError) | |
throw new Jb(T.JSON_PARSE_ERROR, "servicetokendata " + ka, oa) | |
.setEntity(aa) | |
.setEntity(W); | |
throw oa; | |
} | |
if ( | |
!ca || | |
"number" !== typeof fa || | |
fa != fa || | |
"number" !== typeof xa || | |
xa != xa || | |
"boolean" !== typeof Sa || | |
(Ma && "string" !== typeof Ma) || | |
"string" !== typeof Ra | |
) | |
throw new Jb(T.JSON_PARSE_ERROR, "servicetokendata " + ka) | |
.setEntity(aa) | |
.setEntity(W); | |
if ((Z.mtserialnumber && 0 > fa) || fa > Rb) | |
throw new gb( | |
T.SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, | |
"servicetokendata " + ka | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
if ((Z.uitserialnumber && 0 > xa) || xa > Rb) | |
throw new gb( | |
T.SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, | |
"servicetokendata " + ka | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
if (-1 != fa && (!aa || fa != aa.serialNumber)) | |
throw new gb( | |
T.SERVICETOKEN_MASTERTOKEN_MISMATCH, | |
"st mtserialnumber " + fa + "; mt " + aa | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
if (-1 != xa && (!W || xa != W.serialNumber)) | |
throw new gb( | |
T.SERVICETOKEN_USERIDTOKEN_MISMATCH, | |
"st uitserialnumber " + xa + "; uit " + W | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
Sa = !0 === Sa; | |
if (Ma) { | |
if (!Kc[Ma]) throw new gb(T.UNIDENTIFIED_COMPRESSION, Ma); | |
Xa = Ma; | |
} else Xa = null; | |
ha | |
? ha.verify(qa, Aa, { | |
result: function (oa) { | |
Na(va, function () { | |
var ya, Ea; | |
if (oa) { | |
try { | |
ya = Mb(Ra); | |
} catch (Ja) { | |
throw new gb( | |
T.SERVICETOKEN_SERVICEDATA_INVALID, | |
"servicetokendata " + ka, | |
Ja | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
} | |
if (!ya || (0 != Ra.length && 0 == ya.length)) | |
throw new gb( | |
T.SERVICETOKEN_SERVICEDATA_INVALID, | |
"servicetokendata " + ka | |
) | |
.setEntity(aa) | |
.setEntity(W); | |
if (Sa && 0 < ya.length) | |
ha.decrypt(ya, { | |
result: function (Ja) { | |
Na(va, function () { | |
var Da, Va; | |
Da = Xa ? xd(Xa, Ja) : Ja; | |
Va = new X(qa, Aa, oa); | |
new Fc( | |
U, | |
ca, | |
Da, | |
-1 != fa ? aa : null, | |
-1 != xa ? W : null, | |
Sa, | |
Xa, | |
ha, | |
Va, | |
va | |
); | |
}); | |
}, | |
error: function (Ja) { | |
Na(va, function () { | |
Ja instanceof gb && | |
(Ja.setEntity(aa), Ja.setUser(W)); | |
throw Ja; | |
}); | |
}, | |
}); | |
else { | |
ya = Xa ? xd(Xa, ya) : ya; | |
Ea = new X(qa, Aa, oa); | |
new Fc( | |
U, | |
ca, | |
ya, | |
-1 != fa ? aa : null, | |
-1 != xa ? W : null, | |
Sa, | |
Xa, | |
ha, | |
Ea, | |
va | |
); | |
} | |
} else (ya = "" == Ra ? new Uint8Array(0) : null), (Ea = new X(qa, Aa, oa)), new Fc(U, ca, ya, -1 != fa ? aa : null, -1 != xa ? W : null, Sa, Xa, ha, Ea, va); | |
}); | |
}, | |
error: function (oa) { | |
Na(va, function () { | |
oa instanceof gb && (oa.setEntity(aa), oa.setUser(W)); | |
throw oa; | |
}); | |
}, | |
}) | |
: ((ra = "" == Ra ? new Uint8Array(0) : null), | |
(ia = new X(qa, Aa, !1)), | |
new Fc( | |
U, | |
ca, | |
ra, | |
-1 != fa ? aa : null, | |
-1 != xa ? W : null, | |
Sa, | |
Xa, | |
ha, | |
ia, | |
va | |
)); | |
}); | |
}; | |
})(); | |
Gc = { | |
EMAIL_PASSWORD: "EMAIL_PASSWORD", | |
NETFLIXID: "NETFLIXID", | |
SSO: "SSO", | |
SWITCH_PROFILE: "SWITCH_PROFILE", | |
MDX: "MDX", | |
}; | |
Object.freeze(Gc); | |
(function () { | |
$c = Hb.Class.create({ | |
init: function (da) { | |
Object.defineProperties(this, { | |
scheme: { value: da, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getAuthData: function () {}, | |
equals: function (da) { | |
return this === da | |
? !0 | |
: da instanceof $c | |
? this.scheme == da.scheme | |
: !1; | |
}, | |
toJSON: function () { | |
var da; | |
da = {}; | |
da.scheme = this.scheme; | |
da.authdata = this.getAuthData(); | |
return da; | |
}, | |
}); | |
Qe = function (da, X, U, V) { | |
Na(V, function () { | |
var aa, W, ha; | |
aa = U.scheme; | |
W = U.authdata; | |
if (!aa || !W) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"userauthdata " + JSON.stringify(U) | |
); | |
if (!Gc[aa]) throw new Cc(T.UNIDENTIFIED_USERAUTH_SCHEME, aa); | |
ha = da.getUserAuthenticationFactory(aa); | |
if (!ha) throw new Cc(T.USERAUTH_FACTORY_NOT_FOUND, aa); | |
ha.createData(da, X, W, V); | |
}); | |
}; | |
})(); | |
bf = Hb.Class.create({ | |
init: function (da) { | |
Object.defineProperties(this, { | |
scheme: { value: da, writable: !1, configurable: !1 }, | |
}); | |
}, | |
createData: function (da, X, U, V) {}, | |
authenticate: function (da, X, U, V) {}, | |
}); | |
(function () { | |
hd = $c.extend({ | |
init: function V(X, U) { | |
V.base.call(this, Gc.NETFLIXID); | |
Object.defineProperties(this, { | |
netflixId: { value: X, writable: !1, configurable: !1 }, | |
secureNetflixId: { value: U, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getAuthData: function () { | |
var X; | |
X = {}; | |
X.netflixid = this.netflixId; | |
this.secureNetflixId && (X.securenetflixid = this.secureNetflixId); | |
return X; | |
}, | |
equals: function V(U) { | |
return this === U | |
? !0 | |
: U instanceof hd | |
? V.base.call(this, U) && | |
this.netflixId == U.netflixId && | |
this.secureNetflixId == U.secureNetflixId | |
: !1; | |
}, | |
}); | |
cf = function (U) { | |
var V, aa; | |
V = U.netflixid; | |
aa = U.securenetflixid; | |
if (!V) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"NetflixId authdata " + JSON.stringify(U) | |
); | |
return new hd(V, aa); | |
}; | |
})(); | |
Df = bf.extend({ | |
init: function X() { | |
X.base.call(this, Gc.NETFLIXID); | |
}, | |
createData: function (X, U, V, aa) { | |
Na(aa, function () { | |
return cf(V); | |
}); | |
}, | |
authenticate: function (X, U, V, aa) { | |
if (!(V instanceof hd)) | |
throw new Bb("Incorrect authentication data type " + V + "."); | |
X = V.secureNetflixId; | |
if (!V.netflixId || !X) | |
throw new Cc(T.NETFLIXID_COOKIES_BLANK).setUser(V); | |
throw new Cc(T.UNSUPPORTED_USERAUTH_DATA, this.scheme).setUser(V); | |
}, | |
}); | |
(function () { | |
id = $c.extend({ | |
init: function aa(U, V) { | |
aa.base.call(this, Gc.EMAIL_PASSWORD); | |
Object.defineProperties(this, { | |
email: { value: U, writable: !1, configurable: !1 }, | |
password: { value: V, writable: !1, configurable: !1 }, | |
}); | |
}, | |
getAuthData: function () { | |
var U; | |
U = {}; | |
U.email = this.email; | |
U.password = this.password; | |
return U; | |
}, | |
equals: function aa(V) { | |
return this === V | |
? !0 | |
: V instanceof id | |
? aa.base.call(this, this, V) && | |
this.email == V.email && | |
this.password == V.password | |
: !1; | |
}, | |
}); | |
df = function (V) { | |
var aa, W; | |
aa = V.email; | |
W = V.password; | |
if (!aa || !W) | |
throw new Jb( | |
T.JSON_PARSE_ERROR, | |
"email/password authdata " + JSON.stringify(V) | |
); | |
return new id(aa, W); | |
}; | |
})(); | |
Ef = bf.extend({ | |
init: function U() { | |
U.base.call(this, Gc.EMAIL_PASSWORD); | |
}, | |
createData: function (U, V, aa, W) { | |
Na(W, function () { | |
return df(aa); | |
}); | |
}, | |
authenticate: function (U, V, aa, W) { | |
if (!(aa instanceof id)) | |
throw new Bb("Incorrect authentication data type " + aa + "."); | |
U = aa.password; | |
if (!aa.email || !U) throw new Cc(T.EMAILPASSWORD_BLANK).setUser(aa); | |
throw new Cc(T.UNSUPPORTED_USERAUTH_DATA, this.scheme).setUser(aa); | |
}, | |
}); | |
Object.freeze({ | |
ENTITY_REAUTH: Ga.ENTITY_REAUTH, | |
ENTITYDATA_REAUTH: Ga.ENTITYDATA_REAUTH, | |
}); | |
Ff = Hb.Class.create({ | |
getTime: function () {}, | |
getRandom: function () {}, | |
isPeerToPeer: function () {}, | |
getMessageCapabilities: function () {}, | |
getEntityAuthenticationData: function (U, V) {}, | |
getMslCryptoContext: function () {}, | |
getEntityAuthenticationFactory: function (U) {}, | |
getUserAuthenticationFactory: function (U) {}, | |
getTokenFactory: function () {}, | |
getKeyExchangeFactory: function (U) {}, | |
getKeyExchangeFactories: function () {}, | |
getMslStore: function () {}, | |
}); | |
ef = Hb.Class.create({ | |
setCryptoContext: function (U, V) {}, | |
getMasterToken: function () {}, | |
getNonReplayableId: function (U) {}, | |
getCryptoContext: function (U) {}, | |
removeCryptoContext: function (U) {}, | |
clearCryptoContexts: function () {}, | |
addUserIdToken: function (U, V) {}, | |
getUserIdToken: function (U) {}, | |
removeUserIdToken: function (U) {}, | |
clearUserIdTokens: function () {}, | |
addServiceTokens: function (U) {}, | |
getServiceTokens: function (U, V) {}, | |
removeServiceTokens: function (U, V, aa) {}, | |
clearServiceTokens: function () {}, | |
}); | |
(function () { | |
var U; | |
U = Kc; | |
Wd = function (V, aa) { | |
var W; | |
W = {}; | |
switch (V) { | |
case U.LZW: | |
return ke(aa, W); | |
case U.GZIP: | |
return gzip$compress(aa); | |
default: | |
throw new gb(T.UNSUPPORTED_COMPRESSION, V); | |
} | |
}; | |
xd = function (V, aa, W) { | |
switch (V) { | |
case U.LZW: | |
return le(aa); | |
case U.GZIP: | |
return gzip$uncompress(aa); | |
default: | |
throw new gb(T.UNSUPPORTED_COMPRESSION, V.name()); | |
} | |
}; | |
})(); | |
ef.extend({ | |
setCryptoContext: function (U, V) {}, | |
getMasterToken: function () { | |
return null; | |
}, | |
getNonReplayableId: function (U) { | |
return 1; | |
}, | |
getCryptoContext: function (U) { | |
return null; | |
}, | |
removeCryptoContext: function (U) {}, | |
clearCryptoContexts: function () {}, | |
addUserIdToken: function (U, V) {}, | |
getUserIdToken: function (U) { | |
return null; | |
}, | |
removeUserIdToken: function (U) {}, | |
clearUserIdTokens: function () {}, | |
addServiceTokens: function (U) {}, | |
getServiceTokens: function (U, V) { | |
if (V) { | |
if (!U) throw new gb(T.USERIDTOKEN_MASTERTOKEN_NULL); | |
if (!V.isBoundTo(U)) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_MISMATCH, | |
"uit mtserialnumber " + | |
V.mtSerialNumber + | |
"; mt " + | |
U.serialNumber | |
); | |
} | |
return []; | |
}, | |
removeServiceTokens: function (U, V, aa) { | |
if (aa && V && !aa.isBoundTo(V)) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_MISMATCH, | |
"uit mtserialnumber " + | |
aa.masterTokenSerialNumber + | |
"; mt " + | |
V.serialNumber | |
); | |
}, | |
clearServiceTokens: function () {}, | |
}); | |
(function () { | |
ff = ef.extend({ | |
init: function V() { | |
V.base.call(this); | |
Object.defineProperties(this, { | |
masterTokens: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
cryptoContexts: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
userIdTokens: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
nonReplayableIds: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
unboundServiceTokens: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
mtServiceTokens: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
uitServiceTokens: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
setCryptoContext: function (V, aa) { | |
var W; | |
if (aa) { | |
W = V.uniqueKey(); | |
this.masterTokens[W] = V; | |
this.cryptoContexts[W] = aa; | |
} else this.removeCryptoContext(V); | |
}, | |
getMasterToken: function () { | |
var V, aa, W; | |
V = null; | |
for (aa in this.masterTokens) { | |
W = this.masterTokens[aa]; | |
if (!V || W.isNewerThan(V)) V = W; | |
} | |
return V; | |
}, | |
getNonReplayableId: function (V) { | |
var aa; | |
V = V.serialNumber; | |
aa = this.nonReplayableIds[V] !== Gb ? this.nonReplayableIds[V] : 0; | |
if (0 > aa || aa > Rb) | |
throw new Bb( | |
"Non-replayable ID " + aa + " is outside the valid range." | |
); | |
aa = aa == Rb ? 0 : aa + 1; | |
return (this.nonReplayableIds[V] = aa); | |
}, | |
getCryptoContext: function (V) { | |
return this.cryptoContexts[V.uniqueKey()]; | |
}, | |
removeCryptoContext: function (V) { | |
var aa, W, ha, va; | |
aa = V.uniqueKey(); | |
if (this.masterTokens[aa]) { | |
W = V.serialNumber; | |
for (ha in this.masterTokens) { | |
va = this.masterTokens[ha]; | |
if (!va.equals(V) && va.serialNumber == W) { | |
delete this.masterTokens[aa]; | |
delete this.cryptoContexts[aa]; | |
return; | |
} | |
} | |
Object.keys(this.userIdTokens).forEach(function (ra) { | |
ra = this.userIdTokens[ra]; | |
ra.isBoundTo(V) && this.removeUserIdToken(ra); | |
}, this); | |
try { | |
this.removeServiceTokens(null, V, null); | |
} catch (ra) { | |
if (ra instanceof gb) | |
throw new Bb( | |
"Unexpected exception while removing master token bound service tokens.", | |
ra | |
); | |
throw ra; | |
} | |
delete this.nonReplayableIds[W]; | |
delete this.masterTokens[aa]; | |
delete this.cryptoContexts[aa]; | |
} | |
}, | |
clearCryptoContexts: function () { | |
[ | |
this.masterTokens, | |
this.cryptoContexts, | |
this.nonReplayableIds, | |
this.userIdTokens, | |
this.uitServiceTokens, | |
this.mtServiceTokens, | |
].forEach(function (V) { | |
for (var aa in V) { | |
delete V[aa]; | |
} | |
}, this); | |
}, | |
addUserIdToken: function (V, aa) { | |
var W, ha; | |
W = !1; | |
for (ha in this.masterTokens) { | |
if (aa.isBoundTo(this.masterTokens[ha])) { | |
W = !0; | |
break; | |
} | |
} | |
if (!W) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_NOT_FOUND, | |
"uit mtserialnumber " + aa.mtSerialNumber | |
); | |
this.userIdTokens[V] = aa; | |
}, | |
getUserIdToken: function (V) { | |
return this.userIdTokens[V]; | |
}, | |
removeUserIdToken: function (V) { | |
var aa, W, ha; | |
aa = null; | |
for (W in this.masterTokens) { | |
ha = this.masterTokens[W]; | |
if (V.isBoundTo(ha)) { | |
aa = ha; | |
break; | |
} | |
} | |
Object.keys(this.userIdTokens).forEach(function (va) { | |
if (this.userIdTokens[va].equals(V)) { | |
try { | |
this.removeServiceTokens(null, aa, V); | |
} catch (ra) { | |
if (ra instanceof gb) | |
throw new Bb( | |
"Unexpected exception while removing user ID token bound service tokens.", | |
ra | |
); | |
throw ra; | |
} | |
delete this.userIdTokens[va]; | |
} | |
}, this); | |
}, | |
clearUserIdTokens: function () { | |
for (var V in this.userIdTokens) { | |
this.removeUserIdToken(this.userIdTokens[V]); | |
} | |
}, | |
addServiceTokens: function (V) { | |
V.forEach(function (aa) { | |
var W, ha; | |
if (aa.isMasterTokenBound()) { | |
W = !1; | |
for (ha in this.masterTokens) { | |
if (aa.isBoundTo(this.masterTokens[ha])) { | |
W = !0; | |
break; | |
} | |
} | |
if (!W) | |
throw new gb( | |
T.SERVICETOKEN_MASTERTOKEN_NOT_FOUND, | |
"st mtserialnumber " + aa.mtSerialNumber | |
); | |
} | |
if (aa.isUserIdTokenBound()) { | |
W = !1; | |
for (var va in this.userIdTokens) { | |
if (aa.isBoundTo(this.userIdTokens[va])) { | |
W = !0; | |
break; | |
} | |
} | |
if (!W) | |
throw new gb( | |
T.SERVICETOKEN_USERIDTOKEN_NOT_FOUND, | |
"st uitserialnumber " + aa.uitSerialNumber | |
); | |
} | |
}, this); | |
V.forEach(function (aa) { | |
var W; | |
if (aa.isUnbound()) this.unboundServiceTokens[aa.uniqueKey()] = aa; | |
else { | |
if (aa.isMasterTokenBound()) { | |
W = this.mtServiceTokens[aa.mtSerialNumber]; | |
W || (W = {}); | |
W[aa.uniqueKey()] = aa; | |
this.mtServiceTokens[aa.mtSerialNumber] = W; | |
} | |
aa.isUserIdTokenBound() && | |
((W = this.uitServiceTokens[aa.uitSerialNumber]) || (W = {}), | |
(W[aa.uniqueKey()] = aa), | |
(this.uitServiceTokens[aa.uitSerialNumber] = W)); | |
} | |
}, this); | |
}, | |
getServiceTokens: function (V, aa) { | |
var W, ha, va; | |
if (aa) { | |
if (!V) throw new gb(T.USERIDTOKEN_MASTERTOKEN_NULL); | |
if (!aa.isBoundTo(V)) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_MISMATCH, | |
"uit mtserialnumber " + | |
aa.mtSerialNumber + | |
"; mt " + | |
V.serialNumber | |
); | |
} | |
W = {}; | |
for (ha in this.unboundServiceTokens) { | |
va = this.unboundServiceTokens[ha]; | |
W[va.uniqueKey()] = va; | |
} | |
if (V && (ha = this.mtServiceTokens[V.serialNumber])) | |
for (var ra in ha) { | |
va = ha[ra]; | |
va.isUserIdTokenBound() || (W[ra] = va); | |
} | |
if (aa && (aa = this.uitServiceTokens[aa.serialNumber])) | |
for (var ia in aa) { | |
ra = aa[ia]; | |
ra.isBoundTo(V) && (W[ia] = ra); | |
} | |
V = []; | |
for (var qa in W) { | |
V.push(W[qa]); | |
} | |
return V; | |
}, | |
removeServiceTokens: function (V, aa, W) { | |
var ha, va, ra; | |
if (W && aa && !W.isBoundTo(aa)) | |
throw new gb( | |
T.USERIDTOKEN_MASTERTOKEN_MISMATCH, | |
"uit mtserialnumber " + | |
W.mtSerialNumber + | |
"; mt " + | |
aa.serialNumber | |
); | |
!V || | |
aa || | |
W || | |
Object.keys(this.unboundServiceTokens).forEach(function (ia) { | |
this.unboundServiceTokens[ia].name == V && | |
delete this.unboundServiceTokens[ia]; | |
}, this); | |
if (aa && !W && (ha = this.mtServiceTokens[aa.serialNumber])) { | |
ra = Object.keys(ha); | |
ra.forEach(function (ia) { | |
var qa; | |
qa = ha[ia]; | |
(V && qa.name != V) || delete ha[ia]; | |
}, this); | |
this.mtServiceTokens[aa.serialNumber] = ha; | |
} | |
W && | |
(va = this.uitServiceTokens[W.serialNumber]) && | |
((aa = Object.keys(va)), | |
aa.forEach(function (ia) { | |
var qa; | |
qa = va[ia]; | |
(V && qa.name != V) || delete va[ia]; | |
}, this), | |
(this.uitServiceTokens[W.serialNumber] = va)); | |
}, | |
clearServiceTokens: function () { | |
[ | |
this.unboundServiceTokens, | |
this.mtServiceTokens, | |
this.uitServiceTokens, | |
].forEach(function (V) { | |
for (var aa in V) { | |
delete V[aa]; | |
} | |
}, this); | |
}, | |
}); | |
})(); | |
Af.extend({ | |
init: function V() { | |
V.base.call(this); | |
Object.defineProperties(this, { | |
_contextMap: { | |
value: {}, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
}); | |
}, | |
addCryptoContext: function (V, aa) { | |
aa && V && V.length && ((V = Kb(V)), (this._contextMap[V] = aa)); | |
}, | |
getCryptoContext: function (V) { | |
return V && V.length | |
? ((V = Kb(V)), this._contextMap[V] || null) | |
: null; | |
}, | |
removeCryptoContext: function (V) { | |
V && V.length && ((V = Kb(V)), delete this._contextMap[V]); | |
}, | |
}); | |
sf.extend({ | |
init: function ra(aa, W, ha, va) { | |
ra.base.call(this, aa); | |
Object.defineProperties(this, { | |
_kde: { value: W, writable: !1, enumerable: !1, configurable: !1 }, | |
_kdh: { value: ha, writable: !1, enumerable: !1, configurable: !1 }, | |
_kdw: { value: va, writable: !1, enumerable: !1, configurable: !1 }, | |
}); | |
}, | |
getCryptoContext: function (aa, W) { | |
if (!(W instanceof xc)) | |
throw new Bb( | |
"Incorrect authentication data type " + JSON.stringify(W) + "." | |
); | |
if (W.identity != this.localIdentity) | |
throw new rc(T.ENTITY_NOT_FOUND, "mgk " + W.identity); | |
return new rd(aa, this.localIdentity, this._kde, this._kdh, this._kdw); | |
}, | |
}); | |
tf.extend({ | |
init: function ia(W, ha, va, ra) { | |
ia.base.call(this, W); | |
Object.defineProperties(this, { | |
_kpe: { value: ha, writable: !1, enumerable: !1, configurable: !1 }, | |
_kph: { value: va, writable: !1, enumerable: !1, configurable: !1 }, | |
_kpw: { value: ra, writable: !1, enumerable: !1, configurable: !1 }, | |
}); | |
}, | |
getCryptoContext: function (W, ha) { | |
if (!(ha instanceof yc)) | |
throw new Bb( | |
"Incorrect authentication data type " + JSON.stringify(ha) + "." | |
); | |
if (ha.identity != this.localIdentity) | |
throw new rc(T.ENTITY_NOT_FOUND, "psk " + ha.identity); | |
return new rd(W, this.localIdentity, this._kpe, this._kph, this._kpw); | |
}, | |
}); | |
Hf = ff.extend({ | |
init: function ka(ha, va, ra, ia, qa, Aa) { | |
ka.base.call(this); | |
this._log = ha; | |
this._esn = va; | |
this._keyRequestData = ra; | |
this._createKeyRequestData = ia; | |
this._systemKeyName = qa; | |
this._systemKeyWrapFormat = Aa; | |
}, | |
setCryptoContext: function qa(va, ra, ia) { | |
var Aa; | |
Aa = this; | |
Aa._log.trace("Adding MasterToken", { | |
SequenceNumber: va.sequenceNumber, | |
SerialNumber: va.serialNumber, | |
Expiration: va.expiration.getTime(), | |
}); | |
qa.base.call(this, va, ra); | |
!ia && | |
(va = Aa._createKeyRequestData) && | |
(Aa._log.trace("Generating new keyx request data"), | |
va().then( | |
function (ka) { | |
Aa._keyRequestData = ka; | |
}, | |
function (ka) { | |
Aa._log.error( | |
"Unable to generate new keyx request data", | |
"" + ka | |
); | |
} | |
)); | |
}, | |
addUserIdToken: function qa(ra, ia) { | |
this._log.trace("Adding UserIdToken", { | |
UserId: ra, | |
SerialNumber: ia.serialNumber, | |
MTSerialNumber: ia.mtSerialNumber, | |
Expiration: ia.expiration.getTime(), | |
}); | |
qa.base.call(this, ra, ia); | |
}, | |
addServiceTokens: function qa(ia) { | |
qa.base.call( | |
this, | |
ia.filter(function (Aa) { | |
return !Gf[Aa.name]; | |
}) | |
); | |
}, | |
getUserIdTokenKeys: function () { | |
var ia, qa; | |
ia = []; | |
for (qa in this.userIdTokens) { | |
ia.push(qa); | |
} | |
return ia; | |
}, | |
rekeyUserIdToken: function (ia, qa) { | |
this.userIdTokens[ia] && | |
((this.userIdTokens[qa] = this.userIdTokens[ia]), | |
delete this.userIdTokens[ia]); | |
}, | |
getKeyRequestData: function () { | |
return this._keyRequestData; | |
}, | |
getStoreState: function (ia) { | |
var qa; | |
qa = this; | |
Na(ia, function () { | |
var Aa; | |
Aa = qa.getMasterToken(); | |
Aa | |
? qa.getKeysForStore(Aa, { | |
result: function (ka) { | |
Na(ia, function () { | |
var Z, ca, fa; | |
Z = qa.userIdTokens; | |
ca = Object.keys(Z).map(function (xa) { | |
var Sa; | |
Sa = Z[xa]; | |
return { | |
userId: xa, | |
userIdTokenJSON: Z[xa].toJSON(), | |
serviceTokenJSONList: qa | |
.getServiceTokens(Aa, Sa) | |
.map(mf), | |
}; | |
}); | |
ka.esn = qa._esn; | |
ka.masterTokenJSON = Aa.toJSON(); | |
ka.userList = ca; | |
fa = qa._keyRequestData.storeData; | |
fa && | |
Object.keys(fa).forEach(function (xa) { | |
ka[xa] = fa[xa]; | |
}); | |
return ka; | |
}); | |
}, | |
timeout: ia.timeout, | |
error: ia.error, | |
}) | |
: ia.result(null); | |
}); | |
}, | |
getKeysForStore: function (ia, qa) { | |
var Aa; | |
Aa = this; | |
Na(qa, function () { | |
var ka; | |
ka = Aa.getCryptoContext(ia); | |
ka = { encryptionKey: ka.encryptionKey, hmacKey: ka.hmacKey }; | |
if (ka.encryptionKey && ka.hmacKey) { | |
if (Aa._systemKeyWrapFormat) Aa.wrapKeysWithSystemKey(ka, qa); | |
else return ka; | |
} else throw new gb(T.INTERNAL_EXCEPTION, "Unable to get CryptoContext keys"); | |
}); | |
}, | |
wrapKeysWithSystemKey: function (ia, qa) { | |
var Aa; | |
Aa = this; | |
ee(this._systemKeyName, { | |
result: function (ka) { | |
Na(qa, function () { | |
var Z, ca, fa, xa; | |
Z = ia.encryptionKey; | |
ca = ia.hmacKey; | |
fa = Z[Xc]; | |
xa = ca[Xc]; | |
if (fa && xa) | |
return { wrappedEncryptionKey: fa, wrappedHmacKey: xa }; | |
Promise.resolve() | |
.then(function () { | |
return Promise.all([ | |
Qb.wrapKey(Aa._systemKeyWrapFormat, Z, ka, ka.algorithm), | |
Qb.wrapKey(Aa._systemKeyWrapFormat, ca, ka, ka.algorithm), | |
]); | |
}) | |
.then(function (Sa) { | |
fa = Kb(Sa[0]); | |
Z[Xc] = fa; | |
xa = Kb(Sa[1]); | |
ca[Xc] = xa; | |
qa.result({ wrappedEncryptionKey: fa, wrappedHmacKey: xa }); | |
}) | |
.catch(function (Sa) { | |
qa.error( | |
new gb( | |
T.INTERNAL_EXCEPTION, | |
"Error wrapping key with SYSTEM key", | |
Sa | |
) | |
); | |
}); | |
}); | |
}, | |
timeout: qa.timeout, | |
error: qa.error, | |
}); | |
}, | |
unwrapKeysWithSystemKey: function (ia, qa) { | |
var Aa; | |
Aa = this; | |
ee(this._systemKeyName, { | |
result: function (ka) { | |
Na(qa, function () { | |
var Z, ca; | |
Z = Mb(ia.wrappedEncryptionKey); | |
ca = Mb(ia.wrappedHmacKey); | |
Promise.resolve() | |
.then(function () { | |
return Promise.all([ | |
Qb.unwrapKey( | |
Aa._systemKeyWrapFormat, | |
Z, | |
ka, | |
ka.algorithm, | |
oc, | |
!1, | |
Dc | |
), | |
Qb.unwrapKey( | |
Aa._systemKeyWrapFormat, | |
ca, | |
ka, | |
ka.algorithm, | |
pc, | |
!1, | |
Mc | |
), | |
]); | |
}) | |
.then(function (fa) { | |
var xa; | |
xa = fa[0]; | |
fa = fa[1]; | |
xa[Xc] = ia.wrappedEncryptionKey; | |
fa[Xc] = ia.wrappedHmacKey; | |
qa.result({ encryptionKey: xa, hmacKey: fa }); | |
}) | |
.catch(function (fa) { | |
qa.error( | |
new gb( | |
T.INTERNAL_EXCEPTION, | |
"Error unwrapping with SYSTEM key", | |
fa | |
) | |
); | |
}); | |
}); | |
}, | |
timeout: qa.timeout, | |
error: qa.error, | |
}); | |
}, | |
loadStoreState: function (ia, qa, Aa, ka) { | |
var fa, xa; | |
function Z(Sa, Ma) { | |
var Ra; | |
try { | |
Ra = Aa.userList.slice(); | |
} catch (Xa) {} | |
Ra | |
? (function oa() { | |
var ya; | |
ya = Ra.shift(); | |
ya | |
? vd(qa, ya.userIdTokenJSON, Sa, { | |
result: function (Ea) { | |
try { | |
fa.addUserIdToken(ya.userId, Ea); | |
ca(Sa, Ea, ya.serviceTokenJSONList, { | |
result: oa, | |
timeout: oa, | |
error: oa, | |
}); | |
} catch (Ja) { | |
oa(); | |
} | |
}, | |
timeout: oa, | |
error: oa, | |
}) | |
: Ma.result(); | |
})() | |
: Ma.result(); | |
} | |
function ca(Sa, Ma, Ra, Xa) { | |
var oa, ya; | |
try { | |
oa = Ra.slice(); | |
} catch (Ea) {} | |
if (oa) { | |
ya = fa.getCryptoContext(Sa); | |
(function Ja() { | |
var Da; | |
Da = oa.shift(); | |
Da | |
? wd(qa, Da, Sa, Ma, ya, { | |
result: function (Va) { | |
fa.addServiceTokens([Va]); | |
Ja(); | |
}, | |
timeout: function () { | |
Ja(); | |
}, | |
error: function () { | |
Ja(); | |
}, | |
}) | |
: Xa.result(); | |
})(); | |
} else Xa.result(); | |
} | |
fa = this; | |
xa = fa._log; | |
Aa.esn != fa._esn | |
? (xa.error("Esn mismatch, starting fresh"), ka.error()) | |
: (function (Sa) { | |
var Xa, oa, ya, Ea; | |
function Ma() { | |
var Ja; | |
if (!Xa && oa && ya && Ea) { | |
Xa = !0; | |
Ja = new mc(qa, oa, ia.esn, { rawKey: ya }, { rawKey: Ea }); | |
fa.setCryptoContext(oa, Ja, !0); | |
Sa.result(oa); | |
} | |
} | |
function Ra(Ja, Da) { | |
xa.error(Ja, Da && "" + Da); | |
Xa || ((Xa = !0), Sa.error()); | |
} | |
Aa.masterTokenJSON | |
? (ed(qa, Aa.masterTokenJSON, { | |
result: function (Ja) { | |
oa = Ja; | |
Ma(); | |
}, | |
timeout: function () { | |
Ra("Timeout parsing MasterToken"); | |
}, | |
error: function (Ja) { | |
Ra("Error parsing MasterToken", Ja); | |
}, | |
}), | |
fa._systemKeyWrapFormat | |
? fa.unwrapKeysWithSystemKey(Aa, { | |
result: function (Ja) { | |
ya = Ja.encryptionKey; | |
Ea = Ja.hmacKey; | |
Ma(); | |
}, | |
timeout: function () { | |
Ra("Timeout unwrapping keys"); | |
}, | |
error: function (Ja) { | |
Ra("Error unwrapping keys", Ja); | |
}, | |
}) | |
: Promise.resolve() | |
.then(function () { | |
return Qb.encrypt( | |
{ name: oc.name, iv: new Uint8Array(16) }, | |
Aa.encryptionKey, | |
new Uint8Array(1) | |
); | |
}) | |
.then(function (Ja) { | |
ya = Aa.encryptionKey; | |
}) | |
.catch(function (Ja) { | |
Ra("Error loading encryptionKey"); | |
}) | |
.then(function () { | |
return Qb.sign(pc, Aa.hmacKey, new Uint8Array(1)); | |
}) | |
.then(function (Ja) { | |
Ea = Aa.hmacKey; | |
Ma(); | |
}) | |
.catch(function (Ja) { | |
Ra("Error loading hmacKey"); | |
})) | |
: Ra("Persisted store is corrupt"); | |
})({ | |
result: function (Sa) { | |
Z(Sa, ka); | |
}, | |
timeout: ka.timeout, | |
error: ka.error, | |
}); | |
}, | |
}); | |
Gf = { | |
"streaming.servicetokens.movie": !0, | |
"streaming.servicetokens.license": !0, | |
}; | |
Xc = "$netflix$msl$wrapsys"; | |
If = Ff.extend({ | |
init: function (ia, qa, Aa, ka, Z, ca) { | |
var fa, xa; | |
fa = new fd([Kc.LZW]); | |
xa = new vf(); | |
xa.addPublicKey(qa, Aa); | |
ka[Wb.RSA] = new uf(xa); | |
qa = {}; | |
qa[Gc.EMAIL_PASSWORD] = new Ef(); | |
qa[Gc.NETFLIXID] = new Df(); | |
ia = { | |
_mslCryptoContext: { | |
value: new rf(), | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_capabilities: { | |
value: fa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_entityAuthData: { | |
value: Z, | |
writable: !0, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_entityAuthFactories: { | |
value: ka, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_userAuthFactories: { | |
value: qa, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_keyExchangeFactories: { | |
value: ca, | |
writable: !1, | |
enumerable: !1, | |
configurable: !1, | |
}, | |
_store: { value: ia, writable: !1, enumerable: !1, configurable: !1 }, | |
}; | |
Object.defineProperties(this, ia); | |
}, | |
getTime: function () { | |
return Date.now(); | |
}, | |
getRandom: function () { | |
return new pe(); | |
}, | |
isPeerToPeer: function () { | |
return !1; | |
}, | |
getMessageCapabilities: function () { | |
return this._capabilities; | |
}, | |
getEntityAuthenticationData: function (ia, qa) { | |
qa.result(this._entityAuthData); | |
}, | |
getMslCryptoContext: function () { | |
return this._mslCryptoContext; | |
}, | |
getEntityAuthenticationFactory: function (ia) { | |
return this._entityAuthFactories[ia]; | |
}, | |
getUserAuthenticationFactory: function (ia) { | |
return this._userAuthFactories[ia]; | |
}, | |
getTokenFactory: function () { | |
return null; | |
}, | |
getKeyExchangeFactory: function (ia) { | |
return this._keyExchangeFactories.filter(function (qa) { | |
return qa.scheme == ia; | |
})[0]; | |
}, | |
getKeyExchangeFactories: function () { | |
return this._keyExchangeFactories; | |
}, | |
getMslStore: function () { | |
return this._store; | |
}, | |
}); | |
ge = Ze.extend({ | |
init: function (ia, qa, Aa, ka) { | |
this._log = ia; | |
this._mslContext = qa; | |
this._mslRequest = Aa; | |
this._keyRequestData = ka; | |
}, | |
getCryptoContexts: function () { | |
return {}; | |
}, | |
isEncrypted: function () { | |
return !!this._mslRequest.encrypted; | |
}, | |
isNonReplayable: function () { | |
return !!this._mslRequest.nonReplayable; | |
}, | |
isRequestingTokens: function () { | |
return !0; | |
}, | |
getUserId: function () { | |
return this._mslRequest.profileGuid || this._mslRequest.userId || null; | |
}, | |
getUserAuthData: function (ia, qa, Aa, ka) { | |
var Z; | |
Z = this._mslRequest; | |
Na(ka, function () { | |
return ia || !Z.shouldSendUserAuthData | |
? null | |
: Z.email | |
? new id(Z.email, Z.password) | |
: Z.useNetflixUserAuthData || (Aa && Z.sendUserAuthIfRequired) | |
? new hd() | |
: null; | |
}); | |
}, | |
getCustomer: function () { | |
return null; | |
}, | |
getKeyRequestData: function (ia) { | |
ia.result( | |
this._mslRequest.allowTokenRefresh ? [this._keyRequestData] : [] | |
); | |
}, | |
updateServiceTokens: function (ia, qa, Aa) { | |
var ka, Z, ca, fa, xa, Sa; | |
ka = this._log; | |
Z = (this._mslRequest.serviceTokens || []).slice(); | |
ca = this._mslContext; | |
qa = ca.getMslStore(); | |
fa = ia.builder.getMasterToken(); | |
xa = this.getUserId(); | |
Sa = qa.getUserIdToken(xa); | |
(function Ra() { | |
var Xa; | |
Xa = Z.shift(); | |
if (Xa) | |
try { | |
Xa instanceof Fc | |
? (ia.addPrimaryServiceToken(Xa), Ra()) | |
: wd(ca, Xa, fa, Sa, null, { | |
result: function (oa) { | |
try { | |
ia.addPrimaryServiceToken(oa); | |
} catch (ya) { | |
ka.warn("Exception adding service token", "" + ya); | |
} | |
Ra(); | |
}, | |
timeout: function () { | |
ka.warn("Timeout parsing service token"); | |
Ra(); | |
}, | |
error: function (oa) { | |
ka.warn("Error parsing service token", "" + oa); | |
Ra(); | |
}, | |
}); | |
} catch (oa) { | |
ka.warn("Exception processing service token", "" + oa); | |
Ra(); | |
} | |
else Aa.result(!0); | |
})(); | |
}, | |
write: function (ia, qa, Aa) { | |
var ka; | |
ka = fc(this._mslRequest.body); | |
ia.write(ka, 0, ka.length, qa, { | |
result: function (Z) { | |
Z != ka.length | |
? Aa.error(new Zb("Not all data was written to output.")) | |
: ia.flush(qa, { | |
result: function () { | |
Aa.result(!0); | |
}, | |
timeout: function () { | |
Aa.timeout(); | |
}, | |
error: function (ca) { | |
Aa.error(ca); | |
}, | |
}); | |
}, | |
timeout: function () { | |
Aa.timeout(); | |
}, | |
error: function (Z) { | |
Aa.error(Z); | |
}, | |
}); | |
}, | |
getDebugContext: function () { | |
this._dc || (this._dc = new Jf(this._log, this._mslRequest)); | |
return this._dc; | |
}, | |
}); | |
Jf = Cf.extend({ | |
init: function (ia, qa) { | |
this._log = ia; | |
this._mslRequest = qa; | |
}, | |
sentHeader: function (ia) { | |
this._log.trace( | |
"Sent MSL header", | |
fe(this._mslRequest, ia), | |
ia.serviceTokens && ia.serviceTokens.map(nf).join("\n") | |
); | |
}, | |
receivedHeader: function (ia) { | |
var qa, Aa; | |
qa = fe(this._mslRequest, ia); | |
Aa = ia.errorCode; | |
Aa | |
? this._log.warn("Received MSL error header", qa, { | |
errorCode: Aa, | |
errorMessage: ia.errorMessage, | |
internalCode: ia.internalCode, | |
}) | |
: this._log.trace("Received MSL header", qa); | |
}, | |
}); | |
Kf = { | |
JWK_RSA: function (ia) { | |
return pf( | |
ia, | |
{ | |
name: "RSA-OAEP", | |
modulusLength: 2048, | |
publicExponent: new Uint8Array([1, 0, 1]), | |
hash: { name: "SHA-1" }, | |
}, | |
Ee.JWK_RSA | |
); | |
}, | |
}; | |
ob.netflix = ob.netflix || {}; | |
ob.netflix.msl = { | |
createMslClient: function (ia, qa) { | |
var Aa, ka, Z, ca, fa; | |
Aa = ia.log; | |
fa = ia.notifyMilestone || function () {}; | |
Promise.resolve() | |
.then(function () { | |
if (!(Vb && Vb.generateKey && Vb.importKey && Vb.unwrapKey)) | |
throw new gb(T.INTERNAL_EXCEPTION, "No WebCrypto"); | |
dc = Vb.generateKey({ name: "AES-CBC", length: 128 }, !0, Dc).then | |
? md.V2014_02 | |
: md.LEGACY; | |
fa("mslisik"); | |
return Qb.importKey("spki", ia.serverIdentityKeyData, qe, !1, [ | |
"verify", | |
]); | |
}) | |
.then(function (xa) { | |
return new Promise(function (Sa, Ma) { | |
Jc(xa, { | |
result: Sa, | |
error: function () { | |
Ma( | |
new gb( | |
T.KEY_IMPORT_ERROR, | |
"Unable to create server identity verification key" | |
) | |
); | |
}, | |
}); | |
}); | |
}) | |
.then(function (xa) { | |
ka = xa; | |
if ((xa = Kf.JWK_RSA)) return fa("mslcc"), xa(ia); | |
throw new gb( | |
T.INTERNAL_EXCEPTION, | |
"Invalid authenticationType: JWK_RSA" | |
); | |
}) | |
.then(function (xa) { | |
var Sa; | |
Z = new Hf( | |
Aa, | |
ia.esn, | |
xa.keyRequestData, | |
xa.createKeyRequestData, | |
ia.authenticationKeyNames.s, | |
ia.systemKeyWrapFormat | |
); | |
ca = new If( | |
Z, | |
ia.serverIdentityId, | |
ka, | |
xa.entityAuthFactories, | |
xa.entityAuthData, | |
xa.keyExchangeFactories | |
); | |
Sa = ia.storeState; | |
if (Sa) | |
return ( | |
fa("mslss"), | |
Aa.info("Loading store state"), | |
new Promise(function (Ma, Ra) { | |
Z.loadStoreState(ia, ca, Sa, { | |
result: Ma, | |
timeout: Ma, | |
error: Ma, | |
}); | |
}) | |
); | |
Aa.info("No store state, starting fresh"); | |
}) | |
.then(function () { | |
var xa; | |
xa = new $e(); | |
fa("msldone"); | |
qa.result(new of(Aa, xa, ca, Z, ia.ErrorSubCodes)); | |
}) | |
.catch(function (xa) { | |
qa.error(xa); | |
}); | |
}, | |
IHttpLocation: yf, | |
MslIoException: Zb, | |
}; | |
(function () { | |
var db, Ya, mb, qb, sb, ub, vb, Eb, Db; | |
function ia(pa) { | |
var Fa; | |
Fa = 0; | |
return function () { | |
return Fa < pa.length ? { done: !1, value: pa[Fa++] } : { done: !0 }; | |
}; | |
} | |
function qa(pa, Fa) { | |
var Pa, b; | |
if (Fa) | |
a: { | |
Pa = Ya; | |
pa = pa.split("."); | |
for (var r = 0; r < pa.length - 1; r++) { | |
b = pa[r]; | |
if (!(b in Pa)) break a; | |
Pa = Pa[b]; | |
} | |
pa = pa[pa.length - 1]; | |
r = Pa[pa]; | |
Fa = Fa(r); | |
Fa != r && | |
null != Fa && | |
db(Pa, pa, { configurable: !0, writable: !0, value: Fa }); | |
} | |
} | |
function Aa(pa) { | |
pa = { next: pa }; | |
pa[Symbol.iterator] = function () { | |
return this; | |
}; | |
return pa; | |
} | |
function ka(pa) { | |
var Fa; | |
Fa = | |
"undefined" != typeof Symbol && | |
Symbol.iterator && | |
pa[Symbol.iterator]; | |
return Fa ? Fa.call(pa) : { next: ia(pa) }; | |
} | |
function Z(pa) { | |
for (var Fa, Pa = []; !(Fa = pa.next()).done; ) { | |
Pa.push(Fa.value); | |
} | |
return Pa; | |
} | |
function ca(pa) { | |
return pa instanceof Array ? pa : Z(ka(pa)); | |
} | |
function fa(pa, Fa) { | |
var r; | |
pa.prototype = mb(Fa.prototype); | |
pa.prototype.constructor = pa; | |
if (Eb) Eb(pa, Fa); | |
else | |
for (var Pa in Fa) { | |
if ("prototype" != Pa) | |
if (Object.defineProperties) { | |
r = Object.getOwnPropertyDescriptor(Fa, Pa); | |
r && Object.defineProperty(pa, Pa, r); | |
} else pa[Pa] = Fa[Pa]; | |
} | |
pa.Mhc = Fa.prototype; | |
} | |
function xa() { | |
this.uU = !1; | |
this.PC = null; | |
this.AY = void 0; | |
this.Cv = 1; | |
this.qYa = this.Yia = 0; | |
this.pE = null; | |
} | |
function Sa(pa) { | |
if (pa.uU) throw new TypeError("Generator is already running"); | |
pa.uU = !0; | |
} | |
function Ma(pa, Fa, Pa) { | |
pa.Cv = Pa; | |
return { value: Fa }; | |
} | |
function Ra(pa) { | |
this.tf = new xa(); | |
this.VXb = pa; | |
} | |
function Xa(pa, Fa) { | |
var Pa; | |
Sa(pa.tf); | |
Pa = pa.tf.PC; | |
if (Pa) | |
return oa( | |
pa, | |
"return" in Pa | |
? Pa["return"] | |
: function (r) { | |
return { value: r, done: !0 }; | |
}, | |
Fa, | |
pa.tf.return | |
); | |
pa.tf.return(Fa); | |
return ya(pa); | |
} | |
function oa(pa, Fa, Pa, r) { | |
var b, a; | |
try { | |
b = Fa.call(pa.tf.PC, Pa); | |
if (!(b instanceof Object)) | |
throw new TypeError("Iterator result " + b + " is not an object"); | |
if (!b.done) return (pa.tf.uU = !1), b; | |
a = b.value; | |
} catch (c) { | |
return (pa.tf.PC = null), pa.tf.LX(c), ya(pa); | |
} | |
pa.tf.PC = null; | |
r.call(pa.tf, a); | |
return ya(pa); | |
} | |
function ya(pa) { | |
var Fa; | |
for (; pa.tf.Cv; ) { | |
try { | |
Fa = pa.VXb(pa.tf); | |
if (Fa) return (pa.tf.uU = !1), { value: Fa.value, done: !1 }; | |
} catch (Pa) { | |
pa.tf.AY = void 0; | |
pa.tf.LX(Pa); | |
} | |
} | |
pa.tf.uU = !1; | |
if (pa.tf.pE) { | |
Fa = pa.tf.pE; | |
pa.tf.pE = null; | |
if (Fa.RNb) throw Fa.TXa; | |
return { value: Fa.return, done: !0 }; | |
} | |
return { value: void 0, done: !0 }; | |
} | |
function Ea(pa) { | |
this.next = function (Fa) { | |
return pa.vV(Fa); | |
}; | |
this.throw = function (Fa) { | |
return pa.LX(Fa); | |
}; | |
this.return = function (Fa) { | |
return Xa(pa, Fa); | |
}; | |
this[Symbol.iterator] = function () { | |
return this; | |
}; | |
} | |
function Ja(pa, Fa) { | |
Fa = new Ea(new Ra(Fa)); | |
Eb && pa.prototype && Eb(Fa, pa.prototype); | |
return Fa; | |
} | |
function Da(pa, Fa) { | |
var Pa, r, b; | |
pa instanceof String && (pa += ""); | |
Pa = 0; | |
r = !1; | |
b = { | |
next: function () { | |
var a; | |
if (!r && Pa < pa.length) { | |
a = Pa++; | |
return { value: Fa(a, pa[a]), done: !1 }; | |
} | |
r = !0; | |
return { done: !0, value: void 0 }; | |
}, | |
}; | |
b[Symbol.iterator] = function () { | |
return b; | |
}; | |
return b; | |
} | |
function Va(pa, Fa) { | |
return Object.prototype.hasOwnProperty.call(pa, Fa); | |
} | |
function Ha(pa, Fa, Pa) { | |
var a; | |
pa instanceof String && (pa = String(pa)); | |
for (var r = pa.length, b = 0; b < r; b++) { | |
a = pa[b]; | |
if (Fa.call(Pa, a, b, pa)) return { w1a: b, waa: a }; | |
} | |
return { w1a: -1, waa: void 0 }; | |
} | |
function ab(pa, Fa, Pa) { | |
if (null == pa) | |
throw new TypeError( | |
"The 'this' value for String.prototype." + | |
Pa + | |
" must not be null or undefined" | |
); | |
if (Fa instanceof RegExp) | |
throw new TypeError( | |
"First argument to String.prototype." + | |
Pa + | |
" must not be a regular expression" | |
); | |
return pa + ""; | |
} | |
db = | |
"function" == typeof Object.defineProperties | |
? Object.defineProperty | |
: function (pa, Fa, Pa) { | |
if (pa == Array.prototype || pa == Object.prototype) return pa; | |
pa[Fa] = Pa.value; | |
return pa; | |
}; | |
Ya = (function (pa) { | |
var Pa; | |
pa = [ | |
"object" == typeof globalThis && globalThis, | |
pa, | |
"object" == typeof ob && ob, | |
"object" == typeof self && self, | |
"object" == typeof global && global, | |
]; | |
for (var Fa = 0; Fa < pa.length; ++Fa) { | |
Pa = pa[Fa]; | |
if (Pa && Pa.Math == Math) return Pa; | |
} | |
throw Error("Cannot find global object"); | |
})(this); | |
qa("Symbol", function (pa) { | |
var r; | |
function Fa(b) { | |
if (this instanceof Fa) | |
throw new TypeError("Symbol is not a constructor"); | |
return new Pa("jscomp_symbol_" + (b || "") + "_" + r++, b); | |
} | |
function Pa(b, a) { | |
this.Xfb = b; | |
db(this, "description", { configurable: !0, writable: !0, value: a }); | |
} | |
if (pa) return pa; | |
Pa.prototype.toString = function () { | |
return this.Xfb; | |
}; | |
r = 0; | |
return Fa; | |
}); | |
qa("Symbol.iterator", function (pa) { | |
var r; | |
if (pa) return pa; | |
pa = Symbol("Symbol.iterator"); | |
for ( | |
var Fa = | |
"Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array".split( | |
" " | |
), | |
Pa = 0; | |
Pa < Fa.length; | |
Pa++ | |
) { | |
r = Ya[Fa[Pa]]; | |
"function" === typeof r && | |
"function" != typeof r.prototype[pa] && | |
db(r.prototype, pa, { | |
configurable: !0, | |
writable: !0, | |
value: function () { | |
return Aa(ia(this)); | |
}, | |
}); | |
} | |
return pa; | |
}); | |
mb = | |
"function" == typeof Object.create | |
? Object.create | |
: function (pa) { | |
function Fa() {} | |
Fa.prototype = pa; | |
return new Fa(); | |
}; | |
qb = (function () { | |
var Fa; | |
function pa() { | |
function Pa() {} | |
new Pa(); | |
Reflect.construct(Pa, [], function () {}); | |
return new Pa() instanceof Pa; | |
} | |
if ("undefined" != typeof Reflect && Reflect.construct) { | |
if (pa()) return Reflect.construct; | |
Fa = Reflect.construct; | |
return function (Pa, r, b) { | |
Pa = Fa(Pa, r); | |
b && Reflect.setPrototypeOf(Pa, b.prototype); | |
return Pa; | |
}; | |
} | |
return function (Pa, r, b) { | |
void 0 === b && (b = Pa); | |
b = mb(b.prototype || Object.prototype); | |
return Function.prototype.apply.call(Pa, b, r) || b; | |
}; | |
})(); | |
if ("function" == typeof Object.setPrototypeOf) | |
sb = Object.setPrototypeOf; | |
else { | |
a: { | |
ub = { a: !0 }; | |
vb = {}; | |
try { | |
vb.__proto__ = ub; | |
sb = vb.a; | |
break a; | |
} catch (pa) {} | |
sb = !1; | |
} | |
sb = sb | |
? function (pa, Fa) { | |
pa.__proto__ = Fa; | |
if (pa.__proto__ !== Fa) | |
throw new TypeError(pa + " is not extensible"); | |
return pa; | |
} | |
: null; | |
} | |
Eb = sb; | |
xa.prototype.vV = function (pa) { | |
this.AY = pa; | |
}; | |
xa.prototype.LX = function (pa) { | |
this.pE = { TXa: pa, RNb: !0 }; | |
this.Cv = this.Yia || this.qYa; | |
}; | |
xa.prototype.return = function (pa) { | |
this.pE = { return: pa }; | |
this.Cv = this.qYa; | |
}; | |
Ra.prototype.vV = function (pa) { | |
Sa(this.tf); | |
if (this.tf.PC) return oa(this, this.tf.PC.next, pa, this.tf.vV); | |
this.tf.vV(pa); | |
return ya(this); | |
}; | |
Ra.prototype.LX = function (pa) { | |
Sa(this.tf); | |
if (this.tf.PC) return oa(this, this.tf.PC["throw"], pa, this.tf.vV); | |
this.tf.LX(pa); | |
return ya(this); | |
}; | |
qa("Reflect", function (pa) { | |
return pa ? pa : {}; | |
}); | |
qa("Reflect.construct", function () { | |
return qb; | |
}); | |
qa("Reflect.setPrototypeOf", function (pa) { | |
return pa | |
? pa | |
: Eb | |
? function (Fa, Pa) { | |
try { | |
return Eb(Fa, Pa), !0; | |
} catch (r) { | |
return !1; | |
} | |
} | |
: null; | |
}); | |
qa("Promise", function (pa) { | |
var b, a; | |
function Fa(c) { | |
var l; | |
this.SN = 0; | |
this.OW = void 0; | |
this.FM = []; | |
this.U2a = !1; | |
l = this.fka(); | |
try { | |
c(l.resolve, l.reject); | |
} catch (g) { | |
l.reject(g); | |
} | |
} | |
function Pa() { | |
this.tA = null; | |
} | |
function r(c) { | |
return c instanceof Fa | |
? c | |
: new Fa(function (l) { | |
l(c); | |
}); | |
} | |
if (pa) return pa; | |
Pa.prototype.sSa = function (c) { | |
var l; | |
if (null == this.tA) { | |
this.tA = []; | |
l = this; | |
this.tSa(function () { | |
l.LEb(); | |
}); | |
} | |
this.tA.push(c); | |
}; | |
b = Ya.setTimeout; | |
Pa.prototype.tSa = function (c) { | |
b(c, 0); | |
}; | |
Pa.prototype.LEb = function () { | |
var c, g; | |
for (; this.tA && this.tA.length; ) { | |
c = this.tA; | |
this.tA = []; | |
for (var l = 0; l < c.length; ++l) { | |
g = c[l]; | |
c[l] = null; | |
try { | |
g(); | |
} catch (k) { | |
this.ytb(k); | |
} | |
} | |
} | |
this.tA = null; | |
}; | |
Pa.prototype.ytb = function (c) { | |
this.tSa(function () { | |
throw c; | |
}); | |
}; | |
Fa.prototype.fka = function () { | |
var l, g; | |
function c(k) { | |
return function (d) { | |
g || ((g = !0), k.call(l, d)); | |
}; | |
} | |
l = this; | |
g = !1; | |
return { resolve: c(this.m_b), reject: c(this.Hua) }; | |
}; | |
Fa.prototype.m_b = function (c) { | |
var l; | |
if (c === this) | |
this.Hua(new TypeError("A Promise cannot resolve to itself")); | |
else if (c instanceof Fa) this.D1b(c); | |
else { | |
a: switch (typeof c) { | |
case "object": | |
l = null != c; | |
break a; | |
case "function": | |
l = !0; | |
break a; | |
default: | |
l = !1; | |
} | |
l ? this.l_b(c) : this.cZa(c); | |
} | |
}; | |
Fa.prototype.l_b = function (c) { | |
var l; | |
l = void 0; | |
try { | |
l = c.then; | |
} catch (g) { | |
this.Hua(g); | |
return; | |
} | |
"function" == typeof l ? this.E1b(l, c) : this.cZa(c); | |
}; | |
Fa.prototype.Hua = function (c) { | |
this.pbb(2, c); | |
}; | |
Fa.prototype.cZa = function (c) { | |
this.pbb(1, c); | |
}; | |
Fa.prototype.pbb = function (c, l) { | |
if (0 != this.SN) | |
throw Error( | |
"Cannot settle(" + | |
c + | |
", " + | |
l + | |
"): Promise already settled in state" + | |
this.SN | |
); | |
this.SN = c; | |
this.OW = l; | |
2 === this.SN && this.Y_b(); | |
this.MEb(); | |
}; | |
Fa.prototype.Y_b = function () { | |
var c; | |
c = this; | |
b(function () { | |
var l; | |
if (c.rTb()) { | |
l = Ya.console; | |
"undefined" !== typeof l && l.error(c.OW); | |
} | |
}, 1); | |
}; | |
Fa.prototype.rTb = function () { | |
var c, l, g; | |
if (this.U2a) return !1; | |
c = Ya.CustomEvent; | |
l = Ya.Event; | |
g = Ya.dispatchEvent; | |
if ("undefined" === typeof g) return !0; | |
"function" === typeof c | |
? (c = new c("unhandledrejection", { cancelable: !0 })) | |
: "function" === typeof l | |
? (c = new l("unhandledrejection", { cancelable: !0 })) | |
: ((c = Ya.document.createEvent("CustomEvent")), | |
c.initCustomEvent("unhandledrejection", !1, !0, c)); | |
c.promise = this; | |
c.reason = this.OW; | |
return g(c); | |
}; | |
Fa.prototype.MEb = function () { | |
if (null != this.FM) { | |
for (var c = 0; c < this.FM.length; ++c) { | |
a.sSa(this.FM[c]); | |
} | |
this.FM = null; | |
} | |
}; | |
a = new Pa(); | |
Fa.prototype.D1b = function (c) { | |
var l; | |
l = this.fka(); | |
c.X2(l.resolve, l.reject); | |
}; | |
Fa.prototype.E1b = function (c, l) { | |
var g; | |
g = this.fka(); | |
try { | |
c.call(l, g.resolve, g.reject); | |
} catch (k) { | |
g.reject(k); | |
} | |
}; | |
Fa.prototype.then = function (c, l) { | |
var k, d, f; | |
function g(m, h) { | |
return "function" == typeof m | |
? function (n) { | |
try { | |
k(m(n)); | |
} catch (p) { | |
d(p); | |
} | |
} | |
: h; | |
} | |
f = new Fa(function (m, h) { | |
k = m; | |
d = h; | |
}); | |
this.X2(g(c, k), g(l, d)); | |
return f; | |
}; | |
Fa.prototype.catch = function (c) { | |
return this.then(void 0, c); | |
}; | |
Fa.prototype.X2 = function (c, l) { | |
var k; | |
function g() { | |
switch (k.SN) { | |
case 1: | |
c(k.OW); | |
break; | |
case 2: | |
l(k.OW); | |
break; | |
default: | |
throw Error("Unexpected state: " + k.SN); | |
} | |
} | |
k = this; | |
null == this.FM ? a.sSa(g) : this.FM.push(g); | |
this.U2a = !0; | |
}; | |
Fa.resolve = r; | |
Fa.reject = function (c) { | |
return new Fa(function (l, g) { | |
g(c); | |
}); | |
}; | |
Fa.race = function (c) { | |
return new Fa(function (l, g) { | |
for (var k = ka(c), d = k.next(); !d.done; d = k.next()) { | |
r(d.value).X2(l, g); | |
} | |
}); | |
}; | |
Fa.all = function (c) { | |
var l, g; | |
l = ka(c); | |
g = l.next(); | |
return g.done | |
? r([]) | |
: new Fa(function (k, d) { | |
var m, h; | |
function f(n) { | |
return function (p) { | |
m[n] = p; | |
h--; | |
0 == h && k(m); | |
}; | |
} | |
m = []; | |
h = 0; | |
do { | |
m.push(void 0); | |
h++; | |
r(g.value).X2(f(m.length - 1), d); | |
g = l.next(); | |
} while (!g.done); | |
}); | |
}; | |
return Fa; | |
}); | |
qa("Number.MAX_SAFE_INTEGER", function () { | |
return 9007199254740991; | |
}); | |
qa("Array.prototype.keys", function (pa) { | |
return pa | |
? pa | |
: function () { | |
return Da(this, function (Fa) { | |
return Fa; | |
}); | |
}; | |
}); | |
qa("WeakMap", function (pa) { | |
var c, l; | |
function Fa(g) { | |
this.ZT = (l += Math.random() + 1).toString(); | |
if (g) { | |
g = ka(g); | |
for (var k; !(k = g.next()).done; ) { | |
k = k.value; | |
this.set(k[0], k[1]); | |
} | |
} | |
} | |
function Pa() {} | |
function r(g) { | |
var k; | |
k = typeof g; | |
return ("object" === k && null !== g) || "function" === k; | |
} | |
function b(g) { | |
var k; | |
if (!Va(g, c)) { | |
k = new Pa(); | |
db(g, c, { value: k }); | |
} | |
} | |
function a(g) { | |
var k; | |
k = Object[g]; | |
k && | |
(Object[g] = function (d) { | |
if (d instanceof Pa) return d; | |
Object.isExtensible(d) && b(d); | |
return k(d); | |
}); | |
} | |
if ( | |
(function () { | |
var g, k, d; | |
if (!pa || !Object.seal) return !1; | |
try { | |
g = Object.seal({}); | |
k = Object.seal({}); | |
d = new pa([ | |
[g, 2], | |
[k, 3], | |
]); | |
if (2 != d.get(g) || 3 != d.get(k)) return !1; | |
d.delete(g); | |
d.set(k, 4); | |
return !d.has(g) && 4 == d.get(k); | |
} catch (f) { | |
return !1; | |
} | |
})() | |
) | |
return pa; | |
c = "$jscomp_hidden_" + Math.random(); | |
a("freeze"); | |
a("preventExtensions"); | |
a("seal"); | |
l = 0; | |
Fa.prototype.set = function (g, k) { | |
if (!r(g)) throw Error("Invalid WeakMap key"); | |
b(g); | |
if (!Va(g, c)) throw Error("WeakMap key fail: " + g); | |
g[c][this.ZT] = k; | |
return this; | |
}; | |
Fa.prototype.get = function (g) { | |
return r(g) && Va(g, c) ? g[c][this.ZT] : void 0; | |
}; | |
Fa.prototype.has = function (g) { | |
return r(g) && Va(g, c) && Va(g[c], this.ZT); | |
}; | |
Fa.prototype.delete = function (g) { | |
return r(g) && Va(g, c) && Va(g[c], this.ZT) | |
? delete g[c][this.ZT] | |
: !1; | |
}; | |
return Fa; | |
}); | |
qa("Map", function (pa) { | |
var a, c; | |
function Fa() { | |
var l; | |
l = {}; | |
return (l.$l = l.next = l.head = l); | |
} | |
function Pa(l, g) { | |
var k; | |
k = l.Xx; | |
return Aa(function () { | |
if (k) { | |
for (; k.head != l.Xx; ) { | |
k = k.$l; | |
} | |
for (; k.next != k.head; ) { | |
return (k = k.next), { done: !1, value: g(k) }; | |
} | |
k = null; | |
} | |
return { done: !0, value: void 0 }; | |
}); | |
} | |
function r(l, g) { | |
var k, d, f; | |
k = g && typeof g; | |
"object" == k || "function" == k | |
? a.has(g) | |
? (k = a.get(g)) | |
: ((k = "" + ++c), a.set(g, k)) | |
: (k = "p_" + g); | |
d = l.Hx[k]; | |
if (d && Va(l.Hx, k)) | |
for (l = 0; l < d.length; l++) { | |
f = d[l]; | |
if ((g !== g && f.key !== f.key) || g === f.key) | |
return { id: k, list: d, index: l, entry: f }; | |
} | |
return { id: k, list: d, index: -1, entry: void 0 }; | |
} | |
function b(l) { | |
this.Hx = {}; | |
this.Xx = Fa(); | |
this.size = 0; | |
if (l) { | |
l = ka(l); | |
for (var g; !(g = l.next()).done; ) { | |
g = g.value; | |
this.set(g[0], g[1]); | |
} | |
} | |
} | |
if ( | |
(function () { | |
var l, g, k, d; | |
if ( | |
!pa || | |
"function" != typeof pa || | |
!pa.prototype.entries || | |
"function" != typeof Object.seal | |
) | |
return !1; | |
try { | |
l = Object.seal({ x: 4 }); | |
g = new pa(ka([[l, "s"]])); | |
if ( | |
"s" != g.get(l) || | |
1 != g.size || | |
g.get({ x: 4 }) || | |
g.set({ x: 4 }, "t") != g || | |
2 != g.size | |
) | |
return !1; | |
k = g.entries(); | |
d = k.next(); | |
if (d.done || d.value[0] != l || "s" != d.value[1]) return !1; | |
d = k.next(); | |
return d.done || | |
4 != d.value[0].x || | |
"t" != d.value[1] || | |
!k.next().done | |
? !1 | |
: !0; | |
} catch (f) { | |
return !1; | |
} | |
})() | |
) | |
return pa; | |
a = new WeakMap(); | |
b.prototype.set = function (l, g) { | |
var k; | |
l = 0 === l ? 0 : l; | |
k = r(this, l); | |
k.list || (k.list = this.Hx[k.id] = []); | |
k.entry | |
? (k.entry.value = g) | |
: ((k.entry = { | |
next: this.Xx, | |
$l: this.Xx.$l, | |
head: this.Xx, | |
key: l, | |
value: g, | |
}), | |
k.list.push(k.entry), | |
(this.Xx.$l.next = k.entry), | |
(this.Xx.$l = k.entry), | |
this.size++); | |
return this; | |
}; | |
b.prototype.delete = function (l) { | |
l = r(this, l); | |
return l.entry && l.list | |
? (l.list.splice(l.index, 1), | |
l.list.length || delete this.Hx[l.id], | |
(l.entry.$l.next = l.entry.next), | |
(l.entry.next.$l = l.entry.$l), | |
(l.entry.head = null), | |
this.size--, | |
!0) | |
: !1; | |
}; | |
b.prototype.clear = function () { | |
this.Hx = {}; | |
this.Xx = this.Xx.$l = Fa(); | |
this.size = 0; | |
}; | |
b.prototype.has = function (l) { | |
return !!r(this, l).entry; | |
}; | |
b.prototype.get = function (l) { | |
return (l = r(this, l).entry) && l.value; | |
}; | |
b.prototype.entries = function () { | |
return Pa(this, function (l) { | |
return [l.key, l.value]; | |
}); | |
}; | |
b.prototype.keys = function () { | |
return Pa(this, function (l) { | |
return l.key; | |
}); | |
}; | |
b.prototype.values = function () { | |
return Pa(this, function (l) { | |
return l.value; | |
}); | |
}; | |
b.prototype.forEach = function (l, g) { | |
for (var k = this.entries(), d; !(d = k.next()).done; ) { | |
d = d.value; | |
l.call(g, d[1], d[0], this); | |
} | |
}; | |
b.prototype[Symbol.iterator] = b.prototype.entries; | |
c = 0; | |
return b; | |
}); | |
qa("Set", function (pa) { | |
function Fa(Pa) { | |
this.yv = new Map(); | |
if (Pa) { | |
Pa = ka(Pa); | |
for (var r; !(r = Pa.next()).done; ) { | |
this.add(r.value); | |
} | |
} | |
this.size = this.yv.size; | |
} | |
if ( | |
(function () { | |
var Pa, r, b, a; | |
if ( | |
!pa || | |
"function" != typeof pa || | |
!pa.prototype.entries || | |
"function" != typeof Object.seal | |
) | |
return !1; | |
try { | |
Pa = Object.seal({ x: 4 }); | |
r = new pa(ka([Pa])); | |
if ( | |
!r.has(Pa) || | |
1 != r.size || | |
r.add(Pa) != r || | |
1 != r.size || | |
r.add({ x: 4 }) != r || | |
2 != r.size | |
) | |
return !1; | |
b = r.entries(); | |
a = b.next(); | |
if (a.done || a.value[0] != Pa || a.value[1] != Pa) return !1; | |
a = b.next(); | |
return a.done || | |
a.value[0] == Pa || | |
4 != a.value[0].x || | |
a.value[1] != a.value[0] | |
? !1 | |
: b.next().done; | |
} catch (c) { | |
return !1; | |
} | |
})() | |
) | |
return pa; | |
Fa.prototype.add = function (Pa) { | |
Pa = 0 === Pa ? 0 : Pa; | |
this.yv.set(Pa, Pa); | |
this.size = this.yv.size; | |
return this; | |
}; | |
Fa.prototype.delete = function (Pa) { | |
Pa = this.yv.delete(Pa); | |
this.size = this.yv.size; | |
return Pa; | |
}; | |
Fa.prototype.clear = function () { | |
this.yv.clear(); | |
this.size = 0; | |
}; | |
Fa.prototype.has = function (Pa) { | |
return this.yv.has(Pa); | |
}; | |
Fa.prototype.entries = function () { | |
return this.yv.entries(); | |
}; | |
Fa.prototype.values = function () { | |
return this.yv.values(); | |
}; | |
Fa.prototype.keys = Fa.prototype.values; | |
Fa.prototype[Symbol.iterator] = Fa.prototype.values; | |
Fa.prototype.forEach = function (Pa, r) { | |
var b; | |
b = this; | |
this.yv.forEach(function (a) { | |
return Pa.call(r, a, a, b); | |
}); | |
}; | |
return Fa; | |
}); | |
qa("Array.prototype.find", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
return Ha(this, Fa, Pa).waa; | |
}; | |
}); | |
qa("Number.isFinite", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
return "number" !== typeof Fa | |
? !1 | |
: !isNaN(Fa) && Infinity !== Fa && -Infinity !== Fa; | |
}; | |
}); | |
Db = | |
"function" == typeof Object.assign | |
? Object.assign | |
: function (pa, Fa) { | |
var r; | |
for (var Pa = 1; Pa < arguments.length; Pa++) { | |
r = arguments[Pa]; | |
if (r) | |
for (var b in r) { | |
Va(r, b) && (pa[b] = r[b]); | |
} | |
} | |
return pa; | |
}; | |
qa("Object.assign", function (pa) { | |
return pa || Db; | |
}); | |
qa("Object.is", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
return Fa === Pa | |
? 0 !== Fa || 1 / Fa === 1 / Pa | |
: Fa !== Fa && Pa !== Pa; | |
}; | |
}); | |
qa("Array.prototype.includes", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
var r, b, a; | |
r = this; | |
r instanceof String && (r = String(r)); | |
b = r.length; | |
Pa = Pa || 0; | |
for (0 > Pa && (Pa = Math.max(Pa + b, 0)); Pa < b; Pa++) { | |
a = r[Pa]; | |
if (a === Fa || Object.is(a, Fa)) return !0; | |
} | |
return !1; | |
}; | |
}); | |
qa("String.prototype.includes", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
return -1 !== ab(this, Fa, "includes").indexOf(Fa, Pa || 0); | |
}; | |
}); | |
qa("Object.entries", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
var Pa, r; | |
Pa = []; | |
for (r in Fa) { | |
Va(Fa, r) && Pa.push([r, Fa[r]]); | |
} | |
return Pa; | |
}; | |
}); | |
qa("Object.values", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
var Pa, r; | |
Pa = []; | |
for (r in Fa) { | |
Va(Fa, r) && Pa.push(Fa[r]); | |
} | |
return Pa; | |
}; | |
}); | |
qa("Array.prototype.entries", function (pa) { | |
return pa | |
? pa | |
: function () { | |
return Da(this, function (Fa, Pa) { | |
return [Fa, Pa]; | |
}); | |
}; | |
}); | |
qa("Array.prototype.findIndex", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
return Ha(this, Fa, Pa).w1a; | |
}; | |
}); | |
qa("Promise.prototype.finally", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
return this.then( | |
function (Pa) { | |
return Promise.resolve(Fa()).then(function () { | |
return Pa; | |
}); | |
}, | |
function (Pa) { | |
return Promise.resolve(Fa()).then(function () { | |
throw Pa; | |
}); | |
} | |
); | |
}; | |
}); | |
qa("Number.parseInt", function (pa) { | |
return pa || parseInt; | |
}); | |
qa("Array.prototype.values", function (pa) { | |
return pa | |
? pa | |
: function () { | |
return Da(this, function (Fa, Pa) { | |
return Pa; | |
}); | |
}; | |
}); | |
qa("String.prototype.endsWith", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
var r; | |
r = ab(this, Fa, "endsWith"); | |
Fa += ""; | |
void 0 === Pa && (Pa = r.length); | |
Pa = Math.max(0, Math.min(Pa | 0, r.length)); | |
for (var b = Fa.length; 0 < b && 0 < Pa; ) { | |
if (r[--Pa] != Fa[--b]) return !1; | |
} | |
return 0 >= b; | |
}; | |
}); | |
qa("Array.from", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa, r) { | |
var b, a; | |
Pa = | |
null != Pa | |
? Pa | |
: function (l) { | |
return l; | |
}; | |
b = []; | |
a = | |
"undefined" != typeof Symbol && | |
Symbol.iterator && | |
Fa[Symbol.iterator]; | |
if ("function" == typeof a) { | |
Fa = a.call(Fa); | |
for (var c = 0; !(a = Fa.next()).done; ) { | |
b.push(Pa.call(r, a.value, c++)); | |
} | |
} else | |
for (a = Fa.length, c = 0; c < a; c++) { | |
b.push(Pa.call(r, Fa[c], c)); | |
} | |
return b; | |
}; | |
}); | |
qa("String.prototype.startsWith", function (pa) { | |
return pa | |
? pa | |
: function (Fa, Pa) { | |
var r, b, a; | |
r = ab(this, Fa, "startsWith"); | |
Fa += ""; | |
b = r.length; | |
a = Fa.length; | |
Pa = Math.max(0, Math.min(Pa | 0, r.length)); | |
for (var c = 0; c < a && Pa < b; ) { | |
if (r[Pa++] != Fa[c++]) return !1; | |
} | |
return c >= a; | |
}; | |
}); | |
qa("Number.isNaN", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
return "number" === typeof Fa && isNaN(Fa); | |
}; | |
}); | |
qa("Object.getOwnPropertySymbols", function (pa) { | |
return pa | |
? pa | |
: function () { | |
return []; | |
}; | |
}); | |
qa("Reflect.apply", function (pa) { | |
var Fa; | |
if (pa) return pa; | |
Fa = Function.prototype.apply; | |
return function (Pa, r, b) { | |
return Fa.call(Pa, r, b); | |
}; | |
}); | |
qa("Math.tanh", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
var Pa; | |
Fa = Number(Fa); | |
if (0 === Fa) return Fa; | |
Pa = Math.exp(-2 * Math.abs(Fa)); | |
Pa = (1 - Pa) / (1 + Pa); | |
return 0 > Fa ? -Pa : Pa; | |
}; | |
}); | |
qa("String.fromCodePoint", function (pa) { | |
return pa | |
? pa | |
: function (Fa) { | |
var b; | |
for (var Pa = "", r = 0; r < arguments.length; r++) { | |
b = Number(arguments[r]); | |
if (0 > b || 1114111 < b || b !== Math.floor(b)) | |
throw new RangeError("invalid_code_point " + b); | |
65535 >= b | |
? (Pa += String.fromCharCode(b)) | |
: ((b -= 65536), | |
(Pa += String.fromCharCode(((b >>> 10) & 1023) | 55296)), | |
(Pa += String.fromCharCode((b & 1023) | 56320))); | |
} | |
return Pa; | |
}; | |
}); | |
qa("Object.setPrototypeOf", function (pa) { | |
return pa || Eb; | |
}); | |
(function () { | |
var Fa, Pa; | |
function pa(r) { | |
var b; | |
b = Pa[r]; | |
if (void 0 !== b) return b.exports; | |
b = Pa[r] = { exports: {} }; | |
Fa[r].call(b.exports, b, b.exports, pa); | |
return b.exports; | |
} | |
Fa = { | |
60328: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.v = void 0; | |
b.v = { ia: 0, $: 1, Ia: 2 }; | |
}, | |
45929: function (r, b, a) { | |
var c, l; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.assert = void 0; | |
c = a(5163); | |
l = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
return k; | |
})(Error); | |
b.assert = function (g, k) { | |
if (!g) throw new l(k || "Assertion failed"); | |
}; | |
}, | |
5102: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.YYa = b.Daa = b.XYa = void 0; | |
b.XYa = { | |
23976: { sa: 24e3, R: 1001 }, | |
24: { sa: 24e3, R: 1e3 }, | |
25: { sa: 25e3, R: 1e3 }, | |
2997: { sa: 3e4, R: 1001 }, | |
30: { sa: 3e4, R: 1e3 }, | |
}; | |
b.Daa = ["23976", "24", "25", "2997", "30"]; | |
b.YYa = function (a, c) { | |
return a.sa / a.R === c.sa / c.R; | |
}; | |
}, | |
40138: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACBCBtFvB2gDYBdsbXZoBkgA4BgAAJC7CAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABeWdHJhBrgBYBBcB0BrgOYDgIIKgLoOgCYDgCgDgO4rcBMm1kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBNBlgIgBBIBhBugEQABlgEYDfdbWluBmgA4BAQgoIAgKgLAkgEwAgC4DccZHJlgA4CgTwGcMdXJsAggBYFehc3RiBsgO4CgA4ABzgHYGgC4CdFZWMtAzgaQPAGgMYAgwQJANBkgEgAAzgCQAAgAPgBgCAUBignwAB0gAwAADgpYBDugB4CDAgSADF0BzgSAJgB4BBzBjgB4JAUgB4BB6gn4NgEYBBjBvgB4JA4hAIABlB4gC4CBtBlgbgGAwgAgCAggNwAgC4DgUAGgAYBgRQAg5QFAA", | |
$a: !0, | |
eb: [176, 590], | |
size: 610, | |
}; | |
b.Y = { | |
data: "IABkBtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdMdHJhgC4CAgB0gC4CACAAA6gC4FgAYBAGgAwBADgCQBgAADAQgD4ABkB0gG4FgAACAUgG4AB1BugFYFAIgAYBBsgAQAcYCG1kBhB0ALB3ABB/A/CHDAgKAAgCgBgHYCAEBIAfgAYAgAAAIBAAJAIQgBgBcY+fPnDPCfA+B8gAwBDfDzCrgBQGDHD8DqgC4Gfx/zq+gCQCgBgCB/DOCvgD4EgBgAAfgFgLgQwCcDxtttC2DbDHCPAeA7G7C4gB4BcNa1rWC1CggBABAbgCwBdvHjx4LuDggWQFB4gFQCd48ePHJ3gCQFADgCIBBtgCAACPAdHdDcgCQFAPgHIRgbgBgdIBDjgFgMAGC1CtgNgADQgOYCgCwBC3gQIAA8gKwBBwgGAFA8gFQCC8gNYBgSoAC7CAgtgFgCIBC2gPgBCOgK4BgEoFAHCNgHIQA2gAoDDxgFgMADgagBCtBogOYCgdoMgAACAeA2gCYBDegVwADxgSoADdguoAgAAEgdARgk4NgAACAbgioSABgagBDWC0gjQogdARgk4NgAACANgDYDgioOgagBgNgAgjQpgdAQgk4NgAACAGgDYDgioOhCwCCtgjQphHokBghiAJgAAEBIA4hf//hf//hf//hf//hf//hf//hf//hf//hf//hf//hf70", | |
$a: !0, | |
eb: [44], | |
size: 6252, | |
}; | |
b.X = { sa: 1536, R: 48e3 }; | |
b.duration = { sa: 12288, R: 48e3 }; | |
b.bitrate = 192; | |
b.profile = "ddplus-5.1-dash"; | |
b.channels = "5.1"; | |
}, | |
10697: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACBCBtFvB2gDYBdsbXZoBkgA4BgAAJC7CAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABeWdHJhBrgBYBBcB0BrgOYDgIIKgLoOgCYDgCgDgO4rcBMm1kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBNBlgIgBBIBhBugEQABlgEYDfdbWluBmgA4BAQgoIAgKgLAkgEwAgC4DccZHJlgA4CgTwGcMdXJsAggBYFehc3RiBsgO4CgA4ABzgHYGgC4CdFZWMtAzgaQPAGgMYAgwQJANBkgEgAAzAIgZYAAPgBgCAUBignwAB0gAwAAEgAQAADDogGYGgSAAF0BzgSAJgB4BBzBjgB4JAUgB4BB6gn4NgEYBBjBvgB4JA4hAIABlB4gC4CBtBlgbgGAwgAgCAggNwAgC4DgUAGgAYBgToAg5QFAA", | |
$a: !0, | |
eb: [176, 590], | |
size: 610, | |
}; | |
b.Y = { | |
data: "IABkBtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdMdHJhgC4CAgB0gC4CACAAA6gC4FgAYBAGgAwBAEgCQBgAADAQgD4ABkB0gG4FgAACAUgG4AB1BugFYFAIgAYBBsgIQBcIbWRhB0ALB3ABD/A/CHDAgBoAgCgBgHYCcD+B9lEEEBAAFAEQgBAAcY+fPnDPCfA+B9D/A6C+B8gBQEgAwUB/DOCvgDQWgAwDAfDzCrgHgYgAwBDHD8DqgLwaD5DxgQAgCggXoBd3zWtagCAABtC2DbgAQJe1rWtAgDIdBfA+gDAMDWgDIABogDAAAOD5gD4AgDIvDIgoYCC+gNYADXDPCbgD4LgNYBBagDIegXIxgDIVB2gAYBcAHfNaDWgmgAgDgKgAQAgNYBDQgDIdgXIygDIVCyhPQCDvCagjQADzDmgNgMgDoADWCAgDIdgXIxgDIWCQgQoBAHB8gNYAhUQAA2gD4LgNYBC0gDIegXIxgDIVDsgAYBAAA7DmgjQAhWQAg2ILDbgDoAC1hXYBgDIbgXIygDIViJoGgAADBABZh///h///h///h///h///h///h///h///h///h///h///h///h///h//x", | |
$a: !0, | |
eb: [44], | |
size: 8300, | |
}; | |
b.X = { sa: 1536, R: 48e3 }; | |
b.duration = { sa: 12288, R: 48e3 }; | |
b.bitrate = 256; | |
b.profile = "ddplus-5.1hq-dash"; | |
b.channels = "5.1"; | |
}, | |
28922: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACBCBtFvB2gDYBdsbXZoBkgA4BgAAJC7CAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABeWdHJhBrgBYBBcB0BrgOYDgIIKgLoOgCYDgCgDgO4rcBMm1kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBNBlgIgBBIBhBugEQABlgEYDfdbWluBmgA4BAQgoIAgKgLAkgEwAgC4DccZHJlgA4CgTwGcMdXJsAggBYFehc3RiBsgO4CgA4ABzgHYGgC4CdFZWMtAzgaQPAGgMYAgwQJANBkgEgAAzAMgZYAAPgBgCAUBignwAB0gEICAAAFDcgGYCgEQCgSAAF0BzgSAJgB4BBzBjgB4JAUgB4BB6gn4NgEYBBjBvgB4JA4hAIABlB4gC4CBtBlgbgGAwgAgCAggNwAgC4DgUAGgAYBgPYBg5QEAA", | |
$a: !0, | |
eb: [176, 590], | |
size: 610, | |
}; | |
b.Y = { | |
data: "IABkBtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdMdHJhgC4CAgB0gC4CACAAA6gC4FgAYBAGgAwBgAYAgCQAgAADAQgD4ABkB0gG4FgAACAUgG4AB1BugFYFAIgAYBBsgAQAcwCG1kBhB0ALB3ACD/A/CHDAgKAAgCgBgHYCcEEB+6EEEBAAFAEQgBAAcY+fPnDPCfA+B9D/A6C+B8gBQEgAwlDHD8DqgF4rgAwAAfDzCrgF4rgAwAB/DOCvgF4rD5DxgYwygnwCA2gGwCdttttvAeA8B4DxDjDHCPgAwDgB4AgCYAda1rWtBrgAgCBogEoBBvgGYBDbgEoBgD4FgAwCgBoADfA+gD4DgAgDgEYBANgLQBCbgEYBgIwIgAwAcbbbfPCagEYGBrBAgEgAADBrgP4BA2gJQBgEgbgSQBDmgEYBDegSQJB2gB4AgCYAgEYGBaDQgN4BDZgXwCgJ4SAegB4AgV4AA1gFQGDWCAhHgBgd4BDNgTIABtC8gJ4IDGgJ4PgZwAgOwAgEYBC3gcQIgAwAgB4AgCYAgJAHC0glwVgEgPA3gsQBgEYBBtgSQJA3glwQCQgv3/gvz/gABZBYAGi///iQH/i///i///iQH/i///i///iQH/i///i///iQH/i///i///iQH/i///i///iQH/i///i///iQH/i//q", | |
$a: !0, | |
eb: [44], | |
size: 12396, | |
}; | |
b.X = { sa: 1536, R: 48e3 }; | |
b.duration = { sa: 12288, R: 48e3 }; | |
b.bitrate = 384; | |
b.profile = "ddplus-5.1hq-dash"; | |
b.channels = "5.1"; | |
}, | |
16658: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACBCBtFvB2gDYBdsbXZoBkgA4BgAAJC7CAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABeWdHJhBrgBYBBcB0BrgOYDgIIKgLoOgCYDgCgDgO4rcBMm1kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBNBlgIgBBIBhBugEQABlgEYDfdbWluBmgA4BAQgoIAgKgLAkgEwAgC4DccZHJlgA4CgTwGcMdXJsAggBYFehc3RiBsgO4CgA4ABzgHYGgC4CdFZWMtAzgaQPAGgMYAgwQJANBkgEgAAzAOgZYAAPgBgCAUBignwAB0gAwAAHgEgBDWgGYCDAgSADF0BzgSAJgB4BBzBjgB4JAUgB4BB6gn4NgEYBBjBvgB4JA4hAIABlB4gC4CBtBlgbgGAwgAgCAggNwAgC4DgUAGgAYBgToAg5QFAA", | |
$a: !0, | |
eb: [176, 590], | |
size: 610, | |
}; | |
b.Y = { | |
data: "IABkBtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdMdHJhgC4CAgB0gC4CACAAA6gC4FgAYBAGgAwBAHgCQBgAADAQgD4ABkB0gG4FgAACAUgG4AB1BugFYFAIgAYBBsgAQAc4CG1kBhB0ALB3ADB/A/CHDAgKAAgCgBgHYCcEKB/MAEgEoAdAEAQYD5DzDnDPCfA+B8gAwBDfDzCrgBQGgAwoDHD8DqgF4rgAwDfx/zq+gMwsgAwCB/DOCvgTougAwAAfgag1gpwCcb5tttC2gAQAe3jx48R3gAACd48ePHCPAbgCYAfPmta1CtBrBagAgEC0gFgLA7S7gAABC8gFgCCNgCgADnDNgFAGgAgCgFYBANDzgFQCgAQAgJIAgFgrAdTdgAABDeA8gFgBDGgCgADzDmgQYIgAgAgFYBAGD5gFQDBtgUYBgFgMB2gFgSDwgcgCgRZwgFgcCOTugAABDvguoAgFgBgCgAgx4AgQYJDWCAgFYAADB8gFQDC2gUYBgFgMC7gFgSB4gcgCgRZwgFgdhJ4HhLYBgFgAgCgAhOoAgQYJBrBAh4QBC+gtIEgxICgFgLDdgFgSC8gcgCgRZwgFgdhJwGC7hLYBgFgAgCgAh+YAgQYJC1CggWQBDfA2gQoDhN4CgFgLBugFgSDeijwDgRZvgFgdhJwGDdhLYBgFgAgCgADfA+hmYKDQgFYBBvCbgQoDhN4CgFgLA3gFgTi5ADgRZvgFgdhJwGDuifoCAegN4ABvCfA1gtQJBogFYBA3DNgtIDBvgUYBgFgLAbgCYBgFgQhQABgABpBhBJjf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf//jf7m", | |
$a: !0, | |
eb: [44], | |
size: 14444, | |
}; | |
b.X = { sa: 1536, R: 48e3 }; | |
b.duration = { sa: 12288, R: 48e3 }; | |
b.bitrate = 448; | |
b.profile = "ddplus-5.1hq-dash"; | |
b.channels = "5.1"; | |
}, | |
47708: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACBCBtFvB2gDYBdsbXZoBkgA4BgAAJC7CAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABeWdHJhBrgBYBBcB0BrgOYDgIIKgLoOgCYDgCgDgO4rcBMm1kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBNBlgIgBBIBhBugEQABlgEYDfdbWluBmgA4BAQgoIAgKgLAkgEwAgC4DccZHJlgA4CgTwGcMdXJsAggBYFehc3RiBsgO4CgA4ABzgHYGgC4CdFZWMtAzgaQPAGgMYAgwQJANBkgEgAAzAUgZYAAPgBgCAUBignwAB0gAwAAKgAQAAJgYQCACgEQCgSAAF0BzgSAJgB4BBzBjgB4JAUgB4BB6gn4NgEYBBjBvgB4JA4hAIABlB4gC4CBtBlgbgGAwgAgCAggNwAgC4DgUAGgAYBgToAg5QFAA", | |
$a: !0, | |
eb: [176, 590], | |
size: 610, | |
}; | |
b.Y = { | |
data: "IABkBtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdMdHJhgC4CAgB0gC4CACAAA6gC4FgAYBAGgAwBAKgCQBgAADAQgD4ABkB0gG4FgAACAUgG4AB1BugFYFAIgAYBBsgAQAdQCG1kBhB0ALB3AED/A/CHDAgEgDBAgAYBeOBhhhCGAfDzCrDnDPCfA+B8D5DzgAw0B/DOCvgHo5f58f86C+gHo4gAwADHD8DqgHo5gAwAgfxACggtQCfePHjxPdgrgEgAAQADK7dtttttgdYAfWta1rBagIYMgEACc7x48eA7gEgBC4gIAVAAJ3gIACC3DPCagIICBfgQ4LCAgD4BAHgQAADjDHgEgBB3gIAWAOHuDtgIABC2gGAABagIICgZYLDwgEACDvAegYgAgEYAgAAADggIAVABgb4BgIACDfA+gYAAgIIBghAMgEACAdgQAACPAdgEgBDcgQQWgcABgIACDbDnDNgIIChG4MgnICADC8glYDC8gZQBghQBC7gawCgAASAHgcgAB2gIwCgGwAgpQBgI4AgpYLD4glYDgpYAA8ghQCBwgRAWgcoBgIACBvCfA1gIIChQAMglYDgpYBCOghYCgIAWgcwBgIACBtDzDmg5wCDXhC4Lgn4ChCCDglYDhCzDhCCAghQDhCzEhCCAgHIDhCzDhCCBgHIDjH0FhCA/gHIWgADBAXBQk///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k///k//c", | |
$a: !0, | |
eb: [44], | |
size: 20588, | |
}; | |
b.X = { sa: 1536, R: 48e3 }; | |
b.duration = { sa: 12288, R: 48e3 }; | |
b.bitrate = 640; | |
b.profile = "ddplus-5.1hq-dash"; | |
b.channels = "5.1"; | |
}, | |
94340: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACCtBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABefdHJhBrgBYBBcB0BrgOYDADgLoZgCYDgCgDgO4rcBO21kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBTgB4BBkBIBhgAYABsBlgEYDfmbWluBmgA4BAQgoIAgKgLAkgNYAgC4DccZHJlgA4CgTwGcMdXJsAggBYFeqc3RiBsgA4BBegA4ABzgHYGgC4CdObXA0gVACgaQMgkwAAQgwQJAqBlgGQABzgBACADAcgAgBcEFEAVgAoAAXgAQAAFBYgBoBCAEFcTEFblAAAGABgrQBgTIBF0gFIDgAAFgB4BBzBjgB4JAUgB4BB6gpANgEYBBjBvgB4JA4hBQABlB4gC4CBtBlgcoGA0gAgCAgg2wAgC4DgVIGgAYBAEg6YGgAACdidWR0gZICBagG4AgA4DgAACAhgrwKgyQBg/AAFwggoCgAAHAtBpBsgPwAgA4BAlCpB0hRAAgA4BAdhS4AgHgDghQDdMYXZmA1A5AuAyA3AuAxEw", | |
$a: !0, | |
eb: [176, 599], | |
size: 717, | |
}; | |
b.Y = { | |
data: "IAB8BtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdkdHJhgC4CAcB0gC4CACAAAqgC4FgAYBAEgBwBgAADAQgDYAgEwAgGYFgAACAwgGYAB1BugAwAACgE4CAHgAYBCEgAYBAXgAYBAGgAYVdDbWRhB0DegJgAdMYXZjA1A5AuAzA3AuAxEwcAQiAIDBAYA4AhAQAEBgCMAcgAoc", | |
$a: !0, | |
eb: [44], | |
size: 191, | |
}; | |
b.X = { sa: 1024, R: 24e3 }; | |
b.duration = { sa: 7168, R: 24e3 }; | |
b.bitrate = 128; | |
b.profile = "heaac-2hq-dash"; | |
b.channels = "2.0"; | |
}, | |
42608: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACCtBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABefdHJhBrgBYBBcB0BrgOYDADgLoZgCYDgCgDgO4rcBO21kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBTgB4BBkBIBhgAYABsBlgEYDfmbWluBmgA4BAQgoIAgKgLAkgNYAgC4DccZHJlgA4CgTwGcMdXJsAggBYFeqc3RiBsgA4BBegA4ABzgHYGgC4CdObXA0gVACgaQMgkwAAQgwQJAqBlgGQABzgBACADAcgAgBcEFEAVgAoAAXgAQAAFBYge4CEFcTEFblAAAGABgrQBgTIBF0gFIDgAAFgB4BBzBjgB4JAUgB4BB6gpANgEYBBjBvgB4JA4hBQABlB4gC4CBtBlgcoGA0gAgCAgg2wAgC4DgVIGgAYBAEg6YGgAACdidWR0gZICBagG4AgA4DgAACAhgrwKgyQBg/AAFwggoCgAAHAtBpBsgPwAgA4BAlCpB0hRAAgA4BAdhS4AgHgDghQDdMYXZmA1A5AuAyA3AuAxEw", | |
$a: !0, | |
eb: [176, 599], | |
size: 717, | |
}; | |
b.Y = { | |
data: "IAB8BtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdkdHJhgC4CAcB0gC4CACAAAqgC4FgAYBAEgBwBgAADAQgDYAgEwAgGYFgAACAwgGYAB1BugAwAACgE4CAHgAYBCEgAYBAXgAYBAGgAYVdDbWRhB0DegJgAdMYXZjA1A5AuAzA3AuAxEwcAQiAIDBAYA4AhAQAEBgCMAcgAoc", | |
$a: !0, | |
eb: [44], | |
size: 191, | |
}; | |
b.X = { sa: 1024, R: 24e3 }; | |
b.duration = { sa: 7168, R: 24e3 }; | |
b.bitrate = 64; | |
b.profile = "heaac-2-dash"; | |
b.channels = "2.0"; | |
}, | |
14613: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.channels = b.profile = b.bitrate = b.duration = b.X = void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACCtBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgGABefdHJhBrgBYBBcB0BrgOYDADgLoZgCYDgCgDgO4rcBO21kBpBhgf4CgA4Aga4UBVDEgBgDAtgDoABsBygDIGgjwAB1BugFIKBTgB4BBkBIBhgAYABsBlgEYDfmbWluBmgA4BAQgoIAgKgLAkgNYAgC4DccZHJlgA4CgTwGcMdXJsAggBYFeqc3RiBsgA4BBegA4ABzgHYGgC4CdObXA0gVACgaQMgkwAAQgwQJAqBlgGQABzgBACADAcgAgBcEFEAVgAoAAXgAQAAFBYgBoBBgEFcTEFblAAAGABgrQBgTIBF0gFIDgAAFgB4BBzBjgB4JAUgB4BB6gpANgEYBBjBvgB4JA4hBQABlB4gC4CBtBlgcoGA0gAgCAgg2wAgC4DgVIGgAYBAEg6YGgAACdidWR0gZICBagG4AgA4DgAACAhgrwKgyQBg/AAFwggoCgAAHAtBpBsgPwAgA4BAlCpB0hRAAgA4BAdhS4AgHgDghQDdMYXZmA1A5AuAyA3AuAxEw", | |
$a: !0, | |
eb: [176, 599], | |
size: 717, | |
}; | |
b.Y = { | |
data: "IAB8BtFvBmgA4BcQbWZoBkgA4BgAACABgAYBdkdHJhgC4CAcB0gC4CACAAAqgC4FgAYBAEgBwBgAADAQgDYAgEwAgGYFgAACAwgGYAB1BugAwAACgE4CAHgAYBCEgAYBAXgAYBAGgAYVdDbWRhB0DegJgAdMYXZjA1A5AuAzA3AuAxEwcAQiAIDBAYA4AhAQAEBgCMAcgAoc", | |
$a: !0, | |
eb: [44], | |
size: 191, | |
}; | |
b.X = { sa: 1024, R: 24e3 }; | |
b.duration = { sa: 7168, R: 24e3 }; | |
b.bitrate = 96; | |
b.profile = "heaac-2-dash"; | |
b.channels = "2.0"; | |
}, | |
52426: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.xSa = b.ifb = void 0; | |
b.ifb = { | |
padding: { | |
"16:9": { | |
h264: { | |
23976: function () { | |
return a(77496); | |
}, | |
24: function () { | |
return a(49242); | |
}, | |
25: function () { | |
return a(2267); | |
}, | |
2997: function () { | |
return a(89792); | |
}, | |
30: function () { | |
return a(50519); | |
}, | |
}, | |
h264hpl: { | |
23976: function () { | |
return a(36260); | |
}, | |
24: function () { | |
return a(60398); | |
}, | |
25: function () { | |
return a(99234); | |
}, | |
2997: function () { | |
return a(63029); | |
}, | |
30: function () { | |
return a(99477); | |
}, | |
}, | |
"hevc-main10": { | |
23976: function () { | |
return a(83331); | |
}, | |
24: function () { | |
return a(58028); | |
}, | |
25: function () { | |
return a(42500); | |
}, | |
2997: function () { | |
return a(51930); | |
}, | |
30: function () { | |
return a(33298); | |
}, | |
}, | |
}, | |
"4:3": { | |
h264: { | |
23976: function () { | |
return a(21902); | |
}, | |
24: function () { | |
return a(11024); | |
}, | |
25: function () { | |
return a(43698); | |
}, | |
2997: function () { | |
return a(1370); | |
}, | |
30: function () { | |
return a(87767); | |
}, | |
}, | |
h264hpl: { | |
23976: function () { | |
return a(66101); | |
}, | |
24: function () { | |
return a(67200); | |
}, | |
25: function () { | |
return a(92443); | |
}, | |
2997: function () { | |
return a(53040); | |
}, | |
30: function () { | |
return a(28437); | |
}, | |
}, | |
"hevc-main10": { | |
23976: function () { | |
return a(34896); | |
}, | |
24: function () { | |
return a(99109); | |
}, | |
25: function () { | |
return a(61988); | |
}, | |
2997: function () { | |
return a(1136); | |
}, | |
30: function () { | |
return a(62373); | |
}, | |
}, | |
}, | |
}, | |
}; | |
b.xSa = { | |
silence: { | |
heaac: { | |
64: function () { | |
return a(42608); | |
}, | |
96: function () { | |
return a(14613); | |
}, | |
128: function () { | |
return a(94340); | |
}, | |
}, | |
ddp: { | |
192: function () { | |
return a(40138); | |
}, | |
256: function () { | |
return a(10697); | |
}, | |
384: function () { | |
return a(28922); | |
}, | |
448: function () { | |
return a(16658); | |
}, | |
640: function () { | |
return a(47708); | |
}, | |
}, | |
}, | |
}; | |
}, | |
21902: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACDNBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgAQBchdHJhBrgBYBBcB0BrgOYDgIIKgLoOgO4rABgAgCDwgBwDckZWR0BzgA4BccZWxzB0gGIMAHDSgBIEcBmW1kBpBhgkYCgA4AgfYUBVDEgBgDAtgDoABsBygDIGd2aWRlgFIKBNgNAAgIgABIBhBugEQABlgEYCcBRG1pBuBmgBABAUB2BtgbgPAkgFQAgDYDccZHJlgA4CgSgGcMdXJsAggtQFAEgVwABiBsgBYBC4gA4ABzgSgGgEYCeoYXZjAxgkgWgfABgewABIgBABgAYCgowcgAAGAYH/gAoBAugKoBdDAU1AAND/DhAAAWBngA4BDsGgD9CACIgDAAAfgJIAcF3AB4ChBMCwgJQAcFaOvjDLgT4CAQBwhGgABwgLoFgAYCAUBig5IAgrgBACguQBBnDggAYEgEYAgW4AgvADgAAGgB4BBzBjgB4JAUgB4BB6gRYNgEYBBjBvgB4JA4hRgABlB4gC4CBtBlgzAGAXhUgCAggNwAgC4DgcIGgAYBADDpgBoG", | |
$a: !0, | |
eb: [176, 729], | |
size: 749, | |
}; | |
b.Y = { | |
data: "AAAAtm1vb2YAAAAQbWZoZAAAAAAAAAABAAAAnnRyYWYAAAAYdGZoZAACAAoAAAABAAAAAQAAA+kAAAAQdGZkdAAAAAAAAAAAAAAAXHRydW4AAA4BAAAABgAAAL4AAALwAmAAAAAAB9IAAAAQAWEAAAAAE40AAAAOAWEAAAAAB9IAAAAOAaEAAAAAAAAAAAAOAaEAAAAAA+kAAAAWAWEAAAAAB9IAAAASc2R0cAAAAAAmFhYaGhYAAANIbWRhdAAAAq4GBf//qtxF6b3m2Ui3lizYINkj7u94MjY0IC0gY29yZSAxNjQgcjMwOTUgYmFlZTQwMCAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjIgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDE6MHgxMTEgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTAgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz03IGxvb2thaGVhZF90aHJlYWRzPTEgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yMyBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAADpliIQAN//+9vD+BTZWBFCXEc3onTMfvxW4ujQ3vc4AAq1PEG+4LBNpT2AQQAABnxHdErgspBAQL0rrAAAADEGaJGxC//6MsAADagAAAApBnkJ4hf8AAIOBAAAACgGeYXRCvwAAtoAAAAAKAZ5jakK/AAC2gQAAABJBmmVJqEFomUwIV//+OEAADUk=", | |
$a: !1, | |
eb: [44], | |
size: 1022, | |
}; | |
b.X = { sa: 1001, R: 24e3 }; | |
b.duration = { sa: 6006, R: 24e3 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
11024: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(21902); | |
b.ka = { | |
data: "hdghDPhdhxAjhdh9DQhdgFCbhdhSBGhdg9AGhdgFC6hdgNCqhdhTAwhdgJAYhdgKADAAAIgAgBABCAhdwohJoBgAYDhdxXgO4ChdwSDogBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "h/o1Doh/otDQh/oJCIh/oJgC4Ch/oSgL4Ch/oGgEYCh/v/h/pBg9AAh/sP", | |
$a: !0, | |
eb: [44], | |
size: 1022, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 24e3 }; | |
b.duration = { sa: 6e3, R: 24e3 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
43698: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(21902); | |
b.ka = { | |
data: "hdghDPhdgYBhCohdhVAjhdh9DQhdgFCbhdgYgfYEhdgyBGhdg9AGhdgFC6hdgNCqhdhTAwhdgJAYhdgKADAAAIgAgBABCQhdwoBehJwBgAYChdxWAbBYhdwVDogBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDDh/oVCrh/oZDoh/oRgvQAh/oIAHgAYBDLh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFALC4gC4NATiBIMAagCwBBWiBX/iBQug/4AiBTHdDP/6eAQhgYAh1QCiBQrBmiBQEAUDwCviBQHgEYBCFgEYF", | |
$a: !0, | |
eb: [44], | |
size: 1049, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 25e3 }; | |
b.duration = { sa: 7e3, R: 25e3 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
1370: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(21902); | |
b.ka = { | |
data: "hdg8B1Awhdj4gfYEhdj8AHBThdgpBkDogAYEhdhWgR4Bhdgd", | |
$a: !0, | |
eb: [176, 729], | |
size: 749, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/othkQAh/oIAIgAYBDYh/pEAPCkgHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1001, R: 3e4 }; | |
b.duration = { sa: 8008, R: 3e4 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
87767: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(21902); | |
b.ka = { | |
data: "hdghDPhdgYB1AwhdhVAjhdh9DQhdgFCbhdgYgfYEhdgyBGhdg9AGhdgFC6hdgNCqhdhTAwhdgJAYhdgKADAAAIgAgBABDghdwogioCgjIDhdxVAfg7gChdwSDogBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/oZDoh/oRhkQAh/oIAIgAYBDYh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFAPCggHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 3e4 }; | |
b.duration = { sa: 8e3, R: 3e4 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
66101: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACDPBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgAQBcjdHJhBrgBYBBcB0BrgOYDgIIKgLoOgO4rABgAgCDwgBwDckZWR0BzgA4BccZWxzB0gGIMAHDSgBIEcBm21kBpBhgkYCgA4AgfYUBVDEgBgDAtgDoABsBygDIGd2aWRlgFIKBNgNAAgIgABIBhBugEQABlgEYCcBRm1pBuBmgBABAUB2BtgbgPAkgFQAgDYDccZHJlgA4CgSgGcMdXJsAggtQFAGgVwABiBsgBYBC6gA4ABzgSgGgEYCeqYXZjAxgkgWgfABgewABIgBABgAYCgowcgAAGAYH/gAoBAwgKoBBDABgM4AcN/+EAAXBngA4BCsDZFBD7ABAQgDIAc+kAALC4AADxBCCZBggJYAcGaOvjDLAigiQCAQBwhGwABwgL4FgAYCAUBig5YAgrwBACgugBBnDggAYEgEYAgXIAgvQDgAAGgB4BBzBjgB4JAUgB4BB6gRoNgEYBBjBvgB4JA4hRwABlB4gC4CBtBlgzQGAXhUwCAggNwAgC4DgcYGgAYBADDpgBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
}; | |
b.Y = { | |
data: "AAAAtm1vb2YAAAAQbWZoZAAAAAAAAAABAAAAnnRyYWYAAAAYdGZoZAACAAoAAAABAAAAAQAAA+kAAAAQdGZkdAAAAAAAAAAAAAAAXHRydW4AAA4BAAAABgAAAL4AAALwAmAAAAAAB9IAAAAQAWEAAAAAE40AAAAOAWEAAAAAB9IAAAAOAaEAAAAAAAAAAAAOAaEAAAAAA+kAAAAWAWEAAAAAB9IAAAASc2R0cAAAAAAmFhYaGhYAAANIbWRhdAAAAq4GBf//qtxF6b3m2Ui3lizYINkj7u94MjY0IC0gY29yZSAxNjQgcjMwOTUgYmFlZTQwMCAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjIgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz03IGxvb2thaGVhZF90aHJlYWRzPTEgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yMyBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAADpliIQAN//+9vD+BTZWBFCXEc3onTMfvxW4ujQ3vc4AAq1PEG+4LBNpT2AQQAABnxHdErgspBAQL0rrAAAADEGaJGxC//6MsAADagAAAApBnkJ4hf8AAIOBAAAACgGeYXRCvwAAtoAAAAAKAZ5jakK/AAC2gQAAABJBmmVJqEFomUwIV//+OEAADUk=", | |
$a: !1, | |
eb: [44], | |
size: 1022, | |
}; | |
b.X = { sa: 1001, R: 24e3 }; | |
b.duration = { sa: 6006, R: 24e3 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
67200: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(66101); | |
b.ka = { | |
data: "hdwhDRhdxxAlhdx9DQhdwFCdhdxSBIhdw9AIhdwFC8hdwNCshdxTAyhdwJAZhdwLADhNQAgAgBgAoAheAphJ4BgAYDheBXgO4CheASDogBoG", | |
$a: !0, | |
eb: [176, 733], | |
size: 753, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "h/o1Doh/otDQh/oJCIh/oJgC4Ch/oSgL4Ch/oGgEYCh/v/h/pBg9AAh/sP", | |
$a: !0, | |
eb: [44], | |
size: 1022, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 24e3 }; | |
b.duration = { sa: 6e3, R: 24e3 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
92443: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(66101); | |
b.ka = { | |
data: "hdwhDRhdwYBhCohdxVAlhdx9DQhdwFCdhdwYgfYEhdwyBIhdw9AIhdwFC8hdwNCshdxTAyhdwJAZhdwLADhNQAgAgBADAgheApBehKABgAYCheBWAbBYheAVDogBoG", | |
$a: !0, | |
eb: [176, 733], | |
size: 753, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDDh/oVCrh/oZDoh/oRgvQAh/oIAHgAYBDLh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFALC4gC4NATiBIMAagCwBBWiBX/iBQug/4AiBTHdDP/6eAQhgYAh1QCiBQrBmiBQEAUDwCviBQHgEYBCFgEYF", | |
$a: !0, | |
eb: [44], | |
size: 1049, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 25e3 }; | |
b.duration = { sa: 7e3, R: 25e3 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
53040: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(66101); | |
b.ka = { | |
data: "hdw8B1Awhdz4gfYEhdz9AOCmhdwqBkDogAYEhdxWAfgbYChdwb", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/othkQAh/oIAIgAYBDYh/pEAPCkgHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1001, R: 3e4 }; | |
b.duration = { sa: 8008, R: 3e4 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
28437: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(66101); | |
b.ka = { | |
data: "hdwhDRhdwYB1AwhdxVAlhdx9DQhdwFCdhdwYgfYEhdwyBIhdw9AIhdwFC8hdwNCshdxTAyhdwJAZhdwLADhNQAgAgBADDAheApgi4CgjYDheBVAfg7wCheASDogBoG", | |
$a: !0, | |
eb: [176, 733], | |
size: 753, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/oZDoh/oRhkQAh/oIAIgAYBDYh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFAPCggHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 3e4 }; | |
b.duration = { sa: 8e3, R: 3e4 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
34896: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAADBsBtFvB2gDYBgA4AB2BoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgAQBfAdHJhBrgBYBBcB0BrgOYDgIIKgLoOgO4rABgAgCDwgBwDckZWR0BzgA4BccZWxzB0gGIMAHDSgBIEcCOG1kBpBhgkYCgA4AgfYUBVDEgBgDAtgDoABsBygDIGd2aWRlgFIKBNgNAAgIgABIBhBugEQABlgEYCcB421pBuBmgBABAUB2BtgbgPAkgFQAgDYDccZHJlgA4CgSgGcMdXJsAggtQFCjgVwABiBsgA4BBXgA4ABzgSgGgC4CdHaHZjAxgkgWgfABgewABIgBABgAYCgowcgAAGAYH/gAoBC6gKoBBDABACgPgCCQgfAEgI4AH9H6gBAAAPADCggIoBcYQAEMABgFIAgEACADgEICgAgAgAQBddmLAkChgDgBBtBCEBgDINegCggPATBnCYC5AkApAQATC4BCCwGJfl9/o8DZDLD6A5CUDJB7gAgAezL9GFAIBOAiCxAmBeD+COBsDLD0BhBEBOBqDECbD2BlD6AwCmCcCVCUDfCjAKBKDABaKACCg0QDcAu4H0BVDvB+AACXBAASDwABAuCAAlDhCigOIBcHRAHBByD2A8gVQCAQBwhYAABwgdIFgAYCATBjBvg0gAduY2x4gBoBgAICgwQCBihNAAg/YCBngAQAAigGQBgAYCgGwAgqwAhC4DgAAGgB4BBzBjgB4JAUgB4BB6glQNgEYBgLgAgB4JhG4AB2BlgMwAgC4BBtBlhG4GAXhoYCAggNwAgC4DgwAGgAYBADDpgBoG", | |
$a: !0, | |
eb: [176, 888], | |
size: 908, | |
}; | |
b.Y = { | |
data: "IAC2BtFvBmgA4BcQbWZoBkgA4BgAACABgAYBeedHJhgC4CAYB0gC4CACAAAKgC4FgAYBADDpgF4CgC4ABkB0gF4FgAACBcgF4AB1BugAwAAOgEYCAGgAYBC+gAYBBnACBggDQCAHDSgAgBAkABBhgBYCATCNgAgBAhgBYEgC4FChgIYHAjgBYEgL4DAigEYJASBzgNQABwgBoCAmEWEaAWgQgBcdbWRhgPoCcGTgGBABADCAgBIBAWgBIAgSYACggHgBcAIPWAAKD8CAgAoDCQgDICANgDIAABgSIBgDAAgAQBAEgCACcuJgGsB9DgCECCAkC/D/D8BhgAwAczjsxSCKBCD8BJgDQBgEAAADA8gFIDBXDAgeQAgBIEDagIQOAHgCACcPAgHgAmBYDCA+DwCYgCQCCjgCQCAMgEYFggABgMoDANgEQBcWKMI2DwCagBoAACCCgIgJgpYAgAYBgIgDgY4ADgAOA4gIgLgEYGgNICgawDAOgEYBceSMIRC8CVgBoBBTgSoAgAAAALgEQEAEgMwFgRICcovGEfB4gIgF", | |
$a: !0, | |
eb: [44], | |
size: 467, | |
}; | |
b.X = { sa: 1001, R: 24e3 }; | |
b.duration = { sa: 6006, R: 24e3 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
99109: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(34896); | |
b.ka = { | |
data: "hxYhBuhxZxDChxZ9DQhxYFA6hxZSDlhxY9ClhxYFBZhxYNBJhxZTC8hxY6BvhxZXgJIAhE4BgAgAAxhxpKgZwAgAYDhxpXgRQChxoSDogBoG", | |
$a: !0, | |
eb: [176, 890], | |
size: 910, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "g6Q1Dog6QtDQg6QJCIg6QJgC4Eg6QQgL4Cg6QGgEYCg6Uq", | |
$a: !0, | |
eb: [44], | |
size: 467, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 24e3 }; | |
b.duration = { sa: 6e3, R: 24e3 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
61988: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(34896); | |
b.ka = { | |
data: "hxYhBuhxYYBhCohxZVDChxZ9DQhxYFA6hxYYgfYEhxYyDlhxY9ClhxYFBZhxYNBJhxZTC8hxY6BvhxZXgJIAhE4BgAgAAzhxpJAjAIgAYEhxpWAbBYhxoVDogBoG", | |
$a: !0, | |
eb: [176, 890], | |
size: 910, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCQBDDg6QVCrg6QZDog6QRBog6QJAHgAYBDLg6QJDQg6QJCIg3QDg1wEgC4Eg6QQgL4Cg6QFALC4gC4NATg7wMAagSIBBCg76ggEQCg74Bg3oSg8JHAFgNAGcw6rGEAjB4gEIHgRYFAFgIYGgM4Ccol8YQCNDggEQE", | |
$a: !0, | |
eb: [44], | |
size: 517, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 25e3 }; | |
b.duration = { sa: 7e3, R: 25e3 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
1136: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(34896); | |
b.ka = { | |
data: "hxY8B1Awhxb4gfYEhxd7DqBhhxZJAoCAgAYEhxZWAfgvAChxYb", | |
$a: !0, | |
eb: [176, 888], | |
size: 908, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCQBDQg6QVC4g6QtF0g6QIAIgAYBDYg6QZg1wKg4wFg6QPgBYAgEYDALC7gC4NhBwKAUg9QMg9gDBig9igAOg9gEg0wJg9oPg5ICg9oBgEQRg9gjAFgEACAQgMwBcw6rGEAnB4CTgRQCAiggQBgRQGAFgIgGhKoCcol8YQCNDggIoOgJACgVgGA4hGQAAIDegEAE", | |
$a: !0, | |
eb: [44], | |
size: 562, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1001, R: 3e4 }; | |
b.duration = { sa: 8008, R: 3e4 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
62373: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(34896); | |
b.ka = { | |
data: "hxYhBuhxYYB1AwhxZVDChxZ9DQhxYFA6hxYYgfYEhxYyDlhxY9ClhxYFBZhxYNBJhxZTC8hxY6BvhxZXgJIAhE4BgAgAA9hxpJAoCogAYEhxpWAfhPYChxoSDogBoG", | |
$a: !0, | |
eb: [176, 890], | |
size: 910, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCQBDQg6QVC4g6QZDog6QRF0g6QIAIgAYBDYg6QJDQg6QJCIg3QDg1wEgC4Cg4wFg6QLgL4CgEYFALC4gC4NhBwGgHYCAUg9QMg9gDBjg9iggEQCg9gBg5QSg9wHg5QCg9wBg5QJg9orAFgEACAQgM4Bcw6rGEAnB4CTgNACAiggYBgRYGAFgIgGhKwCcol8YQCNDggIoOgJACgMwDgIoBA4hGYAAIDegEAE", | |
$a: !0, | |
eb: [44], | |
size: 563, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 3e4 }; | |
b.duration = { sa: 8e3, R: 3e4 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 1; | |
b.Ib = 1; | |
}, | |
77496: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACDNBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgAQBchdHJhBrgBYBBcB0BrgOYDgIIKgLoOgO4rABCqgAgBDwgBwDckZWR0BzgA4BccZWxzB0gGIMAHDSgBIEcBmW1kBpBhgkYCgA4AgfYUBVDEgBgDAtgDoABsBygDIGd2aWRlgFIKBNgNAAgIgABIBhBugEQABlgEYCcBRG1pBuBmgBABAUB2BtgbgPAkgFQAgDYDccZHJlgA4CgSgGcMdXJsAggtQFAEgVwABiBsgBYBC4gA4ABzgSgGgEYCeoYXZjAxgkgWABgfoAgewABIgBABgAYCgowcgAAGAYH/gAoBAugKoBdDAU1AAND/DhAAAWBngA4BDsGgD9CHAIgDAAAfgJIAcF3AB4ChBMCwgJQAcFaOvjDLgT4CAQBwhGgABwgA4BAEgAYBADgcYCBig5IAgrgBACguQBBnDggAYEgEYAgW4AgvADgAAGgB4BBzBjgB4JAUgB4BB6gRYNgEYBBjBvgB4JA4hRgABlB4gC4CBtBlgzAGAXhUgCAggNwAgC4DgcIGgAYBADDpgBoG", | |
$a: !0, | |
eb: [176, 729], | |
size: 749, | |
}; | |
b.Y = { | |
data: "AAAAtm1vb2YAAAAQbWZoZAAAAAAAAAABAAAAnnRyYWYAAAAYdGZoZAACAAoAAAABAAAAAQAAA+kAAAAQdGZkdAAAAAAAAAAAAAAAXHRydW4AAA4BAAAABgAAAL4AAALwAmAAAAAAB9IAAAAQAWEAAAAAE40AAAAOAWEAAAAAB9IAAAAOAaEAAAAAAAAAAAAOAaEAAAAAA+kAAAAWAWEAAAAAB9IAAAASc2R0cAAAAAAmFhYaGhYAAANIbWRhdAAAAq4GBf//qtxF6b3m2Ui3lizYINkj7u94MjY0IC0gY29yZSAxNjQgcjMwOTUgYmFlZTQwMCAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjIgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDE6MHgxMTEgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTAgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz03IGxvb2thaGVhZF90aHJlYWRzPTEgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yMyBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAADpliIQAN//+9vD+BTZWBFCXEc3onTMfvxW4ujQ3vc4AAq1PEG+4LBNpT2AQQAABnxHdErgspBAQL0rrAAAADEGaJGxC//6MsAADagAAAApBnkJ4hf8AAIOBAAAACgGeYXRCvwAAtoAAAAAKAZ5jakK/AAC2gQAAABJBmmVJqEFomUwIV//+OEAADUk=", | |
$a: !1, | |
eb: [44], | |
size: 1022, | |
}; | |
b.X = { sa: 1001, R: 24e3 }; | |
b.duration = { sa: 6006, R: 24e3 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
49242: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(77496); | |
b.ka = { | |
data: "hdghDPhdhxAjhdh9DQhdgFCbhdhSBGhdg9AGhdgFC6hdgNCqhdhTAwhdgJAYhdgKhZYAgAgCABCAhdwohJoBgAYDhdxXgO4ChdwSDogBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "h/o1Doh/otDQh/oJCIh/oJgC4Ch/oSgL4Ch/oGgEYCh/v/h/pBg9AAh/sP", | |
$a: !0, | |
eb: [44], | |
size: 1022, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 24e3 }; | |
b.duration = { sa: 6e3, R: 24e3 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
2267: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(77496); | |
b.ka = { | |
data: "hdghDPhdgYBhCohdhVAjhdh9DQhdgFCbhdgYgfYEhdgyBGhdg9AGhdgFC6hdgNCqhdhTAwhdgJAYhdgKhZYAgAgCABCQhdwoBehJwBgAYChdxWAbBYhdwVDogBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDDh/oVCrh/oZDoh/oRgvQAh/oIAHgAYBDLh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFALC4gC4NATiBIMAagCwBBWiBX/iBQug/4AiBTHdDP/6eAQhgYAh1QCiBQrBmiBQEAUDwCviBQHgEYBCFgEYF", | |
$a: !0, | |
eb: [44], | |
size: 1049, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 25e3 }; | |
b.duration = { sa: 7e3, R: 25e3 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
89792: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(77496); | |
b.ka = { | |
data: "hdg8B1Awhdj4gfYEhdj8AHBThdgpBkDogAYEhdhWgR4Bhdgd", | |
$a: !0, | |
eb: [176, 729], | |
size: 749, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/othkQAh/oIAIgAYBDYh/pEAPCkgHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1001, R: 3e4 }; | |
b.duration = { sa: 8008, R: 3e4 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
50519: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(77496); | |
b.ka = { | |
data: "hdghDPhdgYB1AwhdhVAjhdh9DQhdgFCbhdgYgfYEhdgyBGhdg9AGhdgFC6hdgNCqhdhTAwhdgJAYhdgKhZYAgAgCABDghdwogioCgjIDhdxVAfg8IChdwSDogBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/oZDoh/oRhkQAh/oIAIgAYBDYh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFAPCggHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 3e4 }; | |
b.duration = { sa: 8e3, R: 3e4 }; | |
b.profile = "playready-h264mpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
36260: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAACDPBtFvB2gDYBdsbXZoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgAQBcjdHJhBrgBYBBcB0BrgOYDgIIKgLoOgO4rABCqgAgBDwgBwDckZWR0BzgA4BccZWxzB0gGIMAHDSgBIEcBm21kBpBhgkYCgA4AgfYUBVDEgBgDAtgDoABsBygDIGd2aWRlgFIKBNgNAAgIgABIBhBugEQABlgEYCcBRm1pBuBmgBABAUB2BtgbgPAkgFQAgDYDccZHJlgA4CgSgGcMdXJsAggtQFAGgVwABiBsgBYBC6gA4ABzgSgGgEYCeqYXZjAxgkgWABgfoAgewABIgBABgAYCgowcgAAGAYH/gAoBAwgKoBBDABgM4AcN/+EAAXBngA4BCsDZFBD7AOAQgDIAc+kAALC4AADxBCCZBggJYAcGaOvjDLAigiQCAQBwhGwABwgA4BAEgAYBADgcoCBig5YAgrwBACgugBBnDggAYEgEYAgXIAgvQDgAAGgB4BBzBjgB4JAUgB4BB6gRoNgEYBBjBvgB4JA4hRwABlB4gC4CBtBlgzQGAXhUwCAggNwAgC4DgcYGgAYBADDpgBoG", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
}; | |
b.Y = { | |
data: "AAAAtm1vb2YAAAAQbWZoZAAAAAAAAAABAAAAnnRyYWYAAAAYdGZoZAACAAoAAAABAAAAAQAAA+kAAAAQdGZkdAAAAAAAAAAAAAAAXHRydW4AAA4BAAAABgAAAL4AAALwAmAAAAAAB9IAAAAQAWEAAAAAE40AAAAOAWEAAAAAB9IAAAAOAaEAAAAAAAAAAAAOAaEAAAAAA+kAAAAWAWEAAAAAB9IAAAASc2R0cAAAAAAmFhYaGhYAAANIbWRhdAAAAq4GBf//qtxF6b3m2Ui3lizYINkj7u94MjY0IC0gY29yZSAxNjQgcjMwOTUgYmFlZTQwMCAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjIgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz03IGxvb2thaGVhZF90aHJlYWRzPTEgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yMyBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAADpliIQAN//+9vD+BTZWBFCXEc3onTMfvxW4ujQ3vc4AAq1PEG+4LBNpT2AQQAABnxHdErgspBAQL0rrAAAADEGaJGxC//6MsAADagAAAApBnkJ4hf8AAIOBAAAACgGeYXRCvwAAtoAAAAAKAZ5jakK/AAC2gQAAABJBmmVJqEFomUwIV//+OEAADUk=", | |
$a: !1, | |
eb: [44], | |
size: 1022, | |
}; | |
b.X = { sa: 1001, R: 24e3 }; | |
b.duration = { sa: 6006, R: 24e3 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
60398: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(36260); | |
b.ka = { | |
data: "hdwhDRhdxxAlhdx9DQhdwFCdhdxSBIhdw9AIhdwFC8hdwNCshdxTAyhdwJAZhdwLhZgAgAgCgAoAheAphJ4BgAYDheBXgO4CheASDogBoG", | |
$a: !0, | |
eb: [176, 733], | |
size: 753, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "h/o1Doh/otDQh/oJCIh/oJgC4Ch/oSgL4Ch/oGgEYCh/v/h/pBg9AAh/sP", | |
$a: !0, | |
eb: [44], | |
size: 1022, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 24e3 }; | |
b.duration = { sa: 6e3, R: 24e3 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
99234: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(36260); | |
b.ka = { | |
data: "hdwhDRhdwYBhCohdxVAlhdx9DQhdwFCdhdwYgfYEhdwyBIhdw9AIhdwFC8hdwNCshdxTAyhdwJAZhdwLhZgAgAgCADAgheApBehKABgAYCheBWAbBYheAVDogBoG", | |
$a: !0, | |
eb: [176, 733], | |
size: 753, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDDh/oVCrh/oZDoh/oRgvQAh/oIAHgAYBDLh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFALC4gC4NATiBIMAagCwBBWiBX/iBQug/4AiBTHdDP/6eAQhgYAh1QCiBQrBmiBQEAUDwCviBQHgEYBCFgEYF", | |
$a: !0, | |
eb: [44], | |
size: 1049, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 25e3 }; | |
b.duration = { sa: 7e3, R: 25e3 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
63029: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(36260); | |
b.ka = { | |
data: "hdw8B1Awhdz4gfYEhdz9AOCmhdwqBkDogAYEhdxWAfgbYChdwb", | |
$a: !0, | |
eb: [176, 731], | |
size: 751, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/othkQAh/oIAIgAYBDYh/pEAPCkgHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1001, R: 3e4 }; | |
b.duration = { sa: 8008, R: 3e4 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
99477: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(36260); | |
b.ka = { | |
data: "hdwhDRhdwYB1AwhdxVAlhdx9DQhdwFCdhdwYgfYEhdwyBIhdw9AIhdwFC8hdwNCshdxTAyhdwJAZhdwLhZgAgAgCADDAheApgi4CgjYDheBVAfg8YCheASDogBoG", | |
$a: !0, | |
eb: [176, 733], | |
size: 753, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCoBDQh/oVC4h/oZDoh/oRhkQAh/oIAIgAYBDYh/oJDQh/oJCIh/oJgC4Ch/oSgL4Ch/oFAPCggHYIgC4DgEYKAUiCoMgAYAgC4BBmiC//iC4ug/4AiC6JAziC4BDsC+iC4AAUDIiC4BcsxdpKBwA+AqCkGAB3A0DAhlwAcW5YhODXD+DzDeDPCABpgBoAcKgHlYBoAkA0CnARCRDmDoBxiC4XB/h/YFiC4EgBoBDpiC4IgBoCiC4FBniC4FdP//3xgCAAAfDhgJ4DCeCFBFgQIAAriLIBgIIGCmgGYF", | |
$a: !0, | |
eb: [44], | |
size: 1078, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 3e4 }; | |
b.duration = { sa: 8e3, R: 3e4 }; | |
b.profile = "playready-h264hpl30-dash"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
83331: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
void 0; | |
b.ka = { | |
data: "IAcgZnR5BwBpBzBvA2gBYBABgA4CBkBzBtgAIBdpeGRhBzBogCQAADBsBtFvB2gDYBgA4AB2BoBkgA4BgAAJBdDAgAwDABgAQDgAAIgBgLgB4QBAgDwNgAANACgAQBfAdHJhBrgBYBBcB0BrgOYDgIIKgLoOgO4rABCqgAgBDwgBwDckZWR0BzgA4BccZWxzB0gGIMAHDSgBIEcCOG1kBpBhgkYCgA4AgfYUBVDEgBgDAtgDoABsBygDIGd2aWRlgFIKBNgNAAgIgABIBhBugEQABlgEYCcB421pBuBmgBABAUB2BtgbgPAkgFQAgDYDccZHJlgA4CgSgGcMdXJsAggtQFCjgVwABiBsgA4BBXgA4ABzgSgGgC4CdHaHZjAxgkgWABgfoAgewABIgBABgAYCgowcgAAGAYH/gAoBC6gKoBBDABACgPgCCQgfAEgI4AH9H6gBAAAPADCggIoBcYQAEMABgFIAgEACADgEICgAgAgAQBddmLAkChgDgBBtBCEBgDINegCggPATBnCYC5AkApAQATC4BCCwGJfl9/o8DZDLD6A5CUDJB7gAgAezL9GFAIBOAiCxAmBeD+COBsDLD0BhBEBOBqDECbD2BlD6AwCmCcCVCUDfCjAKBKDDCaKACCg0QDcAu4H0BVDvB+AACXBAASDwABAuCAAlDhCigOIBcHRAHBByD2A8gVQCAQBwhYAABwgA4BAEgAYBgPYBcAE2Nvg0gAduY2x4gEwBgAICgwQCBihNAAg/YCBngAQAAigGQBgAYCgGwAgqwAhC4DgAAGgB4BBzBjgB4JAUgB4BB6glQNgEYBgLgAgB4JhG4AB2BlgMwAgC4BBtBlhG4GAXhoYCAggNwAgC4DgwAGgAYBADDpgBoG", | |
$a: !0, | |
eb: [176, 888], | |
size: 908, | |
}; | |
b.Y = { | |
data: "IAC2BtFvBmgA4BcQbWZoBkgA4BgAACABgAYBeedHJhgC4CAYB0gC4CACAAAKgC4FgAYBADDpgF4CgC4ABkB0gF4FgAACBcgF4AB1BugAwAAOgEYCAGgAYBC+gAYBBnACBggDQCAHDSgAgBAkABBhgBYCATCNgAgBAhgBYEgC4FChgIYHAjgBYEgL4DAigEYJASBzgNQABwgBoCAmEWEaAWgQgBcdbWRhgPoCcGTgGBABADCAgBIBAWgBIAgSYACggHgBcAIPWAAKD8CAgAoDCQgDICANgDIAABgSIBgDAAgAQBAEgCACcuJgGsB9DgCECCAkC/D/D8BhgAwAczjsxSCKBCD8BJgDQBgEAAADA8gFIDBXDAgeQAgBIEDagIQOAHgCACcPAgHgAmBYDCA+DwCYgCQCCjgCQCAMgEYFggABgMoDANgEQBcWKMI2DwCagBoAACCCgIgJgpYAgAYBgIgDgY4ADgAOA4gIgLgEYGgNICgawDAOgEYBceSMIRC8CVgBoBBTgSoAgAAAALgEQEAEgMwFgRICcovGEfB4gIgF", | |
$a: !0, | |
eb: [44], | |
size: 467, | |
}; | |
b.X = { sa: 1001, R: 24e3 }; | |
b.duration = { sa: 6006, R: 24e3 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
58028: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(83331); | |
b.ka = { | |
data: "hxYhBuhxZxDChxZ9DQhxYFA6hxZSDlhxY9ClhxYFBZhxYNBJhxZTC8hxY6BvhxZXgJIAhE4BgAgAAxhxpKgZwAgAYDhxpXgRQChxoSDogBoG", | |
$a: !0, | |
eb: [176, 890], | |
size: 910, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "g6Q1Dog6QtDQg6QJCIg6QJgC4Eg6QQgL4Cg6QGgEYCg6Uq", | |
$a: !0, | |
eb: [44], | |
size: 467, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 24e3 }; | |
b.duration = { sa: 6e3, R: 24e3 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
42500: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(83331); | |
b.ka = { | |
data: "hxYhBuhxYYBhCohxZVDChxZ9DQhxYFA6hxYYgfYEhxYyDlhxY9ClhxYFBZhxYNBJhxZTC8hxY6BvhxZXgJIAhE4BgAgAAzhxpJAjAIgAYEhxpWAbBYhxoVDogBoG", | |
$a: !0, | |
eb: [176, 890], | |
size: 910, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCQBDDg6QVCrg6QZDog6QRBog6QJAHgAYBDLg6QJDQg6QJCIg3QDg1wEgC4Eg6QQgL4Cg6QFALC4gC4NATg7wMAagSIBBCg76ggEQCg74Bg3oSg8JHAFgNAGcw6rGEAjB4gEIHgRYFAFgIYGgM4Ccol8YQCNDggEQE", | |
$a: !0, | |
eb: [44], | |
size: 517, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 25e3 }; | |
b.duration = { sa: 7e3, R: 25e3 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
51930: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(83331); | |
b.ka = { | |
data: "hxY8B1Awhxb4gfYEhxd7DqBhhxZJAoCYgAYEhxZWAfgvAChxYb", | |
$a: !0, | |
eb: [176, 888], | |
size: 908, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCQBDQg6QVC4g6QtF0g6QIAIgAYBDYg6QZg3QAg1wIg4wFg6QPgEYFALC7gC4NhBwKAUg9QMg9gDBjg9iggEQCg9gBg5QSg9wHg5QCg9wBg5QJg9orAFgEACAQgM4Bcw6rGEAnB4CTgNACAiggYBgRYGAFgIgGhKwCcol8YQCNDggIoOgJACgMwDgIoBA4hGYAAIDegEAE", | |
$a: !0, | |
eb: [44], | |
size: 563, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1001, R: 3e4 }; | |
b.duration = { sa: 8008, R: 3e4 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
33298: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ib = | |
b.Hb = | |
b.height = | |
b.width = | |
b.bitrate = | |
b.profile = | |
b.duration = | |
b.X = | |
b.Y = | |
b.ka = | |
void 0; | |
r = a(83331); | |
b.ka = { | |
data: "hxYhBuhxYYB1AwhxZVDChxZ9DQhxYFA6hxYYgfYEhxYyDlhxY9ClhxYFBZhxYNBJhxZTC8hxY6BvhxZXgJIAhE4BgAgAA9hxpJAoCogAYEhxpWAfhQAChxoSDogBoG", | |
$a: !0, | |
eb: [176, 890], | |
size: 910, | |
mc: r.ka, | |
}; | |
b.Y = { | |
data: "gCQBDQg6QVC4g6QZDog6QRF0g6QIAIgAYBDYg6QJDQg6QJCIg3QDg1wEgC4Cg4wFg6QLgL4CgEYFALC4gC4NhBwGgHYCAUg9QMg9gDBjg9iggEQCg9gBg5QSg9wHg5QCg9wBg5QJg9orAFgEACAQgM4Bcw6rGEAnB4CTgNACAiggYBgRYGAFgIgGhKwCcol8YQCNDggIoOgJACgMwDgIoBA4hGYAAIDegEAE", | |
$a: !0, | |
eb: [44], | |
size: 563, | |
mc: r.Y, | |
}; | |
b.X = { sa: 1e3, R: 3e4 }; | |
b.duration = { sa: 8e3, R: 3e4 }; | |
b.profile = "hevc-main10-L30-dash-cenc-prk-do"; | |
b.bitrate = 64; | |
b.width = 320; | |
b.height = 240; | |
b.Hb = 4; | |
b.Ib = 3; | |
}, | |
8604: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
r = a(5163); | |
r.__exportStar(a(56163), b); | |
r.__exportStar(a(5102), b); | |
}, | |
38315: function (r, b, a) { | |
var d; | |
function c(f) { | |
return ( | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="[ | |
f >> 6 | |
] + | |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="[ | |
f & 63 | |
] | |
); | |
} | |
function l(f, m) { | |
(0, d.assert)(0 < m && 8 > m); | |
return c(((m - 1) << 8) + f); | |
} | |
function g(f) { | |
return ( | |
c(1792 + f[0]) + | |
c((f[1] << 4) + (f[2] >>> 4)) + | |
c(((f[2] << 8) & 3840) + f[3]) | |
); | |
} | |
function k(f) { | |
return 43 === f | |
? 62 | |
: 47 === f | |
? 63 | |
: 58 > f | |
? f - 48 + 52 | |
: 91 > f | |
? f - 65 | |
: f - 71; | |
} | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.n7 = b.xQb = void 0; | |
d = a(45929); | |
b.xQb = function (f, m) { | |
var p, q, u, t, v, w; | |
function h(y, x) { | |
var z; | |
z = p; | |
y = q - x - y; | |
(0, d.assert)(1 <= y); | |
(0, d.assert)(16384 > y - 1); | |
(0, d.assert)(2 <= x && 512 > x - 2); | |
x = | |
c(2048 + ((y - 1) >>> 3)) + c((((y - 1) & 7) << 9) + (x - 2)); | |
p = z + x; | |
u = q; | |
t = 0; | |
} | |
function n(y, x, z) { | |
return f.subarray(y, y + z).every(function (A, B) { | |
return A === f[x + B]; | |
}); | |
} | |
p = ""; | |
q = m || 0; | |
u = q; | |
t = 0; | |
for (m = 0; q < f.byteLength; ) { | |
v = u; | |
w = t; | |
if (0 !== t && 513 > t && f[q] === f[u + t]) ++t, ++q; | |
else if (513 === t) h(v, w), (m = 0); | |
else { | |
for ( | |
--u; | |
0 <= u && | |
u >= q - t - 16384 && | |
(f[v] !== f[u] || (0 < t && !n(q - t, u, t + 1))); | |
) { | |
--u; | |
} | |
if (0 <= u && u >= q - t - 16384) ++t, ++q; | |
else if (v === q || 1 === w) { | |
q -= w; | |
for (v = 1; 5 > v && f[q + v] === f[q]; ) { | |
++v; | |
} | |
p += l(f[q], v); | |
q += v; | |
m = 1 < v ? 0 : m + 1; | |
4 === m && | |
((p = p.slice(0, p.length - 8)), | |
(p += g(f.subarray(q - 4, q)))); | |
u = q; | |
t = 0; | |
} else h(v, w), (m = 0); | |
} | |
} | |
1 === t ? (p += l(f[u], 1)) : 1 < t && h(u, t); | |
return p; | |
}; | |
b.n7 = function (f, m) { | |
var t; | |
function h(w, y) { | |
var x; | |
if (u + y > p.byteLength) { | |
x = new Uint8Array(2 * p.byteLength); | |
x.set(p, 0); | |
p = x; | |
} | |
if (w + y <= u) p.set(p.subarray(w, w + y), u); | |
else | |
for (x = 0; x < y; ++x) { | |
p[u + x] = p[w + x]; | |
} | |
u += y; | |
} | |
function n() { | |
var w; | |
w = f.slice(q, (q += 2)); | |
return (k(w.charCodeAt(0)) << 6) + k(w.charCodeAt(1)); | |
} | |
for ( | |
var p = m || new Uint8Array(4096), | |
q = 0, | |
u = m ? m.byteLength : 0; | |
q < f.length; | |
) { | |
t = n(); | |
if (t & 2048) | |
(m = n()), | |
h(u - (((t & 2047) << 3) + (m >>> 9) + 1), (m & 511) + 2); | |
else if (1792 === (t & 3840)) | |
(p[u++] = t & 255), | |
(m = n()), | |
(t = n()), | |
(p[u++] = m >>> 4), | |
(p[u++] = ((m << 4) & 240) + (t >>> 8)), | |
(p[u++] = t & 255); | |
else { | |
m = t & 255; | |
t = (t >>> 8) + 1; | |
for (var v = 0; v < t; ++v) { | |
p[u++] = m; | |
} | |
} | |
} | |
return p.subarray(0, u); | |
}; | |
}, | |
88458: function (r, b, a) { | |
var c; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Ntb = | |
b.Ltb = | |
b.Otb = | |
b.Ktb = | |
b.Mtb = | |
b.Ptb = | |
b.r7b = | |
b.l7b = | |
b.vO = | |
b.t7b = | |
b.Daa = | |
void 0; | |
c = a(5102); | |
Object.defineProperty(b, "videoMediaFrameRatesList", { | |
enumerable: !0, | |
get: function () { | |
return c.Daa; | |
}, | |
}); | |
b.t7b = ["padding"]; | |
b.vO = ["h264", "h264hpl", "hevc-main10"]; | |
b.l7b = ["16:9", "4:3"]; | |
b.r7b = { | |
h264: "playready-h264mpl30-dash", | |
h264hpl: "playready-h264hpl30-dash", | |
"hevc-main10": "hevc-main10-L30-dash-cenc-prk-do", | |
}; | |
b.Ptb = ["silence"]; | |
b.Mtb = ["heaac", "ddp"]; | |
b.Ktb = { heaac: [64, 96, 128], ddp: [192, 256, 384, 448, 640] }; | |
b.Otb = { | |
heaac: { | |
64: "heaac-2-dash", | |
96: "heaac-2-dash", | |
128: "heaac-2hq-dash", | |
}, | |
ddp: { | |
192: "ddplus-5.1-dash", | |
256: "ddplus-5.1hq-dash", | |
384: "ddplus-5.1hq-dash", | |
448: "ddplus-5.1hq-dash", | |
640: "ddplus-5.1hq-dash", | |
}, | |
}; | |
b.Ltb = { | |
heaac: { 64: "2.0", 96: "2.0", 128: "2.0" }, | |
ddp: { | |
192: "5.1", | |
256: "5.1", | |
384: "5.1", | |
448: "5.1", | |
640: "5.1", | |
}, | |
}; | |
b.Ntb = { | |
heaac: { sa: 1024, R: 24e3 }, | |
ddp: { sa: 1536, R: 48e3 }, | |
}; | |
}, | |
56163: function (r, b, a) { | |
var l, g, k, d, f, m, h; | |
function c(n) { | |
if (-1 !== d.vO.indexOf(n)) return n; | |
for (var p, q = 0; q < d.vO.length; ++q) { | |
if (-1 !== n.indexOf(d.vO[q])) { | |
p = d.vO[q]; | |
break; | |
} | |
} | |
(0, m.assert)(p); | |
return p; | |
} | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.PMa = void 0; | |
l = a(5163); | |
g = a(42866); | |
k = a(52426); | |
d = a(88458); | |
f = a(5102); | |
m = a(45929); | |
h = a(38315); | |
r = (function () { | |
function n(p, q) { | |
this.atob = p; | |
this.console = q; | |
this.fK = 1; | |
this.lY = []; | |
this.KR = []; | |
} | |
n.prototype.AKb = function (p, q, u, t, v) { | |
var w, z; | |
void 0 === t && (t = { w: 16, Rq: 9 }); | |
void 0 === v && (v = 1); | |
q = c(q); | |
w = (0, g.zc)(f.Daa, function (A) { | |
return (0, f.YYa)(u, f.XYa[A]); | |
}); | |
(0, m.assert)(w); | |
(0, m.assert)( | |
(16 === t.w && 9 === t.Rq) || (4 === t.w && 3 === t.Rq) | |
); | |
t = 16 === t.w ? "16:9" : "4:3"; | |
for (var y = 0, x = this.lY; y < x.length; y++) { | |
z = x[y]; | |
if ( | |
z.type === p && | |
z.lx === t && | |
z.vd === q && | |
z.frameRate === w && | |
z.trackId === v | |
) | |
return z; | |
} | |
p = this.tBb(p, t, q, w, v); | |
this.lY.unshift(p); | |
this.lY.length > this.fK && | |
this.lY.splice(this.fK, this.lY.length - this.fK); | |
return p; | |
}; | |
n.prototype.zKb = function (p, q, u) { | |
var y; | |
void 0 === u && (u = 1); | |
for (var t, v = 0, w = this.KR; v < w.length; v++) { | |
y = w[v]; | |
"silence" === y.type && | |
y.vd === p && | |
y.bitrate === q && | |
y.trackId === u && | |
(t = y); | |
} | |
void 0 === t && | |
((t = this.jBb(p, q, u)), | |
this.KR.unshift(t), | |
this.KR.length > this.fK && | |
this.KR.splice(this.fK, this.KR.length - this.fK)); | |
return t; | |
}; | |
n.prototype.tBb = function (p, q, u, t, v) { | |
var w; | |
w = k.ifb[p][q][u][t](); | |
return l.__assign(l.__assign({}, this.decode(w, v)), { | |
type: p, | |
lx: q, | |
vd: u, | |
frameRate: t, | |
width: w.width, | |
height: w.height, | |
Hb: w.Hb, | |
Ib: w.Ib, | |
}); | |
}; | |
n.prototype.jBb = function (p, q, u) { | |
var t; | |
t = k.xSa.silence[p][q]; | |
(0, m.assert)(t); | |
t = t(); | |
return l.__assign(l.__assign({}, this.decode(t, u)), { | |
type: "silence", | |
vd: p, | |
bitrate: q, | |
channels: t.channels, | |
}); | |
}; | |
n.prototype.decode = function (p, q) { | |
var u, t, v, w, y, x, z, A, B; | |
z = p.ka.$a | |
? this.eWa( | |
p.ka.data, | |
null === (u = p.ka.mc) || void 0 === u ? void 0 : u.data, | |
null === (t = p.ka.mc) || void 0 === t ? void 0 : t.size, | |
null === (v = p.ka.mc) || void 0 === v ? void 0 : v.$a | |
) | |
: this.atob(p.ka.data); | |
u = p.Y.$a | |
? this.eWa( | |
p.Y.data, | |
null === (w = p.Y.mc) || void 0 === w ? void 0 : w.data, | |
null === (y = p.Y.mc) || void 0 === y ? void 0 : y.size, | |
null === (x = p.Y.mc) || void 0 === x ? void 0 : x.$a | |
) | |
: this.atob(p.Y.data); | |
if (1 !== q) { | |
A = new DataView(z); | |
B = new DataView(u); | |
p.ka.eb.forEach(function (D) { | |
return A.setUint32(D, q); | |
}); | |
p.Y.eb.forEach(function (D) { | |
return B.setUint32(D, q); | |
}); | |
} | |
return l.__assign(l.__assign({}, p), { | |
ka: z, | |
Y: u, | |
trackId: q, | |
}); | |
}; | |
n.prototype.eWa = function (p, q, u, t) { | |
p = | |
void 0 === q | |
? (0, h.n7)(p) | |
: t | |
? (0, h.n7)(q + p) | |
: (0, h.n7)(p, new Uint8Array(this.atob(q))); | |
return p.buffer.slice( | |
p.byteOffset + (u || 0), | |
p.byteOffset + p.byteLength | |
); | |
}; | |
return n; | |
})(); | |
b.PMa = r; | |
}, | |
831: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Xha = b.sgb = b.AbortController = void 0; | |
c = a(5163); | |
r = (function (g) { | |
function k() { | |
var d; | |
d = (null !== g && g.apply(this, arguments)) || this; | |
d.yOa = !1; | |
return d; | |
} | |
c.__extends(k, g); | |
Object.defineProperties(k.prototype, { | |
aborted: { | |
get: function () { | |
return this.yOa; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(k.prototype, { | |
reason: { | |
get: function () { | |
return this.mqb; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(k.prototype, { | |
signal: { | |
get: function () { | |
return this; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
k.prototype.abort = function (d) { | |
this.mqb = new l(d); | |
this.yOa = !0; | |
this.emit("abort", { type: "abort" }); | |
}; | |
return k; | |
})(a(57055).EventEmitter); | |
b.AbortController = r; | |
l = (function (g) { | |
function k(d) { | |
d = g.call(this, d) || this; | |
d.name = "AbortError"; | |
return d; | |
} | |
c.__extends(k, g); | |
return k; | |
})(Error); | |
b.sgb = l; | |
b.Xha = function (g) { | |
return new Promise(function (k) { | |
g.aborted && k(); | |
g.addListener("abort", function () { | |
return k(); | |
}); | |
}); | |
}; | |
}, | |
1386: function (r, b, a) { | |
var g; | |
function c(k) { | |
return k.filter(function (d, f) { | |
return k.indexOf(d) === f; | |
}); | |
} | |
function l(k, d, f) { | |
return f | |
? k.filter(function (m) { | |
return !d.some(function (h) { | |
return f(m, h); | |
}); | |
}) | |
: k.filter(function (m) { | |
return -1 === d.indexOf(m); | |
}); | |
} | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.vUa = | |
b.kSa = | |
b.j8 = | |
b.jLb = | |
b.Zxb = | |
b.flatten = | |
b.J5a = | |
b.qxb = | |
b.XJ = | |
b.vq = | |
b.p2 = | |
b.lSa = | |
b.Uha = | |
b.Vha = | |
b.Uu = | |
b.Wha = | |
b.zc = | |
void 0; | |
g = a(5163); | |
b.zc = function (k, d) { | |
for (var f = 0; f < k.length; f++) { | |
if (d(k[f], f, k)) return k[f]; | |
} | |
}; | |
b.Wha = function (k, d) { | |
for (var f = k.length - 1; 0 <= f; --f) { | |
if (d(k[f], f, k)) return k[f]; | |
} | |
}; | |
b.Uu = function (k, d) { | |
var f; | |
f = -1; | |
return k.some(function (m, h, n) { | |
f = h; | |
return d(m, h, n); | |
}) | |
? f | |
: -1; | |
}; | |
b.Vha = function (k, d) { | |
for (var f = k.length - 1; 0 <= f; f--) { | |
if (d(k[f], f, k)) return f; | |
} | |
return -1; | |
}; | |
b.Uha = c; | |
b.lSa = function (k, d) { | |
return k.filter(function (f, m) { | |
return k.indexOf(f) === m && -1 !== d.indexOf(f); | |
}); | |
}; | |
b.p2 = function (k, d) { | |
d = k.indexOf(d); | |
if (-1 === d) return !1; | |
k.splice(d, 1); | |
return !0; | |
}; | |
b.vq = l; | |
b.XJ = function (k, d) { | |
return c(k.concat(d)); | |
}; | |
b.qxb = function (k) { | |
return function (d, f) { | |
return k(d) - k(f); | |
}; | |
}; | |
b.J5a = function (k) { | |
return function (d, f) { | |
return k(d) < k(f) ? d : f; | |
}; | |
}; | |
b.flatten = function (k) { | |
var d; | |
return (d = []).concat.apply( | |
d, | |
g.__spreadArray([], g.__read(k), !1) | |
); | |
}; | |
b.Zxb = function (k, d) { | |
void 0 === d && | |
(d = function (f) { | |
return f; | |
}); | |
return k.reduce(function (f, m) { | |
m = d(m); | |
return void 0 === f[m] ? (f[m] = 1) : ++f[m], f; | |
}, {}); | |
}; | |
b.jLb = function (k, d) { | |
return k.reduce(function (f, m) { | |
var h; | |
h = d(m); | |
return void 0 === f[h] ? (f[h] = [m]) : f[h].push(m), f; | |
}, {}); | |
}; | |
b.j8 = function (k) { | |
return null !== k && void 0 !== k; | |
}; | |
b.kSa = function (k) { | |
var d, m; | |
d = []; | |
if (Array.isArray(k)) | |
for (var f = 0; f < k.length; f++) { | |
m = k[f]; | |
Array.isArray(m) | |
? (d = d.concat( | |
m.filter(function (h) { | |
return void 0 !== h; | |
}) | |
)) | |
: void 0 !== m && d.push(m); | |
} | |
return d; | |
}; | |
b.vUa = function (k, d, f) { | |
var m; | |
m = l(k, d, f); | |
d = l(d, k, f); | |
k = l(k, m); | |
return { Jua: m, osb: d, O8a: k, result: k.concat(d) }; | |
}; | |
}, | |
20837: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.assert = b.AssertionError = void 0; | |
c = a(5163); | |
l = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
return k; | |
})(Error); | |
b.AssertionError = l; | |
b.assert = function (g, k) { | |
if (!g) throw new l(k || "Assertion failed"); | |
}; | |
}, | |
92709: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.DCa = void 0; | |
c = a(20837); | |
l = a(81786); | |
g = a(7666); | |
r = (function () { | |
function k(d) { | |
this.cDb = d; | |
this.Dya = !1; | |
this.Iaa = new g.yLa(); | |
} | |
k.prototype.z7b = function (d, f) { | |
var h, n; | |
function m() { | |
var u, t, v, w, y, x; | |
u = p.pop(); | |
t = u.node; | |
v = u.k2; | |
u = v.MWb; | |
w = v.bF; | |
v = v.state; | |
if (!q.Iaa.has(t)) { | |
u = f(t, w, u, v); | |
y = u.Haa; | |
x = u.state; | |
u.h2 || q.Iaa.add(t); | |
n(t).forEach(function (z) { | |
var A; | |
A = z.i7b; | |
h.Iaa.has(A) || | |
((z = w + z.weight), | |
y && | |
p.push({ node: A, k2: { bF: z, MWb: t, state: x } })); | |
}); | |
} | |
} | |
h = this; | |
n = this.cDb; | |
(0, c.assert)(!this.Dya); | |
this.Dya = !0; | |
this.Iaa.clear(); | |
for ( | |
var p = new l.K_( | |
[ | |
{ | |
node: d, | |
k2: { | |
bF: 0, | |
state: { root: !1, complete: !0, z$a: 0, Ir: 0 }, | |
}, | |
}, | |
], | |
function (u, t) { | |
return u.k2.bF - t.k2.bF; | |
} | |
), | |
q = this; | |
!p.empty; | |
) { | |
m(); | |
} | |
this.Dya = !1; | |
}; | |
return k; | |
})(); | |
b.DCa = r; | |
}, | |
88047: function (r, b) { | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.ZA = void 0; | |
b.ZA = function (a, c) { | |
var l; | |
a = Math.abs(a); | |
for (c = Math.abs(c); c; ) { | |
l = c; | |
c = a % c; | |
a = l; | |
} | |
return a; | |
}; | |
}, | |
42866: function (r, b, a) { | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
r = a(5163); | |
r.__exportStar(a(831), b); | |
r.__exportStar(a(20837), b); | |
r.__exportStar(a(92709), b); | |
r.__exportStar(a(88047), b); | |
r.__exportStar(a(81786), b); | |
r.__exportStar(a(70885), b); | |
r.__exportStar(a(76556), b); | |
r.__exportStar(a(41969), b); | |
r.__exportStar(a(7666), b); | |
r.__exportStar(a(48803), b); | |
r.__exportStar(a(1386), b); | |
}, | |
81786: function (r, b, a) { | |
var l; | |
function c(g, k) { | |
return g < k ? -1 : g > k ? 1 : 0; | |
} | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.K_ = void 0; | |
l = a(5163); | |
r = (function () { | |
function g(k, d) { | |
this.data = null !== k && void 0 !== k ? k : []; | |
this.compare = null !== d && void 0 !== d ? d : c; | |
if (!this.empty) | |
for (k = (this.length >> 1) - 1; 0 <= k; k--) { | |
this.Hfa(k); | |
} | |
} | |
Object.defineProperties(g.prototype, { | |
length: { | |
get: function () { | |
return this.data.length; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
empty: { | |
get: function () { | |
return 0 === this.data.length; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
g.prototype.push = function (k) { | |
this.data.push(k); | |
this.QQa(this.length - 1); | |
}; | |
g.prototype.pop = function () { | |
var k, d; | |
if (!this.empty) { | |
k = this.data[0]; | |
d = this.data.pop(); | |
this.empty || ((this.data[0] = d), this.Hfa(0)); | |
return k; | |
} | |
}; | |
g.prototype.xt = function () { | |
return this.data[0]; | |
}; | |
g.prototype.map = function (k) { | |
return this.data.map(k); | |
}; | |
g.prototype.find = function (k) { | |
return l.__read(this.data.filter(k), 1)[0]; | |
}; | |
g.prototype.clear = function () { | |
this.data = []; | |
}; | |
g.prototype.remove = function (k) { | |
var d, f, m; | |
d = this.data; | |
k = d.indexOf(k); | |
if (-1 !== k) { | |
f = d.pop(); | |
if (k < d.length) { | |
d[k] = f; | |
m = (k - 1) >> 1; | |
d = d[m]; | |
0 <= m && 0 > this.compare(f, d) | |
? this.QQa(k) | |
: this.Hfa(k); | |
} | |
} | |
}; | |
g.prototype.Ztb = function () { | |
for (var k = this.data, d = 1; d < k.length; d++) { | |
if (0 > this.compare(k[d], k[(d - 1) >> 1])) | |
throw Error( | |
"Audit failed at position ".concat(d, " of ").concat(k) | |
); | |
} | |
}; | |
g.prototype.contains = function (k) { | |
return 0 <= this.data.indexOf(k); | |
}; | |
g.prototype.tk = function () { | |
return this.data.concat([]); | |
}; | |
g.prototype.QQa = function (k) { | |
for ( | |
var d = this.data, f = this.compare, m = d[k], h, n; | |
0 < k; | |
) { | |
h = (k - 1) >> 1; | |
n = d[h]; | |
if (0 <= f(m, n)) break; | |
d[k] = n; | |
k = h; | |
} | |
d[k] = m; | |
}; | |
g.prototype.Hfa = function (k) { | |
for ( | |
var d = this.data, | |
f = this.compare, | |
m = this.length >> 1, | |
h = d[k], | |
n, | |
p, | |
q; | |
k < m; | |
) { | |
n = (k << 1) + 1; | |
q = d[n]; | |
p = n + 1; | |
p < this.length && 0 > f(d[p], q) && ((n = p), (q = d[p])); | |
if (0 <= f(q, h)) break; | |
d[k] = q; | |
k = n; | |
} | |
d[k] = h; | |
}; | |
return g; | |
})(); | |
b.K_ = r; | |
}, | |
76556: function (r, b) { | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Ada = void 0; | |
r = (function () { | |
function a(c, l, g, k) { | |
var d; | |
d = this; | |
this.properties = c; | |
this.transform = l; | |
this.Gs = g; | |
this.state = k; | |
this.ka(); | |
c.forEach(function (f) { | |
return f.addListener(d.Asa); | |
}); | |
this.Asa(); | |
} | |
a.prototype.clear = function () { | |
var c; | |
c = this; | |
this.properties.forEach(function (l) { | |
return l.removeListener(c.Asa); | |
}); | |
}; | |
a.prototype.B2a = function (c) { | |
return void 0 !== c.equal; | |
}; | |
a.prototype.ka = function () { | |
var c; | |
c = this; | |
this.Asa = function () { | |
var l, g; | |
l = c.state; | |
g = c.properties.map(function (k) { | |
return k.value; | |
}); | |
c.state = c.transform(g); | |
(c.B2a(c.state) && c.B2a(l) | |
? c.state.equal(l) | |
: l === c.state) || c.Gs(c.state); | |
}; | |
}; | |
return a; | |
})(); | |
b.Ada = r; | |
}, | |
70885: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.kq = b.Bmb = void 0; | |
c = a(5163); | |
l = a(76556); | |
g = a(41969); | |
r = (function () { | |
function k(d, f) { | |
this.Qa = d; | |
this.Wx = f ? [f] : []; | |
} | |
Object.defineProperties(k.prototype, { | |
value: { | |
get: function () { | |
return this.Qa; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
k.prototype.addListener = function (d) { | |
-1 === this.Wx.indexOf(d) && | |
((this.Wx = this.Wx.slice()), this.Wx.push(d)); | |
}; | |
k.prototype.removeListener = function (d) { | |
d = this.Wx.indexOf(d); | |
-1 !== d && ((this.Wx = this.Wx.slice()), this.Wx.splice(d, 1)); | |
}; | |
return k; | |
})(); | |
b.Bmb = r; | |
r = (function (k) { | |
function d(f, m) { | |
return k.call(this, f, m) || this; | |
} | |
c.__extends(d, k); | |
d.Bfb = function (f, m, h) { | |
return new l.Ada(f, m, h, !1); | |
}; | |
d.K7b = function (f, m, h) { | |
return c.__awaiter(this, void 0, void 0, function () { | |
var n, p, q; | |
q = this; | |
return c.__generator(this, function (u) { | |
switch (u.label) { | |
case 0: | |
(n = void 0), | |
(p = new Promise(function (t) { | |
n = q.Bfb(f, m, t); | |
})), | |
(u.label = 1); | |
case 1: | |
return ( | |
u.Oj.push([1, , 6, 7]), | |
h ? [4, (0, g.p9a)(h, p)] : [3, 3] | |
); | |
case 2: | |
return [2, u.Ra()]; | |
case 3: | |
return [4, p]; | |
case 4: | |
return [2, u.Ra()]; | |
case 5: | |
return [3, 7]; | |
case 6: | |
return n.clear(), [7]; | |
case 7: | |
return [2]; | |
} | |
}); | |
}); | |
}; | |
Object.defineProperties(d.prototype, { | |
value: { | |
get: function () { | |
return this.Qa; | |
}, | |
set: function (f) { | |
this.set(f); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
d.prototype.set = function (f) { | |
var m; | |
m = this.Qa; | |
m !== f && | |
((this.Qa = f), | |
this.Wx.forEach(function (h) { | |
return h({ oldValue: m, newValue: f }); | |
})); | |
}; | |
return d; | |
})(r); | |
b.kq = r; | |
}, | |
41969: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.p9a = b.xz = b.Fpa = void 0; | |
c = a(5163); | |
l = a(831); | |
b.Fpa = function (g) { | |
return ( | |
"function" === | |
typeof (null === g || void 0 === g ? void 0 : g.then) | |
); | |
}; | |
r = (function () { | |
function g() { | |
var k; | |
k = this; | |
this.vQa = !1; | |
this.promise = new Promise(function (d) { | |
k.tQa = d; | |
}); | |
} | |
Object.defineProperties(g.prototype, { | |
then: { | |
get: function () { | |
return this.promise.then.bind(this.promise); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
kva: { | |
get: function () { | |
return this.vQa; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
g.prototype.resolve = function (k) { | |
var d; | |
this.vQa = !0; | |
null === (d = this.tQa) || void 0 === d | |
? void 0 | |
: d.call(this, k); | |
this.tQa = void 0; | |
}; | |
return g; | |
})(); | |
b.xz = r; | |
b.p9a = function (g, k) { | |
return c.__awaiter(this, void 0, void 0, function () { | |
var d; | |
return c.__generator(this, function (f) { | |
switch (f.label) { | |
case 0: | |
return (d = (0, l.Xha)(g)), [4, Promise.race([d, k])]; | |
case 1: | |
return [2, f.Ra()]; | |
} | |
}); | |
}); | |
}; | |
}, | |
7666: function (r, b) { | |
var l, g, k; | |
function a(d) { | |
return void 0 !== (null === d || void 0 === d ? void 0 : d.xOa); | |
} | |
function c(d) { | |
return ( | |
a(d) | |
? d | |
: Object.defineProperties(d, { | |
xOa: { value: {}, configurable: !1, enumerable: !1 }, | |
}) | |
).xOa; | |
} | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.yLa = void 0; | |
g = | |
null !== (l = Number.MAX_SAFE_INTEGER) && void 0 !== l ? l : 1e9; | |
k = Date.now() % g; | |
r = (function () { | |
function d() { | |
this.n$ = 0; | |
this.id = k = (k + 1) % g; | |
} | |
d.prototype.add = function (f) { | |
c(f)[this.id] = this.n$; | |
return this; | |
}; | |
d.prototype.has = function (f) { | |
return a(f) && c(f)[this.id] === this.n$; | |
}; | |
d.prototype.delete = function (f) { | |
if (!this.has(f)) return !1; | |
c(f)[this.id] = void 0; | |
return !0; | |
}; | |
d.prototype.clear = function () { | |
this.n$ = (this.n$ + 1) % g; | |
return this; | |
}; | |
return d; | |
})(); | |
b.yLa = r; | |
}, | |
48803: function (r, b, a) { | |
var l; | |
function c(g, k) { | |
return g && k ? Math.abs((g * k) / (0, l.ZA)(g, k)) : 0; | |
} | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.M = void 0; | |
l = a(88047); | |
r = (function () { | |
function g(k, d) { | |
"object" === typeof k | |
? ((this.pc = k.sa), (this.ib = k.R)) | |
: ((this.pc = k), (this.ib = d)); | |
isFinite(this.pc) || (this.ib = 1); | |
} | |
g.compare = function (k, d) { | |
return k.Ik(d); | |
}; | |
g.abs = function (k) { | |
return new g(Math.abs(k.pc), k.ib); | |
}; | |
g.Na = function (k) { | |
return 0 === k ? g.Ja : new g(k, 1e3); | |
}; | |
g.Fxa = function (k, d) { | |
return Math.floor((1e3 * k) / d); | |
}; | |
g.c6a = function (k, d) { | |
return Math.floor((k * d) / 1e3); | |
}; | |
g.max = function () { | |
for (var k = [], d = 0; d < arguments.length; d++) { | |
k[d] = arguments[d]; | |
} | |
return k.reduce(function (f, m) { | |
return f.greaterThan(m) ? f : m; | |
}); | |
}; | |
g.min = function () { | |
for (var k = [], d = 0; d < arguments.length; d++) { | |
k[d] = arguments[d]; | |
} | |
return k.reduce(function (f, m) { | |
return f.lessThan(m) ? f : m; | |
}); | |
}; | |
g.ZA = function (k, d) { | |
var f; | |
if (k.ib === d.ib) return new g((0, l.ZA)(k.pc, d.pc), k.ib); | |
f = c(k.ib, d.ib); | |
return new g( | |
(0, l.ZA)((k.pc * f) / k.ib, (d.pc * f) / d.ib), | |
f | |
); | |
}; | |
Object.defineProperties(g.prototype, { | |
sa: { | |
get: function () { | |
return this.pc; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
R: { | |
get: function () { | |
return this.ib; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
G: { | |
get: function () { | |
return g.Fxa(this.pc, this.ib); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
Ey: { | |
get: function () { | |
return (1e3 * this.pc) / this.ib; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
nH: { | |
get: function () { | |
var k; | |
k = this.Ey; | |
return 0 > k ? Math.ceil(k) : Math.floor(k); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(g.prototype, { | |
vh: { | |
get: function () { | |
return this.pc / this.ib; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
g.prototype.Xe = function (k) { | |
k /= this.ib; | |
return new g(Math.floor(this.pc * k), Math.floor(this.ib * k)); | |
}; | |
g.prototype.add = function (k) { | |
var d; | |
if (this.ib === k.ib) return new g(this.pc + k.pc, this.ib); | |
d = c(this.ib, k.ib); | |
return new g((this.pc * d) / this.ib + (k.pc * d) / k.ib, d); | |
}; | |
g.prototype.xa = function (k) { | |
var d; | |
if (this.ib === k.ib) return new g(this.pc - k.pc, this.ib); | |
d = c(this.ib, k.ib); | |
return new g((this.pc * d) / this.ib - (k.pc * d) / k.ib, d); | |
}; | |
g.prototype.VB = function (k) { | |
return new g(this.pc * k, this.ib); | |
}; | |
g.prototype.Ni = function (k) { | |
var d; | |
if ("number" === typeof k) { | |
if (Math.floor(k) === k) { | |
d = c(this.pc, k); | |
if (d !== this.pc) | |
return this.Xe((d / this.pc) * this.ib).Ni(k); | |
} | |
return new g(Math.floor(this.pc / k), this.ib); | |
} | |
if (this.ib === k.ib) return this.pc / k.pc; | |
d = c(this.ib, k.ib); | |
return (this.pc * d) / this.ib / ((k.pc * d) / k.ib); | |
}; | |
g.prototype.DK = function (k) { | |
var d; | |
if (this.ib === k.ib) | |
return new g(Math.abs(this.pc - k.pc), this.ib); | |
d = c(this.ib, k.ib); | |
return new g( | |
Math.abs((this.pc * d) / this.ib - (k.pc * d) / k.ib), | |
d | |
); | |
}; | |
g.prototype.N9a = function () { | |
return new g(this.ib, this.pc); | |
}; | |
g.prototype.compare = function (k, d) { | |
var f; | |
if (this.ib === d.ib) return k(this.pc, d.pc); | |
f = c(this.ib, d.ib); | |
return k((this.pc * f) / this.ib, (d.pc * f) / d.ib); | |
}; | |
g.prototype.Ik = function (k) { | |
var d; | |
if (this.ib === k.ib) | |
return this.sa === k.pc ? 0 : this.pc - k.pc; | |
d = c(this.ib, k.ib); | |
return (this.pc * d) / this.ib - (k.pc * d) / k.ib; | |
}; | |
g.prototype.equal = function (k) { | |
return this.compare(function (d, f) { | |
return d === f; | |
}, k); | |
}; | |
g.prototype.Vra = function (k) { | |
return this.compare(function (d, f) { | |
return d !== f; | |
}, k); | |
}; | |
g.prototype.lessThan = function (k) { | |
return this.compare(function (d, f) { | |
return d < f; | |
}, k); | |
}; | |
g.prototype.greaterThan = function (k) { | |
return this.compare(function (d, f) { | |
return d > f; | |
}, k); | |
}; | |
g.prototype.EB = function (k) { | |
return this.compare(function (d, f) { | |
return d <= f; | |
}, k); | |
}; | |
g.prototype.fi = function (k) { | |
return this.compare(function (d, f) { | |
return d >= f; | |
}, k); | |
}; | |
g.prototype.isFinite = function () { | |
return !!this.ib && isFinite(this.pc); | |
}; | |
g.prototype.x0a = function (k) { | |
return c(this.R, k); | |
}; | |
g.prototype.toJSON = function () { | |
return { ticks: this.pc, timescale: this.ib }; | |
}; | |
g.prototype.toString = function () { | |
return "".concat(this.pc, "/").concat(this.ib); | |
}; | |
g.prototype.ob = function () { | |
return "" | |
.concat(this.pc, "/") | |
.concat(this.ib, " (") | |
.concat(this.G, "ms)"); | |
}; | |
g.Ja = new g(0, 1e3); | |
g.yy = new g(1, 1e3); | |
g.Cp = new g(Infinity, 1); | |
g.pSb = new g(-Infinity, 1); | |
return g; | |
})(); | |
b.M = r; | |
}, | |
27411: function (r, b) { | |
var a; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.H7a = void 0; | |
a = [ | |
96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, | |
11025, 8e3, 7350, | |
]; | |
b.H7a = function (c) { | |
var l, g, k, d; | |
l = c.read(5); | |
g = c.read(4); | |
if (15 === g) { | |
k = c.read(24); | |
g = a.indexOf(k); | |
} else k = a[g]; | |
d = c.read(4); | |
switch (l) { | |
case 1: | |
case 2: | |
case 4: | |
if (c.read(1)) throw Error("frameLengthFlag not supported"); | |
break; | |
default: | |
throw Error("AAC profile " + l + " not supported."); | |
} | |
return { gp: l, sampleRate: k, Y9: g, ldc: d, FGb: 1024 }; | |
}; | |
}, | |
28798: function (r, b, a) { | |
var c; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.U8a = void 0; | |
c = a(76338); | |
b.U8a = function (l, g, k) { | |
var d, f; | |
d = l.read(1); | |
if (d) { | |
f = new c.BFa(l, d, g); | |
1 === l.read(2) && l.advance(f.BM * f.dV); | |
} | |
(0, c.aua)(l, g, f, k); | |
(0, c.aua)(l, g, f, k); | |
}; | |
}, | |
13865: function (r, b, a) { | |
var c, l; | |
b.w = void 0; | |
c = a(11909); | |
l = a(17793); | |
b.w = function (g, k, d, f) { | |
var m; | |
m = new c.PY(g); | |
f = f && f.Y9; | |
k = (0, l.X8a)(m, { nx: k, lH: d }, f); | |
m = m.offset; | |
return { frame: g.subarray(0, m), Qsa: m, qic: k }; | |
}; | |
}, | |
53710: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.W8a = void 0; | |
b.W8a = function (a, c, l) { | |
15 === c && (c += a.read(8) - 1); | |
0 < c && 1 !== l.nx && !l.lH | |
? (a.write(4, 0), a.advance(8 * c - 4)) | |
: a.advance(8 * c); | |
}; | |
}, | |
17793: function (r, b, a) { | |
var c, l; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.X8a = void 0; | |
c = a(15427); | |
l = a(52148); | |
b.X8a = function (g, k, d) { | |
var f, m, h; | |
if (4095 === g.read(12)) { | |
g.advance(3); | |
f = !!g.read(1); | |
m = g.read(2) + 1; | |
d = g.read(4); | |
g.advance(8); | |
h = g.read(13); | |
g.advance(13 + (f ? 0 : 16)); | |
f = { gp: m, Y9: d, FGb: h }; | |
} else g.reverse(12); | |
(0, c.assert)(void 0 !== d); | |
(0, l.b9a)(g, d, k); | |
return f; | |
}; | |
}, | |
2e3: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.rEa = | |
b.iEa = | |
b.hEa = | |
b.qEa = | |
b.pEa = | |
b.oEa = | |
b.nEa = | |
b.mEa = | |
b.lEa = | |
b.kEa = | |
b.jEa = | |
b.gEa = | |
void 0; | |
b.gEa = { | |
width: 2, | |
table: new Uint16Array([ | |
1, 0, 5, 16, 5, 17, 5, 18, 5, 19, 5, 20, 5, 21, 5, 22, 5, 23, 7, | |
96, 7, 97, 7, 98, 7, 99, 7, 100, 7, 101, 7, 102, 7, 103, 7, 104, | |
7, 105, 7, 106, 7, 107, 7, 108, 7, 109, 7, 110, 7, 111, 7, 112, | |
7, 113, 7, 114, 7, 115, 7, 116, 7, 117, 7, 118, 7, 119, 9, 480, | |
9, 481, 9, 482, 9, 483, 9, 484, 9, 485, 9, 486, 9, 487, 9, 488, | |
9, 489, 9, 490, 9, 491, 9, 492, 9, 493, 9, 494, 9, 495, 9, 496, | |
9, 497, 9, 498, 9, 499, 9, 500, 9, 501, 9, 502, 9, 503, 10, | |
1008, 10, 1009, 10, 1010, 10, 1011, 10, 1012, 10, 1013, 10, | |
1014, 10, 1015, 11, 2032, 11, 2033, 11, 2034, 11, 2035, 11, | |
2036, 11, 2037, 11, 2038, 11, 2039, 11, 2040, 11, 2041, 11, | |
2042, 11, 2043, 11, 2044, 11, 2045, 11, 2046, 11, 2047, | |
]), | |
}; | |
b.jEa = { | |
width: 2, | |
table: new Uint16Array([ | |
3, 0, 4, 2, 5, 6, 5, 7, 5, 8, 5, 9, 5, 10, 5, 11, 5, 12, 6, 26, | |
6, 27, 6, 28, 6, 29, 6, 30, 6, 31, 6, 32, 6, 33, 6, 34, 6, 35, | |
6, 36, 6, 37, 6, 38, 6, 39, 6, 40, 6, 41, 6, 42, 6, 43, 6, 44, | |
6, 45, 6, 46, 6, 47, 6, 48, 6, 49, 7, 100, 7, 101, 7, 102, 7, | |
103, 7, 104, 7, 105, 7, 106, 7, 107, 7, 108, 7, 109, 7, 110, 7, | |
111, 7, 112, 7, 113, 7, 114, 8, 230, 8, 231, 8, 232, 8, 233, 8, | |
234, 8, 235, 8, 236, 8, 237, 8, 238, 8, 239, 8, 240, 8, 241, 8, | |
242, 8, 243, 8, 244, 8, 245, 8, 246, 8, 247, 8, 248, 9, 498, 9, | |
499, 9, 500, 9, 501, 9, 502, 9, 503, 9, 504, 9, 505, 9, 506, 9, | |
507, 9, 508, 9, 509, 9, 510, 9, 511, | |
]), | |
}; | |
b.kEa = { | |
width: 3, | |
table: new Uint16Array([ | |
1, 0, 0, 4, 8, 1, 4, 9, 1, 4, 10, 1, 4, 11, 1, 5, 24, 2, 5, 25, | |
2, 6, 52, 2, 6, 53, 2, 6, 54, 2, 6, 55, 3, 6, 56, 2, 6, 57, 3, | |
7, 116, 4, 7, 117, 3, 7, 118, 3, 8, 238, 1, 8, 239, 1, 8, 240, | |
2, 8, 241, 2, 8, 242, 3, 9, 486, 2, 9, 487, 3, 9, 488, 2, 9, | |
489, 3, 9, 490, 3, 9, 491, 1, 9, 492, 2, 9, 493, 2, 9, 494, 1, | |
9, 495, 2, 9, 496, 2, 9, 497, 4, 9, 498, 3, 9, 499, 3, 9, 500, | |
4, 10, 1002, 3, 10, 1003, 2, 10, 1004, 3, 10, 1005, 2, 10, 1006, | |
4, 10, 1007, 4, 10, 1008, 3, 10, 1009, 3, 10, 1010, 2, 10, 1011, | |
3, 10, 1012, 3, 10, 1013, 3, 10, 1014, 2, 10, 1015, 2, 10, 1016, | |
3, 11, 2034, 2, 11, 2035, 4, 11, 2036, 3, 11, 2037, 3, 11, 2038, | |
4, 11, 2039, 4, 11, 2040, 2, 11, 2041, 3, 12, 4084, 3, 12, 4085, | |
3, 12, 4086, 3, 12, 4087, 3, 12, 4088, 3, 12, 4089, 4, 12, 4090, | |
4, 12, 4091, 4, 12, 4092, 4, 13, 8186, 2, 13, 8187, 2, 13, 8188, | |
3, 14, 16378, 3, 14, 16379, 4, 14, 16380, 3, 15, 32762, 4, 15, | |
32763, 4, 15, 32764, 4, 15, 32765, 3, 15, 32766, 2, 16, 65534, | |
3, 16, 65535, 3, | |
]), | |
}; | |
b.lEa = { | |
width: 3, | |
table: new Uint16Array([ | |
4, 0, 4, 4, 1, 3, 4, 2, 3, 4, 3, 3, 4, 4, 3, 4, 5, 1, 4, 6, 2, | |
4, 7, 0, 4, 8, 2, 4, 9, 2, 5, 20, 2, 5, 21, 2, 5, 22, 1, 5, 23, | |
2, 5, 24, 1, 5, 25, 1, 7, 104, 4, 7, 105, 4, 7, 106, 4, 7, 107, | |
4, 7, 108, 3, 7, 109, 3, 7, 110, 3, 7, 111, 3, 7, 112, 3, 8, | |
226, 3, 8, 227, 3, 8, 228, 3, 8, 229, 3, 8, 230, 3, 8, 231, 3, | |
8, 232, 3, 8, 233, 2, 8, 234, 2, 8, 235, 2, 8, 236, 2, 8, 237, | |
2, 8, 238, 2, 8, 239, 2, 8, 240, 2, 8, 241, 2, 8, 242, 2, 8, | |
243, 2, 8, 244, 2, 8, 245, 1, 8, 246, 1, 9, 494, 1, 9, 495, 1, | |
9, 496, 4, 9, 497, 4, 9, 498, 4, 9, 499, 4, 9, 500, 4, 9, 501, | |
4, 10, 1004, 3, 10, 1005, 3, 10, 1006, 3, 10, 1007, 3, 10, 1008, | |
3, 10, 1009, 3, 10, 1010, 3, 10, 1011, 3, 10, 1012, 3, 10, 1013, | |
4, 10, 1014, 3, 10, 1015, 3, 10, 1016, 3, 10, 1017, 4, 11, 2036, | |
4, 11, 2037, 4, 11, 2038, 2, 11, 2039, 2, 11, 2040, 2, 11, 2041, | |
2, 11, 2042, 2, 11, 2043, 2, 11, 2044, 4, 11, 2045, 3, 11, 2046, | |
3, 12, 4094, 3, 12, 4095, 3, | |
]), | |
}; | |
b.mEa = { | |
width: 2, | |
table: new Uint16Array([ | |
1, 0, 4, 8, 4, 9, 4, 10, 4, 11, 5, 24, 5, 25, 5, 26, 5, 27, 7, | |
112, 7, 113, 7, 114, 7, 115, 8, 232, 8, 233, 8, 234, 8, 235, 8, | |
236, 8, 237, 8, 238, 8, 239, 8, 240, 8, 241, 8, 242, 8, 243, 9, | |
488, 9, 489, 9, 490, 9, 491, 9, 492, 9, 493, 9, 494, 9, 495, 9, | |
496, 9, 497, 9, 498, 9, 499, 10, 1e3, 10, 1001, 10, 1002, 10, | |
1003, 10, 1004, 10, 1005, 10, 1006, 10, 1007, 10, 1008, 10, | |
1009, 10, 1010, 10, 1011, 11, 2024, 11, 2025, 11, 2026, 11, | |
2027, 11, 2028, 11, 2029, 11, 2030, 11, 2031, 11, 2032, 11, | |
2033, 11, 2034, 11, 2035, 11, 2036, 11, 2037, 11, 2038, 11, | |
2039, 11, 2040, 11, 2041, 12, 4084, 12, 4085, 12, 4086, 12, | |
4087, 12, 4088, 12, 4089, 12, 4090, 12, 4091, 12, 4092, 12, | |
4093, 13, 8188, 13, 8189, 13, 8190, 13, 8191, | |
]), | |
}; | |
b.nEa = { | |
width: 2, | |
table: new Uint16Array([ | |
4, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4, 5, 4, 6, 4, 7, 4, 8, 6, 36, 6, | |
37, 6, 38, 6, 39, 6, 40, 6, 41, 6, 42, 6, 43, 6, 44, 6, 45, 6, | |
46, 6, 47, 6, 48, 6, 49, 6, 50, 6, 51, 7, 104, 7, 105, 7, 106, | |
7, 107, 7, 108, 7, 109, 7, 110, 7, 111, 7, 112, 7, 113, 7, 114, | |
7, 115, 7, 116, 8, 234, 8, 235, 8, 236, 8, 237, 8, 238, 8, 239, | |
8, 240, 8, 241, 9, 484, 9, 485, 9, 486, 9, 487, 9, 488, 9, 489, | |
9, 490, 9, 491, 9, 492, 9, 493, 9, 494, 9, 495, 9, 496, 9, 497, | |
9, 498, 9, 499, 9, 500, 9, 501, 9, 502, 9, 503, 9, 504, 9, 505, | |
9, 506, 10, 1014, 10, 1015, 10, 1016, 10, 1017, 10, 1018, 10, | |
1019, 10, 1020, 10, 1021, 11, 2044, 11, 2045, 11, 2046, 11, | |
2047, | |
]), | |
}; | |
b.oEa = { | |
width: 3, | |
table: new Uint16Array([ | |
1, 0, 0, 3, 4, 1, 3, 5, 1, 4, 12, 2, 6, 52, 2, 6, 53, 2, 6, 54, | |
1, 6, 55, 1, 7, 112, 2, 7, 113, 2, 7, 114, 2, 7, 115, 1, 7, 116, | |
1, 8, 234, 2, 8, 235, 2, 8, 236, 2, 8, 237, 2, 8, 238, 2, 8, | |
239, 2, 8, 240, 2, 8, 241, 2, 8, 242, 1, 8, 243, 1, 9, 488, 2, | |
9, 489, 2, 9, 490, 2, 9, 491, 1, 9, 492, 2, 9, 493, 1, 9, 494, | |
2, 9, 495, 2, 9, 496, 2, 9, 497, 2, 9, 498, 2, 9, 499, 2, 9, | |
500, 2, 9, 501, 2, 10, 1004, 2, 10, 1005, 1, 10, 1006, 1, 10, | |
1007, 2, 10, 1008, 2, 10, 1009, 2, 10, 1010, 2, 10, 1011, 2, 10, | |
1012, 2, 10, 1013, 2, 10, 1014, 2, 10, 1015, 2, 10, 1016, 2, 10, | |
1017, 2, 10, 1018, 2, 11, 2038, 1, 11, 2039, 1, 11, 2040, 2, 11, | |
2041, 2, 11, 2042, 2, 11, 2043, 2, 11, 2044, 2, 11, 2045, 2, 12, | |
4092, 2, 12, 4093, 2, 12, 4094, 2, 12, 4095, 2, | |
]), | |
}; | |
b.pEa = { | |
width: 3, | |
table: new Uint16Array([ | |
3, 0, 2, 4, 2, 2, 4, 3, 1, 4, 4, 2, 4, 5, 1, 4, 6, 2, 5, 14, 0, | |
5, 15, 1, 5, 16, 1, 5, 17, 2, 5, 18, 2, 5, 19, 2, 5, 20, 2, 6, | |
42, 2, 6, 43, 2, 6, 44, 2, 6, 45, 2, 6, 46, 2, 6, 47, 1, 6, 48, | |
1, 6, 49, 2, 6, 50, 2, 6, 51, 2, 7, 104, 2, 7, 105, 2, 7, 106, | |
2, 7, 107, 2, 7, 108, 2, 7, 109, 2, 7, 110, 2, 7, 111, 1, 7, | |
112, 2, 7, 113, 1, 7, 114, 2, 7, 115, 2, 7, 116, 2, 7, 117, 2, | |
8, 236, 2, 8, 237, 2, 8, 238, 2, 8, 239, 1, 8, 240, 2, 8, 241, | |
1, 8, 242, 2, 8, 243, 2, 8, 244, 2, 8, 245, 2, 8, 246, 2, 8, | |
247, 2, 8, 248, 2, 8, 249, 2, 8, 250, 2, 9, 502, 2, 9, 503, 2, | |
9, 504, 1, 9, 505, 2, 9, 506, 1, 9, 507, 2, 9, 508, 2, 9, 509, | |
2, 10, 1020, 2, 10, 1021, 1, 10, 1022, 1, 10, 1023, 2, | |
]), | |
}; | |
b.qEa = { | |
width: 3, | |
table: new Uint16Array([ | |
1, 0, 0, 3, 4, 1, 3, 5, 1, 4, 12, 2, 6, 52, 2, 6, 53, 2, 6, 54, | |
1, 6, 55, 1, 7, 112, 2, 7, 113, 2, 7, 114, 2, 8, 230, 1, 8, 231, | |
1, 8, 232, 2, 8, 233, 2, 8, 234, 2, 8, 235, 2, 8, 236, 2, 8, | |
237, 2, 9, 476, 2, 9, 477, 2, 9, 478, 1, 9, 479, 1, 9, 480, 2, | |
9, 481, 2, 9, 482, 2, 9, 483, 2, 9, 484, 2, 9, 485, 2, 9, 486, | |
2, 10, 974, 1, 10, 975, 2, 10, 976, 1, 10, 977, 2, 10, 978, 2, | |
10, 979, 2, 10, 980, 2, 10, 981, 2, 10, 982, 2, 10, 983, 2, 10, | |
984, 2, 10, 985, 1, 10, 986, 2, 10, 987, 2, 10, 988, 2, 10, 989, | |
2, 10, 990, 2, 10, 991, 2, 10, 992, 2, 10, 993, 2, 11, 1988, 1, | |
11, 1989, 2, 11, 1990, 2, 11, 1991, 2, 11, 1992, 1, 11, 1993, 2, | |
11, 1994, 2, 11, 1995, 2, 11, 1996, 2, 11, 1997, 1, 11, 1998, 2, | |
11, 1999, 2, 11, 2e3, 2, 11, 2001, 2, 11, 2002, 1, 11, 2003, 1, | |
11, 2004, 2, 11, 2005, 2, 11, 2006, 2, 11, 2007, 2, 11, 2008, 2, | |
11, 2009, 2, 11, 2010, 2, 11, 2011, 2, 11, 2012, 2, 11, 2013, 2, | |
11, 2014, 2, 11, 2015, 2, 11, 2016, 2, 11, 2017, 1, 11, 2018, 2, | |
12, 4038, 2, 12, 4039, 2, 12, 4040, 1, 12, 4041, 2, 12, 4042, 2, | |
12, 4043, 2, 12, 4044, 2, 12, 4045, 2, 12, 4046, 2, 12, 4047, 2, | |
12, 4048, 2, 12, 4049, 2, 12, 4050, 2, 12, 4051, 2, 12, 4052, 2, | |
12, 4053, 2, 12, 4054, 2, 12, 4055, 2, 12, 4056, 2, 12, 4057, 2, | |
12, 4058, 2, 12, 4059, 2, 12, 4060, 2, 12, 4061, 1, 12, 4062, 2, | |
12, 4063, 2, 12, 4064, 1, 12, 4065, 2, 12, 4066, 2, 12, 4067, 2, | |
12, 4068, 2, 12, 4069, 2, 12, 4070, 2, 12, 4071, 2, 12, 4072, 1, | |
12, 4073, 2, 12, 4074, 2, 12, 4075, 2, 13, 8152, 2, 13, 8153, 2, | |
13, 8154, 2, 13, 8155, 2, 13, 8156, 2, 13, 8157, 2, 13, 8158, 2, | |
13, 8159, 2, 13, 8160, 2, 13, 8161, 2, 13, 8162, 2, 13, 8163, 2, | |
13, 8164, 1, 13, 8165, 2, 13, 8166, 2, 13, 8167, 1, 13, 8168, 2, | |
13, 8169, 2, 13, 8170, 2, 13, 8171, 2, 13, 8172, 1, 13, 8173, 2, | |
13, 8174, 2, 13, 8175, 2, 13, 8176, 2, 13, 8177, 2, 13, 8178, 2, | |
13, 8179, 2, 13, 8180, 2, 13, 8181, 2, 13, 8182, 2, 13, 8183, 2, | |
14, 16368, 2, 14, 16369, 2, 14, 16370, 2, 14, 16371, 2, 14, | |
16372, 2, 14, 16373, 2, 14, 16374, 2, 14, 16375, 2, 14, 16376, | |
2, 14, 16377, 2, 14, 16378, 2, 14, 16379, 2, 14, 16380, 2, 14, | |
16381, 2, 15, 32764, 2, 15, 32765, 2, 15, 32766, 2, 15, 32767, | |
2, | |
]), | |
}; | |
b.hEa = { | |
width: 3, | |
table: new Uint16Array([ | |
4, 0, 2, 4, 1, 2, 4, 2, 2, 5, 6, 2, 5, 7, 1, 5, 8, 1, 5, 9, 2, | |
5, 10, 2, 5, 11, 2, 5, 12, 2, 5, 13, 2, 6, 28, 1, 6, 29, 1, 6, | |
30, 2, 6, 31, 2, 6, 32, 2, 6, 33, 2, 6, 34, 0, 6, 35, 2, 6, 36, | |
2, 6, 37, 1, 6, 38, 1, 6, 39, 2, 6, 40, 2, 6, 41, 2, 7, 84, 2, | |
7, 85, 2, 7, 86, 2, 7, 87, 2, 7, 88, 2, 7, 89, 2, 7, 90, 2, 7, | |
91, 2, 7, 92, 2, 7, 93, 1, 7, 94, 2, 7, 95, 1, 7, 96, 2, 7, 97, | |
2, 7, 98, 2, 7, 99, 2, 7, 100, 2, 8, 202, 2, 8, 203, 2, 8, 204, | |
2, 8, 205, 2, 8, 206, 2, 8, 207, 2, 8, 208, 2, 8, 209, 1, 8, | |
210, 2, 8, 211, 1, 8, 212, 2, 8, 213, 2, 8, 214, 2, 8, 215, 2, | |
8, 216, 2, 8, 217, 2, 8, 218, 2, 8, 219, 2, 8, 220, 2, 8, 221, | |
2, 8, 222, 2, 8, 223, 2, 8, 224, 2, 8, 225, 2, 8, 226, 2, 9, | |
454, 2, 9, 455, 2, 9, 456, 2, 9, 457, 1, 9, 458, 2, 9, 459, 2, | |
9, 460, 2, 9, 461, 2, 9, 462, 2, 9, 463, 1, 9, 464, 2, 9, 465, | |
2, 9, 466, 2, 9, 467, 2, 9, 468, 2, 9, 469, 2, 9, 470, 2, 9, | |
471, 2, 9, 472, 2, 9, 473, 2, 9, 474, 2, 9, 475, 2, 9, 476, 2, | |
9, 477, 2, 9, 478, 2, 9, 479, 2, 9, 480, 2, 9, 481, 1, 9, 482, | |
2, 9, 483, 1, 9, 484, 2, 10, 970, 2, 10, 971, 2, 10, 972, 2, 10, | |
973, 2, 10, 974, 2, 10, 975, 2, 10, 976, 1, 10, 977, 2, 10, 978, | |
2, 10, 979, 2, 10, 980, 2, 10, 981, 2, 10, 982, 2, 10, 983, 1, | |
10, 984, 2, 10, 985, 2, 10, 986, 2, 10, 987, 2, 10, 988, 2, 10, | |
989, 2, 10, 990, 2, 10, 991, 2, 10, 992, 2, 10, 993, 2, 10, 994, | |
2, 10, 995, 2, 10, 996, 2, 10, 997, 2, 10, 998, 2, 10, 999, 2, | |
10, 1e3, 2, 10, 1001, 1, 10, 1002, 2, 10, 1003, 1, 10, 1004, 2, | |
10, 1005, 1, 10, 1006, 2, 10, 1007, 2, 10, 1008, 2, 10, 1009, 2, | |
10, 1010, 2, 11, 2022, 2, 11, 2023, 2, 11, 2024, 2, 11, 2025, 2, | |
11, 2026, 2, 11, 2027, 2, 11, 2028, 2, 11, 2029, 2, 11, 2030, 2, | |
11, 2031, 2, 11, 2032, 1, 11, 2033, 2, 11, 2034, 1, 11, 2035, 2, | |
11, 2036, 2, 11, 2037, 2, 11, 2038, 1, 11, 2039, 2, 11, 2040, 2, | |
11, 2041, 2, 11, 2042, 1, 11, 2043, 2, 12, 4088, 2, 12, 4089, 2, | |
12, 4090, 2, 12, 4091, 2, 12, 4092, 2, 12, 4093, 1, 12, 4094, 2, | |
12, 4095, 2, | |
]), | |
}; | |
b.iEa = { | |
width: 4, | |
table: new Uint16Array([ | |
4, 0, 0, 0, 4, 1, 2, 0, 5, 4, 2, 2, 5, 5, 1, 0, 5, 6, 1, 0, 5, | |
7, 2, 0, 5, 8, 2, 0, 5, 9, 2, 0, 6, 20, 2, 0, 6, 21, 2, 0, 6, | |
22, 2, 0, 6, 23, 1, 0, 6, 24, 2, 0, 6, 25, 1, 0, 6, 26, 2, 0, 7, | |
54, 2, 0, 7, 55, 2, 0, 7, 56, 2, 0, 7, 57, 2, 0, 7, 58, 2, 0, 7, | |
59, 2, 0, 7, 60, 1, 0, 7, 61, 1, 0, 7, 62, 2, 0, 7, 63, 2, 0, 7, | |
64, 2, 0, 7, 65, 2, 0, 7, 66, 2, 0, 7, 67, 2, 0, 7, 68, 2, 0, 7, | |
69, 2, 0, 8, 140, 2, 0, 8, 141, 2, 0, 8, 142, 2, 0, 8, 143, 2, | |
0, 8, 144, 2, 0, 8, 145, 2, 0, 8, 146, 2, 0, 8, 147, 2, 1, 8, | |
148, 2, 1, 8, 149, 2, 1, 8, 150, 2, 1, 8, 151, 2, 1, 8, 152, 2, | |
0, 8, 153, 2, 1, 8, 154, 1, 0, 8, 155, 2, 0, 8, 156, 1, 0, 8, | |
157, 2, 1, 8, 158, 2, 0, 8, 159, 2, 1, 8, 160, 2, 1, 8, 161, 2, | |
1, 8, 162, 2, 1, 8, 163, 2, 0, 8, 164, 2, 0, 8, 165, 2, 0, 8, | |
166, 2, 0, 8, 167, 2, 0, 8, 168, 2, 1, 8, 169, 2, 1, 8, 170, 2, | |
0, 8, 171, 2, 0, 8, 172, 2, 1, 8, 173, 2, 1, 8, 174, 2, 1, 8, | |
175, 2, 0, 8, 176, 2, 0, 8, 177, 2, 1, 8, 178, 2, 0, 8, 179, 2, | |
1, 8, 180, 2, 1, 8, 181, 2, 1, 8, 182, 2, 0, 8, 183, 2, 1, 8, | |
184, 2, 0, 8, 185, 2, 0, 8, 186, 2, 1, 8, 187, 2, 1, 8, 188, 2, | |
0, 8, 189, 2, 0, 8, 190, 2, 0, 8, 191, 1, 0, 8, 192, 2, 1, 8, | |
193, 2, 1, 8, 194, 2, 0, 8, 195, 2, 0, 8, 196, 2, 0, 8, 197, 2, | |
0, 8, 198, 1, 0, 9, 398, 2, 0, 9, 399, 2, 1, 9, 400, 2, 1, 9, | |
401, 2, 0, 9, 402, 2, 0, 9, 403, 2, 1, 9, 404, 2, 0, 9, 405, 2, | |
1, 9, 406, 2, 0, 9, 407, 2, 0, 9, 408, 2, 0, 9, 409, 2, 0, 9, | |
410, 2, 0, 9, 411, 2, 0, 9, 412, 2, 0, 9, 413, 2, 1, 9, 414, 2, | |
0, 9, 415, 2, 0, 9, 416, 1, 0, 9, 417, 2, 0, 9, 418, 2, 0, 9, | |
419, 2, 0, 9, 420, 2, 0, 9, 421, 2, 0, 9, 422, 2, 0, 9, 423, 1, | |
0, 9, 424, 2, 0, 9, 425, 2, 0, 9, 426, 2, 0, 9, 427, 2, 0, 9, | |
428, 2, 0, 9, 429, 2, 0, 9, 430, 2, 0, 9, 431, 2, 0, 9, 432, 2, | |
0, 9, 433, 2, 0, 9, 434, 2, 0, 9, 435, 2, 0, 9, 436, 2, 0, 9, | |
437, 2, 0, 9, 438, 1, 0, 9, 439, 2, 0, 9, 440, 2, 0, 9, 441, 2, | |
0, 9, 442, 2, 0, 9, 443, 2, 0, 9, 444, 2, 0, 9, 445, 2, 0, 9, | |
446, 2, 0, 9, 447, 2, 0, 9, 448, 2, 0, 9, 449, 2, 0, 9, 450, 1, | |
1, 9, 451, 2, 0, 9, 452, 2, 0, 10, 906, 2, 0, 10, 907, 2, 0, 10, | |
908, 2, 0, 10, 909, 2, 0, 10, 910, 1, 1, 10, 911, 2, 0, 10, 912, | |
1, 0, 10, 913, 2, 0, 10, 914, 2, 0, 10, 915, 2, 0, 10, 916, 2, | |
0, 10, 917, 2, 0, 10, 918, 2, 0, 10, 919, 2, 0, 10, 920, 2, 0, | |
10, 921, 2, 0, 10, 922, 2, 0, 10, 923, 2, 0, 10, 924, 2, 0, 10, | |
925, 2, 0, 10, 926, 2, 0, 10, 927, 2, 0, 10, 928, 2, 0, 10, 929, | |
2, 0, 10, 930, 2, 0, 10, 931, 2, 0, 10, 932, 2, 0, 10, 933, 2, | |
0, 10, 934, 2, 0, 10, 935, 2, 0, 10, 936, 2, 0, 10, 937, 2, 0, | |
10, 938, 2, 0, 10, 939, 2, 0, 10, 940, 2, 0, 10, 941, 2, 0, 10, | |
942, 2, 0, 10, 943, 1, 0, 10, 944, 2, 0, 10, 945, 2, 0, 10, 946, | |
2, 0, 10, 947, 2, 0, 10, 948, 2, 0, 10, 949, 2, 0, 10, 950, 2, | |
0, 10, 951, 2, 0, 10, 952, 2, 0, 10, 953, 2, 0, 10, 954, 2, 0, | |
10, 955, 2, 0, 10, 956, 2, 0, 10, 957, 2, 0, 10, 958, 2, 0, 10, | |
959, 2, 0, 10, 960, 2, 0, 10, 961, 2, 0, 10, 962, 1, 0, 10, 963, | |
2, 0, 10, 964, 2, 0, 10, 965, 2, 0, 10, 966, 2, 0, 10, 967, 2, | |
0, 10, 968, 2, 0, 10, 969, 2, 0, 10, 970, 2, 0, 10, 971, 2, 0, | |
10, 972, 2, 0, 10, 973, 2, 0, 10, 974, 2, 0, 10, 975, 2, 0, 10, | |
976, 2, 0, 10, 977, 2, 0, 10, 978, 2, 0, 10, 979, 2, 0, 10, 980, | |
2, 0, 10, 981, 2, 0, 10, 982, 2, 0, 10, 983, 2, 0, 10, 984, 2, | |
0, 10, 985, 2, 0, 10, 986, 2, 0, 10, 987, 2, 0, 10, 988, 2, 0, | |
10, 989, 2, 0, 10, 990, 1, 0, 10, 991, 1, 0, 10, 992, 2, 0, 10, | |
993, 2, 0, 10, 994, 2, 0, 10, 995, 2, 0, 10, 996, 2, 0, 10, 997, | |
2, 0, 10, 998, 2, 0, 10, 999, 2, 0, 10, 1e3, 2, 0, 11, 2002, 2, | |
0, 11, 2003, 2, 0, 11, 2004, 2, 0, 11, 2005, 2, 0, 11, 2006, 2, | |
0, 11, 2007, 2, 0, 11, 2008, 2, 0, 11, 2009, 2, 0, 11, 2010, 2, | |
0, 11, 2011, 2, 0, 11, 2012, 2, 0, 11, 2013, 2, 0, 11, 2014, 2, | |
0, 11, 2015, 2, 0, 11, 2016, 2, 0, 11, 2017, 2, 0, 11, 2018, 2, | |
0, 11, 2019, 1, 0, 11, 2020, 2, 0, 11, 2021, 2, 0, 11, 2022, 1, | |
0, 11, 2023, 2, 0, 11, 2024, 1, 0, 11, 2025, 2, 0, 11, 2026, 2, | |
0, 11, 2027, 2, 0, 11, 2028, 1, 0, 11, 2029, 2, 0, 11, 2030, 2, | |
0, 11, 2031, 2, 0, 11, 2032, 2, 0, 11, 2033, 2, 0, 11, 2034, 1, | |
0, 11, 2035, 1, 0, 11, 2036, 2, 0, 11, 2037, 2, 0, 11, 2038, 2, | |
0, 11, 2039, 2, 0, 11, 2040, 1, 0, 11, 2041, 2, 0, 11, 2042, 2, | |
0, 11, 2043, 1, 0, 11, 2044, 2, 0, 12, 4090, 1, 0, 12, 4091, 1, | |
0, 12, 4092, 2, 0, 12, 4093, 1, 0, 12, 4094, 1, 0, 12, 4095, 2, | |
0, | |
]), | |
}; | |
b.rEa = { | |
width: 2, | |
table: new Uint32Array([ | |
1, 0, 3, 4, 4, 10, 4, 11, 4, 12, 5, 26, 5, 27, 6, 56, 6, 57, 6, | |
58, 6, 59, 7, 120, 7, 121, 7, 122, 8, 246, 8, 247, 8, 248, 8, | |
249, 8, 250, 9, 502, 9, 503, 9, 504, 9, 505, 10, 1012, 10, 1013, | |
10, 1014, 10, 1015, 10, 1016, 10, 1017, 11, 2036, 11, 2037, 11, | |
2038, 11, 2039, 11, 2040, 11, 2041, 12, 4084, 12, 4085, 12, | |
4086, 12, 4087, 12, 4088, 12, 4089, 13, 8180, 13, 8181, 13, | |
8182, 13, 8183, 13, 8184, 14, 16370, 14, 16371, 14, 16372, 14, | |
16373, 14, 16374, 14, 16375, 14, 16376, 14, 16377, 15, 32756, | |
15, 32757, 15, 32758, 15, 32759, 16, 65520, 16, 65521, 16, | |
65522, 16, 65523, 16, 65524, 16, 65525, 16, 65526, 17, 131054, | |
17, 131055, 17, 131056, 18, 262114, 18, 262115, 18, 262116, 18, | |
262117, 18, 262118, 18, 262119, 18, 262120, 19, 524242, 19, | |
524243, 19, 524244, 19, 524245, 19, 524246, 19, 524247, 19, | |
524248, 19, 524249, 19, 524250, 19, 524251, 19, 524252, 19, | |
524253, 19, 524254, 19, 524255, 19, 524256, 19, 524257, 19, | |
524258, 19, 524259, 19, 524260, 19, 524261, 19, 524262, 19, | |
524263, 19, 524264, 19, 524265, 19, 524266, 19, 524267, 19, | |
524268, 19, 524269, 19, 524270, 19, 524271, 19, 524272, 19, | |
524273, 19, 524274, 19, 524275, 19, 524276, 19, 524277, 19, | |
524278, 19, 524279, 19, 524280, 19, 524281, 19, 524282, 19, | |
524283, 19, 524284, 19, 524285, 19, 524286, 19, 524287, | |
]), | |
}; | |
}, | |
34581: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.z_ = void 0; | |
c = a(2e3); | |
l = [ | |
c.gEa, | |
c.jEa, | |
c.kEa, | |
c.lEa, | |
c.mEa, | |
c.nEa, | |
c.oEa, | |
c.pEa, | |
c.qEa, | |
c.hEa, | |
c.iEa, | |
]; | |
g = [!1, !1, !0, !0, !1, !1, !0, !0, !0, !0, !0]; | |
b.z_ = (function () { | |
function k() {} | |
k.wYa = function (d, f) { | |
var m, q, u; | |
m = f.table; | |
f = f.width; | |
for (var h = 0, n = m[0], p = d.read(n); p !== m[h + 1]; ) { | |
h += f; | |
q = m[h]; | |
u = q - n; | |
n = q; | |
p <<= u; | |
p |= d.read(u); | |
} | |
return h; | |
}; | |
k.Hbb = function (d) { | |
for (var f = 4; d.read(1); ) { | |
++f; | |
} | |
d.advance(f); | |
}; | |
k.Ibb = function (d, f) { | |
for (; f--; ) { | |
k.wYa(d, c.rEa); | |
} | |
}; | |
k.t2b = function (d, f) { | |
var m, h; | |
m = l[f - 1]; | |
h = m.table; | |
m = this.wYa(d, m); | |
if (11 > f) g[f - 1] && (f = h[m + 2]) && d.advance(f); | |
else if (11 === f || 15 < f) | |
(m += 2), | |
(f = h[m]) && d.advance(f), | |
(h = h[m + 1]) && this.Hbb(d), | |
1 < h && this.Hbb(d); | |
else throw Error("Huffman: unknown spectral codebook: " + f); | |
}; | |
return k; | |
})(); | |
}, | |
76338: function (r, b, a) { | |
var c, l, g, k, d, f; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.BFa = b.aua = void 0; | |
c = a(15427); | |
l = a(34581); | |
g = a(86707); | |
b.aua = function (m, h, n, p) { | |
var q, u, t; | |
q = m.read(8); | |
p = Math.max( | |
0, | |
Math.ceil( | |
q + (4 * Math.log(Math.pow(10, p.nx / 20))) / Math.log(2) | |
) | |
); | |
m.reverse(8); | |
m.write(8, p); | |
n || (n = new f(m, 0, h)); | |
q = n; | |
u = 2 === q.Kya ? 3 : 5; | |
t = (1 << u) - 1; | |
h = []; | |
p = []; | |
for (var v = [], w = 0; w < q.BM; ++w) { | |
for (var y = 0, x = 0; y < q.dV; ) { | |
for (var z = m.read(4), A = 0, B; (B = m.read(u)) === t; ) { | |
A += B; | |
} | |
A += B; | |
y += A; | |
h.push(z); | |
p.push(A); | |
++x; | |
} | |
v.push(x); | |
} | |
q = !0; | |
for (u = 0; u < h.length; ++u) { | |
0 !== h[u] && | |
(13 === h[u] && q | |
? (m.advance(9), (q = !1), l.z_.Ibb(m, p[u] - 1)) | |
: l.z_.Ibb(m, p[u])); | |
} | |
m.read(1) && m.advance(6 + 9 * (m.read(2) + 1)); | |
if (m.read(1)) | |
for (q = n, u = 2 === q.Kya ? k : d, t = 0; t < q.P6a; ++t) { | |
if ((v = m.read(u[0]))) | |
for (w = m.read(1), y = 0; y < v; ++y) { | |
if ((m.advance(u[1]), (x = m.read(u[2])))) | |
m.advance(1), | |
(z = m.read(1)), | |
m.advance(x * (w + 3 - z)); | |
} | |
} | |
(0, c.assert)(!m.read(1)); | |
q = n.BM; | |
u = n.dV; | |
t = n.Ncb; | |
n = n.Laa; | |
for (w = v = 0; w < q; ++w) { | |
for (y = n[w], x = 0; x < u; ++v) { | |
if ( | |
((z = h[v]), | |
(A = p[v]), | |
0 === z || 13 === z || 15 === z || 14 === z) | |
) | |
x += A; | |
else { | |
B = 5 <= z ? 2 : 4; | |
for (var D = 0; D < A; ++D, ++x) { | |
for ( | |
var C = (y * (t[x + 1] - t[x])) / B, F = 0; | |
F < C; | |
++F | |
) { | |
l.z_.t2b(m, z); | |
} | |
} | |
} | |
} | |
} | |
}; | |
k = [1, 4, 3]; | |
d = [2, 6, 5]; | |
f = (function () { | |
return function (m, h, n) { | |
var p; | |
this.Laa = []; | |
this.BM = 1; | |
this.Laa[0] = 1; | |
m.advance(1); | |
this.Kya = m.read(2); | |
m.read(1); | |
if (2 === this.Kya) { | |
this.P6a = 8; | |
this.dV = m.read(4); | |
for (h = 0; 7 > h; ++h) { | |
m.read(1) | |
? this.Laa[this.BM - 1]++ | |
: (this.BM++, (this.Laa[this.BM - 1] = 1)); | |
} | |
this.Ncb = g.fMa[n]; | |
} else { | |
this.P6a = 1; | |
this.dV = m.read(6); | |
if (m.read(1)) { | |
p = 14 + Math.min(this.dV, 40); | |
m.read(1) && m.advance(p); | |
h && m.read(1) && m.advance(p); | |
} | |
this.Ncb = g.eMa[n]; | |
} | |
}; | |
})(); | |
b.BFa = f; | |
}, | |
52148: function (r, b, a) { | |
var c, l; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.b9a = void 0; | |
c = a(28798); | |
l = a(53710); | |
b.b9a = function (g, k, d) { | |
var m; | |
for (var f; 7 !== (f = g.read(3)); ) { | |
m = g.read(4); | |
switch (f) { | |
case 1: | |
(0, c.U8a)(g, k, d); | |
break; | |
case 6: | |
(0, l.W8a)(g, m, d); | |
break; | |
default: | |
throw Error("Unsupported AAC element ".concat(f)); | |
} | |
} | |
g.fvb(); | |
}; | |
}, | |
86707: function (r, b) { | |
var a, c, l, g, k, d, f, m, h, n, p, q; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.Fmb = b.fkb = b.Gmb = b.anb = b.bnb = b.fMa = b.eMa = void 0; | |
r = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, | |
80, 88, 96, 108, 120, 132, 144, 156, 172, 188, 212, 240, 276, 320, | |
384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, | |
]); | |
a = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128, | |
]); | |
c = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, | |
80, 88, 100, 112, 124, 140, 156, 172, 192, 216, 240, 268, 304, | |
344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824, | |
864, 904, 944, 984, 1024, | |
]); | |
l = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128, | |
]); | |
g = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, | |
96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292, 320, | |
352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, | |
768, 800, 832, 864, 896, 928, 1024, | |
]); | |
k = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128, | |
]); | |
d = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, | |
96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292, 320, | |
352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, | |
768, 800, 832, 864, 896, 928, 960, 992, 1024, | |
]); | |
f = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 76, 84, | |
92, 100, 108, 116, 124, 136, 148, 160, 172, 188, 204, 220, 240, | |
260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704, | |
768, 832, 896, 960, 1024, | |
]); | |
m = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128, | |
]); | |
h = new Uint16Array([ | |
0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124, 136, | |
148, 160, 172, 184, 196, 212, 228, 244, 260, 280, 300, 320, 344, | |
368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, | |
960, 1024, | |
]); | |
n = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128, | |
]); | |
p = new Uint16Array([ | |
0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172, | |
188, 204, 220, 236, 252, 268, 288, 308, 328, 348, 372, 396, 420, | |
448, 476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024, | |
]); | |
q = new Uint16Array([ | |
0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128, | |
]); | |
b.eMa = [r, r, c, g, g, d, f, f, h, h, h, p]; | |
b.fMa = [a, a, l, k, k, k, m, m, n, n, n, q]; | |
b.bnb = new Uint8Array([ | |
12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15, | |
]); | |
b.anb = new Uint8Array([ | |
41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40, | |
]); | |
b.Gmb = (function () { | |
for (var u = new Float32Array(428), t = 0; 428 > t; t++) { | |
u[t] = Math.pow(2, (t - 200) / 4); | |
} | |
return u; | |
})(); | |
b.fkb = (function () { | |
for ( | |
var u = new Float32Array(8191), t = 4 / 3, v = 0; | |
8191 > v; | |
v++ | |
) { | |
u[v] = Math.pow(v, t); | |
} | |
return u; | |
})(); | |
b.Fmb = new Int32Array([ | |
96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, | |
11025, 8e3, 7350, | |
]); | |
}, | |
15427: function (r, b, a) { | |
var c, l; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.assert = void 0; | |
c = a(5163); | |
l = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
return k; | |
})(Error); | |
b.assert = function (g, k) { | |
if (!g) throw new l(k || "Assertion failed"); | |
}; | |
}, | |
11909: function (r, b) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.PY = void 0; | |
r = (function () { | |
function a(c) { | |
this.data = c; | |
this.zq = this.Zb = this.qd = 0; | |
this.view = new DataView(c.buffer, c.byteOffset, c.byteLength); | |
} | |
Object.defineProperty(a.prototype, "offset", { | |
get: function () { | |
return this.Zb; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}); | |
a.prototype.read = function (c) { | |
if (0 === this.qd) { | |
if (8 === c) return this.data[this.Zb++]; | |
if (16 === c) | |
return ( | |
(c = this.view.getUint16(this.Zb)), (this.Zb += 2), c | |
); | |
if (32 === c) | |
return ( | |
(c = this.view.getUint32(this.Zb)), (this.Zb += 4), c | |
); | |
} | |
for (; this.qd < c; ) { | |
this.zq = (this.zq << 8) + this.data[this.Zb++]; | |
this.qd += 8; | |
} | |
this.qd -= c; | |
return (this.zq >>> this.qd) & ((1 << c) - 1); | |
}; | |
a.prototype.advance = function (c) { | |
var l; | |
if (c <= this.qd) this.qd -= c; | |
else { | |
c -= this.qd; | |
l = Math.floor(c / 8); | |
this.Zb += l; | |
this.zq = this.data[this.Zb++]; | |
this.qd = 8 - (c - 8 * l); | |
} | |
}; | |
a.prototype.write = function (c, l) { | |
var g, k; | |
l &= (1 << c) - 1; | |
if (0 === this.qd) { | |
if (8 === c) { | |
this.data[this.Zb++] = l; | |
return; | |
} | |
if (16 === c) { | |
this.view.setUint16(this.Zb, l); | |
this.Zb += 2; | |
return; | |
} | |
if (32 === c) { | |
this.view.setUint32(this.Zb, l); | |
this.Zb += 4; | |
return; | |
} | |
} | |
if (0 < this.qd) { | |
g = Math.min(c, this.qd); | |
k = | |
this.data[this.Zb - 1] & | |
(~((1 << this.qd) - 1) ^ ((1 << (this.qd - g)) - 1)); | |
this.data[this.Zb - 1] = | |
k ^ (c >= g ? l >>> (c - g) : l << (this.qd - g)); | |
this.qd -= g; | |
c -= g; | |
} | |
for (; 8 <= c; ) { | |
c -= 8; | |
this.data[this.Zb++] = (l >>> c) & 255; | |
} | |
0 < c && | |
((this.qd = 8 - c), | |
(k = this.data[this.Zb] & ((1 << this.qd) - 1)), | |
(this.zq = this.data[this.Zb++] = | |
k ^ ((l & ((1 << c) - 1)) << (8 - c)))); | |
}; | |
a.prototype.reverse = function (c) { | |
0 !== this.qd && c <= 8 - this.qd | |
? (this.qd += c) | |
: (0 !== this.qd && ((c -= 8 - this.qd), --this.Zb), | |
(this.Zb -= Math.floor(c / 8)), | |
(this.zq = this.data[this.Zb - 1]), | |
(this.qd = c % 8)); | |
}; | |
a.prototype.fvb = function () { | |
0 !== this.qd && (this.qd = 0); | |
}; | |
return a; | |
})(); | |
b.PY = r; | |
}, | |
77151: function (r, b) { | |
var a; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.dVa = void 0; | |
a = new Uint16Array([ | |
0, 32773, 32783, 10, 32795, 30, 20, 32785, 32819, 54, 60, 32825, | |
40, 32813, 32807, 34, 32867, 102, 108, 32873, 120, 32893, 32887, | |
114, 80, 32853, 32863, 90, 32843, 78, 68, 32833, 32963, 198, 204, | |
32969, 216, 32989, 32983, 210, 240, 33013, 33023, 250, 33003, 238, | |
228, 32993, 160, 32933, 32943, 170, 32955, 190, 180, 32945, 32915, | |
150, 156, 32921, 136, 32909, 32903, 130, 33155, 390, 396, 33161, | |
408, 33181, 33175, 402, 432, 33205, 33215, 442, 33195, 430, 420, | |
33185, 480, 33253, 33263, 490, 33275, 510, 500, 33265, 33235, 470, | |
476, 33241, 456, 33229, 33223, 450, 320, 33093, 33103, 330, 33115, | |
350, 340, 33105, 33139, 374, 380, 33145, 360, 33133, 33127, 354, | |
33059, 294, 300, 33065, 312, 33085, 33079, 306, 272, 33045, 33055, | |
282, 33035, 270, 260, 33025, 33539, 774, 780, 33545, 792, 33565, | |
33559, 786, 816, 33589, 33599, 826, 33579, 814, 804, 33569, 864, | |
33637, 33647, 874, 33659, 894, 884, 33649, 33619, 854, 860, 33625, | |
840, 33613, 33607, 834, 960, 33733, 33743, 970, 33755, 990, 980, | |
33745, 33779, 1014, 1020, 33785, 1e3, 33773, 33767, 994, 33699, | |
934, 940, 33705, 952, 33725, 33719, 946, 912, 33685, 33695, 922, | |
33675, 910, 900, 33665, 640, 33413, 33423, 650, 33435, 670, 660, | |
33425, 33459, 694, 700, 33465, 680, 33453, 33447, 674, 33507, 742, | |
748, 33513, 760, 33533, 33527, 754, 720, 33493, 33503, 730, 33483, | |
718, 708, 33473, 33347, 582, 588, 33353, 600, 33373, 33367, 594, | |
624, 33397, 33407, 634, 33387, 622, 612, 33377, 544, 33317, 33327, | |
554, 33339, 574, 564, 33329, 33299, 534, 540, 33305, 520, 33293, | |
33287, 514, | |
]); | |
b.dVa = function (c, l) { | |
void 0 === l && (l = 0); | |
l = ~~l; | |
for (var g = 0; g < c.length; g++) { | |
l = (a[((l >> 8) ^ c[g]) & 255] ^ (l << 8)) & 65535; | |
} | |
return l; | |
}; | |
}, | |
91459: function (r, b, a) { | |
var c, l; | |
b.w = void 0; | |
c = a(11909); | |
l = a(29652); | |
b.w = function (g, k, d) { | |
var f; | |
f = new c.PY(g); | |
k = (0, l.fSa)( | |
f, | |
k, | |
null === d || void 0 === d ? void 0 : d.tG | |
).HGb; | |
g = g.subarray(0, k); | |
(0, l.hbb)(g); | |
return { frame: g, Qsa: k }; | |
}; | |
}, | |
29652: function (r, b, a) { | |
var c, l; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.hbb = b.fSa = void 0; | |
c = a(15427); | |
l = a(77151); | |
b.fSa = function (g, k, d) { | |
var f, m; | |
f = g.read(16); | |
(0, c.assert)(2935 === f); | |
f = 2 * ((g.read(16) & 2047) + 1); | |
g.advance(13); | |
m = g.read(5); | |
g.reverse(5); | |
d && (k *= -m / d); | |
g.write(5, Math.min(31, Math.max(1, Math.floor(m + k)))); | |
return { HGb: f }; | |
}; | |
b.hbb = function (g) { | |
var k; | |
k = (0, l.dVa)(g.subarray(2, g.length - 2)); | |
g[g.length - 2] = k >> 8; | |
g[g.length - 1] = k & 255; | |
}; | |
}, | |
73644: function (r, b, a) { | |
var c, l, g, k; | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
b.cYa = void 0; | |
c = a(11909); | |
l = a(27411); | |
b.cYa = function () { | |
var m, h, n, p; | |
for (var d = [], f = 0; f < arguments.length; f++) { | |
d[f] = arguments[f]; | |
} | |
m = | |
"string" === typeof d[0] | |
? { vd: d[0], frame: d[1], nx: d[2], hxb: d[3], tG: d[4] } | |
: d[0]; | |
h = m.vd; | |
d = m.frame; | |
f = m.nx; | |
n = m.hxb; | |
p = m.tG; | |
m = m.lH; | |
m = void 0 === m ? !1 : m; | |
switch (h) { | |
case "aac": | |
void 0 === g && (g = a(13865).w); | |
h = 6; | |
n && ((n = new c.PY(n)), (h = (0, l.H7a)(n).Y9)); | |
d = g(d, f, m, { Y9: h }).Qsa; | |
break; | |
case "ddp": | |
void 0 === k && (k = a(91459).w); | |
d = k(d, f, { tG: p }).Qsa; | |
break; | |
default: | |
throw Error("Unrecognized codec in fadeFrame: " + h); | |
} | |
return { GGb: d }; | |
}; | |
}, | |
61901: function (r, b, a) { | |
Object.defineProperty(b, "__esModule", { value: !0 }); | |
a(5163).__exportStar(a(73644), b); | |
}, | |
16936: function (r, b) { | |
var a, c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.zE = void 0; | |
r = { | |
name: "heaac-2-dash reset sample", | |
profile: 53, | |
channels: 2, | |
sampleRate: 24e3, | |
duration: 1024, | |
B$: new Uint8Array([ | |
33, 17, 69, 0, 20, 80, 1, 70, 157, 188, 0, 0, 8, 28, 0, 0, 0, | |
14, | |
]).buffer, | |
}; | |
a = { | |
name: "heaac-2-dash standard sample", | |
profile: 53, | |
channels: 2, | |
sampleRate: 24e3, | |
duration: 1024, | |
B$: new Uint8Array([ | |
33, 17, 69, 0, 20, 80, 1, 70, 240, 77, 251, 1, 60, 8, 64, 0, 0, | |
0, 0, 0, 0, 0, 0, 0, 7, 14, 0, 14, | |
]).buffer, | |
}; | |
c = { | |
name: "ddplus-5.1-dash standard sample", | |
profile: 54, | |
channels: 6, | |
sampleRate: 48e3, | |
duration: 1536, | |
B$: new Uint8Array([ | |
11, 119, 1, 127, 63, 134, 255, 225, 6, 32, 0, 32, 0, 66, 10, 65, | |
0, 135, 216, 68, 3, 254, 202, 2, 88, 163, 1, 16, 177, 64, 146, | |
32, 160, 75, 20, 80, 37, 136, 35, 227, 36, 160, 152, 156, 165, | |
37, 38, 41, 37, 73, 74, 9, 201, 146, 130, 114, 82, 116, 160, | |
152, 152, 150, 136, 58, 125, 89, 245, 39, 207, 159, 63, 116, | |
150, 147, 242, 73, 95, 165, 171, 175, 253, 215, 126, 82, 21, 55, | |
188, 8, 165, 126, 249, 242, 100, 175, 255, 249, 73, 42, 255, | |
253, 215, 124, 246, 156, 23, 239, 108, 36, 134, 249, 211, 228, | |
181, 255, 246, 253, 205, 119, 176, 179, 86, 126, 166, 27, 231, | |
175, 225, 58, 255, 222, 170, 110, 127, 249, 215, 41, 232, 146, | |
73, 183, 0, 88, 211, 192, 0, 0, 31, 7, 178, 116, 62, 122, 114, | |
245, 8, 233, 196, 71, 223, 196, 18, 59, 202, 113, 248, 103, 242, | |
80, 250, 118, 15, 1, 60, 79, 251, 46, 14, 8, 9, 37, 4, 14, 183, | |
67, 131, 195, 103, 241, 250, 32, 124, 81, 61, 76, 9, 40, 161, 2, | |
1, 16, 64, 114, 219, 225, 217, 172, 140, 44, 12, 64, 147, 49, | |
210, 195, 206, 12, 52, 186, 196, 0, 107, 134, 202, 4, 9, 216, | |
72, 67, 11, 127, 185, 13, 125, 124, 124, 194, 90, 203, 69, 1, | |
209, 8, 129, 183, 36, 196, 101, 7, 248, 73, 181, 38, 181, 30, | |
232, 124, 27, 18, 222, 207, 92, 251, 85, 227, 78, 0, 70, 196, | |
59, 0, 207, 194, 0, 252, 226, 209, 111, 144, 239, 111, 148, 54, | |
39, 28, 176, 248, 160, 58, 88, 113, 9, 76, 65, 57, 180, 96, 82, | |
224, 115, 52, 208, 161, 184, 86, 120, 211, 212, 168, 13, 52, | |
217, 124, 121, 189, 237, 163, 53, 72, 52, 157, 245, 160, 110, | |
16, 182, 219, 180, 152, 180, 136, 47, 23, 151, 198, 192, 20, 62, | |
220, 249, 107, 82, 0, 0, 0, 234, 22, 24, 202, 252, 104, 154, | |
198, 95, 7, 98, 110, 113, 104, 187, 197, 110, 105, 201, 123, 18, | |
61, 45, 233, 135, 20, 0, 151, 155, 45, 131, 75, 174, 9, 228, 53, | |
214, 32, 19, 131, 131, 87, 146, 156, 22, 16, 160, 0, 0, 5, 169, | |
31, 241, 155, 119, 242, 21, 168, 176, 225, 35, 130, 186, 60, 97, | |
189, 244, 57, 5, 158, 124, 200, 224, 156, 74, 33, 48, 12, 75, | |
235, 252, 25, 83, 61, 12, 178, 134, 75, 92, 124, 56, 71, 63, | |
232, 35, 142, 23, 11, 179, 154, 25, 17, 254, 160, 55, 0, 28, | |
144, 253, 91, 117, 102, 221, 190, 135, 231, 10, 70, 30, 23, 176, | |
0, 0, 1, 176, 4, 8, 133, 150, 0, 255, 79, 159, 83, 83, 77, 46, | |
180, 197, 95, 161, 141, 13, 44, 47, 253, 61, 176, 86, 148, 52, | |
201, 148, 194, 126, 246, 155, 165, 78, 181, 18, 73, 32, 28, 45, | |
70, 221, 101, 80, 78, 20, 6, 206, 130, 30, 219, 0, 30, 251, 237, | |
127, 232, 113, 255, 107, 248, 25, 147, 2, 185, 140, 224, 224, | |
189, 152, 101, 89, 28, 152, 47, 182, 88, 216, 198, 90, 3, 213, | |
0, 64, 150, 89, 96, 5, 18, 73, 32, 18, 105, 56, 170, 112, 129, | |
132, 77, 233, 15, 190, 8, 58, 109, 254, 217, 232, 164, 181, 91, | |
34, 227, 8, 27, 140, 83, 141, 186, 71, 175, 110, 91, 83, 37, 82, | |
15, 247, 58, 112, 134, 42, 42, 18, 3, 0, 8, 18, 196, 44, 5, 18, | |
73, 32, 25, 234, 135, 27, 145, 161, 76, 95, 163, 44, 124, 140, | |
151, 13, 189, 174, 93, 108, 80, 63, 112, 61, 88, 28, 46, 219, | |
213, 65, 40, 74, 243, 69, 108, 141, 37, 80, 21, 72, 191, 2, 50, | |
88, 122, 3, 0, 0, 10, 36, 146, 64, 54, 170, 52, 196, 80, 163, | |
79, 142, 148, 81, 36, 46, 131, 66, 255, 221, 26, 128, 73, 23, | |
103, 49, 192, 55, 30, 59, 219, 161, 166, 249, 122, 141, 88, 62, | |
36, 228, 107, 116, 158, 14, 252, 92, 103, 226, 0, 0, 20, 73, 36, | |
128, 113, 105, 27, 109, 199, 165, 26, 100, 240, 30, 8, 113, 124, | |
175, 175, 166, 144, 115, 74, 138, 80, 24, 32, 117, 28, 206, 194, | |
21, 85, 40, 218, 254, 177, 100, 37, 127, 63, 131, 208, 68, 250, | |
76, 169, 40, 0, 0, 0, 0, 0, 0, 0, 95, 208, 40, 5, | |
]).buffer, | |
}; | |
l = { | |
name: "ddplus-2.0-dash standard sample", | |
profile: 57, | |
channels: 2, | |
sampleRate: 48e3, | |
duration: 1536, | |
B$: new Uint8Array([ | |
11, 119, 0, 191, 52, 134, 255, 224, 4, 32, 24, 132, 33, 46, 136, | |
15, 236, 128, 165, 150, 32, 161, 69, 16, 65, 66, 33, 0, 160, | |
224, 136, 32, 48, 40, 56, 176, 233, 159, 62, 203, 176, 139, 218, | |
213, 221, 58, 124, 249, 83, 239, 245, 26, 179, 232, 106, 97, | |
174, 75, 74, 149, 104, 85, 223, 38, 74, 253, 242, 95, 253, 47, | |
117, 10, 116, 228, 206, 145, 61, 126, 153, 83, 169, 201, 146, | |
214, 124, 251, 202, 125, 62, 3, 184, 113, 105, 44, 145, 91, 107, | |
58, 206, 87, 7, 170, 74, 27, 187, 48, 217, 65, 241, 1, 161, 157, | |
113, 91, 21, 163, 111, 51, 104, 115, 118, 123, 44, 77, 110, 247, | |
112, 43, 8, 73, 76, 172, 73, 150, 207, 95, 153, 3, 182, 105, | |
124, 66, 2, 0, 118, 237, 94, 135, 88, 83, 124, 41, 205, 76, 76, | |
109, 131, 40, 166, 169, 150, 166, 233, 51, 26, 43, 143, 131, | |
162, 201, 227, 35, 146, 30, 46, 75, 41, 1, 28, 21, 124, 91, 11, | |
74, 112, 106, 170, 137, 88, 102, 81, 122, 90, 108, 154, 41, 64, | |
72, 81, 74, 40, 176, 29, 246, 45, 81, 141, 178, 47, 68, 210, | |
113, 129, 217, 48, 217, 176, 77, 157, 147, 211, 28, 106, 174, | |
210, 66, 110, 190, 228, 106, 249, 236, 107, 188, 90, 91, 41, 31, | |
191, 71, 149, 201, 40, 136, 209, 138, 100, 91, 53, 25, 18, 245, | |
27, 148, 208, 18, 20, 81, 70, 24, 7, 147, 116, 48, 233, 47, 145, | |
81, 32, 242, 74, 51, 50, 138, 85, 186, 6, 202, 227, 8, 169, 201, | |
206, 77, 68, 201, 80, 186, 57, 179, 90, 232, 234, 208, 230, 109, | |
96, 154, 4, 249, 38, 86, 153, 185, 81, 45, 38, 146, 243, 73, | |
117, 105, 140, 5, 34, 48, 227, 11, 10, 32, 130, 14, 49, 4, 40, | |
131, 127, 229, 199, 232, 95, 78, 126, 229, 243, 175, 254, 117, | |
124, 233, 83, 154, 239, 93, 63, 195, 190, 120, 247, 107, 232, | |
10, 68, 177, 11, 22, 24, 32, 66, 4, 99, 231, 207, 159, 7, 124, | |
241, 174, 215, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 40, 187, | |
227, | |
]).buffer, | |
}; | |
b.zE = { | |
standard: { | |
"heaac-2-dash": a, | |
"heaac-2hq-dash": a, | |
"ddplus-5.1-dash": c, | |
"ddplus-5.1hq-dash": c, | |
"ddplus-2.0-dash": l, | |
}, | |
reset: { "heaac-2-dash": r, "heaac-2hq-dash": r }, | |
"heaac-2-dash": r, | |
"heaac-2-dash-alt": a, | |
"ddplus-5.1-dash": c, | |
"ddplus-2.0-dash": l, | |
}; | |
}, | |
82818: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.XCa = b.Qya = void 0; | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
var k; | |
k = (null !== l && l.apply(this, arguments)) || this; | |
k.uF = 1536; | |
return k; | |
} | |
c.__extends(g, l); | |
g.Qc = !0; | |
return g; | |
})(a(61671).default); | |
b["default"] = r; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "ac-3"; | |
return g; | |
})(r); | |
b.Qya = a; | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "ec-3"; | |
return g; | |
})(r); | |
b.XCa = r; | |
}, | |
24475: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function () { | |
this.VGb = this.L.Rc(2); | |
this.Jub = this.L.Rc(5); | |
this.Kub = this.L.Rc(3); | |
this.lrb = this.L.Rc(3); | |
this.L.Rc(1); | |
this.L.Rc(5); | |
this.L.Rc(5); | |
return !0; | |
}; | |
g.re = "dac3"; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
27235: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
this.L.Rc(1); | |
this.L.Rc(7); | |
this.Aab = this.L.Rc(3); | |
this.zab = this.L.Rc(5); | |
this.Bab = this.L.Rc(1); | |
this.i1a = this.L.Rc(1); | |
this.Wdb = this.L.Rc(1); | |
this.$5a = this.L.Rc(1); | |
this.XTa = this.L.Rc(1); | |
this.YTa = this.L.Rc(1); | |
this.WTa = this.L.Rc(2); | |
this.L.Rc(3); | |
(this.fpa = this.L.Rc(1)) | |
? (this.X1a = this.L.Rc(4)) | |
: this.L.Rc(4); | |
k && | |
(k.Rcc = { | |
Aab: this.Aab, | |
zab: this.zab, | |
Bab: this.Bab, | |
i1a: this.i1a, | |
Wdb: this.Wdb, | |
$5a: this.$5a, | |
XTa: this.XTa, | |
YTa: this.YTa, | |
WTa: this.WTa, | |
fpa: this.fpa, | |
X1a: this.X1a, | |
}); | |
return !0; | |
}; | |
g.re = "av1C"; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
24895: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
var d; | |
this.L.kd(); | |
this.rgb = this.L.kd(); | |
this.L.kd(); | |
this.L.kd(); | |
this.L.kd(); | |
this.G$ = this.Fga(this.L.kd() & 31); | |
this.C8a = this.Fga(this.L.kd()); | |
this.dN = this.G$.length ? this.G$[0][1] : this.rgb; | |
this.fQa = this.L.offset; | |
this.startOffset + this.length < this.L.offset && | |
(100 === this.dN || | |
110 === this.dN || | |
122 === this.dN || | |
144 === this.dN) && | |
(this.L.kd(), this.L.kd(), this.Fga(this.L.kd())); | |
d = this.startOffset + this.length - this.fQa; | |
0 < d && this.am(d, this.fQa); | |
k && | |
k.nia && | |
((k.nia.G$ = this.G$), | |
(k.nia.C8a = this.C8a), | |
(k.nia.dN = this.dN)); | |
return !0; | |
}; | |
g.prototype.Fga = function (k) { | |
var m; | |
for (var d = [], f = 0; f < k; ++f) { | |
m = this.L.If(); | |
d.push(this.L.w9(m)); | |
} | |
return d; | |
}; | |
g.re = "avcC"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
61671: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(85571); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
var f; | |
f = g.prototype.parse.call(this, d); | |
this.L.offset += 8; | |
this.eja = this.L.If(); | |
this.yva = this.L.If(); | |
this.L.offset += 4; | |
this.samplerate = this.L.If(); | |
this.L.offset += 2; | |
l.K && | |
this.L.console.trace( | |
"MP4AudioSampleEntry: channelcount: " + | |
this.eja + | |
", samplesize: " + | |
this.yva + | |
", samplerate: " + | |
this.samplerate | |
); | |
if (null === d || void 0 === d ? 0 : d.He) | |
(d.He.eja = this.eja), | |
(d.He.yva = this.yva), | |
(d.He.samplerate = this.samplerate); | |
return f; | |
}; | |
k.Qc = !1; | |
return k; | |
})(a(44126).default); | |
b["default"] = r; | |
}, | |
22770: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function () { | |
this.Fc = this.Qv([ | |
{ adc: "int32" }, | |
{ maxBitrate: "int32" }, | |
{ I2: "int32" }, | |
]); | |
return !0; | |
}; | |
g.re = "btrt"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
85571: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Ye = b.K = void 0; | |
c = a(27172); | |
b.K = !1; | |
r = (function () { | |
function l(g, k, d, f, m) { | |
this.Pb = g; | |
this.type = k; | |
this.byteOffset = d; | |
this.byteLength = f; | |
this.parent = m; | |
this.Ed = {}; | |
this.KG = f; | |
} | |
l.Px = function (g, k) { | |
var f, h; | |
function d(n) { | |
n && n.Px && ((n = n.Px(k)), n.length && (f = f.concat(n))); | |
} | |
f = []; | |
g.type === k && f.push(g); | |
if (g.Ed) | |
for (var m in g.Ed) { | |
h = g.Ed[m]; | |
Array.isArray(h) && h.forEach(d); | |
} | |
return f; | |
}; | |
l.xR = function (g, k) { | |
void 0 === g.Ed[k.type] && (g.Ed[k.type] = []); | |
g.Ed[k.type].push(k); | |
}; | |
l.Tm = function (g, k) { | |
return l.Px(g, k)[0]; | |
}; | |
Object.defineProperties(l.prototype, { | |
startOffset: { | |
get: function () { | |
return this.byteOffset; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(l.prototype, { | |
length: { | |
get: function () { | |
return this.byteLength; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(l.prototype, { | |
L: { | |
get: function () { | |
return this.Pb; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
l.prototype.vg = function () { | |
var g; | |
g = this.Pb.Rb(); | |
this.version = g >> 24; | |
this.flags = g & 16777215; | |
}; | |
l.prototype.xR = function (g) { | |
l.xR(this, g); | |
}; | |
l.prototype.Px = function (g) { | |
return l.Px(this, g); | |
}; | |
l.prototype.Tm = function (g) { | |
return l.Tm(this, g); | |
}; | |
l.prototype.parse = function () { | |
return !0; | |
}; | |
l.prototype.XS = function () { | |
return !0; | |
}; | |
l.prototype.yo = function (g) { | |
if ((g = this.Ed[g]) && Array.isArray(g) && 1 === g.length) | |
return g[0]; | |
}; | |
l.prototype.am = function (g, k) { | |
k = void 0 === k ? this.Pb.offset : k; | |
(0, c.assert)( | |
k >= this.startOffset + 8 && | |
k + g <= this.startOffset + this.KG, | |
"Removal range [0x" + | |
k.toString(16) + | |
"-0x" + | |
(k + g).toString(16) + | |
") must be in box [0x" + | |
this.startOffset.toString(16) + | |
"-0x" + | |
(this.startOffset + this.KG).toString(16) + | |
")" | |
); | |
this.Pb.am(g, k, this); | |
}; | |
l.prototype.H9 = function (g, k, d) { | |
d = void 0 === d ? this.Pb.offset : d; | |
(0, c.assert)( | |
d >= this.startOffset + 8 && | |
d + g <= this.startOffset + this.KG, | |
"Removal range [0x" + | |
d.toString(16) + | |
"-0x" + | |
(d + g).toString(16) + | |
") must be in box [0x" + | |
this.startOffset.toString(16) + | |
"-0x" + | |
(this.startOffset + this.KG).toString(16) + | |
")" | |
); | |
this.Pb.H9(g, k, d, this); | |
}; | |
l.prototype.D9a = function (g, k, d) { | |
if (1 < d) { | |
for (var f = []; 0 < d--; ) { | |
f.push(this.lQa(g, k)); | |
} | |
return f; | |
} | |
return this.lQa(g, k); | |
}; | |
l.prototype.Qv = function (g) { | |
var k, d; | |
d = this; | |
void 0 === k && (k = {}); | |
g.forEach(function (f) { | |
var m, h; | |
if ("offset" === f.type) { | |
m = f.offset; | |
if (0 < m % 8) | |
throw Error( | |
"Requested offset " + | |
f.offset + | |
"is not an even byte multiple" | |
); | |
d.Pb.offset += m / 8; | |
} else | |
for (m in f) { | |
h = f[m]; | |
k[m] = | |
"string" === typeof h | |
? d.D9a(h) | |
: d.D9a(h.type, h.length, h.ctb); | |
} | |
}); | |
return k; | |
}; | |
l.prototype.lQa = function (g, k) { | |
var d; | |
d = this.byteLength - this.Pb.offset + this.startOffset; | |
"undefined" === typeof k && (k = d); | |
switch (g) { | |
case "int8": | |
g = this.Pb.kd(); | |
break; | |
case "int64": | |
g = this.Pb.Ti(); | |
break; | |
case "int32": | |
g = this.Pb.Rb(); | |
break; | |
case "int16": | |
g = this.Pb.If(); | |
break; | |
case "string": | |
g = this.Pb.qYb(Math.min(k, d)); | |
break; | |
default: | |
throw Error("Invalid type: " + g); | |
} | |
return g; | |
}; | |
l.Qc = !1; | |
return l; | |
})(); | |
b.Ye = r; | |
}, | |
89525: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
var d, f, m; | |
d = this.L.offset; | |
f = this.L.If(); | |
this.YVa = f >> 3; | |
this.zTb = f & 7; | |
this.D3b = []; | |
for (f = 0; f <= this.zTb; f++) { | |
m = { | |
VGb: this.L.Rc(2), | |
Jub: this.L.Rc(5), | |
Kub: this.L.Rc(5), | |
lrb: this.L.Rc(3), | |
yfc: this.L.Rc(1), | |
C$a: this.L.Rc(3), | |
yTb: this.L.Rc(4), | |
}; | |
0 < m.yTb ? (m.kdc = this.L.Rc(9)) : this.L.Rc(1); | |
this.D3b.push(m); | |
} | |
k && | |
k.dXa && | |
((k.dXa.YVa = this.YVa), | |
2 <= this.byteLength - (this.L.offset - d) && | |
(this.L.Rc(7), (d = this.L.Rc(1)), (k.dXa.Kcc = 1 === d))); | |
return !0; | |
}; | |
g.re = "dec3"; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
46079: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(26678); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
this.vg(); | |
this.Zib = l.gca.w9a(this.L, d); | |
return !0; | |
}; | |
k.re = "esds"; | |
k.Qc = !1; | |
return k; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
57199: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(27172); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
var f, m, h, n, p, q, u; | |
if (null === d || void 0 === d || !d.Fg) return !0; | |
p = | |
null === | |
(n = | |
null === | |
(h = | |
null === | |
(m = | |
null === (f = this.parent) || void 0 === f | |
? void 0 | |
: f.parent) || void 0 === m | |
? void 0 | |
: m.Tm("tkhd")) || void 0 === h | |
? void 0 | |
: h.Fc) || void 0 === n | |
? void 0 | |
: n.trackId; | |
if ("undefined" === typeof p) return !0; | |
(0, l.assert)(d.Fg[p]); | |
if (!d.Fg[p]) return !0; | |
this.vg(); | |
f = this.L.Rb(); | |
for (m = 0; m < f; m++) { | |
h = 1 === this.version ? this.L.Ti() : this.L.Rb(); | |
n = 1 === this.version ? this.L.Ti() : this.L.Rb(); | |
q = this.L.If(); | |
u = this.L.If(); | |
h = { ohc: h, Wfc: n, Vfc: q, Ufc: u }; | |
d.Fg[p].gXa || (d.Fg[p].gXa = []); | |
d.Fg[p].gXa.push(h); | |
} | |
return !0; | |
}; | |
k.re = "elst"; | |
k.Qc = !1; | |
return k; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
89849: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function () { | |
this.L.Iy(); | |
this.L.Iy(); | |
for ( | |
this.Fja = []; | |
this.L.offset <= this.byteOffset + this.byteLength - 4; | |
) { | |
this.Fja.push(this.L.Iy()); | |
} | |
return !0; | |
}; | |
g.re = "ftyp"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
21501: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
this.XAb = this.L.Iy(); | |
k && k.He && (k.He.J_b = this.XAb); | |
return !0; | |
}; | |
g.re = "frma"; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
36464: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(97001); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
var f, m, h, n, p; | |
this.vg(); | |
this.Fc = this.Qv([ | |
{ Kgc: "int32" }, | |
{ moa: "int32" }, | |
{ offset: 96, type: "offset" }, | |
{ name: "string" }, | |
]); | |
this.Fc.moa = (0, l.Pz)(this.Fc.moa); | |
if (d && d.Fg) { | |
p = | |
null === | |
(n = | |
null === | |
(h = | |
null === | |
(m = | |
null === (f = this.parent) || void 0 === f | |
? void 0 | |
: f.parent) || void 0 === m | |
? void 0 | |
: m.Tm("tkhd")) || void 0 === h | |
? void 0 | |
: h.Fc) || void 0 === n | |
? void 0 | |
: n.trackId; | |
"number" === typeof p && | |
d.Fg[p] && | |
(d.Fg[p].ov = this.Fc.moa); | |
} | |
return !0; | |
}; | |
k.re = "hdlr"; | |
k.Qc = !1; | |
return k; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
12228: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(27172); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.XS = function () { | |
var d; | |
d = this.Tm("esds"); | |
if ((d = d && d.Zib.Tm(5))) | |
(0, l.assert)(this.samplerate), | |
(this.uF = (d.uF * this.samplerate) / d.X9); | |
return !0; | |
}; | |
k.re = "mp4a"; | |
k.Qc = !0; | |
return k; | |
})(a(61671).default); | |
b["default"] = r; | |
}, | |
17904: function (r, b) { | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
}, | |
97291: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function () { | |
this.vg(); | |
this.Fc = | |
1 === this.version | |
? this.Qv([ | |
{ creationTime: "int64" }, | |
{ modificationTime: "int64" }, | |
{ R: "int32" }, | |
{ duration: "int64" }, | |
]) | |
: this.Qv([ | |
{ creationTime: "int32" }, | |
{ modificationTime: "int32" }, | |
{ R: "int32" }, | |
{ duration: "int32" }, | |
]); | |
return !0; | |
}; | |
g.re = "mvhd"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
60841: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function () { | |
this.vg(); | |
this.Fc = this.Qv( | |
1 === this.version ? [{ BGb: "int64" }] : [{ BGb: "int32" }] | |
); | |
return !0; | |
}; | |
g.re = "mehd"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
75706: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = a(26464); | |
a = a(85571); | |
l = r.tda; | |
a = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function () { | |
this.vg(); | |
this.Fc = this.Qv([{ ut: "int32" }, { Ns: "int16" }]); | |
return !0; | |
}; | |
k.re = l; | |
k.Qc = !1; | |
return k; | |
})(a.Ye); | |
b["default"] = a; | |
}, | |
79798: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(26464); | |
r = a(85571); | |
g = l.uda; | |
r = (function (k) { | |
function d() { | |
return (null !== k && k.apply(this, arguments)) || this; | |
} | |
c.__extends(d, k); | |
d.prototype.parse = function () { | |
this.vg(); | |
this.fileSize = this.L.Ti(); | |
this.R = this.L.Ti(); | |
this.duration = this.L.Ti(!1, !0); | |
this.MTb = this.L.Ti(); | |
this.L.Ti(); | |
this.QTb = this.L.Ti(); | |
this.YSb = this.L.Rb(); | |
this.NTb = this.L.Ti(); | |
this.iGb = this.L.Rb(); | |
this.L.z9(); | |
this.Yk = { | |
moof: { offset: this.MTb }, | |
sidx: { offset: this.NTb, size: this.iGb }, | |
}; | |
this.Yk[l.dIa] = { offset: this.QTb, size: this.YSb }; | |
this.L.offset - this.startOffset <= this.length - 24 && | |
((this.PTb = this.L.Ti()), | |
(this.LSb = this.L.Rb()), | |
(this.OTb = this.L.Ti()), | |
(this.KSb = this.L.Rb()), | |
(this.Yk[l.O_] = { offset: this.PTb, size: this.LSb }), | |
(this.Yk[l.N_] = { offset: this.OTb, size: this.KSb })); | |
return !0; | |
}; | |
d.re = g; | |
d.Qc = !1; | |
return d; | |
})(r.Ye); | |
b["default"] = r; | |
}, | |
30855: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = a(26464); | |
a = a(85571); | |
l = r.vda; | |
a = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function () { | |
var d, h, n; | |
this.vg(); | |
1 <= this.version && this.L.z9(); | |
d = this.L.Rb(); | |
this.Yk = {}; | |
for ( | |
var f = this.startOffset + this.length, m = 0; | |
m < d; | |
++m | |
) { | |
h = this.L.Iy(); | |
"uuid" === h && (h = this.L.z9()); | |
n = this.L.Ti(); | |
this.Yk[h] = { offset: f, size: n }; | |
f += n; | |
} | |
return !0; | |
}; | |
k.re = l; | |
k.Qc = !1; | |
return k; | |
})(a.Ye); | |
b["default"] = a; | |
}, | |
60440: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
this.Fc = this.Qv([{ fMb: "int32" }, { j7b: "int32" }]); | |
if (null === k || void 0 === k ? 0 : k.He) | |
(k.He.Mec = this.Fc.fMb), (k.He.sic = this.Fc.j7b); | |
return !0; | |
}; | |
g.re = "pasp"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
44210: function (r, b, a) { | |
var c, l, g, k, d; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(26464); | |
g = a(255); | |
k = a(61671); | |
r = a(85571); | |
d = a(6483); | |
a = (function (f) { | |
function m() { | |
return (null !== f && f.apply(this, arguments)) || this; | |
} | |
c.__extends(m, f); | |
m.prototype.parse = function () { | |
this.vg(); | |
this.TK = this.L.Rb(); | |
return !0; | |
}; | |
m.prototype.XS = function (h) { | |
var n; | |
n = Object.keys(this.Ed); | |
n.length && | |
((n = n[0]), | |
this.Ed[n].length && | |
((n = this.Ed[n][0]), | |
n instanceof k.default | |
? (this.X = new g.M(n.uF, n.samplerate)) | |
: n instanceof d.default && | |
(n = n.Ed[l.tda]) && | |
n.length && | |
((n = n[0].Fc), | |
(1e3 !== n.Ns && 1001 !== n.Ns) || 0 !== n.ut % 1e3 | |
? this.L.console.warn( | |
"Unexpected frame rate in NetflixFrameRateBox: " + | |
n.ut + | |
"/" + | |
n.Ns | |
) | |
: (this.X = new g.M(n.Ns, n.ut))), | |
h && this.X && (h.X = this.X))); | |
return !0; | |
}; | |
m.prototype.g$a = function (h) { | |
void 0 !== this.Ed[h] && | |
0 !== this.Ed[h].length && | |
(this.Pb.$t(this.TK - 1, this.byteOffset + 12), | |
(h = this.Ed[h][0]), | |
this.am(h.byteLength, h.byteOffset)); | |
}; | |
m.re = "stsd"; | |
m.Qc = !0; | |
return m; | |
})(r.Ye); | |
b["default"] = a; | |
}, | |
44126: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = a(85571); | |
l = a(85571); | |
a = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
this.L.offset += 6; | |
this.L.If(); | |
l.K && | |
this.L.console.trace( | |
"VideoSampleEntry sampleEntryType: " + this.type | |
); | |
if (null === d || void 0 === d ? 0 : d.He) d.He.J_b = this.type; | |
return !0; | |
}; | |
return k; | |
})(r.Ye); | |
b["default"] = a; | |
}, | |
80586: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(85571); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
this.vg(); | |
this.Jva = this.L.Iy(); | |
l.K && | |
this.L.console.trace("SchemeTypeBoxTranslator: " + this.Jva); | |
if ("cenc" === this.Jva) { | |
if ( | |
((this.L.offset -= 4), | |
l.K && | |
this.L.console.trace( | |
"SchemeTypeBoxTranslator: writing type piff at offset " + | |
this.L.offset | |
), | |
this.Pb.Jfb("piff"), | |
null === d || void 0 === d ? 0 : d.He) | |
) | |
d.He.lEb = "piff"; | |
} else if (null === d || void 0 === d ? 0 : d.He) | |
d.He.lEb = this.Jva; | |
this.L.Rb(); | |
return !0; | |
}; | |
k.re = "schm"; | |
k.Qc = !1; | |
return k; | |
})(l.Ye); | |
b["default"] = r; | |
}, | |
85978: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
l = a(255); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.XS = function (d) { | |
var f; | |
if (d && d.X && !d.RUb) { | |
f = this.yo("mdia"); | |
f && | |
(f = f.yo("mdhd")) && | |
f.R !== d.X.R && | |
(d.X = new l.M(d.X).Xe(f.R)); | |
} | |
return !0; | |
}; | |
k.re = "trak"; | |
k.Qc = !0; | |
return k; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
85830: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
var d, f, m, h, n; | |
this.vg(); | |
d = this.Qv([ | |
{ kO: "int32" }, | |
{ Ika: "int32" }, | |
{ dv: "int32" }, | |
{ Jx: "int32" }, | |
{ Ix: "int32" }, | |
]); | |
f = d.kO; | |
m = d.Ika; | |
h = d.dv; | |
n = d.Ix; | |
d = d.Jx; | |
this.Fc = { trackId: f, Gdc: m, J3: h, Hdc: n, Idc: d }; | |
(null === k || void 0 === k ? 0 : k.Fg) && | |
k.Fg[f] && | |
((k.Fg[f].Ika = m), | |
(k.Fg[f].dv = h), | |
(k.Fg[f].Ix = n), | |
(k.Fg[f].Jx = d)); | |
this.kO = f; | |
this.Ika = m; | |
this.dv = h; | |
this.Jx = d; | |
this.Ix = n; | |
return !0; | |
}; | |
g.re = "trex"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
20968: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
var d; | |
this.vg(); | |
d = | |
1 === this.version | |
? [ | |
{ creationTime: "int64" }, | |
{ modificationTime: "int64" }, | |
{ trackId: "int32" }, | |
{ offset: 32, type: "offset" }, | |
{ duration: "int64" }, | |
] | |
: [ | |
{ creationTime: "int32" }, | |
{ modificationTime: "int32" }, | |
{ trackId: "int32" }, | |
{ offset: 32, type: "offset" }, | |
{ duration: "int32" }, | |
]; | |
d = d.concat( | |
{ offset: 64, type: "offset" }, | |
{ wfc: "int16" }, | |
{ Hcc: "int16" }, | |
{ volume: "int16" }, | |
{ offset: 16, type: "offset" }, | |
{ offset: 288, type: "offset" }, | |
{ width: "int32" }, | |
{ height: "int32" } | |
); | |
this.Fc = this.Qv(d); | |
this.Fc.cic = !!(this.flags & 1); | |
this.Fc.dic = !!(this.flags & 2); | |
this.Fc.eic = !!(this.flags & 4); | |
this.Fc.fic = !!(this.flags & 8); | |
if (null === k || void 0 === k ? 0 : k.He) | |
(k.He.width = this.Fc.width), (k.He.height = this.Fc.height); | |
k && k.Fg && (k.Fg[this.Fc.trackId] = {}); | |
return !0; | |
}; | |
g.re = "tkhd"; | |
g.Qc = !1; | |
return g; | |
})(a(85571).Ye); | |
b["default"] = r; | |
}, | |
58853: function (r, b, a) { | |
var c, l, g, k; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.zNa = void 0; | |
c = a(5163); | |
l = a(61901); | |
g = a(27172); | |
k = a(16936); | |
r = (function (d) { | |
function f(m, h, n, p, q) { | |
m = d.call(this, m, h, n, p, q) || this; | |
m.IS = !1; | |
return m; | |
} | |
c.__extends(f, d); | |
Object.defineProperties(f.prototype, { | |
XVa: { | |
get: function () { | |
return !!(this.flags & 1); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(f.prototype, { | |
K4: { | |
get: function () { | |
return !!(this.flags & 4); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(f.prototype, { | |
U9: { | |
get: function () { | |
return !!(this.flags & 256); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(f.prototype, { | |
W9: { | |
get: function () { | |
return !!(this.flags & 512); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(f.prototype, { | |
xva: { | |
get: function () { | |
return !!(this.flags & 1024); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
Object.defineProperties(f.prototype, { | |
wva: { | |
get: function () { | |
return !!(this.flags & 2048); | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
f.prototype.parse = function (m) { | |
var h, n, p; | |
this.vg(); | |
this.xia = this.L.offset; | |
this.rd = this.L.Rb(); | |
this.Lm = this.XVa ? this.L.y9() : 0; | |
this.kGb = this.K4 ? this.L.Rb() : void 0; | |
this.vva = | |
(this.U9 ? 4 : 0) + | |
(this.W9 ? 4 : 0) + | |
(this.xva ? 4 : 0) + | |
(this.wva ? 4 : 0); | |
this.cL = this.L.offset; | |
(0, g.assert)( | |
this.XVa, | |
"Expected data offset to be present in Track Run" | |
); | |
(0, g.assert)( | |
this.length - (this.L.offset - this.startOffset) === | |
this.rd * this.vva, | |
"Expected remaining data in box to be sample information" | |
); | |
if (m && m.Y) { | |
m.Y.Lm = this.Lm; | |
m.Y.rd = this.rd; | |
this.Ij = []; | |
p = | |
null === | |
(n = | |
null === (h = this.parent) || void 0 === h | |
? void 0 | |
: h.Tm("tfhd")) || void 0 === n | |
? void 0 | |
: n.kO; | |
for (h = 0; h < this.rd; h++) { | |
n = {}; | |
this.U9 | |
? (n.T9 = this.L.Rb()) | |
: m.Y.dv | |
? (n.T9 = m.Y.dv) | |
: p && m.Fg && m.Fg[p] && (n.T9 = m.Fg[p].dv); | |
this.W9 | |
? (n.pH = this.L.Rb()) | |
: m.Y | |
? (n.pH = m.Y.Jx) | |
: p && m.Fg && m.Fg[p] && (n.pH = m.Fg[p].Jx); | |
this.xva | |
? (n.V9 = this.L.Rb()) | |
: m.Y | |
? (n.V9 = m.Y.Ix) | |
: p && m.Fg && m.Fg[p] && (n.V9 = m.Fg[p].Ix); | |
this.wva && | |
(n.dhc = 0 === this.version ? this.L.Rb() : this.L.y9()); | |
0 === h && this.K4 && (n.V9 = this.kGb); | |
this.Ij.push(n); | |
} | |
m.Y.Ij = this.Ij; | |
if (m.Y.oH) | |
for ( | |
(0, g.assert)( | |
m.Y.oH.length === m.Y.Ij.length, | |
"num fragment samples: ".concat(m.Y.Ij.length, ", ") + | |
"num samples in auxiliary info: ".concat( | |
m.Y.oH.length | |
) | |
), | |
p = 0; | |
p < m.Y.Ij.length; | |
p++ | |
) { | |
m.Y.Ij[p].Eca = m.Y.oH[p].Eca; | |
m.Y.Ij[p].exa = m.Y.oH[p].exa; | |
} | |
} | |
return !0; | |
}; | |
f.prototype.y1 = function (m, h, n) { | |
var p, q, u; | |
p = this.U9 ? this.L.Rb() : m.dv; | |
q = this.W9 ? this.L.Rb() : m.Jx; | |
m = this.xva ? this.L.Rb() : m.Ix; | |
u = this.wva | |
? 0 === this.version | |
? this.L.Rb() | |
: this.L.y9() | |
: 0; | |
return { | |
L_b: u, | |
V9: m, | |
pH: q, | |
T9: p, | |
Mgc: (n || 0) + u - (void 0 !== h ? h : u), | |
}; | |
}; | |
f.prototype.Ha = function (m, h, n, p, q, u, t) { | |
var v, w, y, x; | |
(0, g.assert)(void 0 !== this.Lm); | |
(0, g.assert)(void 0 !== this.cL); | |
(0, g.assert)(void 0 !== this.xia); | |
(0, g.assert)(void 0 !== this.rd); | |
(0, g.assert)(void 0 !== m.yq); | |
v = 0; | |
w = 0; | |
this.Pb.offset = this.cL; | |
for (p = 0; p < q; ++p) { | |
y = this.y1(h, x, w); | |
if (0 === p) x = y.L_b; | |
v += y.pH; | |
w += y.T9; | |
} | |
p = q; | |
q = this.L.offset; | |
y = this.y1(h, x, w); | |
this.Lua = t; | |
this.MN = p; | |
this.Kbb = w; | |
if (t) { | |
if (((this.nN = this.Lm + v), (this.Tp = 0), p === this.rd)) | |
return !0; | |
} else if (((this.nN = this.Lm), (this.Tp = v), 0 === p)) | |
return !0; | |
if (0 === p || p === this.rd) return !1; | |
this.IS = !0; | |
if (t) { | |
this.Tp += y.pH; | |
for (t = p + 1; t < this.rd; ++t) { | |
y = this.y1(h, x, w); | |
this.Tp += y.pH; | |
} | |
this.Pb.offset = this.xia; | |
this.rd = p; | |
this.Pb.$t(this.rd); | |
this.Pb.Nya(u); | |
this.K4 && (this.L.offset += 4); | |
this.am(this.length - (q - this.startOffset), q); | |
} else | |
(h = q - this.cL), | |
(this.cL = q), | |
(this.Pb.offset = this.xia), | |
(this.rd -= p), | |
this.Pb.$t(this.rd), | |
(this.Lm += v), | |
this.Pb.Nya(u, this.Lm), | |
this.K4 && (this.L.offset += 4), | |
this.am(h, this.Pb.offset); | |
n.am(this.Tp, m.yq + this.nN); | |
return !0; | |
}; | |
f.prototype.tSb = function (m, h, n, p, q, u, t, v) { | |
var w, x, z, A, B; | |
void 0 === t && (t = !1); | |
(0, g.assert)(void 0 !== this.Lm); | |
(0, g.assert)(void 0 !== this.cL); | |
(0, g.assert)(void 0 !== this.rd); | |
(0, g.assert)(void 0 !== this.vva); | |
(0, g.assert)(void 0 !== m.yq); | |
for (var y = p.length; y < this.rd; ++y) { | |
p[y] = p[y - 1]; | |
} | |
p.some(function (D) { | |
return 0 >= D; | |
}) && | |
(x = | |
null === (w = this.Hob(q, u)) || void 0 === w | |
? void 0 | |
: w.B$); | |
this.L.offset = this.cL; | |
m = m.yq + this.Lm; | |
q = -1 !== q.indexOf("heaac") ? "aac" : "ddp"; | |
u = new Uint8Array( | |
this.L.view.buffer, | |
this.L.view.byteOffset, | |
this.L.view.byteLength | |
); | |
for (y = 0; y < this.rd; ++y) { | |
w = this.y1(h).pH; | |
if (-Infinity === p[y]) { | |
if (x && this.W9) { | |
n.H9(w, x, m); | |
z = this.vva - (this.U9 ? 4 : 0); | |
this.Pb.offset -= z; | |
this.Pb.$t(x.byteLength); | |
this.Pb.offset += z - 4; | |
} | |
} else if (0 > p[y]) | |
try { | |
A = u.subarray(m, m + w); | |
B = (0, l.cYa)({ | |
vd: q, | |
frame: A, | |
nx: p[y], | |
lH: t, | |
tG: v, | |
}).GGb; | |
B !== w && | |
this.L.console.error( | |
"TrackRunBoxEditor: parse frame size error " | |
.concat(B, " should be ") | |
.concat(w) | |
); | |
} catch (D) { | |
this.L.console.error( | |
"TrackRunBoxEditor: fadeFrame error: " | |
.concat(D.message, " ") | |
.concat(D.stack) | |
); | |
} | |
m += w; | |
} | |
}; | |
f.prototype.Hob = function (m, h) { | |
if ("string" === typeof h) | |
return ( | |
(0, g.assert)("reset" !== h && "standard" !== h), k.zE[h] | |
); | |
if (void 0 !== m) | |
return h | |
? k.zE.reset[m] || k.zE.standard[m] | |
: k.zE.standard[m]; | |
}; | |
f.re = "trun"; | |
f.Qc = !1; | |
return f; | |
})(a(85571).Ye); | |
b.zNa = r; | |
}, | |
6483: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Vya = b.tEa = b.IEa = b.aza = b.$ya = b.Zya = b.Yya = void 0; | |
c = a(5163); | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.prototype.parse = function (k) { | |
l.prototype.parse.call(this, k); | |
this.Fc = this.Qv([ | |
{ offset: 16, type: "offset" }, | |
{ offset: 16, type: "offset" }, | |
{ offset: 96, type: "offset" }, | |
{ width: "int16" }, | |
{ height: "int16" }, | |
{ afc: "int32" }, | |
{ tic: "int32" }, | |
{ offset: 32, type: "offset" }, | |
{ wec: "int16" }, | |
{ tdc: { type: "int8", ctb: 32 } }, | |
{ depth: "int16" }, | |
{ offset: 16, type: "offset" }, | |
]); | |
return !0; | |
}; | |
g.Qc = !0; | |
return g; | |
})(a(44126).default); | |
b["default"] = r; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "avc1"; | |
return g; | |
})(r); | |
b.Yya = a; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "avc2"; | |
return g; | |
})(r); | |
b.Zya = a; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "avc3"; | |
return g; | |
})(r); | |
b.$ya = a; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "avc4"; | |
return g; | |
})(r); | |
b.aza = a; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "hvc1"; | |
return g; | |
})(r); | |
b.IEa = a; | |
a = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "hev1"; | |
return g; | |
})(r); | |
b.tEa = a; | |
r = (function (l) { | |
function g() { | |
return (null !== l && l.apply(this, arguments)) || this; | |
} | |
c.__extends(g, l); | |
g.re = "av01"; | |
return g; | |
})(r); | |
b.Vya = r; | |
}, | |
91418: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.QY = void 0; | |
c = a(5163); | |
l = a(85571); | |
g = a(97001); | |
r = (function (k) { | |
function d(f, m, h, n, p) { | |
h = k.call(this, h, n, p) || this; | |
h.Eub = f; | |
h.TN = m; | |
h.Ed = {}; | |
return h; | |
} | |
c.__extends(d, k); | |
d.prototype.parse = function (f) { | |
var m, h, n, p, q, u; | |
this.offset = 0; | |
m = []; | |
for ( | |
f = f || {}; | |
this.offset < this.view.byteLength && | |
!(8 > this.view.byteLength - this.offset); | |
) { | |
h = this.offset; | |
n = this.Rb(); | |
if (0 === n) | |
return { | |
done: !1, | |
offset: this.offset, | |
error: "Invalid zero-length box", | |
}; | |
p = (0, g.Pz)(this.Rb()); | |
if (null === p) | |
return { | |
done: !1, | |
offset: this.offset, | |
error: "Invalid box type", | |
}; | |
if ("uuid" === p) { | |
if (16 > this.view.byteLength - this.offset) break; | |
p = this.z9(); | |
} | |
if (0 === m.length && this.TN.VYa(p, h, n)) break; | |
if (h + n > this.view.byteLength) break; | |
q = this.Eub[p]; | |
u = void 0; | |
if (q) { | |
if ( | |
((u = new q(this, p, h, n, m[0])), | |
(m[0] || this).xR(u), | |
u.parse(f)) | |
) | |
this.config.bta && q.Qc | |
? m.unshift(u) | |
: (this.offset = h + n); | |
else | |
return { | |
done: !1, | |
offset: this.offset, | |
error: "parse error in " + p + " box", | |
}; | |
} else this.offset = h + n; | |
for ( | |
; | |
m.length && this.offset > m[0].byteOffset + m[0].KG - 8; | |
) { | |
u = m.shift(); | |
if (!u.XS(f)) | |
return { | |
done: !1, | |
offset: this.offset, | |
error: "finalize error in " + u.type + " box", | |
}; | |
this.offset = u.byteOffset + u.KG; | |
} | |
if (0 === m.length && this.TN.NWa(p, h, n, u)) break; | |
} | |
return !this.TN.done && | |
((f = this.TN.endOffset | |
? this.TN.endOffset - this.view.byteLength | |
: 4096), | |
0 < f) | |
? { done: !1, offset: this.offset, j6a: f } | |
: { | |
done: !0, | |
offset: Math.min( | |
this.TN.endOffset || Infinity, | |
this.offset | |
), | |
}; | |
}; | |
d.prototype.xR = function (f) { | |
l.Ye.xR(this, f); | |
}; | |
return d; | |
})(a(96785).jOa); | |
b.QY = r; | |
}, | |
51170: function (r) { | |
var c, l; | |
function b() { | |
var g, k; | |
if (DataView.prototype && DataView.prototype.NT && !l) { | |
try { | |
g = new ArrayBuffer(4); | |
k = new DataView(g); | |
k.AL(0, 4, 1); | |
} catch (d) { | |
return; | |
} | |
try { | |
g = new ArrayBuffer(4); | |
k = new DataView(g); | |
k.AL(1, 2, 2); | |
} catch (d) { | |
DataView.prototype.AL = a( | |
DataView.prototype.AL, | |
DataView.prototype.getUint8, | |
Uint8Array | |
); | |
DataView.prototype.K5 = a( | |
DataView.prototype.K5, | |
DataView.prototype.getUint16, | |
Uint16Array | |
); | |
DataView.prototype.NT = a( | |
DataView.prototype.NT, | |
DataView.prototype.getUint32, | |
Uint32Array | |
); | |
DataView.prototype.mna = a( | |
DataView.prototype.mna, | |
DataView.prototype.getInt8, | |
Int8Array | |
); | |
DataView.prototype.kna = a( | |
DataView.prototype.kna, | |
DataView.prototype.getInt16, | |
Int16Array | |
); | |
DataView.prototype.lna = a( | |
DataView.prototype.lna, | |
DataView.prototype.getInt32, | |
Int32Array | |
); | |
} | |
c.WKb = function (d, f, m, h, n) { | |
return m ? d.AL(f, m, h || 1, n) : new Uint8Array(0); | |
}; | |
c.UKb = function (d, f, m, h, n) { | |
return m ? d.K5(f, m, h || 2, n) : new Uint16Array(0); | |
}; | |
c.VKb = function (d, f, m, h, n) { | |
return m ? d.NT(f, m, h || 4, n) : new Uint32Array(0); | |
}; | |
c.Gec = function (d, f, m, h, n) { | |
return m ? d.mna(f, m, h || 1, n) : new Int8Array(0); | |
}; | |
c.Eec = function (d, f, m, h, n) { | |
return m ? d.kna(f, m, h || 2, n) : new Int16Array(0); | |
}; | |
c.Fec = function (d, f, m, h, n) { | |
return m ? d.lna(f, m, h || 4, n) : new Int32Array(0); | |
}; | |
l = !0; | |
} | |
} | |
function a(g, k, d) { | |
return function (f, m, h, n) { | |
var p; | |
h = h || d.BYTES_PER_ELEMENT; | |
if (f + m * h > this.byteLength) { | |
p = new d(m); | |
p.set(g.call(this, f, m - 1, h, n)); | |
p[m - 1] = k.call(this, f + (m - 1 * h), n); | |
return p; | |
} | |
return g.call(this, f, m, h, n); | |
}; | |
} | |
c = { | |
AL: function (g, k, d, f, m) { | |
var h; | |
h = new Uint8Array(d); | |
f = f || 1; | |
for (var n = 0; n < d; ++n, k += f) { | |
h[n] = g.getUint8(k, m); | |
} | |
return h; | |
}, | |
K5: function (g, k, d, f, m) { | |
var h; | |
h = new Uint16Array(d); | |
f = f || 2; | |
for (var n = 0; n < d; ++n, k += f) { | |
h[n] = g.getUint16(k, m); | |
} | |
return h; | |
}, | |
NT: function (g, k, d, f, m) { | |
var h; | |
h = new Uint32Array(d); | |
f = f || 4; | |
for (var n = 0; n < d; ++n, k += f) { | |
h[n] = g.getUint32(k, m); | |
} | |
return h; | |
}, | |
mna: function (g, k, d, f, m) { | |
var h; | |
h = new Int8Array(d); | |
f = f || 1; | |
for (var n = 0; n < d; ++n, k += f) { | |
h[n] = g.getInt8(k, m); | |
} | |
return h; | |
}, | |
kna: function (g, k, d, f, m) { | |
var h; | |
h = new Int16Array(d); | |
f = f || 2; | |
for (var n = 0; n < d; ++n, k += f) { | |
h[n] = g.getInt16(k, m); | |
} | |
return h; | |
}, | |
lna: function (g, k, d, f, m) { | |
var h; | |
h = new Int32Array(d); | |
f = f || 4; | |
for (var n = 0; n < d; ++n, k += f) { | |
h[n] = g.getInt32(k, m); | |
} | |
return h; | |
}, | |
lec: b, | |
}; | |
l = !1; | |
c.gIb = function () { | |
return l; | |
}; | |
b(); | |
r.exports = c; | |
}, | |
48609: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Wba = void 0; | |
c = a(5163); | |
l = a(85571); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
var f; | |
this.s8 = this.L.kd(); | |
f = this.L.kd(); | |
this.$wa = f >>> 2; | |
this.bya = (f >>> 1) & 1; | |
this.Dia = 256 * this.L.If() + this.L.kd(); | |
this.maxBitrate = this.L.Rb(); | |
this.I2 = this.L.Rb(); | |
l.K && | |
this.L.console.trace( | |
"DecoderConfigDescriptor: objectTypeIndication= 0x" + | |
this.s8.toString(16) + | |
", streamType=" + | |
this.$wa + | |
", upStream=" + | |
this.bya + | |
", bufferSizeDB=" + | |
this.Dia + | |
", maxBitrate=" + | |
this.maxBitrate + | |
", avgBitrate=" + | |
this.I2 | |
); | |
if (null === d || void 0 === d ? 0 : d.Mi) | |
(d.Mi.s8 = this.s8), | |
(d.Mi.$wa = this.$wa), | |
(d.Mi.bya = this.bya), | |
(d.Mi.Dia = this.Dia), | |
(d.Mi.maxBitrate = this.maxBitrate), | |
(d.Mi.I2 = this.I2); | |
this.kQa(d); | |
return !0; | |
}; | |
k.tag = 4; | |
return k; | |
})(a(4420).sZ); | |
b.Wba = r; | |
}, | |
91737: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.pCa = void 0; | |
c = a(5163); | |
l = a(85571); | |
r = a(4420); | |
g = a(26678); | |
a = (function (k) { | |
function d() { | |
return (null !== k && k.apply(this, arguments)) || this; | |
} | |
c.__extends(d, k); | |
d.prototype.C9a = function () { | |
var f; | |
f = this.L.Rc(4); | |
return 15 !== f | |
? [ | |
96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, | |
12e3, 11025, 8e3, 7350, | |
][f] | |
: this.L.Rc(24); | |
}; | |
d.prototype.parse = function (f, m) { | |
if (this.MNb(m) && 64 === m.s8) { | |
if (null === f || void 0 === f ? 0 : f.Mi) { | |
m = this.L.PZa(this.length); | |
for ( | |
var h = new ArrayBuffer(this.length), | |
n = new Uint8Array(h), | |
p = 0; | |
p < this.length; | |
p++ | |
) { | |
n[p] = m.getUint8(p); | |
} | |
f.Mi.Fdc = h; | |
} | |
this.gp = this.u9a(); | |
this.X9 = this.C9a(); | |
this.dja = this.L.Rc(4); | |
this.Bva = this.US = 5 === this.gp || 29 === this.gp ? 5 : -1; | |
this.iua = 29 === this.gp ? 1 : -1; | |
0 < this.US && | |
((this.Pla = this.C9a()), | |
(this.gp = this.u9a()), | |
22 === this.gp && (this.Ola = this.L.Rc(4))); | |
switch (this.gp) { | |
case 1: | |
case 2: | |
case 3: | |
case 4: | |
case 6: | |
case 7: | |
case 17: | |
case 19: | |
case 20: | |
case 21: | |
case 22: | |
case 23: | |
(this.iT = this.L.Rc(1)), | |
(this.$ja = (this.YBb = this.L.Rc(1)) | |
? this.L.Rc(14) | |
: void 0), | |
this.L.Rc(1), | |
(this.uF = | |
3 === this.gp | |
? 256 | |
: 23 === this.gp | |
? this.iT | |
? 480 | |
: 512 | |
: this.iT | |
? 960 | |
: 1024); | |
} | |
l.K && | |
this.L.console.trace( | |
"AudioSpecificConfig: audioObjectType=" + | |
this.gp + | |
", samplingFrequency=" + | |
this.X9 + | |
", channelConfiguration=" + | |
this.dja + | |
", extensionAudioObjectType=" + | |
this.US + | |
", sbrPresentFlag=" + | |
this.Bva + | |
", psPresentFlag=" + | |
this.iua + | |
", extensionSamplingFrequency=" + | |
this.Pla + | |
", extensionChannelConfiguration=" + | |
this.Ola + | |
", frameLengthFlag=" + | |
this.iT + | |
", coreCoderDelay=" + | |
this.$ja + | |
", frameLength=" + | |
this.uF | |
); | |
if (null === f || void 0 === f ? 0 : f.Mi) | |
(f.Mi.gp = this.gp), | |
(f.Mi.X9 = this.X9), | |
(f.Mi.dja = this.dja), | |
(f.Mi.US = this.US), | |
(f.Mi.Bva = this.Bva), | |
(f.Mi.iua = this.iua), | |
(f.Mi.Pla = this.Pla), | |
(f.Mi.Ola = this.Ola), | |
(f.Mi.iT = this.iT), | |
(f.Mi.$ja = this.$ja), | |
(f.Mi.uF = this.uF); | |
} | |
this.skip(); | |
return !0; | |
}; | |
d.prototype.u9a = function () { | |
var f; | |
f = this.L.Rc(5); | |
31 === f && (f = 32 + this.L.Rc(6)); | |
return f; | |
}; | |
d.prototype.MNb = function (f) { | |
return f.tag === g.Wba.tag; | |
}; | |
d.tag = 5; | |
return d; | |
})(r.sZ); | |
b.pCa = a; | |
}, | |
4420: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.sZ = void 0; | |
c = a(5163); | |
l = a(26678); | |
r = (function () { | |
function g(k, d, f) { | |
this.tag = k; | |
this.view = d; | |
this.L = f; | |
this.startOffset = f.offset; | |
} | |
g.w9a = function (k, d, f) { | |
var m, h; | |
m = k.kd(); | |
h = k.sYb(); | |
k = new (l.YE[m] || g)(m, k.PZa(h), k); | |
k.parse(d, f); | |
return k; | |
}; | |
Object.defineProperties(g.prototype, { | |
length: { | |
get: function () { | |
return this.view.byteLength; | |
}, | |
enumerable: !1, | |
configurable: !0, | |
}, | |
}); | |
g.prototype.parse = function () { | |
this.L.offset = this.startOffset + this.length; | |
this.L.qd = 0; | |
return !0; | |
}; | |
g.prototype.sYa = function (k) { | |
var d, m; | |
d = []; | |
this.tag === k && d.push(this); | |
if (this.YE) | |
for (var f = 0; f < this.YE.length; f++) { | |
m = this.YE[f]; | |
d = c.__spreadArray( | |
c.__spreadArray([], d, !0), | |
m.sYa(k), | |
!0 | |
); | |
} | |
return d; | |
}; | |
g.prototype.Tm = function (k) { | |
for (k = this.sYa(k); 0 < k.length; ) { | |
return k[0]; | |
} | |
}; | |
g.prototype.kQa = function (k) { | |
for ( | |
this.YE = []; | |
this.L.offset < this.startOffset + this.length; | |
) { | |
this.YE.push(g.w9a(this.L, k, this)); | |
} | |
}; | |
return g; | |
})(); | |
b.sZ = r; | |
r.prototype.skip = r.prototype.parse; | |
}, | |
26678: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.YE = void 0; | |
r = a(5163); | |
r.__exportStar(a(4420), b); | |
r.__exportStar(a(99128), b); | |
r.__exportStar(a(48609), b); | |
r.__exportStar(a(91737), b); | |
r = a(48609); | |
c = a(91737); | |
a = a(99128); | |
b.YE = { 3: a.gca, 4: r.Wba, 5: c.pCa }; | |
}, | |
99128: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.gca = void 0; | |
c = a(5163); | |
l = a(85571); | |
r = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.parse = function (d) { | |
var f; | |
this.$ib = this.L.If(); | |
f = this.L.kd(); | |
this.mcb = !!(f & 128); | |
this.ONa = !!(f & 64); | |
this.xIa = !!(f & 32); | |
this.l3b = f & 31; | |
this.ZBb = this.mcb ? this.L.If() : void 0; | |
this.ONa && this.L.w9(this.L.kd()); | |
this.flb = this.xIa ? this.L.If() : void 0; | |
l.K && | |
this.L.console.trace( | |
"ESDescriptor: ES_ID=" + | |
this.$ib + | |
", streamDependenceFlag=" + | |
this.mcb + | |
", URL_Flag=" + | |
this.ONa + | |
", OCRstreamFlag=" + | |
this.xIa + | |
", streamPriority=" + | |
this.l3b + | |
", dependsOn_ES_ID=" + | |
this.ZBb + | |
", OCR_ES_Id=" + | |
this.flb | |
); | |
this.kQa(d); | |
return !0; | |
}; | |
k.tag = 3; | |
return k; | |
})(a(4420).sZ); | |
b.gca = r; | |
}, | |
36418: function (r, b, a) { | |
var c, l, g, k, d, f, m; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.v = | |
b.zE = | |
b.w0 = | |
b.Zea = | |
b.xib = | |
b.Pz = | |
b.rP = | |
b.KB = | |
b.Xr = | |
b.Fw = | |
b.Fo = | |
void 0; | |
r = a(52297); | |
c = a(51170); | |
b.xib = c; | |
c = a(11174); | |
b.Zea = c; | |
c = a(16936); | |
b.zE = c; | |
b.w0 = r.vM.Ed.sidx; | |
l = a(56602); | |
Object.defineProperties(b, { | |
Fo: { | |
enumerable: !0, | |
get: function () { | |
return l.Fo; | |
}, | |
}, | |
}); | |
g = a(46788); | |
Object.defineProperties(b, { | |
Fw: { | |
enumerable: !0, | |
get: function () { | |
return g.Fw; | |
}, | |
}, | |
}); | |
k = a(70190); | |
Object.defineProperties(b, { | |
Xr: { | |
enumerable: !0, | |
get: function () { | |
return k.Xr; | |
}, | |
}, | |
}); | |
Object.defineProperties(b, { | |
KB: { | |
enumerable: !0, | |
get: function () { | |
return k.KB; | |
}, | |
}, | |
}); | |
d = a(49478); | |
Object.defineProperties(b, { | |
rP: { | |
enumerable: !0, | |
get: function () { | |
return d.rP; | |
}, | |
}, | |
}); | |
f = a(97001); | |
Object.defineProperties(b, { | |
Pz: { | |
enumerable: !0, | |
get: function () { | |
return f.Pz; | |
}, | |
}, | |
}); | |
m = a(23378); | |
Object.defineProperties(b, { | |
v: { | |
enumerable: !0, | |
get: function () { | |
return m.v; | |
}, | |
}, | |
}); | |
}, | |
49478: function (r, b, a) { | |
var c, l; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.rP = void 0; | |
c = a(5163); | |
r = a(46788); | |
l = a(57821); | |
a = (function (g) { | |
function k() { | |
return (null !== g && g.apply(this, arguments)) || this; | |
} | |
c.__extends(k, g); | |
k.prototype.Ha = function (d) { | |
var f, m, h, n; | |
f = this; | |
if (!this.parse().done) return !1; | |
m = this.Ed.moov; | |
if (!m || 0 === m.length) return !1; | |
h = m[0].Tm("tenc"); | |
if (!h) return !1; | |
n = new Uint8Array(h.co); | |
d.forEach(function (p) { | |
for (var q = p.from, u = !0, t = 0; t < q.length; t++) { | |
if (n[t] !== q[t]) { | |
u = !1; | |
break; | |
} | |
} | |
u && f.gf.H9(p.from.length, p.to, h.Rpa); | |
}); | |
return (0, l.concat)(this.gf.Ha()); | |
}; | |
return k; | |
})(r.Fw); | |
b.rP = a; | |
}, | |
23378: function (r, b, a) { | |
var c; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.v = void 0; | |
c = a(60328); | |
Object.defineProperties(b, { | |
v: { | |
enumerable: !0, | |
get: function () { | |
return c.v; | |
}, | |
}, | |
}); | |
}, | |
52297: function (r, b, a) { | |
var F, | |
G, | |
E, | |
I, | |
M, | |
L, | |
H, | |
N, | |
K, | |
J, | |
P, | |
R, | |
S, | |
na, | |
sa, | |
ja, | |
ta, | |
za, | |
Ia, | |
Ua, | |
$a, | |
Y, | |
la, | |
Ca, | |
Ka, | |
Q, | |
O, | |
ba, | |
ea, | |
wa, | |
Oa, | |
Ta, | |
lb, | |
Za, | |
Ab, | |
Fb; | |
function c(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function l(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function g(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function k(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
this.Cwa = Wa.config.Cwa; | |
this.bf = this.sizes = void 0; | |
} | |
function d(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function f() { | |
for ( | |
var Wa = new DataView(this), bb = "", jb, tb = 0; | |
tb < this.byteLength; | |
tb++ | |
) { | |
jb = Wa.getUint8(tb); | |
bb += ("00" + jb.toString(16)).slice(-2); | |
} | |
return bb; | |
} | |
function m(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function h(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function n(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function p(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function q(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function u(Wa) { | |
function bb(jb, tb, pb, rb, zb) { | |
I.call(this, jb, tb, pb, rb, zb); | |
this.SSb = Wa; | |
} | |
bb.Qc = !1; | |
bb.prototype = new I(); | |
bb.prototype.constructor = bb; | |
Object.defineProperties(bb.prototype, { | |
gCa: { | |
get: function () { | |
return this.SSb; | |
}, | |
}, | |
}); | |
bb.prototype.parse = function () { | |
this.L.offset = this.startOffset + 4; | |
this.Pb.Jfb(this.gCa); | |
this.type = this.gCa; | |
return !0; | |
}; | |
return bb; | |
} | |
function t(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function v(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function w(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function y(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function x(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function z(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function A(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function B(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function D(Wa, bb, jb, tb, pb) { | |
I.call(this, Wa, bb, jb, tb, pb); | |
} | |
function C(Wa, bb) { | |
Wa.forEach(function (jb) { | |
bb[jb.re] = jb; | |
}); | |
} | |
F = a(27172).assert; | |
b = a(26464); | |
G = a(255).M; | |
E = a(11174); | |
a(51170); | |
a(97001); | |
a(97001); | |
a(97001); | |
I = a(85571).Ye; | |
M = a(97291)["default"]; | |
L = a(85978)["default"]; | |
H = a(20968)["default"]; | |
N = a(60841)["default"]; | |
K = a(60440)["default"]; | |
J = a(22770)["default"]; | |
P = a(89849)["default"]; | |
R = a(36464)["default"]; | |
S = a(44210)["default"]; | |
a(44126); | |
a(61671); | |
na = a(82818).Qya; | |
sa = a(82818).XCa; | |
ja = a(24475)["default"]; | |
ta = a(89525)["default"]; | |
za = a(6483)["default"]; | |
Ia = a(6483).Yya; | |
Ua = a(6483).Zya; | |
$a = a(6483).$ya; | |
Y = a(6483).aza; | |
la = a(80586)["default"]; | |
Ca = a(24895)["default"]; | |
Ka = a(27235)["default"]; | |
Q = a(6483).IEa; | |
O = a(6483).tEa; | |
ba = a(6483).Vya; | |
ea = a(12228)["default"]; | |
wa = a(46079)["default"]; | |
Oa = a(75706)["default"]; | |
Ta = a(79798)["default"]; | |
lb = a(30855)["default"]; | |
a(4420); | |
a(48609); | |
a(91737); | |
a(99128); | |
Za = a(85830)["default"]; | |
Ab = a(58853).zNa; | |
Fb = a(21501)["default"]; | |
a = a(57199)["default"]; | |
c.Qc = !0; | |
c.prototype = new I(); | |
c.prototype.constructor = c; | |
l.Qc = !0; | |
l.prototype = new I(); | |
l.prototype.constructor = l; | |
g.Qc = !1; | |
g.prototype = new I(); | |
g.prototype.constructor = g; | |
g.prototype.parse = function (Wa) { | |
var bb; | |
this.vg(); | |
1 === this.version | |
? (this.L.Ti(), | |
this.L.Ti(), | |
(this.R = this.L.Rb()), | |
(this.duration = this.L.Ti())) | |
: (this.L.Rb(), | |
this.L.Rb(), | |
(this.R = this.L.Rb()), | |
(this.duration = this.L.Rb())); | |
bb = this.L.If() & 32767; | |
this.language = String.fromCharCode( | |
96 + (bb >>> 10), | |
96 + ((bb >>> 5) & 31), | |
96 + (bb & 31) | |
); | |
Wa && | |
Wa.He && | |
((Wa.He.R = this.R), (Wa.He.duration = this.duration)); | |
return !0; | |
}; | |
k.Qc = !1; | |
k.prototype = new I(); | |
k.prototype.constructor = k; | |
k.prototype.Vpb = function () { | |
this.vg(); | |
this.L.Rb(); | |
this.R = this.L.Rb(); | |
0 === this.version | |
? ((this.aXa = this.L.Rb()), (this.JYa = this.L.Rb())) | |
: ((this.aXa = this.L.Ti()), (this.JYa = this.L.Ti())); | |
this.C$a = this.L.If(); | |
this.S9a = this.L.If(); | |
}; | |
k.prototype.Ynb = function (Wa, bb) { | |
var jb, tb, pb; | |
jb = this.R; | |
Wa = (Wa && Wa.R) || jb; | |
tb = Wa / jb; | |
jb = this.L.v9(bb, 12, !1); | |
pb = | |
1 === tb | |
? this.L.v9(bb, 12, !1) | |
: E.from( | |
Uint32Array, | |
{ length: bb }, | |
function () { | |
var rb; | |
rb = Math.round(this.L.Rb() * tb); | |
this.L.offset += 8; | |
return rb; | |
}, | |
this | |
); | |
this.Rqb(bb, pb, jb, Wa); | |
}; | |
k.prototype.Rqb = function (Wa, bb, jb, tb) { | |
if (this.Cwa) { | |
tb = (this.Cwa * tb) / 1e3; | |
for (var pb = 0, rb = 1; rb < Wa; rb++) { | |
Math.abs(bb[pb] - tb) > Math.abs(bb[pb] + bb[rb] - tb) | |
? ((bb[pb] += bb[rb]), (jb[pb] += jb[rb])) | |
: (++pb, | |
pb !== rb && ((bb[pb] = bb[rb]), (jb[pb] = jb[rb]))); | |
} | |
++pb; | |
bb = new Uint32Array(bb.buffer.slice(0, 4 * pb)); | |
jb = new Uint32Array(jb.buffer.slice(0, 4 * pb)); | |
} | |
this.sizes = jb; | |
this.bf = bb; | |
}; | |
k.prototype.parse = function (Wa) { | |
var bb, jb, tb, pb; | |
this.Vpb(); | |
this.X = Wa.X; | |
bb = this.R; | |
jb = (this.X && this.X.R) || bb; | |
tb = this.S9a; | |
pb = this.startOffset + this.length + this.JYa; | |
bb = new G(this.aXa, bb).Xe(jb).sa; | |
this.Ma = { R: jb, Cr: bb, offset: pb }; | |
this.Ynb(this.X, tb); | |
this.Ma.bf = this.bf; | |
this.Ma.sizes = this.sizes; | |
Wa.qk = this; | |
return !0; | |
}; | |
d.Qc = !1; | |
d.prototype = new I(); | |
d.prototype.constructor = d; | |
d.prototype.parse = function () { | |
var Wa; | |
this.gw = []; | |
this.RVb = []; | |
Wa = (this.length - 11) / 2; | |
this.L.kd(); | |
this.L.kd(); | |
this.L.kd(); | |
for (var bb = 0; bb < Wa; bb++) { | |
this.gw.push(this.L.kd()); | |
this.RVb.push(this.L.kd()); | |
} | |
return !0; | |
}; | |
m.Qc = !1; | |
m.prototype = new I(); | |
m.prototype.constructor = m; | |
m.prototype.parse = function (Wa) { | |
var bb; | |
this.vg(); | |
this.L.offset += 1; | |
if (0 == this.version) this.L.offset += 1; | |
else { | |
bb = this.L.kd(); | |
this.HBb = bb >> 4; | |
this.NBb = bb & 15; | |
Wa && Wa.He && ((Wa.He.Jdc = this.HBb), (Wa.He.Mdc = this.NBb)); | |
} | |
this.qWa = this.L.kd(); | |
this.pWa = this.L.kd(); | |
this.Rpa = this.L.offset; | |
this.co = this.L.x9(16); | |
this.co.toString = f; | |
Wa && | |
Wa.He && | |
((Wa.He.Kdc = this.qWa), | |
(Wa.He.JBb = this.pWa), | |
(Wa.He.Ldc = this.co)); | |
1 == this.qWa && | |
0 == this.pWa && | |
((this.GBb = this.L.kd()), | |
(this.FBb = this.L.x9(this.GBb)), | |
Wa && Wa.He && (Wa.He.IBb = this.FBb)); | |
return !0; | |
}; | |
h.Qc = !1; | |
h.prototype = new I(); | |
h.prototype.constructor = h; | |
h.prototype.parse = function () { | |
this.vg(); | |
this.up = this.L.If(); | |
this.BRb = this.L.v9(this.up, void 0, !0); | |
return !0; | |
}; | |
n.Qc = !1; | |
n.prototype = new I(); | |
n.prototype.constructor = n; | |
n.prototype.parse = function (Wa) { | |
var bb, jb, tb, pb, rb, zb; | |
bb = Wa.qk; | |
F(bb); | |
Wa = Wa.X; | |
jb = bb.R; | |
bb = bb.S9a; | |
F(Wa); | |
F(jb); | |
F(bb); | |
this.vg(); | |
F(2 > this.version); | |
this.up = this.L.If(); | |
this.WM = new Uint16Array(bb + 1); | |
tb = Wa.x0a(jb); | |
pb = tb / jb; | |
rb = Wa.Xe(tb).sa; | |
if (0 === this.version) | |
for ( | |
this.zN = new Uint16Array(), | |
this.ri = new Uint32Array(), | |
Wa = jb = 0; | |
Wa <= bb; | |
++Wa | |
) { | |
if (((this.WM[Wa] = jb), Wa < this.up)) { | |
zb = this.L.kd(); | |
if (0 !== zb) | |
for (tb = 0; tb < zb; ++tb, ++jb) { | |
this.zN[jb] = Math.floor((this.L.Rb() + 1) * pb) / rb; | |
this.ri[jb] = this.L.Rb(); | |
} | |
} | |
} | |
else if (1 === this.version) | |
for ( | |
tb = this.L.pYb(this.up), | |
this.L.offset += 4, | |
this.ri = this.L.v9(this.up, 10, !1), | |
this.L.offset -= 8, | |
this.zN = E.from( | |
Uint16Array, | |
{ length: this.up }, | |
function () { | |
var Lb; | |
Lb = Math.floor((this.L.Rb() + 1) * pb) / rb; | |
this.L.offset += 6; | |
return Lb; | |
}, | |
this | |
), | |
jb = Wa = 0; | |
Wa <= bb; | |
++Wa | |
) { | |
for (; jb < tb.length && tb[jb] < Wa; ) { | |
++jb; | |
} | |
this.WM[Wa] = jb; | |
} | |
this.nj = { WM: this.WM, zN: this.zN, ri: this.ri }; | |
return !0; | |
}; | |
p.Qc = !0; | |
p.prototype = Object.create(c.prototype); | |
p.prototype.constructor = p; | |
q.Qc = !0; | |
q.prototype = Object.create(c.prototype); | |
q.prototype.constructor = q; | |
q.prototype.XS = function () { | |
var Wa; | |
Wa = this.yo("tfhd"); | |
Wa && (this.yq = Wa.OSa ? Wa.yq : this.parent.startOffset); | |
return !0; | |
}; | |
t.Qc = !1; | |
t.prototype = new I(); | |
t.prototype.constructor = t; | |
t.prototype.parse = function () { | |
var Wa, Xb; | |
Wa = this.L.offset; | |
this.vg(); | |
if (1 === this.version) { | |
this.L.offset += 2; | |
for ( | |
var bb = this.L.offset, | |
jb = this.L.kd(), | |
tb = this.L.kd(), | |
pb = this.L.kd(), | |
rb = this.L.kd(), | |
zb = this.L.If(), | |
Lb = [], | |
Sb = 0; | |
Sb < zb; | |
++Sb | |
) { | |
Lb = this.L.kd(); | |
} | |
Sb = (jb & 240) >>> 4; | |
Xb = (jb & 14) >>> 1; | |
jb &= 1; | |
pb = 16 === pb ? 1 : 0; | |
tb != rb && | |
this.L.console.warn( | |
"VP9: Has the VP9 spec for vpcC changed? colourPrimaries " + | |
tb + | |
" and matrixCoefficients " + | |
rb + | |
" should be the same value!" | |
); | |
rb = 2; | |
switch (tb) { | |
case 1: | |
rb = 2; | |
break; | |
case 6: | |
rb = 1; | |
break; | |
case 9: | |
rb = 5; | |
break; | |
default: | |
this.L.console.warn( | |
"VP9: Unknown colourPrimaries " + | |
tb + | |
"! Falling back to default color space VP9_COLOR_SPACE_BT709_6 (2)" | |
); | |
} | |
this.version = 0; | |
this.Pb.Maa(this.version, Wa); | |
this.Pb.Maa((Sb << 4) | rb, bb++); | |
this.Pb.Maa((Xb << 4) | (pb << 1) | jb, bb++); | |
zb += 2; | |
Lb.push(0, 0); | |
this.Pb.X7b(zb); | |
bb += 2; | |
Lb.forEach(function (Ib) { | |
this.Pb.Maa(Ib, bb++); | |
}); | |
} | |
return !0; | |
}; | |
v.Qc = !1; | |
v.prototype = new I(); | |
v.prototype.constructor = v; | |
v.re = "tfhd"; | |
Object.defineProperties(v.prototype, { | |
OSa: { | |
get: function () { | |
return this.flags & 1; | |
}, | |
}, | |
M_b: { | |
get: function () { | |
return this.flags & 2; | |
}, | |
}, | |
KBb: { | |
get: function () { | |
return this.flags & 8; | |
}, | |
}, | |
MBb: { | |
get: function () { | |
return this.flags & 16; | |
}, | |
}, | |
rWa: { | |
get: function () { | |
return this.flags & 32; | |
}, | |
}, | |
}); | |
v.prototype.parse = function (Wa) { | |
this.vg(); | |
this.kO = this.L.Rb(); | |
this.yq = this.OSa ? this.L.Ti() : void 0; | |
this.bab = this.M_b ? this.L.Rb() : void 0; | |
this.dv = this.KBb ? this.L.Rb() : void 0; | |
this.Jx = this.MBb ? this.L.Rb() : void 0; | |
this.Ix = this.rWa ? this.L.Rb() : void 0; | |
Wa && | |
Wa.Y && | |
((Wa.Y.kO = this.kO), | |
(Wa.Y.yq = this.yq), | |
(Wa.Y.bab = this.bab), | |
(Wa.Y.dv = this.dv), | |
(Wa.Y.Jx = this.Jx), | |
(Wa.Y.Ix = this.rWa ? this.Ix : void 0)); | |
return !0; | |
}; | |
w.Qc = !1; | |
w.prototype = new I(); | |
w.prototype.constructor = w; | |
w.prototype.parse = function (Wa) { | |
this.vg(); | |
this.DE = 1 === this.version ? this.L.Ti() : this.L.Rb(); | |
Wa && Wa.Y && (Wa.Y.DE = this.DE); | |
return !0; | |
}; | |
w.prototype.Ha = function (Wa) { | |
var bb; | |
bb = this.startOffset + 12; | |
this.DE += Wa; | |
1 === this.version | |
? this.Pb.Y7b(this.DE, bb) | |
: this.Pb.$t(this.DE, bb); | |
}; | |
y.Qc = !1; | |
y.prototype = Object.create(I.prototype); | |
y.prototype.constructor = y; | |
Object.defineProperties(y.prototype, { | |
BE: { | |
get: function () { | |
return this.flags & 1; | |
}, | |
}, | |
}); | |
y.prototype.parse = function (Wa) { | |
this.vg(); | |
this.BE && this.L.Iy(); | |
this.BE && this.L.Rb(); | |
this.LBb = this.L.kd(); | |
this.rd = this.L.Rb(); | |
this.TMb = this.L.w9(this.rd); | |
Wa && Wa.Y && (Wa.Y.N_b = this.TMb); | |
return !0; | |
}; | |
y.prototype.Ha = function (Wa, bb) { | |
if (Wa && 0 === this.LBb) { | |
Wa = bb ? this.rd - Wa : Wa; | |
this.Pb.offset = this.startOffset + 13 + (this.BE ? 8 : 0); | |
this.rd -= Wa; | |
this.Pb.$t(this.rd); | |
this.tva = 0; | |
if (bb) this.Pb.offset += this.rd; | |
else { | |
for (bb = 0; bb < Wa; ++bb) { | |
this.tva += this.Pb.kd(); | |
} | |
this.Pb.offset -= Wa; | |
} | |
this.am(Wa, this.L.offset); | |
} | |
return !0; | |
}; | |
x.Qc = !1; | |
x.prototype = Object.create(I.prototype); | |
x.prototype.constructor = x; | |
Object.defineProperties(x.prototype, { | |
BE: { | |
get: function () { | |
return this.flags & 1; | |
}, | |
}, | |
}); | |
x.prototype.parse = function (Wa) { | |
var bb, jb, Sb, Xb; | |
this.vg(); | |
this.BE && this.L.Iy(); | |
this.BE && this.L.Rb(); | |
this.up = this.L.Rb(); | |
F( | |
1 === this.up, | |
"Expected a single entry in Sample Auxiliary Information Offsets box" | |
); | |
this.Lm = 0 === this.version ? this.L.y9() : this.L.uYb(); | |
this.L.offset = this.Lm; | |
if (Wa && Wa.Y && Wa.He) { | |
bb = Wa.He.JBb; | |
jb = Wa.Y.N_b; | |
F( | |
0 < bb || void 0 !== Wa.He.IBb, | |
"Expected per sample or constant IV" | |
); | |
F( | |
0 < (jb || []).length, | |
"Expected saix box parsing to find sample info sizes" | |
); | |
Wa.Y.oH = []; | |
for (var tb = 0; tb < jb.length; tb++) { | |
for ( | |
var pb = bb ? this.L.x9(bb) : void 0, | |
rb = [], | |
zb = this.L.If(), | |
Lb = 0; | |
Lb < zb; | |
Lb++ | |
) { | |
Sb = this.L.If(); | |
Xb = this.L.Rb(); | |
rb.push({ ivb: Sb, jvb: Xb }); | |
} | |
Wa.Y.oH.push({ exa: rb, Eca: pb }); | |
} | |
} | |
return !0; | |
}; | |
x.prototype.Ha = function (Wa, bb) { | |
this.Lm += Wa; | |
this.Pb.offset = | |
this.startOffset + | |
16 + | |
(this.BE ? 8 : 0) + | |
(0 === this.version ? 0 : 4); | |
this.Pb.Nya(bb, this.Lm); | |
return !0; | |
}; | |
z.Qc = !1; | |
z.prototype = Object.create(I.prototype); | |
z.prototype.constructor = z; | |
Object.defineProperties(z.prototype, { | |
B7a: { | |
get: function () { | |
return this.flags & 1; | |
}, | |
}, | |
Web: { | |
get: function () { | |
return this.flags & 2; | |
}, | |
}, | |
}); | |
z.prototype.parse = function (Wa) { | |
var bb, zb, Lb; | |
this.vg(); | |
bb = 0; | |
this.B7a && ((bb = this.MOb = this.L.Rb() & 255), this.L.w9(16)); | |
if (Wa && Wa.Y) { | |
if (Wa.Y.oH) return !0; | |
Wa.Y.Ij || (Wa.Y.Ij = []); | |
} | |
if (0 !== bb && 8 !== bb && 16 !== bb) return !0; | |
this.rd = this.L.Rb(); | |
if (Wa && Wa.Y) | |
for (var jb = 0; jb < this.rd; jb++) { | |
if ( | |
((Wa.Y.Ij[jb].Eca = 0 < bb ? this.L.x9(bb) : void 0), | |
this.Web) | |
) { | |
for (var tb = [], pb = this.L.If(), rb = 0; rb < pb; rb++) { | |
zb = this.L.If(); | |
Lb = this.L.Rb(); | |
tb.push({ ivb: zb, jvb: Lb }); | |
} | |
Wa.Y.Ij[jb].exa = tb; | |
} | |
} | |
return !0; | |
}; | |
z.prototype.Ha = function (Wa, bb) { | |
var jb, tb; | |
jb = bb ? this.rd - Wa : Wa; | |
this.Pb.offset = this.startOffset + 28 + (this.B7a ? 20 : 0); | |
this.rd -= jb; | |
this.Pb.$t(this.rd); | |
Wa = this.Pb.offset; | |
if (this.Web) | |
for (jb = bb ? this.rd : jb; 0 < jb; --jb) { | |
this.Pb.offset += 8; | |
tb = this.Pb.If(); | |
this.Pb.offset += 6 * tb; | |
} | |
else this.Pb.offset += 8 * (bb ? this.rd : jb); | |
bb | |
? this.am( | |
this.length - (this.L.offset - this.startOffset), | |
this.L.offset | |
) | |
: this.am(this.L.offset - Wa, Wa); | |
}; | |
A.Qc = !1; | |
A.prototype = Object.create(I.prototype); | |
A.prototype.constructor = A; | |
A.prototype.parse = function (Wa) { | |
this.vg(); | |
if (Wa && Wa.Y) { | |
void 0 === Wa.Y.Ij && (Wa.Y.Ij = []); | |
for (var bb = 0; bb < this.length - 12; bb++) { | |
Wa.Y.Ij[bb].ehc = this.L.kd(); | |
} | |
} | |
return !0; | |
}; | |
A.prototype.Ha = function (Wa, bb, jb) { | |
jb | |
? this.am(bb - Wa, this.startOffset + 12 + Wa) | |
: this.am(Wa, this.startOffset + 12); | |
return !0; | |
}; | |
B.Qc = !1; | |
B.prototype = Object.create(I.prototype); | |
B.prototype.constructor = B; | |
B.prototype.parse = function () { | |
this.vg(); | |
this.L.Iy(); | |
1 === this.version && this.L.Rb(); | |
this.up = this.L.Rb(); | |
this.PW = []; | |
for (var Wa = 0; Wa < this.up; ++Wa) { | |
for ( | |
var bb = this.L.Rb(), jb = this.L.Rb(), tb = 0; | |
tb < bb; | |
++tb | |
) { | |
this.PW.push(jb); | |
} | |
} | |
return !0; | |
}; | |
B.prototype.Ha = function (Wa, bb) { | |
this.PW = bb ? this.PW.slice(0, Wa) : this.PW.slice(Wa); | |
Wa = this.PW.reduce(function (jb, tb) { | |
(0 !== jb.length && jb[jb.length - 1].group === tb) || | |
jb.push({ group: tb, count: 0 }); | |
++jb[jb.length - 1].count; | |
return jb; | |
}, []); | |
this.Pb.offset = | |
this.startOffset + 16 + (1 === this.version ? 4 : 0); | |
this.Pb.$t(Wa.length); | |
Wa.forEach( | |
function (jb) { | |
this.Pb.$t(jb.count); | |
this.Pb.$t(jb.group); | |
}.bind(this) | |
); | |
this.up > Wa.length && this.am(8 * (this.up - Wa.length)); | |
this.up = Wa.length; | |
return !0; | |
}; | |
D.Qc = !1; | |
D.prototype = Object.create(I.prototype); | |
D.prototype.constructor = D; | |
za = { | |
Ed: { | |
moov: l, | |
trak: c, | |
mdia: c, | |
mdhd: g, | |
minf: c, | |
encv: za, | |
schi: c, | |
sidx: k, | |
sinf: c, | |
stbl: c, | |
tenc: m, | |
mvex: c, | |
moof: p, | |
traf: q, | |
tfhd: v, | |
trun: Ab, | |
sbgp: B, | |
sdtp: A, | |
saiz: y, | |
saio: x, | |
tfdt: w, | |
mdat: D, | |
vmaf: d, | |
edts: c, | |
}, | |
f5b: { vpcC: t, SmDm: u("smdm"), CoLL: u("coll") }, | |
Ndb: { schm: la }, | |
uva: {}, | |
}; | |
C( | |
[ | |
Ca, | |
Ka, | |
J, | |
a, | |
P, | |
Fb, | |
R, | |
Q, | |
O, | |
ba, | |
M, | |
N, | |
Ta, | |
lb, | |
K, | |
S, | |
L, | |
H, | |
Za, | |
Ab, | |
], | |
za.Ed | |
); | |
C([na, ja, Ia, Ua, $a, Y, sa, ta, wa, ea], za.uva); | |
C([Ca, la], za.Ndb); | |
za.Ed[b.RIa] = m; | |
za.Ed[b.O_] = h; | |
za.Ed[b.N_] = n; | |
za.Ed[b.QIa] = z; | |
za.uva[b.tda] = Oa; | |
za.Ye = I; | |
r.exports = { vM: za }; | |
}, | |
70190: function (r, b, a) { | |
var l, g, k, d, f; | |
function c(m) { | |
return "number" === typeof m[0] || void 0 === m[0] | |
? { Hj: m[0], R: m[1], nx: m[2], iva: m[3], lH: m[4] } | |
: m[0]; | |
} | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.KB = b.Xr = void 0; | |
l = a(5163); | |
g = a(26464); | |
r = a(46788); | |
k = a(97001); | |
d = a(27172); | |
f = a(85571); | |
a = (function (m) { | |
function h(n, p, q) { | |
return m.call(this, n, p, q) || this; | |
} | |
l.__extends(h, m); | |
h.prototype.b$a = function () { | |
for (var n = [], p = 0; p < arguments.length; p++) { | |
n[p] = arguments[p]; | |
} | |
return this.Ha(l.__assign(l.__assign({}, c(n)), { Lua: !1 })); | |
}; | |
h.prototype.i$a = function () { | |
for (var n = [], p = 0; p < arguments.length; p++) { | |
n[p] = arguments[p]; | |
} | |
return this.Ha(l.__assign(l.__assign({}, c(n)), { Lua: !0 })); | |
}; | |
h.prototype.Ha = function (n) { | |
var q, | |
u, | |
t, | |
v, | |
w, | |
y, | |
x, | |
z, | |
A, | |
B, | |
D, | |
C, | |
F, | |
G, | |
E, | |
I, | |
M, | |
L, | |
H, | |
N, | |
K; | |
function p(R) { | |
z = x[R]; | |
A = z.yo("traf"); | |
if (void 0 === A || void 0 === A.yq) return !1; | |
F = A.yo("tfdt"); | |
if (void 0 === F) return !1; | |
B = A.yo("trun"); | |
return void 0 === B ? !1 : !0; | |
} | |
q = n.Hj; | |
u = n.R; | |
t = n.Lua; | |
v = n.nx; | |
w = n.iva; | |
w = void 0 === w ? !1 : w; | |
y = n.lH; | |
y = void 0 === y ? !1 : y; | |
n = n.tG; | |
if (!this.parse().done) return !1; | |
x = this.Ed.moof; | |
if (!x || 0 === x.length) return !1; | |
if (void 0 !== q) { | |
D = q; | |
for (q = 0; q < x.length; ++q) { | |
if (!p(q, this.gf.console.trace)) return !1; | |
(0, d.assert)(z && A && F && B && void 0 !== B.rd); | |
if (B.rd > D || (t && B.rd === D)) break; | |
D -= B.rd; | |
} | |
(0, d.assert)(z && A && F && B); | |
} else if ( | |
((q = t ? x.length - 1 : 0), !p(q, this.gf.console.trace)) | |
) | |
return !1; | |
(0, d.assert)(z && A && F && B); | |
if (t && q < x.length - 1) { | |
C = x[q + 1]; | |
this.gf.am( | |
this.view.byteOffset - C.startOffset, | |
C.startOffset | |
); | |
} else !t && 0 < q && this.gf.am(z.startOffset, 0); | |
C = A.yo("tfhd"); | |
if (void 0 === C) return !1; | |
F = A.yo("tfdt"); | |
G = B.rd; | |
E = A.yo("saiz"); | |
I = A.yo("saio"); | |
M = A.yo(g.QIa); | |
L = A.yo("sbgp"); | |
if (!((!E && !I) || (E && I))) return !1; | |
H = A.yo("sdtp"); | |
N = f.Ye.Px(this, "mdat"); | |
if (N && q < N.length) K = N[q]; | |
else if (q !== x.length - 1) return !1; | |
void 0 === D && (D = t ? B.rd : 0); | |
if ("number" === typeof v && 0 < v) { | |
N = t ? D : B.rd - D; | |
for (var J = Array(N), P = 0; P < N; ++P) { | |
J[P] = t | |
? P >= N - v | |
? -Infinity | |
: 0 | |
: P < v | |
? -Infinity | |
: 0; | |
} | |
v = J; | |
} | |
if (B.Ha(A, C, K || this.gf, u, D, A.yq, t)) | |
B.IS && | |
((0, d.assert)(void 0 !== B.Kbb), | |
(0, d.assert)(void 0 !== B.MN), | |
!t && F && F.Ha(B.Kbb), | |
E && I && (E.Ha(B.MN, t), I.Ha(M ? 0 : E.tva, A.yq)), | |
M && M.Ha(B.MN, t), | |
H && H.Ha(B.MN, G, t), | |
L && L.Ha(B.MN, t)); | |
else if (!t) { | |
if (q === x.length - 1) return !1; | |
this.gf.am( | |
x[q + 1].startOffset - z.startOffset, | |
z.startOffset | |
); | |
} else if (0 === B.MN) return !1; | |
Array.isArray(v) && | |
K && | |
this.stream.profile && | |
void 0 !== w && | |
B.tSb(A, C, K, v, this.stream.profile, w, y, n); | |
u = this.gf.Ha(); | |
t = u.reduce(function (R, S) { | |
return R + S.byteLength; | |
}, 0); | |
u = { Y: u, length: t, KG: this.gf.view.byteLength }; | |
B.IS && !K && ((u.nN = A.yq + B.nN), (u.Tp = B.Tp)); | |
return u; | |
}; | |
return h; | |
})( | |
(function (m) { | |
function h(n, p, q) { | |
return m.call(this, n, p, q) || this; | |
} | |
l.__extends(h, m); | |
return h; | |
})(r.Fw) | |
); | |
b.Xr = a; | |
b.KB = function (m) { | |
var h, n; | |
h = new ArrayBuffer(8); | |
n = new DataView(h); | |
n.setUint32(0, m + 8); | |
n.setUint32(4, (0, k.zfa)("mdat")); | |
return h; | |
}; | |
}, | |
46788: function (r, b, a) { | |
var c, l, g; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Fw = void 0; | |
c = a(91418); | |
l = a(52297); | |
g = a(27815); | |
r = (function () { | |
function k(d, f, m) { | |
this.console = d; | |
this.stream = f; | |
this.view = | |
m instanceof ArrayBuffer | |
? new DataView(m) | |
: new DataView(m.data, m.offset, m.length); | |
} | |
k.prototype.parse = function (d) { | |
var f; | |
f = new g.Zba(this.view.byteLength); | |
this.gf = new c.QY(l.vM.Ed, f, this.view, this.console, { | |
bta: !0, | |
}); | |
d = this.gf.parse(d); | |
this.Ed = this.gf.Ed; | |
return d; | |
}; | |
return k; | |
})(); | |
b.Fw = r; | |
}, | |
56602: function (r, b, a) { | |
var c, l, g, k, d, f, m, h, n, p, q, u, t; | |
Object.defineProperties(b, { __esModule: { value: !0 } }); | |
b.Fo = void 0; | |
c = a(5163); | |
l = a(44295); | |
g = a(57821); | |
k = a(27172); | |
d = a(255); | |
f = a(85571); | |
r = a(79798); | |
m = a(30855); | |
h = a(91418); | |
n = a(51170); | |
p = a(52297); | |
q = a(26464); | |
u = a(27815); | |
t = a(82441); | |
c.__exportStar(a(17904), b); | |
a = (function () { | |
function v(w, y, x, z, A, B) { | |
this.console = w; | |
this.stream = y; | |
this.It = z; | |
this.lsb = A; | |
this.view = | |
x instanceof ArrayBuffer | |
? new DataView(x) | |
: new DataView(x.data, x.offset, x.length); | |
this.config = B || {}; | |
this.OLb = (0, n.gIb)(); | |
} | |
v.path = function (w, y) { | |
return y.reduce(function (x, z) { | |
return x && x.Ed[z] && x.Ed[z][0]; | |
}, w); | |
}; | |
v.mJb = function (w) { | |
return w && w.Fja && -1 !== w.Fja.indexOf("mcl0") | |
? "mcl0" | |
: void 0; | |
}; | |
v.QFb = function (w, y) { | |
var x, z; | |
(0, k.assert)("mcl0" === w, "Unsupported McClearen brand"); | |
x = y.Ma; | |
w = x.bf; | |
y = new d.M(120, 1).Xe(x.R).sa; | |
z = 0; | |
for (x = x.Cr; z < w.length && x < y; ) { | |
x += w[z++]; | |
} | |
return z; | |
}; | |
v.prototype.parse = function (w) { | |
var y; | |
y = this.T_b(); | |
if (!y.done) { | |
if (y.j6a) return { vt: !1, c2: y.j6a }; | |
this.console.error("Scan error: " + y.error); | |
return { | |
vt: !1, | |
parseError: y.error || "unknown mp4 scan error", | |
}; | |
} | |
if (null === w || void 0 === w ? 0 : w.X) w.RUb = w.X; | |
this.view = new DataView( | |
this.view.buffer, | |
this.view.byteOffset, | |
y.offset | |
); | |
w = this.pVb(w); | |
return w.done | |
? this.Jxb() | |
: (this.console.error("Parse error: " + w.error), | |
{ | |
vt: !1, | |
parseError: w.error || "unknown mp4 parse error", | |
}); | |
}; | |
v.prototype.Px = function (w) { | |
return f.Ye.Px(this, w); | |
}; | |
v.prototype.Tm = function (w) { | |
return f.Ye.Tm(this, w); | |
}; | |
v.prototype.T_b = function () { | |
var w, y; | |
w = new u.QEa( | |
this.It, | |
this.lsb ? [q.O_, q.N_] : [], | |
(this.config && this.config.Thc) || ["moof", q.dIa], | |
this.config && this.config.cta | |
); | |
y = c.__assign(c.__assign({}, this.config), { bta: !1 }); | |
return new h.QY(v.Dva, w, this.view, this.console, y).parse(); | |
}; | |
v.prototype.pVb = function (w) { | |
var y, x, z; | |
y = new u.Zba(this.view.byteLength); | |
x = Object.create(p.vM.Ed); | |
this.config && | |
((this.config.$sa || this.config.Mdb || this.config.F$) && | |
l(p.vM.uva, x), | |
this.config.Mxa && l(p.vM.f5b, x), | |
this.config.Mdb && l(p.vM.Ndb, x)); | |
z = c.__assign(c.__assign({}, this.config), { bta: !0 }); | |
this.gf = new h.QY(x, y, this.view, this.console, z); | |
w = this.gf.parse(w); | |
w.done && (this.Ed = this.gf.Ed); | |
return w; | |
}; | |
v.prototype.Jxb = function () { | |
var w, y, x, z, A, B, D, C; | |
w = { vt: !0 }; | |
y = v.path(this, ["moov"]); | |
x = null === y || void 0 === y ? void 0 : y.Px("trak"); | |
if (1 === (null === x || void 0 === x ? void 0 : x.length)) { | |
z = x[0].yo("tkhd"); | |
z && (w.trackId = z.Fc.trackId); | |
} | |
z = v.path(y, ["trak", "mdia", "minf", "stbl", "stsd"]); | |
if (this.config.$sa) | |
if (z) (w.X = z.X), (w.chc = z.Ed); | |
else | |
return { | |
vt: !1, | |
parseError: "Missing sample descriptions", | |
}; | |
A = v.path(z, ["encv", "sinf", "schi"]); | |
A && | |
(A = v.path(A, ["tenc"]) || v.path(A, [q.RIa])) && | |
(w.kEb = { udc: A.co, Rpa: A.Rpa, sfc: !1 }); | |
if ((A = v.path(y, ["trak", "mdia", "mdhd"]))) w.R = A.R; | |
if ((A = v.path(y, ["mvex", "trex"]))) w.J3 = A && A.Fc.J3; | |
w.J3 && w.R && (w.X = new d.M(w.J3, w.R)); | |
if ((A = v.path(this, ["sidx"]))) { | |
B = v.path(this, [q.O_]); | |
B = B && B.BRb; | |
D = v.path(this, [q.N_]); | |
D = D && D.nj; | |
w.Ma = A.Ma; | |
w.uM = B; | |
w.nj = D; | |
} | |
if ((B = this.Ed.vmaf && this.Ed.vmaf[0])) w.gw = B.gw; | |
if ( | |
this.config.Pua && | |
(B = v.path(y, ["mvex"])) && | |
x && | |
x.length | |
) { | |
C = x.reduce(function (F, G) { | |
return G.byteOffset > F.byteOffset ? G : F; | |
}); | |
C.byteOffset > B.byteOffset && | |
((x = new Uint8Array( | |
this.view.buffer, | |
this.view.byteOffset, | |
this.view.byteLength | |
)), | |
(D = (0, t.Txa)( | |
x, | |
Uint8Array, | |
B.byteOffset, | |
B.byteOffset + B.byteLength | |
)), | |
(C = (0, t.Txa)( | |
x, | |
Uint8Array, | |
B.byteOffset + B.byteLength, | |
C.byteOffset + C.byteLength | |
)), | |
x.set(C, B.byteOffset), | |
x.set(D, B.byteOffset + C.byteLength)); | |
} | |
if (this.config.Q$a) | |
if (y) | |
this.trim(y.byteOffset + y.byteLength), | |
this.config.F$ && | |
z && | |
1 < z.TK && | |
A && | |
(w.Cg = this.F$(z, A)), | |
void 0 === w.Cg && | |
((y = this.gf.IS | |
? (0, g.concat)(this.gf.Ha()) | |
: this.view.buffer), | |
(w.Cg = [{ Ve: 0, data: y }])); | |
else return { vt: !1, parseError: "Missing movie box" }; | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment