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 hidden or 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