Created
June 8, 2019 18:51
-
-
Save extensionsapp/f9d1061cc13ea9408ecf790d0ccb24f1 to your computer and use it in GitHub Desktop.
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
| 'use strict'; | |
| window.jstiming.load.tick("jbl"); | |
| /** @type {string} */ | |
| var aa = "%1$s"; | |
| /** @type {string} */ | |
| var ba = "-caption"; | |
| /** @type {string} */ | |
| var ca = "-content"; | |
| /** @type {string} */ | |
| var da = "-disabled"; | |
| /** @type {string} */ | |
| var ea = "-dropdown"; | |
| /** @type {string} */ | |
| var fa = "//translate.google.com/toolkit/upload?"; | |
| /** @type {string} */ | |
| var ga = "/gen204?"; | |
| /** @type {string} */ | |
| var ha = "/translate/uc?ua=dcp&uav="; | |
| /** @type {string} */ | |
| var ia = "/translate_a/sg?client=t&"; | |
| /** @type {string} */ | |
| var ka = "/translate_a/single"; | |
| /** @type {string} */ | |
| var la = "</div>"; | |
| /** @type {string} */ | |
| var ma = '<div class="gt-pb-lbl">'; | |
| /** @type {string} */ | |
| var na = "Android"; | |
| /** @type {string} */ | |
| var oa = "BUTTON"; | |
| /** @type {string} */ | |
| var pa = "Component already rendered"; | |
| /** @type {string} */ | |
| var qa = "Cyrl"; | |
| /** @type {string} */ | |
| var k = "DIV"; | |
| /** @type {string} */ | |
| var ra = "Edge"; | |
| /** @type {string} */ | |
| var sa = "IMG"; | |
| /** @type {string} */ | |
| var ta = "INPUT"; | |
| /** @type {string} */ | |
| var ua = "Noto Naskh Arabic"; | |
| /** @type {string} */ | |
| var va = "Opera"; | |
| /** @type {string} */ | |
| var wa = "POST"; | |
| /** @type {string} */ | |
| var xa = "SCRIPT"; | |
| /** @type {string} */ | |
| var ya = "SELECT"; | |
| /** @type {string} */ | |
| var za = "SPAN"; | |
| /** @type {string} */ | |
| var Ca = "StartToEnd"; | |
| /** @type {string} */ | |
| var Da = "TEXTAREA"; | |
| /** @type {string} */ | |
| var Ea = "Unable to set parent component"; | |
| /** @type {string} */ | |
| var Fa = "Uneven number of arguments"; | |
| /** @type {string} */ | |
| var Ga = "absolute"; | |
| /** @type {string} */ | |
| var Ha = "accumulate"; | |
| /** @type {string} */ | |
| var p = "action"; | |
| /** @type {string} */ | |
| var Ia = "activedescendant"; | |
| /** @type {string} */ | |
| var Ja = "all"; | |
| /** @type {string} */ | |
| var Ka = "all|all"; | |
| /** @type {string} */ | |
| var La = "alt-edited"; | |
| /** @type {string} */ | |
| var Ma = "application/x-www-form-urlencoded"; | |
| /** @type {string} */ | |
| var Na = "aria-activedescendant"; | |
| /** @type {string} */ | |
| var Oa = "array"; | |
| /** @type {string} */ | |
| var Pa = "authuser"; | |
| /** @type {string} */ | |
| var Qa = "auto"; | |
| /** @type {string} */ | |
| var Ra = "beforedragstart"; | |
| /** @type {string} */ | |
| var Sa = "beforehide"; | |
| /** @type {string} */ | |
| var Ta = "beforeshow"; | |
| /** @type {string} */ | |
| var Ua = "beforeunload"; | |
| /** @type {string} */ | |
| var Va = "blur"; | |
| /** @type {string} */ | |
| var Wa = "border-box"; | |
| /** @type {string} */ | |
| var Xa = "button"; | |
| /** @type {string} */ | |
| var Ya = "change"; | |
| /** @type {string} */ | |
| var Za = "character"; | |
| /** @type {string} */ | |
| var $a = "checked"; | |
| /** @type {string} */ | |
| var r = "click"; | |
| /** @type {string} */ | |
| var ab = "client"; | |
| /** @type {string} */ | |
| var bb = "collapse"; | |
| /** @type {string} */ | |
| var cb = "community-promo"; | |
| /** @type {string} */ | |
| var db = "complete"; | |
| /** @type {string} */ | |
| var eb = "contextmenu"; | |
| /** @type {string} */ | |
| var fb = "data-tooltip"; | |
| /** @type {string} */ | |
| var hb = "data-tooltip-align"; | |
| /** @type {string} */ | |
| var ib = "data-tooltip-contained"; | |
| /** @type {string} */ | |
| var jb = "data-tooltip-suspended"; | |
| /** @type {string} */ | |
| var kb = "default"; | |
| /** @type {string} */ | |
| var lb = "detectSrcUpdated"; | |
| /** @type {string} */ | |
| var nb = "direction"; | |
| /** @type {string} */ | |
| var ob = "direction: %s"; | |
| /** @type {string} */ | |
| var pb = "display:none"; | |
| /** @type {string} */ | |
| var qb = "div"; | |
| /** @type {string} */ | |
| var rb = "dragstart"; | |
| /** @type {string} */ | |
| var sb = "earlycancel"; | |
| /** @type {string} */ | |
| var t = "en"; | |
| /** @type {string} */ | |
| var tb = "en-us-t-k0-intl"; | |
| /** @type {string} */ | |
| var ub = "end"; | |
| /** @type {string} */ | |
| var vb = "finish"; | |
| /** @type {string} */ | |
| var wb = "focus"; | |
| /** @type {string} */ | |
| var xb = "focusin"; | |
| /** @type {string} */ | |
| var yb = "focusout"; | |
| /** @type {string} */ | |
| var zb = "formality"; | |
| /** @type {string} */ | |
| var Ab = "fr-t-k0-und"; | |
| /** @type {string} */ | |
| var Bb = "function"; | |
| /** @type {string} */ | |
| var Cb = "goog-buttonset-default"; | |
| /** @type {string} */ | |
| var Db = "goog-flat-button"; | |
| /** @type {string} */ | |
| var Eb = "goog-flat-menu-button"; | |
| /** @type {string} */ | |
| var Fb = "goog-groupmenu-separator"; | |
| /** @type {string} */ | |
| var Gb = "goog-inline-block"; | |
| /** @type {string} */ | |
| var Hb = "goog-inline-block "; | |
| /** @type {string} */ | |
| var Ib = "goog-menu"; | |
| /** @type {string} */ | |
| var Jb = "goog-menu-button"; | |
| /** @type {string} */ | |
| var Kb = "goog-menuheader"; | |
| /** @type {string} */ | |
| var Lb = "goog-menuitem-emphasize-highlight"; | |
| /** @type {string} */ | |
| var Mb = "goog-menuitem-group"; | |
| /** @type {string} */ | |
| var Nb = "goog-menuseparator"; | |
| /** @type {string} */ | |
| var Ob = "goog-option"; | |
| /** @type {string} */ | |
| var Pb = "goog-option-selected"; | |
| /** @type {string} */ | |
| var Qb = "gt-baf-back"; | |
| /** @type {string} */ | |
| var Rb = "gt-baf-cell"; | |
| /** @type {string} */ | |
| var Sb = "gt-baf-entry-clickable"; | |
| /** @type {string} */ | |
| var Tb = "gt-baf-hl"; | |
| /** @type {string} */ | |
| var Ub = "gt-baf-word-clickable"; | |
| /** @type {string} */ | |
| var Vb = "gt-card-expand-wrapper"; | |
| /** @type {string} */ | |
| var Wb = "gt-card-fadein-wrapper"; | |
| /** @type {string} */ | |
| var Xb = "gt-card-widen-wrapper"; | |
| /** @type {string} */ | |
| var Yb = "gt-cd-cl"; | |
| /** @type {string} */ | |
| var Zb = "gt-cd-pos"; | |
| /** @type {string} */ | |
| var $b = "gt-input-tool"; | |
| /** @type {string} */ | |
| var ac = "gt-related-suggest-message"; | |
| /** @type {string} */ | |
| var bc = "gt-res-copy"; | |
| /** @type {string} */ | |
| var cc = "gt-res-edit"; | |
| /** @type {string} */ | |
| var dc = "gt-res-formality"; | |
| /** @type {string} */ | |
| var ec = "gt-res-tools-r"; | |
| /** @type {string} */ | |
| var fc = "gt-res-undo"; | |
| /** @type {string} */ | |
| var gc = "gt-spell-correct-message"; | |
| /** @type {string} */ | |
| var ic = "gt-src-tools"; | |
| /** @type {string} */ | |
| var jc = "gt-src-tools-l"; | |
| /** @type {string} */ | |
| var kc = "gt-syn-row"; | |
| /** @type {string} */ | |
| var lc = "gt-syn-summary-row"; | |
| /** @type {string} */ | |
| var mc = "haspopup"; | |
| /** @type {string} */ | |
| var nc = "hi-t-k0-qwerty"; | |
| /** @type {string} */ | |
| var oc = "hidden"; | |
| /** @type {string} */ | |
| var pc = "hide"; | |
| /** @type {string} */ | |
| var qc = "highlight"; | |
| /** @type {string} */ | |
| var rc = "horizontal"; | |
| /** @type {string} */ | |
| var sc = "https://chekhov.withgoogle.com/?utm_source=other&utm_medium=gtranslate&utm_campaign="; | |
| /** @type {string} */ | |
| var tc = "iPad"; | |
| /** @type {string} */ | |
| var uc = "iPod"; | |
| /** @type {string} */ | |
| var vc = "init"; | |
| /** @type {string} */ | |
| var wc = "input"; | |
| /** @type {string} */ | |
| var xc = "inputm"; | |
| /** @type {string} */ | |
| var yc = "javascript:void(0)"; | |
| /** @type {string} */ | |
| var zc = "jfk-butterBar-shown"; | |
| /** @type {string} */ | |
| var Ac = "jfk-button-action"; | |
| /** @type {string} */ | |
| var Bc = "jfk-button-img"; | |
| /** @type {string} */ | |
| var Cc = "jfk-button-label"; | |
| /** @type {string} */ | |
| var Dc = "jfk-button-narrow"; | |
| /** @type {string} */ | |
| var Ec = "jfk-button-standard"; | |
| /** @type {string} */ | |
| var Fc = "jfk-checkbox-checkmark"; | |
| /** @type {string} */ | |
| var Gc = "jfk-tooltip-hide"; | |
| /** @type {string} */ | |
| var Hc = "key"; | |
| /** @type {string} */ | |
| var Ic = "keydown"; | |
| /** @type {string} */ | |
| var Jc = "keypress"; | |
| /** @type {string} */ | |
| var Kc = "keyup"; | |
| /** @type {string} */ | |
| var Lc = "label"; | |
| /** @type {string} */ | |
| var Mc = "labelledby"; | |
| /** @type {string} */ | |
| var Nc = "languageSelected"; | |
| /** @type {string} */ | |
| var Oc = "latn-002-t-k0-und"; | |
| /** @type {string} */ | |
| var Pc = "left"; | |
| /** @type {string} */ | |
| var Qc = "ltr"; | |
| /** @type {string} */ | |
| var Rc = "margin"; | |
| /** @type {string} */ | |
| var Sc = "margin-right"; | |
| /** @type {string} */ | |
| var Tc = "margin-top"; | |
| /** @type {string} */ | |
| var Uc = "max-width"; | |
| /** @type {string} */ | |
| var Vc = "mousedown"; | |
| /** @type {string} */ | |
| var Wc = "mousemove"; | |
| /** @type {string} */ | |
| var Xc = "mouseout"; | |
| /** @type {string} */ | |
| var Yc = "mouseover"; | |
| /** @type {string} */ | |
| var Zc = "mouseup"; | |
| /** @type {string} */ | |
| var $c = "move_offscreen"; | |
| /** @type {string} */ | |
| var ad = "none"; | |
| /** @type {string} */ | |
| var bd = "number"; | |
| /** @type {string} */ | |
| var cd = "object"; | |
| /** @type {string} */ | |
| var dd = "opacity 1s linear"; | |
| /** @type {string} */ | |
| var ed = "overflow"; | |
| /** @type {string} */ | |
| var fd = "paddingLeft"; | |
| /** @type {string} */ | |
| var gd = "paddingRight"; | |
| /** @type {string} */ | |
| var hd = "paste"; | |
| /** @type {string} */ | |
| var id = "pbmUpdated"; | |
| /** @type {string} */ | |
| var kd = "play"; | |
| /** @type {string} */ | |
| var ld = "position"; | |
| /** @type {string} */ | |
| var md = "px"; | |
| /** @type {string} */ | |
| var nd = "res-translit"; | |
| /** @type {string} */ | |
| var od = "resize"; | |
| /** @type {string} */ | |
| var pd = "result_box"; | |
| /** @type {string} */ | |
| var qd = "right"; | |
| /** @type {string} */ | |
| var rd = "role"; | |
| /** @type {string} */ | |
| var sd = "rtl"; | |
| /** @type {string} */ | |
| var v = "ru"; | |
| /** @type {string} */ | |
| var td = "scroll"; | |
| /** @type {string} */ | |
| var ud = "select"; | |
| /** @type {string} */ | |
| var vd = "select_document"; | |
| /** @type {string} */ | |
| var wd = "selected"; | |
| /** @type {string} */ | |
| var xd = "separator"; | |
| /** @type {string} */ | |
| var yd = "short_text"; | |
| /** @type {string} */ | |
| var zd = "shortcut"; | |
| /** @type {string} */ | |
| var Ad = "show"; | |
| /** @type {string} */ | |
| var Bd = "sound_error"; | |
| /** @type {string} */ | |
| var Cd = "sound_finished"; | |
| /** @type {string} */ | |
| var Dd = "sound_interrupted"; | |
| /** @type {string} */ | |
| var Ed = "sound_play_start"; | |
| /** @type {string} */ | |
| var Fd = "source"; | |
| /** @type {string} */ | |
| var Gd = "source_changed"; | |
| /** @type {string} */ | |
| var Hd = "span"; | |
| /** @type {string} */ | |
| var Id = "spelling-correction"; | |
| /** @type {string} */ | |
| var Jd = "src-translit"; | |
| /** @type {string} */ | |
| var Kd = "srcEmphasizeUpdated"; | |
| /** @type {string} */ | |
| var Ld = "srcLanguageUpdated"; | |
| /** @type {string} */ | |
| var Md = "srcSuggestionUpdated"; | |
| /** @type {string} */ | |
| var Nd = "start"; | |
| /** @type {string} */ | |
| var Od = "staticSrcSuggestionUpdated"; | |
| /** @type {string} */ | |
| var Pd = "staticTgtSuggestionUpdated"; | |
| /** @type {string} */ | |
| var Qd = "stop_playlist"; | |
| /** @type {string} */ | |
| var Rd = "string"; | |
| /** @type {string} */ | |
| var Sd = "text/javascript"; | |
| /** @type {string} */ | |
| var Td = "textarea"; | |
| /** @type {string} */ | |
| var Ud = "textarea-placeholder-input"; | |
| /** @type {string} */ | |
| var Vd = "tgtEmphasizeUpdated"; | |
| /** @type {string} */ | |
| var Wd = "tgtLanguageUpdated"; | |
| /** @type {string} */ | |
| var Xd = "title"; | |
| /** @type {string} */ | |
| var Yd = "toggle_display"; | |
| /** @type {string} */ | |
| var Zd = "touchend"; | |
| /** @type {string} */ | |
| var $d = "touchmove"; | |
| /** @type {string} */ | |
| var ae = "touchstart"; | |
| /** @type {string} */ | |
| var be = "trans-listen-button"; | |
| /** @type {string} */ | |
| var ce = "trans-pb-button-saved"; | |
| /** @type {string} */ | |
| var de = "trans-target-empty"; | |
| /** @type {string} */ | |
| var ee = "trans-target-highlight"; | |
| /** @type {string} */ | |
| var fe = "transition"; | |
| /** @type {string} */ | |
| var ge = "translate"; | |
| /** @type {string} */ | |
| var he = "translation_changed"; | |
| /** @type {string} */ | |
| var ie = "true"; | |
| /** @type {string} */ | |
| var je = "unhighlight"; | |
| /** @type {string} */ | |
| var ke = "vertical"; | |
| /** @type {string} */ | |
| var le = "visibility"; | |
| /** @type {string} */ | |
| var me = "visible"; | |
| /** @type {string} */ | |
| var ne = "webkitvisibilitychange"; | |
| /** @type {string} */ | |
| var oe = "yue-hant-t-i0-und"; | |
| /** @type {string} */ | |
| var pe = "zh-CN"; | |
| /** @type {string} */ | |
| var qe = "zh-TW"; | |
| /** @type {string} */ | |
| var re = "zh-hant-t-i0-cangjie-1982"; | |
| /** @type {string} */ | |
| var se = "zh-hant-t-i0-pinyin"; | |
| /** @type {string} */ | |
| var te = "zh-hant-t-i0-und"; | |
| /** | |
| * @return {?} | |
| */ | |
| function ue() { | |
| return function() { | |
| }; | |
| } | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| function ve(key) { | |
| return function(knownModel) { | |
| this[key] = knownModel; | |
| }; | |
| } | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| function w(name) { | |
| return function() { | |
| return this[name]; | |
| }; | |
| } | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| function x(obj) { | |
| return function() { | |
| return obj; | |
| }; | |
| } | |
| var y; | |
| var we = we || {}; | |
| /** @type {!global this} */ | |
| var z = this; | |
| /** | |
| * @param {?} num | |
| * @return {?} | |
| */ | |
| var xe = function(num) { | |
| return void 0 !== num; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {(!Function|string)} val | |
| * @return {undefined} | |
| */ | |
| var ye = function(name, val) { | |
| var parts = name.split("."); | |
| var cur = z; | |
| if (!(parts[0] in cur || !cur.execScript)) { | |
| cur.execScript("var " + parts[0]); | |
| } | |
| var part; | |
| for (; parts.length && (part = parts.shift());) { | |
| if (!parts.length && xe(val)) { | |
| /** @type {(!Function|string)} */ | |
| cur[part] = val; | |
| } else { | |
| if (cur[part]) { | |
| cur = cur[part]; | |
| } else { | |
| cur = cur[part] = {}; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} dimension | |
| * @param {string} axis | |
| * @return {?} | |
| */ | |
| var ze = function(dimension, axis) { | |
| var _sizeAnimateTimeStamps = dimension.split("."); | |
| var at = axis || z; | |
| var part; | |
| for (; part = _sizeAnimateTimeStamps.shift();) { | |
| if (null != at[part]) { | |
| at = at[part]; | |
| } else { | |
| return null; | |
| } | |
| } | |
| return at; | |
| }; | |
| var Ae = ue(); | |
| /** | |
| * @param {!Function} x | |
| * @return {undefined} | |
| */ | |
| var Be = function(x) { | |
| /** | |
| * @return {?} | |
| */ | |
| x.M = function() { | |
| return x.Og ? x.Og : x.Og = new x; | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Ce = function(value) { | |
| /** @type {string} */ | |
| var t = typeof value; | |
| if (t == cd) { | |
| if (value) { | |
| if (value instanceof Array) { | |
| return Oa; | |
| } | |
| if (value instanceof Object) { | |
| return t; | |
| } | |
| /** @type {string} */ | |
| var oldCondition = Object.prototype.toString.call(value); | |
| if ("[object Window]" == oldCondition) { | |
| return cd; | |
| } | |
| if ("[object Array]" == oldCondition || typeof value.length == bd && "undefined" != typeof value.splice && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("splice")) { | |
| return Oa; | |
| } | |
| if ("[object Function]" == oldCondition || "undefined" != typeof value.call && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("call")) { | |
| return Bb; | |
| } | |
| } else { | |
| return "null"; | |
| } | |
| } else { | |
| if (t == Bb && "undefined" == typeof value.call) { | |
| return cd; | |
| } | |
| } | |
| return t; | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| var De = function(obj) { | |
| return Ce(obj) == Oa; | |
| }; | |
| /** | |
| * @param {!Object} task | |
| * @return {?} | |
| */ | |
| var Ee = function(task) { | |
| var cmd = Ce(task); | |
| return cmd == Oa || cmd == cd && typeof task.length == bd; | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var Fe = function(val) { | |
| return typeof val == Rd; | |
| }; | |
| /** | |
| * @param {?} num | |
| * @return {?} | |
| */ | |
| var Ge = function(num) { | |
| return typeof num == bd; | |
| }; | |
| /** | |
| * @param {string} e | |
| * @return {?} | |
| */ | |
| var He = function(e) { | |
| return Ce(e) == Bb; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| var Ie = function(type) { | |
| /** @type {string} */ | |
| var typeOfType = typeof type; | |
| return typeOfType == cd && null != type || typeOfType == Bb; | |
| }; | |
| /** | |
| * @param {!Function} val | |
| * @return {?} | |
| */ | |
| var Le = function(val) { | |
| return val[Je] || (val[Je] = ++Ke); | |
| }; | |
| /** @type {string} */ | |
| var Je = "closure_uid_" + (1E9 * Math.random() >>> 0); | |
| /** @type {number} */ | |
| var Ke = 0; | |
| /** | |
| * @param {!Function} a | |
| * @param {!Function} item | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Me = function(a, item, name) { | |
| return a.call.apply(a.bind, arguments); | |
| }; | |
| /** | |
| * @param {!Function} b | |
| * @param {!Function} a | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Ne = function(b, a, name) { | |
| if (!b) { | |
| throw Error(); | |
| } | |
| if (2 < arguments.length) { | |
| /** @type {!Array<?>} */ | |
| var cmd_args = Array.prototype.slice.call(arguments, 2); | |
| return function() { | |
| /** @type {!Array<?>} */ | |
| var c = Array.prototype.slice.call(arguments); | |
| Array.prototype.unshift.apply(c, cmd_args); | |
| return b.apply(a, c); | |
| }; | |
| } | |
| return function() { | |
| return b.apply(a, arguments); | |
| }; | |
| }; | |
| /** | |
| * @param {!Function} a | |
| * @param {!Function} b | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var A = function(a, b, name) { | |
| /** @type {function(!Function, !Function, string): ?} */ | |
| A = Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code") ? Me : Ne; | |
| return A.apply(null, arguments); | |
| }; | |
| /** | |
| * @param {!Function} q | |
| * @param {?} expected | |
| * @return {?} | |
| */ | |
| var Oe = function(q, expected) { | |
| /** @type {!Array<?>} */ | |
| var c = Array.prototype.slice.call(arguments, 1); | |
| return function() { | |
| /** @type {!Array<?>} */ | |
| var all = c.slice(); | |
| all.push.apply(all, arguments); | |
| return q.apply(this, all); | |
| }; | |
| }; | |
| /** @type {function(): number} */ | |
| var Pe = Date.now || function() { | |
| return +new Date; | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @param {!Function} str | |
| * @return {undefined} | |
| */ | |
| var C = function(x, str) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| function B() { | |
| } | |
| B.prototype = str.prototype; | |
| x.v = str.prototype; | |
| x.prototype = new B; | |
| /** @type {!Object} */ | |
| x.prototype.constructor = x; | |
| /** | |
| * @param {?} clss | |
| * @param {?} item | |
| * @param {?} changeMeta | |
| * @return {?} | |
| */ | |
| x.gk = function(clss, item, changeMeta) { | |
| /** @type {!Array} */ | |
| var args = Array(arguments.length - 2); | |
| /** @type {number} */ | |
| var i = 2; | |
| for (; i < arguments.length; i++) { | |
| args[i - 2] = arguments[i]; | |
| } | |
| return str.prototype[item].apply(clss, args); | |
| }; | |
| }; | |
| /** | |
| * @param {?} opt_msg | |
| * @return {undefined} | |
| */ | |
| var Qe = function(opt_msg) { | |
| if (Error.captureStackTrace) { | |
| Error.captureStackTrace(this, Qe); | |
| } else { | |
| /** @type {string} */ | |
| var stack = Error().stack; | |
| if (stack) { | |
| /** @type {string} */ | |
| this.stack = stack; | |
| } | |
| } | |
| if (opt_msg) { | |
| /** @type {string} */ | |
| this.message = String(opt_msg); | |
| } | |
| }; | |
| C(Qe, Error); | |
| /** @type {string} */ | |
| Qe.prototype.name = "CustomError"; | |
| var Re; | |
| /** | |
| * @param {!Object} attr | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var Se = function(attr, val) { | |
| /** @type {number} */ | |
| var key = attr.length - val.length; | |
| return 0 <= key && attr.indexOf(val, key) == key; | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| var Te = function(obj) { | |
| return /^[\s\xa0]*$/.test(obj); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Ue = function(a) { | |
| return a.replace(/(\r\n|\r|\n)/g, "\n"); | |
| }; | |
| /** | |
| * @param {string} value1 | |
| * @return {?} | |
| */ | |
| var Ve = function(value1) { | |
| return value1.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, ""); | |
| }; | |
| /** @type {function(string): ?} */ | |
| var We = String.prototype.trim ? function(a) { | |
| return a.trim(); | |
| } : function(a) { | |
| return a.replace(/^[\s\xa0]+|[\s\xa0]+$/g, ""); | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| var Xe = function(obj) { | |
| return encodeURIComponent(String(obj)); | |
| }; | |
| /** | |
| * @param {string} replacement | |
| * @return {?} | |
| */ | |
| var Ye = function(replacement) { | |
| return decodeURIComponent(replacement.replace(/\+/g, " ")); | |
| }; | |
| /** | |
| * @param {string} commaParam | |
| * @return {?} | |
| */ | |
| var Ze = function(commaParam) { | |
| return commaParam.replace(/(\r\n|\r|\n)/g, "<br>"); | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var hf = function(type) { | |
| if (!$e.test(type)) { | |
| return type; | |
| } | |
| if (-1 != type.indexOf("&")) { | |
| type = type.replace(af, "&"); | |
| } | |
| if (-1 != type.indexOf("<")) { | |
| type = type.replace(bf, "<"); | |
| } | |
| if (-1 != type.indexOf(">")) { | |
| type = type.replace(cf, ">"); | |
| } | |
| if (-1 != type.indexOf('"')) { | |
| type = type.replace(df, """); | |
| } | |
| if (-1 != type.indexOf("'")) { | |
| type = type.replace(ef, "'"); | |
| } | |
| if (-1 != type.indexOf("\x00")) { | |
| type = type.replace(ff, "�"); | |
| } | |
| return type; | |
| }; | |
| /** @type {!RegExp} */ | |
| var af = /&/g; | |
| /** @type {!RegExp} */ | |
| var bf = /</g; | |
| /** @type {!RegExp} */ | |
| var cf = />/g; | |
| /** @type {!RegExp} */ | |
| var df = /"/g; | |
| /** @type {!RegExp} */ | |
| var ef = /'/g; | |
| /** @type {!RegExp} */ | |
| var ff = /\x00/g; | |
| /** @type {!RegExp} */ | |
| var $e = /[\x00&<>"']/; | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var lf = function(key) { | |
| return -1 != key.indexOf("&") ? "document" in z ? jf(key) : kf(key) : key; | |
| }; | |
| /** | |
| * @param {string} path | |
| * @return {?} | |
| */ | |
| var jf = function(path) { | |
| var props = { | |
| "&" : "&", | |
| "<" : "<", | |
| ">" : ">", | |
| """ : '"' | |
| }; | |
| var div; | |
| div = z.document.createElement(qb); | |
| return path.replace(mf, function(i, CardNo18) { | |
| var prop = props[i]; | |
| if (prop) { | |
| return prop; | |
| } | |
| if ("#" == CardNo18.charAt(0)) { | |
| /** @type {number} */ | |
| var n = Number("0" + CardNo18.substr(1)); | |
| if (!isNaN(n)) { | |
| /** @type {string} */ | |
| prop = String.fromCharCode(n); | |
| } | |
| } | |
| if (!prop) { | |
| /** @type {string} */ | |
| div.innerHTML = i + " "; | |
| prop = div.firstChild.nodeValue.slice(0, -1); | |
| } | |
| return props[i] = prop; | |
| }); | |
| }; | |
| /** | |
| * @param {string} arg | |
| * @return {?} | |
| */ | |
| var kf = function(arg) { | |
| return arg.replace(/&([^;]+);/g, function(a, entity) { | |
| switch(entity) { | |
| case "amp": | |
| return "&"; | |
| case "lt": | |
| return "<"; | |
| case "gt": | |
| return ">"; | |
| case "quot": | |
| return '"'; | |
| default: | |
| if ("#" == entity.charAt(0)) { | |
| /** @type {number} */ | |
| var numeric = Number("0" + entity.substr(1)); | |
| if (!isNaN(numeric)) { | |
| return String.fromCharCode(numeric); | |
| } | |
| } | |
| return a; | |
| } | |
| }); | |
| }; | |
| /** @type {!RegExp} */ | |
| var mf = /&([^;\s<&]+);?/g; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var nf = function(value) { | |
| return String(value).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08"); | |
| }; | |
| /** @type {function(string, number): ?} */ | |
| var of = String.prototype.repeat ? function(indentPerLevel, level) { | |
| return indentPerLevel.repeat(level); | |
| } : function(inputHrStr, startIndex) { | |
| return Array(startIndex + 1).join(inputHrStr); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var pf = function(value) { | |
| return null == value ? "" : String(value); | |
| }; | |
| /** | |
| * @param {!Object} string | |
| * @return {?} | |
| */ | |
| var qf = function(string) { | |
| return Array.prototype.join.call(arguments, ""); | |
| }; | |
| /** | |
| * @param {?} t | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| var sf = function(t, x) { | |
| /** @type {number} */ | |
| var center = 0; | |
| var xN = We(String(t)).split("."); | |
| var yN = We(String(x)).split("."); | |
| /** @type {number} */ | |
| var numlabels = Math.max(xN.length, yN.length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; 0 == center && i < numlabels; i++) { | |
| var v2Sub = xN[i] || ""; | |
| var v1Sub = yN[i] || ""; | |
| /** @type {!RegExp} */ | |
| var reg_exp = RegExp("(\\d*)(\\D*)", "g"); | |
| /** @type {!RegExp} */ | |
| var matcher = RegExp("(\\d*)(\\D*)", "g"); | |
| do { | |
| /** @type {!Array} */ | |
| var combatant = reg_exp.exec(v2Sub) || ["", "", ""]; | |
| /** @type {!Array} */ | |
| var regex_splitter = matcher.exec(v1Sub) || ["", "", ""]; | |
| if (0 == combatant[0].length && 0 == regex_splitter[0].length) { | |
| break; | |
| } | |
| center = rf(0 == combatant[1].length ? 0 : parseInt(combatant[1], 10), 0 == regex_splitter[1].length ? 0 : parseInt(regex_splitter[1], 10)) || rf(0 == combatant[2].length, 0 == regex_splitter[2].length) || rf(combatant[2], regex_splitter[2]); | |
| } while (0 == center); | |
| } | |
| return center; | |
| }; | |
| /** | |
| * @param {number} min | |
| * @param {number} max | |
| * @return {?} | |
| */ | |
| var rf = function(min, max) { | |
| return min < max ? -1 : min > max ? 1 : 0; | |
| }; | |
| /** | |
| * @param {string} text | |
| * @return {?} | |
| */ | |
| var tf = function(text) { | |
| return String(text).replace(/\-([a-z])/g, function(a, shortMonthName) { | |
| return shortMonthName.toUpperCase(); | |
| }); | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var uf = function(b) { | |
| var enable_keys = Fe(void 0) ? nf(void 0) : "\\s"; | |
| return b.replace(new RegExp("(^" + (enable_keys ? "|[" + enable_keys + "]+" : "") + ")([a-z])", "g"), function(a, b, shortMonthName) { | |
| return b + shortMonthName.toUpperCase(); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var vf = function(value) { | |
| return value[value.length - 1]; | |
| }; | |
| /** @type {function(!Object, !Object, ?): ?} */ | |
| var wf = Array.prototype.indexOf ? function(obj, b, refC) { | |
| return Array.prototype.indexOf.call(obj, b, refC); | |
| } : function(array, value, i) { | |
| i = null == i ? 0 : 0 > i ? Math.max(0, array.length + i) : i; | |
| if (Fe(array)) { | |
| return Fe(value) && 1 == value.length ? array.indexOf(value, i) : -1; | |
| } | |
| for (; i < array.length; i++) { | |
| if (i in array && array[i] === value) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| }; | |
| /** @type {function(!Object, !Function, !Object): undefined} */ | |
| var xf = Array.prototype.forEach ? function(data, head, b) { | |
| Array.prototype.forEach.call(data, head, b); | |
| } : function(data, t, b) { | |
| var nbElts = data.length; | |
| var results = Fe(data) ? data.split("") : data; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < nbElts; i++) { | |
| if (i in results) { | |
| t.call(b, results[i], i, data); | |
| } | |
| } | |
| }; | |
| /** @type {function(string, !Function, ?): ?} */ | |
| var yf = Array.prototype.filter ? function(obj, p1__3354_SHARP_, refC) { | |
| return Array.prototype.filter.call(obj, p1__3354_SHARP_, refC); | |
| } : function(path, util, repo) { | |
| var length = path.length; | |
| /** @type {!Array} */ | |
| var resp = []; | |
| /** @type {number} */ | |
| var offset = 0; | |
| var value = Fe(path) ? path.split("") : path; | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < length; key++) { | |
| if (key in value) { | |
| var val = value[key]; | |
| if (util.call(repo, val, key, path)) { | |
| resp[offset++] = val; | |
| } | |
| } | |
| } | |
| return resp; | |
| }; | |
| /** @type {function(string, !Function, ?): ?} */ | |
| var zf = Array.prototype.map ? function(a, p1__3354_SHARP_, c) { | |
| return Array.prototype.map.call(a, p1__3354_SHARP_, c); | |
| } : function(obj, fn, array) { | |
| var length = obj.length; | |
| /** @type {!Array} */ | |
| var result = Array(length); | |
| var a = Fe(obj) ? obj.split("") : obj; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < length; i++) { | |
| if (i in a) { | |
| result[i] = fn.call(array, a[i], i, obj); | |
| } | |
| } | |
| return result; | |
| }; | |
| /** @type {function(?, !Function, ?): ?} */ | |
| var Af = Array.prototype.some ? function(gen34_options, p1__3354_SHARP_, refC) { | |
| return Array.prototype.some.call(gen34_options, p1__3354_SHARP_, refC); | |
| } : function(arr, f, opt_obj) { | |
| var arrSize = arr.length; | |
| var arr2 = Fe(arr) ? arr.split("") : arr; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < arrSize; i++) { | |
| if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** @type {function(!Array, ?, ?): ?} */ | |
| var Bf = Array.prototype.every ? function(result, p1__3354_SHARP_, refC) { | |
| return Array.prototype.every.call(result, p1__3354_SHARP_, refC); | |
| } : function(path, util, c) { | |
| var length = path.length; | |
| var keys = Fe(path) ? path.split("") : path; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < length; i++) { | |
| if (i in keys && !util.call(c, keys[i], i, path)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} code | |
| * @param {!Function} content | |
| * @return {?} | |
| */ | |
| var Cf = function(code, content) { | |
| /** @type {number} */ | |
| var c = 0; | |
| xf(code, function(newContent, linear, f) { | |
| if (content.call(void 0, newContent, linear, f)) { | |
| ++c; | |
| } | |
| }, void 0); | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} arr | |
| * @param {!Function} f | |
| * @return {?} | |
| */ | |
| var Df = function(arr, f) { | |
| var index; | |
| a: { | |
| index = arr.length; | |
| var arr2 = Fe(arr) ? arr.split("") : arr; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < index; i++) { | |
| if (i in arr2 && f.call(void 0, arr2[i], i, arr)) { | |
| /** @type {number} */ | |
| index = i; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| index = -1; | |
| } | |
| return 0 > index ? null : Fe(arr) ? arr.charAt(index) : arr[index]; | |
| }; | |
| /** | |
| * @param {!Array} arr | |
| * @param {!Object} msg | |
| * @return {?} | |
| */ | |
| var Ef = function(arr, msg) { | |
| return 0 <= wf(arr, msg); | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Gf = function(a, b) { | |
| if (!Ef(a, b)) { | |
| a.push(b); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} fn | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Hf = function(fn, a) { | |
| var time = wf(fn, a); | |
| var dateOpen; | |
| if (dateOpen = 0 <= time) { | |
| Array.prototype.splice.call(fn, time, 1); | |
| } | |
| return dateOpen; | |
| }; | |
| /** | |
| * @param {!Array} _ref | |
| * @return {?} | |
| */ | |
| var If = function(_ref) { | |
| return Array.prototype.concat.apply(Array.prototype, arguments); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Jf = function(obj) { | |
| var length = obj.length; | |
| if (0 < length) { | |
| /** @type {!Array} */ | |
| var values = Array(length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < length; i++) { | |
| values[i] = obj[i]; | |
| } | |
| return values; | |
| } | |
| return []; | |
| }; | |
| /** | |
| * @param {!Array} data | |
| * @param {!Object} fn | |
| * @return {undefined} | |
| */ | |
| var Kf = function(data, fn) { | |
| /** @type {number} */ | |
| var i = 1; | |
| for (; i < arguments.length; i++) { | |
| var model = arguments[i]; | |
| if (Ee(model)) { | |
| var i = data.length || 0; | |
| var n = model.length || 0; | |
| data.length = i + n; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < n; j++) { | |
| data[i + j] = model[j]; | |
| } | |
| } else { | |
| data.push(model); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {number} b | |
| * @param {number} status | |
| * @param {!Function} f | |
| * @return {undefined} | |
| */ | |
| var Mf = function(a, b, status, f) { | |
| Array.prototype.splice.apply(a, Lf(arguments, 1)); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {number} indent | |
| * @param {?} settings | |
| * @return {?} | |
| */ | |
| var Lf = function(obj, indent, settings) { | |
| return 2 >= arguments.length ? Array.prototype.slice.call(obj, indent) : Array.prototype.slice.call(obj, indent, settings); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!Function} b | |
| * @param {!Object} input | |
| * @return {undefined} | |
| */ | |
| var Nf = function(c, b, input) { | |
| var id; | |
| for (id in c) { | |
| b.call(input, c[id], id, c); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Of = function(item) { | |
| /** @type {!Array} */ | |
| var result = []; | |
| /** @type {number} */ | |
| var j = 0; | |
| var i; | |
| for (i in item) { | |
| result[j++] = item[i]; | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {!Object} pool | |
| * @return {?} | |
| */ | |
| var Pf = function(pool) { | |
| /** @type {!Array} */ | |
| var bBag = []; | |
| /** @type {number} */ | |
| var callbackCount = 0; | |
| var i; | |
| for (i in pool) { | |
| /** @type {string} */ | |
| bBag[callbackCount++] = i; | |
| } | |
| return bBag; | |
| }; | |
| /** | |
| * @param {!Object} menu | |
| * @param {string} items | |
| * @return {?} | |
| */ | |
| var Qf = function(menu, items) { | |
| return null !== menu && items in menu; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Sf = function() { | |
| var a = Rf; | |
| var j; | |
| for (j in a) { | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} tags | |
| * @param {string} name | |
| * @param {!Object} ctor | |
| * @return {undefined} | |
| */ | |
| var Tf = function(tags, name, ctor) { | |
| if (null !== tags && name in tags) { | |
| throw Error('The object already contains the key "' + name + '"'); | |
| } | |
| /** @type {!Object} */ | |
| tags[name] = ctor; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var Uf = function(options) { | |
| var processedOptions = {}; | |
| var name; | |
| for (name in options) { | |
| processedOptions[name] = options[name]; | |
| } | |
| return processedOptions; | |
| }; | |
| /** @type {!Array<string>} */ | |
| var Vf = "constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" "); | |
| /** | |
| * @param {string} obj | |
| * @param {string} source | |
| * @return {undefined} | |
| */ | |
| var Wf = function(obj, source) { | |
| var j; | |
| var a; | |
| /** @type {number} */ | |
| var i = 1; | |
| for (; i < arguments.length; i++) { | |
| a = arguments[i]; | |
| for (j in a) { | |
| obj[j] = a[j]; | |
| } | |
| /** @type {number} */ | |
| var jX = 0; | |
| for (; jX < Vf.length; jX++) { | |
| j = Vf[jX]; | |
| if (Object.prototype.hasOwnProperty.call(a, j)) { | |
| obj[j] = a[j]; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} init | |
| * @return {?} | |
| */ | |
| var Xf = function(init) { | |
| /** @type {number} */ | |
| var argl = arguments.length; | |
| if (1 == argl && De(arguments[0])) { | |
| return Xf.apply(null, arguments[0]); | |
| } | |
| if (argl % 2) { | |
| throw Error(Fa); | |
| } | |
| var rv = {}; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < argl; i = i + 2) { | |
| rv[arguments[i]] = arguments[i + 1]; | |
| } | |
| return rv; | |
| }; | |
| /** | |
| * @param {!Array} i | |
| * @return {?} | |
| */ | |
| var Yf = function(i) { | |
| /** @type {number} */ | |
| var argl = arguments.length; | |
| if (1 == argl && De(arguments[0])) { | |
| return Yf.apply(null, arguments[0]); | |
| } | |
| var LANGUAGES = {}; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < argl; i++) { | |
| /** @type {boolean} */ | |
| LANGUAGES[arguments[i]] = true; | |
| } | |
| return LANGUAGES; | |
| }; | |
| var Zf = { | |
| area : true, | |
| base : true, | |
| br : true, | |
| col : true, | |
| command : true, | |
| embed : true, | |
| hr : true, | |
| img : true, | |
| input : true, | |
| keygen : true, | |
| link : true, | |
| meta : true, | |
| param : true, | |
| source : true, | |
| track : true, | |
| wbr : true | |
| }; | |
| /** @type {!RegExp} */ | |
| var $f = /^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Arab|Hebr|Thaa|Nkoo|Tfng))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i; | |
| /** | |
| * @param {number} id | |
| * @return {?} | |
| */ | |
| var ag = function(id) { | |
| return $f.test(id); | |
| }; | |
| var bg; | |
| a: { | |
| /** @type {!Navigator} */ | |
| var cg = z.navigator; | |
| if (cg) { | |
| /** @type {string} */ | |
| var dg = cg.userAgent; | |
| if (dg) { | |
| /** @type {string} */ | |
| bg = dg; | |
| break a; | |
| } | |
| } | |
| /** @type {string} */ | |
| bg = ""; | |
| } | |
| /** | |
| * @param {string} str | |
| * @return {?} | |
| */ | |
| var D = function(str) { | |
| return -1 != bg.indexOf(str); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var eg = function(a) { | |
| /** @type {!RegExp} */ | |
| var matcher = RegExp("(\\w[\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?", "g"); | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| var dayEle; | |
| for (; dayEle = matcher.exec(a);) { | |
| newNodeLists.push([dayEle[1], dayEle[2], dayEle[3] || void 0]); | |
| } | |
| return newNodeLists; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var fg = function() { | |
| return D("Trident") || D("MSIE"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var gg = function() { | |
| return (D("Chrome") || D("CriOS")) && !D(ra); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var ig = function() { | |
| /** | |
| * @param {!Array} code | |
| * @return {?} | |
| */ | |
| function lookUpValueWithKeys(code) { | |
| code = Df(code, m); | |
| return params[code] || ""; | |
| } | |
| var type = bg; | |
| if (fg()) { | |
| return hg(type); | |
| } | |
| type = eg(type); | |
| var params = {}; | |
| xf(type, function(data) { | |
| params[data[0]] = data[1]; | |
| }); | |
| var m = Oe(Qf, params); | |
| return D(va) ? lookUpValueWithKeys(["Version", va]) : D(ra) ? lookUpValueWithKeys([ra]) : gg() ? lookUpValueWithKeys(["Chrome", "CriOS"]) : (type = type[2]) && type[1] || ""; | |
| }; | |
| /** | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var hg = function(c) { | |
| /** @type {(Array<string>|null)} */ | |
| var s = /rv: *([\d\.]*)/.exec(c); | |
| if (s && s[1]) { | |
| return s[1]; | |
| } | |
| /** @type {string} */ | |
| s = ""; | |
| /** @type {(Array<string>|null)} */ | |
| var a = /MSIE +([\d\.]+)/.exec(c); | |
| if (a && a[1]) { | |
| if (c = /Trident\/(\d.\d)/.exec(c), "7.0" == a[1]) { | |
| if (c && c[1]) { | |
| switch(c[1]) { | |
| case "4.0": | |
| /** @type {string} */ | |
| s = "8.0"; | |
| break; | |
| case "5.0": | |
| /** @type {string} */ | |
| s = "9.0"; | |
| break; | |
| case "6.0": | |
| /** @type {string} */ | |
| s = "10.0"; | |
| break; | |
| case "7.0": | |
| /** @type {string} */ | |
| s = "11.0"; | |
| } | |
| } else { | |
| /** @type {string} */ | |
| s = "7.0"; | |
| } | |
| } else { | |
| /** @type {string} */ | |
| s = a[1]; | |
| } | |
| } | |
| return s; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var kg = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = jg; | |
| }; | |
| /** @type {boolean} */ | |
| kg.prototype.dc = true; | |
| kg.prototype.Lb = w("a"); | |
| /** | |
| * @return {?} | |
| */ | |
| kg.prototype.toString = function() { | |
| return "Const{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| var lg = function(x) { | |
| return x instanceof kg && x.constructor === kg && x.b === jg ? x.a : "type_error:Const"; | |
| }; | |
| var jg = {}; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var mg = function(v) { | |
| var value = new kg; | |
| /** @type {string} */ | |
| value.a = v; | |
| return value; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var og = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = ng; | |
| }; | |
| /** @type {boolean} */ | |
| og.prototype.dc = true; | |
| var ng = {}; | |
| og.prototype.Lb = w("a"); | |
| /** | |
| * @param {string} i | |
| * @return {?} | |
| */ | |
| var pg = function(i) { | |
| var b = new og; | |
| /** @type {string} */ | |
| b.a = i; | |
| return b; | |
| }; | |
| var qg = pg(""); | |
| /** @type {!RegExp} */ | |
| var rg = /^([-,."'%_!# a-zA-Z0-9]+|(?:rgb|hsl)a?\([0-9.%, ]+\))$/; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var tg = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = sg; | |
| }; | |
| /** @type {boolean} */ | |
| tg.prototype.dc = true; | |
| var sg = {}; | |
| tg.prototype.Lb = w("a"); | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var ug = function(a) { | |
| var exportsB = new tg; | |
| /** @type {string} */ | |
| exportsB.a = a; | |
| return exportsB; | |
| }; | |
| ug(""); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var wg = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = vg; | |
| }; | |
| /** @type {boolean} */ | |
| wg.prototype.dc = true; | |
| wg.prototype.Lb = w("a"); | |
| /** @type {boolean} */ | |
| wg.prototype.uf = true; | |
| wg.prototype.oc = x(1); | |
| /** @type {!RegExp} */ | |
| var xg = /^(?:(?:https?|mailto|ftp):|[^&:/?#]*(?:[/?#]|$))/i; | |
| var vg = {}; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var yg = function(a) { | |
| var exportsB = new wg; | |
| /** @type {string} */ | |
| exportsB.a = a; | |
| return exportsB; | |
| }; | |
| yg("about:blank"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ag = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = zg; | |
| }; | |
| /** @type {boolean} */ | |
| Ag.prototype.dc = true; | |
| Ag.prototype.Lb = w("a"); | |
| /** @type {boolean} */ | |
| Ag.prototype.uf = true; | |
| Ag.prototype.oc = x(1); | |
| /** | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| var Bg = function(x) { | |
| if (x instanceof Ag && x.constructor === Ag && x.b === zg) { | |
| return x.a; | |
| } | |
| Ce(x); | |
| return "type_error:TrustedResourceUrl"; | |
| }; | |
| var zg = {}; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Dg = function(a) { | |
| var exportsB = new Ag; | |
| /** @type {number} */ | |
| exportsB.a = a; | |
| return exportsB; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Fg = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.c = Eg; | |
| /** @type {null} */ | |
| this.b = null; | |
| }; | |
| /** @type {boolean} */ | |
| Fg.prototype.uf = true; | |
| Fg.prototype.oc = w("b"); | |
| /** @type {boolean} */ | |
| Fg.prototype.dc = true; | |
| Fg.prototype.Lb = w("a"); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Gg = function(a) { | |
| if (a instanceof Fg && a.constructor === Fg && a.c === Eg) { | |
| return a.a; | |
| } | |
| Ce(a); | |
| return "type_error:SafeHtml"; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Ig = function(obj) { | |
| if (obj instanceof Fg) { | |
| return obj; | |
| } | |
| /** @type {null} */ | |
| var bCreateNode = null; | |
| if (obj.uf) { | |
| bCreateNode = obj.oc(); | |
| } | |
| obj = hf(obj.dc ? obj.Lb() : String(obj)); | |
| return Hg(obj, bCreateNode); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Jg = function(item) { | |
| if (item instanceof Fg) { | |
| return item; | |
| } | |
| item = Ig(item); | |
| var valueProgess = Ze(Gg(item)); | |
| return Hg(valueProgess, item.oc()); | |
| }; | |
| /** @type {!RegExp} */ | |
| var Kg = /^[a-zA-Z0-9-]+$/; | |
| var Lg = { | |
| action : true, | |
| cite : true, | |
| data : true, | |
| formaction : true, | |
| href : true, | |
| manifest : true, | |
| poster : true, | |
| src : true | |
| }; | |
| var Mg = { | |
| APPLET : true, | |
| BASE : true, | |
| EMBED : true, | |
| IFRAME : true, | |
| LINK : true, | |
| MATH : true, | |
| META : true, | |
| OBJECT : true, | |
| SCRIPT : true, | |
| STYLE : true, | |
| SVG : true, | |
| TEMPLATE : true | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {!Object} n | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var Og = function(key, n, c) { | |
| if (!Kg.test(key)) { | |
| throw Error("Invalid tag name <" + key + ">."); | |
| } | |
| if (key.toUpperCase() in Mg) { | |
| throw Error("Tag name <" + key + "> is not allowed for SafeHtml."); | |
| } | |
| return Ng(key, n, c); | |
| }; | |
| /** | |
| * @param {!Object} var_args | |
| * @return {?} | |
| */ | |
| var Pg = function(var_args) { | |
| /** @type {number} */ | |
| var object = 0; | |
| /** @type {string} */ | |
| var is = ""; | |
| /** | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var i = function(type) { | |
| if (De(type)) { | |
| xf(type, i); | |
| } else { | |
| type = Ig(type); | |
| is = is + Gg(type); | |
| type = type.oc(); | |
| if (0 == object) { | |
| /** @type {string} */ | |
| object = type; | |
| } else { | |
| if (0 != type && object != type) { | |
| /** @type {null} */ | |
| object = null; | |
| } | |
| } | |
| } | |
| }; | |
| xf(arguments, i); | |
| return Hg(is, object); | |
| }; | |
| var Eg = {}; | |
| /** | |
| * @param {string} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Hg = function(a, b) { | |
| var xform = new Fg; | |
| /** @type {string} */ | |
| xform.a = a; | |
| /** @type {number} */ | |
| xform.b = b; | |
| return xform; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} options | |
| * @param {string} config | |
| * @return {?} | |
| */ | |
| var Ng = function(name, options, config) { | |
| /** @type {null} */ | |
| var item = null; | |
| var o; | |
| /** @type {string} */ | |
| var s = ""; | |
| if (options) { | |
| for (o in options) { | |
| if (!Kg.test(o)) { | |
| throw Error('Invalid attribute name "' + o + '".'); | |
| } | |
| var obj = options[o]; | |
| if (null != obj) { | |
| var val; | |
| /** @type {string} */ | |
| var str = name; | |
| /** @type {string} */ | |
| val = o; | |
| if (obj instanceof kg) { | |
| obj = lg(obj); | |
| } else { | |
| if ("style" == val.toLowerCase()) { | |
| if (!Ie(obj)) { | |
| throw Error('The "style" attribute requires goog.html.SafeStyle or map of style properties, ' + typeof obj + " given: " + obj); | |
| } | |
| if (!(obj instanceof og)) { | |
| /** @type {string} */ | |
| str = ""; | |
| var name = void 0; | |
| for (name in obj) { | |
| if (!/^[-_a-zA-Z0-9]+$/.test(name)) { | |
| throw Error("Name allows only [-_a-zA-Z0-9], got: " + name); | |
| } | |
| var i = obj[name]; | |
| if (null != i) { | |
| if (i instanceof kg) { | |
| i = lg(i); | |
| } else { | |
| if (rg.test(i)) { | |
| /** @type {boolean} */ | |
| var add = true; | |
| /** @type {boolean} */ | |
| var test = true; | |
| /** @type {number} */ | |
| var level = 0; | |
| for (; level < i.length; level++) { | |
| var adjustedLevel = i.charAt(level); | |
| if ("'" == adjustedLevel && test) { | |
| /** @type {boolean} */ | |
| add = !add; | |
| } else { | |
| if ('"' == adjustedLevel && add) { | |
| /** @type {boolean} */ | |
| test = !test; | |
| } | |
| } | |
| } | |
| if (!(add && test)) { | |
| /** @type {string} */ | |
| i = "zClosurez"; | |
| } | |
| } else { | |
| /** @type {string} */ | |
| i = "zClosurez"; | |
| } | |
| } | |
| /** @type {string} */ | |
| str = str + (name + ":" + i + ";"); | |
| } | |
| } | |
| obj = str ? pg(str) : qg; | |
| } | |
| if (obj instanceof og && obj.constructor === og && obj.b === ng) { | |
| obj = obj.a; | |
| } else { | |
| Ce(obj); | |
| /** @type {string} */ | |
| obj = "type_error:SafeStyle"; | |
| } | |
| } else { | |
| if (/^on/i.test(val)) { | |
| throw Error('Attribute "' + val + '" requires goog.string.Const value, "' + obj + '" given.'); | |
| } | |
| if (val.toLowerCase() in Lg) { | |
| if (obj instanceof Ag) { | |
| obj = Bg(obj); | |
| } else { | |
| if (obj instanceof wg) { | |
| if (obj instanceof wg && obj.constructor === wg && obj.b === vg) { | |
| obj = obj.a; | |
| } else { | |
| Ce(obj); | |
| /** @type {string} */ | |
| obj = "type_error:SafeUrl"; | |
| } | |
| } else { | |
| if (Fe(obj)) { | |
| if (!(obj instanceof wg)) { | |
| obj = obj.dc ? obj.Lb() : String(obj); | |
| if (!xg.test(obj)) { | |
| /** @type {string} */ | |
| obj = "about:invalid#zClosurez"; | |
| } | |
| obj = yg(obj); | |
| } | |
| obj = obj.Lb(); | |
| } else { | |
| throw Error('Attribute "' + val + '" on tag "' + str + '" requires goog.html.SafeUrl, goog.string.Const, or string, value "' + obj + '" given.'); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (obj.dc) { | |
| obj = obj.Lb(); | |
| } | |
| /** @type {string} */ | |
| val = val + '="' + hf(String(obj)) + '"'; | |
| /** @type {string} */ | |
| s = s + (" " + val); | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| o = "<" + name + s; | |
| if (null != config) { | |
| if (!De(config)) { | |
| /** @type {!Array} */ | |
| config = [config]; | |
| } | |
| } else { | |
| /** @type {!Array} */ | |
| config = []; | |
| } | |
| if (true === Zf[name.toLowerCase()]) { | |
| /** @type {string} */ | |
| o = o + ">"; | |
| } else { | |
| item = Pg(config); | |
| /** @type {string} */ | |
| o = o + (">" + Gg(item) + "</" + name + ">"); | |
| item = item.oc(); | |
| } | |
| if (name = options && options.dir) { | |
| if (/^(ltr|rtl|auto)$/i.test(name)) { | |
| /** @type {number} */ | |
| item = 0; | |
| } else { | |
| /** @type {null} */ | |
| item = null; | |
| } | |
| } | |
| return Hg(o, item); | |
| }; | |
| Hg("<!DOCTYPE html>", 0); | |
| var Qg = Hg("", 0); | |
| var Rg = Hg("<br>", 0); | |
| var Sg = "StopIteration" in z ? z.StopIteration : { | |
| message : "StopIteration", | |
| stack : "" | |
| }; | |
| var Tg = ue(); | |
| /** | |
| * @return {?} | |
| */ | |
| Tg.prototype.next = function() { | |
| throw Sg; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Tg.prototype.mb = function() { | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} model | |
| * @return {?} | |
| */ | |
| var Ug = function(model) { | |
| if (model instanceof Tg) { | |
| return model; | |
| } | |
| if (typeof model.mb == Bb) { | |
| return model.mb(false); | |
| } | |
| if (Ee(model)) { | |
| /** @type {number} */ | |
| var x0 = 0; | |
| var deletedChar = new Tg; | |
| /** | |
| * @return {?} | |
| */ | |
| deletedChar.next = function() { | |
| for (;;) { | |
| if (x0 >= model.length) { | |
| throw Sg; | |
| } | |
| if (x0 in model) { | |
| return model[x0++]; | |
| } | |
| x0++; | |
| } | |
| }; | |
| return deletedChar; | |
| } | |
| throw Error("Not implemented"); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {!Function} f | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var Vg = function(m, f, data) { | |
| m = Ug(m); | |
| try { | |
| for (; f.call(data, m.next(), void 0, m);) { | |
| } | |
| } catch (d) { | |
| if (d !== Sg) { | |
| throw d; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {?} ncls | |
| * @return {undefined} | |
| */ | |
| var Wg = function(self, ncls) { | |
| this.b = {}; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| this.g = this.c = 0; | |
| /** @type {number} */ | |
| var m = arguments.length; | |
| if (1 < m) { | |
| if (m % 2) { | |
| throw Error(Fa); | |
| } | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < m; k = k + 2) { | |
| this.set(arguments[k], arguments[k + 1]); | |
| } | |
| } else { | |
| if (self) { | |
| if (self instanceof Wg) { | |
| m = self.tb(); | |
| k = self.Va(); | |
| } else { | |
| m = Pf(self); | |
| k = Of(self); | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < m.length; i++) { | |
| this.set(m[i], k[i]); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Wg.prototype.Va = function() { | |
| Xg(this); | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| newNodeLists.push(this.b[this.a[i]]); | |
| } | |
| return newNodeLists; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Wg.prototype.tb = function() { | |
| Xg(this); | |
| return this.a.concat(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Zg = function(a, b) { | |
| return Yg(a.b, b); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Wg.prototype.clear = function() { | |
| this.b = {}; | |
| /** @type {number} */ | |
| this.g = this.c = this.a.length = 0; | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var $g = function(m, b) { | |
| if (Yg(m.b, b)) { | |
| delete m.b[b]; | |
| m.c--; | |
| m.g++; | |
| if (m.a.length > 2 * m.c) { | |
| Xg(m); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} arr | |
| * @return {undefined} | |
| */ | |
| var Xg = function(arr) { | |
| if (arr.c != arr.a.length) { | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var offset = 0; | |
| for (; i < arr.a.length;) { | |
| var key = arr.a[i]; | |
| if (Yg(arr.b, key)) { | |
| arr.a[offset++] = key; | |
| } | |
| i++; | |
| } | |
| /** @type {number} */ | |
| arr.a.length = offset; | |
| } | |
| if (arr.c != arr.a.length) { | |
| var vertexSet = {}; | |
| /** @type {number} */ | |
| offset = i = 0; | |
| for (; i < arr.a.length;) { | |
| key = arr.a[i]; | |
| if (!Yg(vertexSet, key)) { | |
| arr.a[offset++] = key; | |
| /** @type {number} */ | |
| vertexSet[key] = 1; | |
| } | |
| i++; | |
| } | |
| /** @type {number} */ | |
| arr.a.length = offset; | |
| } | |
| }; | |
| y = Wg.prototype; | |
| /** | |
| * @param {string} prop | |
| * @param {?} dft | |
| * @return {?} | |
| */ | |
| y.get = function(prop, dft) { | |
| return Yg(this.b, prop) ? this.b[prop] : dft; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| y.set = function(name, obj) { | |
| if (!Yg(this.b, name)) { | |
| this.c++; | |
| this.a.push(name); | |
| this.g++; | |
| } | |
| /** @type {!Object} */ | |
| this.b[name] = obj; | |
| }; | |
| /** | |
| * @param {!Function} g | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| y.forEach = function(g, f) { | |
| var colorChunks = this.tb(); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < colorChunks.length; i++) { | |
| var c = colorChunks[i]; | |
| var m = this.get(c); | |
| g.call(f, m, c, this); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| return new Wg(this); | |
| }; | |
| /** | |
| * @param {boolean} bool | |
| * @return {?} | |
| */ | |
| y.mb = function(bool) { | |
| Xg(this); | |
| /** @type {number} */ | |
| var offset = 0; | |
| var g = this.g; | |
| var res = this; | |
| var deletedChar = new Tg; | |
| /** | |
| * @return {?} | |
| */ | |
| deletedChar.next = function() { | |
| if (g != res.g) { | |
| throw Error("The map has changed since the iterator was created"); | |
| } | |
| if (offset >= res.a.length) { | |
| throw Sg; | |
| } | |
| var i = res.a[offset++]; | |
| return bool ? i : res.b[i]; | |
| }; | |
| return deletedChar; | |
| }; | |
| /** | |
| * @param {?} vertexSet | |
| * @param {!Object} args | |
| * @return {?} | |
| */ | |
| var Yg = function(vertexSet, args) { | |
| return Object.prototype.hasOwnProperty.call(vertexSet, args); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var ah = function(a) { | |
| if (a.Va && typeof a.Va == Bb) { | |
| return a.Va(); | |
| } | |
| if (Fe(a)) { | |
| return a.split(""); | |
| } | |
| if (Ee(a)) { | |
| /** @type {!Array} */ | |
| var reorderMap = []; | |
| var startLen = a.length; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < startLen; j++) { | |
| reorderMap.push(a[j]); | |
| } | |
| return reorderMap; | |
| } | |
| return Of(a); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {!Function} i | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var bh = function(self, i, c) { | |
| if (self.forEach && typeof self.forEach == Bb) { | |
| self.forEach(i, c); | |
| } else { | |
| if (Ee(self) || Fe(self)) { | |
| xf(self, i, c); | |
| } else { | |
| var data; | |
| if (self.tb && typeof self.tb == Bb) { | |
| data = self.tb(); | |
| } else { | |
| if (self.Va && typeof self.Va == Bb) { | |
| data = void 0; | |
| } else { | |
| if (Ee(self) || Fe(self)) { | |
| /** @type {!Array} */ | |
| data = []; | |
| var item = self.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < item; i++) { | |
| data.push(i); | |
| } | |
| } else { | |
| data = Pf(self); | |
| } | |
| } | |
| } | |
| item = ah(self); | |
| i = item.length; | |
| /** @type {number} */ | |
| var g = 0; | |
| for (; g < i; g++) { | |
| i.call(c, item[g], data && data[g], self); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Array} n | |
| * @return {undefined} | |
| */ | |
| var dh = function(n) { | |
| this.a = new Wg; | |
| if (n) { | |
| n = ah(n); | |
| var argl = n.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < argl; i++) { | |
| var b = n[i]; | |
| this.a.set(ch(b), b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var ch = function(value) { | |
| /** @type {string} */ | |
| var key = typeof value; | |
| return key == cd && value || key == Bb ? "o" + Le(value) : key.substr(0, 1) + value; | |
| }; | |
| y = dh.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.clear = function() { | |
| this.a.clear(); | |
| }; | |
| /** | |
| * @param {!Object} parent | |
| * @return {?} | |
| */ | |
| y.contains = function(parent) { | |
| return Zg(this.a, ch(parent)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Va = function() { | |
| return this.a.Va(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| return new dh(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.mb = function() { | |
| return this.a.mb(false); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var eh = function() { | |
| return D("iPhone") && !D(uc) && !D(tc); | |
| }; | |
| var fh = D(va); | |
| var E = fg(); | |
| var gh = D(ra); | |
| var hh = gh || E; | |
| var ih = D("Gecko") && !(-1 != bg.toLowerCase().indexOf("webkit") && !D(ra)) && !(D("Trident") || D("MSIE")) && !D(ra); | |
| /** @type {boolean} */ | |
| var G = -1 != bg.toLowerCase().indexOf("webkit") && !D(ra); | |
| var jh = G && D("Mobile"); | |
| var kh = D("Macintosh"); | |
| var lh = D("Windows"); | |
| var mh = D(na); | |
| var nh = eh(); | |
| var oh = D(tc); | |
| var ph = D(uc); | |
| /** | |
| * @return {?} | |
| */ | |
| var qh = function() { | |
| var document = z.document; | |
| return document ? document.documentMode : void 0; | |
| }; | |
| var rh; | |
| a: { | |
| /** @type {string} */ | |
| var sh = ""; | |
| var th = function() { | |
| var colour = bg; | |
| if (ih) { | |
| return /rv:([^\);]+)(\)|;)/.exec(colour); | |
| } | |
| if (gh) { | |
| return /Edge\/([\d\.]+)/.exec(colour); | |
| } | |
| if (E) { | |
| return /\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(colour); | |
| } | |
| if (G) { | |
| return /WebKit\/(\S+)/.exec(colour); | |
| } | |
| if (fh) { | |
| return /(?:Version)[ \/]?(\S+)/.exec(colour); | |
| } | |
| }(); | |
| if (th) { | |
| sh = th ? th[1] : ""; | |
| } | |
| if (E) { | |
| var uh = qh(); | |
| if (null != uh && uh > parseFloat(sh)) { | |
| /** @type {string} */ | |
| rh = String(uh); | |
| break a; | |
| } | |
| } | |
| rh = sh; | |
| } | |
| var vh = rh; | |
| var wh = {}; | |
| /** | |
| * @param {!Object} i | |
| * @return {?} | |
| */ | |
| var I = function(i) { | |
| return wh[i] || (wh[i] = 0 <= sf(vh, i)); | |
| }; | |
| /** | |
| * @param {number} documentMode | |
| * @return {?} | |
| */ | |
| var yh = function(documentMode) { | |
| return Number(xh) >= documentMode; | |
| }; | |
| /** @type {!HTMLDocument} */ | |
| var zh = z.document; | |
| var xh = zh && E ? qh() || ("CSS1Compat" == zh.compatMode ? parseInt(vh, 10) : 5) : void 0; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var Ah = function(val) { | |
| if (val.classList) { | |
| return val.classList; | |
| } | |
| val = val.className; | |
| return Fe(val) && val.match(/\S+/g) || []; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var Bh = function(a, c) { | |
| return a.classList ? a.classList.contains(c) : Ef(Ah(a), c); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| var J = function(a, x) { | |
| if (a.classList) { | |
| a.classList.add(x); | |
| } else { | |
| if (!Bh(a, x)) { | |
| a.className += 0 < a.className.length ? " " + x : x; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {!Array} code | |
| * @return {undefined} | |
| */ | |
| var Ch = function(t, code) { | |
| if (t.classList) { | |
| xf(code, function(b) { | |
| J(t, b); | |
| }); | |
| } else { | |
| var aggregates = {}; | |
| xf(Ah(t), function(summaryIndex) { | |
| /** @type {boolean} */ | |
| aggregates[summaryIndex] = true; | |
| }); | |
| xf(code, function(summaryIndex) { | |
| /** @type {boolean} */ | |
| aggregates[summaryIndex] = true; | |
| }); | |
| /** @type {string} */ | |
| t.className = ""; | |
| var className; | |
| for (className in aggregates) { | |
| t.className += 0 < t.className.length ? " " + className : className; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| var K = function(a, x) { | |
| if (a.classList) { | |
| a.classList.remove(x); | |
| } else { | |
| if (Bh(a, x)) { | |
| a.className = yf(Ah(a), function(z) { | |
| return z != x; | |
| }).join(" "); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Array} v | |
| * @return {undefined} | |
| */ | |
| var Dh = function(a, v) { | |
| if (a.classList) { | |
| xf(v, function(h) { | |
| K(a, h); | |
| }); | |
| } else { | |
| a.className = yf(Ah(a), function(Ignored) { | |
| return !Ef(v, Ignored); | |
| }).join(" "); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {boolean} num | |
| * @return {undefined} | |
| */ | |
| var Eh = function(a, b, num) { | |
| if (num) { | |
| J(a, b); | |
| } else { | |
| K(a, b); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var L = function(a, b) { | |
| this.x = xe(a) ? a : 0; | |
| this.y = xe(b) ? b : 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| L.prototype.clone = function() { | |
| return new L(this.x, this.y); | |
| }; | |
| /** | |
| * @param {number} c | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Fh = function(c, a) { | |
| return new L(c.x - a.x, c.y - a.y); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| L.prototype.ceil = function() { | |
| /** @type {number} */ | |
| this.x = Math.ceil(this.x); | |
| /** @type {number} */ | |
| this.y = Math.ceil(this.y); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| L.prototype.floor = function() { | |
| /** @type {number} */ | |
| this.x = Math.floor(this.x); | |
| /** @type {number} */ | |
| this.y = Math.floor(this.y); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| L.prototype.round = function() { | |
| /** @type {number} */ | |
| this.x = Math.round(this.x); | |
| /** @type {number} */ | |
| this.y = Math.round(this.y); | |
| return this; | |
| }; | |
| /** | |
| * @param {number} width | |
| * @param {number} height | |
| * @return {undefined} | |
| */ | |
| var Gh = function(width, height) { | |
| /** @type {number} */ | |
| this.width = width; | |
| /** @type {number} */ | |
| this.height = height; | |
| }; | |
| /** | |
| * @param {!Object} src | |
| * @param {!Object} dst | |
| * @return {?} | |
| */ | |
| var Hh = function(src, dst) { | |
| return src == dst ? true : src && dst ? src.width == dst.width && src.height == dst.height : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gh.prototype.clone = function() { | |
| return new Gh(this.width, this.height); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gh.prototype.ceil = function() { | |
| /** @type {number} */ | |
| this.width = Math.ceil(this.width); | |
| /** @type {number} */ | |
| this.height = Math.ceil(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gh.prototype.floor = function() { | |
| /** @type {number} */ | |
| this.width = Math.floor(this.width); | |
| /** @type {number} */ | |
| this.height = Math.floor(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gh.prototype.round = function() { | |
| /** @type {number} */ | |
| this.width = Math.round(this.width); | |
| /** @type {number} */ | |
| this.height = Math.round(this.height); | |
| return this; | |
| }; | |
| var Ih = !E || yh(9); | |
| var Jh = !ih && !E || E && yh(9) || ih && I("1.9.1"); | |
| var Kh = E && !I("9"); | |
| var Lh = E || fh || G; | |
| var Mh = E && !yh(9); | |
| /** | |
| * @param {!Element} obj | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| var Nh = function(obj, v) { | |
| obj.innerHTML = Gg(v); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Qh = function(obj) { | |
| return obj ? new Oh(Ph(obj)) : Re || (Re = new Oh); | |
| }; | |
| /** | |
| * @param {string} node | |
| * @return {?} | |
| */ | |
| var M = function(node) { | |
| return Fe(node) ? document.getElementById(node) : node; | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {string} value | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var Sh = function(type, value, name) { | |
| return Rh(document, type, value, name); | |
| }; | |
| /** | |
| * @param {string} id | |
| * @param {!Object} text | |
| * @return {?} | |
| */ | |
| var Th = function(id, text) { | |
| var parent = text || document; | |
| return parent.querySelectorAll && parent.querySelector ? parent.querySelectorAll("." + id) : Rh(document, "*", id, text); | |
| }; | |
| /** | |
| * @param {string} s | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var O = function(s, a) { | |
| var parent = a || document; | |
| /** @type {null} */ | |
| var d = null; | |
| if (parent.getElementsByClassName) { | |
| d = parent.getElementsByClassName(s)[0]; | |
| } else { | |
| if (parent.querySelectorAll && parent.querySelector) { | |
| d = parent.querySelector("." + s); | |
| } else { | |
| d = Rh(document, "*", s, a)[0]; | |
| } | |
| } | |
| return d || null; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| var Rh = function(element, name, type, target) { | |
| element = target || element; | |
| name = name && "*" != name ? name.toUpperCase() : ""; | |
| if (element.querySelectorAll && element.querySelector && (name || type)) { | |
| return element.querySelectorAll(name + (type ? "." + type : "")); | |
| } | |
| if (type && element.getElementsByClassName) { | |
| element = element.getElementsByClassName(type); | |
| if (name) { | |
| target = {}; | |
| /** @type {number} */ | |
| var l = 0; | |
| /** @type {number} */ | |
| var j = 0; | |
| var data; | |
| for (; data = element[j]; j++) { | |
| if (name == data.nodeName) { | |
| target[l++] = data; | |
| } | |
| } | |
| /** @type {number} */ | |
| target.length = l; | |
| return target; | |
| } | |
| return element; | |
| } | |
| element = element.getElementsByTagName(name || "*"); | |
| if (type) { | |
| target = {}; | |
| /** @type {number} */ | |
| j = l = 0; | |
| for (; data = element[j]; j++) { | |
| name = data.className; | |
| if (typeof name.split == Bb && Ef(name.split(/\s+/), type)) { | |
| target[l++] = data; | |
| } | |
| } | |
| /** @type {number} */ | |
| target.length = l; | |
| return target; | |
| } | |
| return element; | |
| }; | |
| /** | |
| * @param {!Element} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Vh = function(a, b) { | |
| Nf(b, function(value, key) { | |
| if ("style" == key) { | |
| /** @type {string} */ | |
| a.style.cssText = value; | |
| } else { | |
| if ("class" == key) { | |
| /** @type {string} */ | |
| a.className = value; | |
| } else { | |
| if ("for" == key) { | |
| /** @type {string} */ | |
| a.htmlFor = value; | |
| } else { | |
| if (Uh.hasOwnProperty(key)) { | |
| a.setAttribute(Uh[key], value); | |
| } else { | |
| if (0 == key.lastIndexOf("aria-", 0) || 0 == key.lastIndexOf("data-", 0)) { | |
| a.setAttribute(key, value); | |
| } else { | |
| /** @type {string} */ | |
| a[key] = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }); | |
| }; | |
| var Uh = { | |
| cellpadding : "cellPadding", | |
| cellspacing : "cellSpacing", | |
| colspan : "colSpan", | |
| frameborder : "frameBorder", | |
| height : "height", | |
| maxlength : "maxLength", | |
| nonce : "nonce", | |
| role : rd, | |
| rowspan : "rowSpan", | |
| type : "type", | |
| usemap : "useMap", | |
| valign : "vAlign", | |
| width : "width" | |
| }; | |
| /** | |
| * @param {!Object} doc | |
| * @return {?} | |
| */ | |
| var Xh = function(doc) { | |
| doc = doc.document; | |
| doc = Wh(doc) ? doc.documentElement : doc.body; | |
| return new Gh(doc.clientWidth, doc.clientHeight); | |
| }; | |
| /** | |
| * @param {!Document} doc | |
| * @return {?} | |
| */ | |
| var Zh = function(doc) { | |
| var a = Yh(doc); | |
| doc = doc.parentWindow || doc.defaultView; | |
| return E && I("10") && doc.pageYOffset != a.scrollTop ? new L(a.scrollLeft, a.scrollTop) : new L(doc.pageXOffset || a.scrollLeft, doc.pageYOffset || a.scrollTop); | |
| }; | |
| /** | |
| * @param {!Document} doc | |
| * @return {?} | |
| */ | |
| var Yh = function(doc) { | |
| return doc.scrollingElement ? doc.scrollingElement : !G && Wh(doc) ? doc.documentElement : doc.body || doc.documentElement; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var $h = function(node) { | |
| return node ? node.parentWindow || node.defaultView : window; | |
| }; | |
| /** | |
| * @param {string} tag | |
| * @param {string} pos | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var P = function(tag, pos, value) { | |
| return ai(document, arguments); | |
| }; | |
| /** | |
| * @param {!HTMLDocument} d | |
| * @param {!Object} args | |
| * @return {?} | |
| */ | |
| var ai = function(d, args) { | |
| /** @type {string} */ | |
| var result = String(args[0]); | |
| var t = args[1]; | |
| if (!Ih && t && (t.name || t.type)) { | |
| /** @type {!Array} */ | |
| result = ["<", result]; | |
| if (t.name) { | |
| result.push(' name="', hf(t.name), '"'); | |
| } | |
| if (t.type) { | |
| result.push(' type="', hf(t.type), '"'); | |
| var e = {}; | |
| Wf(e, t); | |
| delete e.type; | |
| t = e; | |
| } | |
| result.push(">"); | |
| /** @type {string} */ | |
| result = result.join(""); | |
| } | |
| result = d.createElement(result); | |
| if (t) { | |
| if (Fe(t)) { | |
| result.className = t; | |
| } else { | |
| if (De(t)) { | |
| result.className = t.join(" "); | |
| } else { | |
| Vh(result, t); | |
| } | |
| } | |
| } | |
| if (2 < args.length) { | |
| bi(d, result, args, 2); | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {!Document} d | |
| * @param {!Object} a | |
| * @param {!Object} item | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var bi = function(d, a, item, i) { | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| function e(b) { | |
| if (b) { | |
| a.appendChild(Fe(b) ? d.createTextNode(b) : b); | |
| } | |
| } | |
| for (; i < item.length; i++) { | |
| var value = item[i]; | |
| if (!Ee(value) || Ie(value) && 0 < value.nodeType) { | |
| e(value); | |
| } else { | |
| xf(ci(value) ? Jf(value) : value, e); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var di = function(name) { | |
| return document.createElement(String(name)); | |
| }; | |
| /** | |
| * @param {string} text | |
| * @return {?} | |
| */ | |
| var ei = function(text) { | |
| return document.createTextNode(String(text)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var gi = function() { | |
| var wbr = Og("WBR"); | |
| return fi(document, wbr); | |
| }; | |
| /** | |
| * @param {!Document} document | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var fi = function(document, name) { | |
| var node = document.createElement(k); | |
| if (E) { | |
| Nh(node, Pg(Rg, name)); | |
| node.removeChild(node.firstChild); | |
| } else { | |
| Nh(node, name); | |
| } | |
| if (1 == node.childNodes.length) { | |
| node = node.removeChild(node.firstChild); | |
| } else { | |
| var parent = document.createDocumentFragment(); | |
| for (; node.firstChild;) { | |
| parent.appendChild(node.firstChild); | |
| } | |
| node = parent; | |
| } | |
| return node; | |
| }; | |
| /** | |
| * @param {!Document} doc | |
| * @return {?} | |
| */ | |
| var Wh = function(doc) { | |
| return "CSS1Compat" == doc.compatMode; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var hi = function(value) { | |
| if (1 != value.nodeType) { | |
| return false; | |
| } | |
| switch(value.tagName) { | |
| case "APPLET": | |
| case "AREA": | |
| case "BASE": | |
| case "BR": | |
| case "COL": | |
| case "COMMAND": | |
| case "EMBED": | |
| case "FRAME": | |
| case "HR": | |
| case sa: | |
| case ta: | |
| case "IFRAME": | |
| case "ISINDEX": | |
| case "KEYGEN": | |
| case "LINK": | |
| case "NOFRAMES": | |
| case "NOSCRIPT": | |
| case "META": | |
| case "OBJECT": | |
| case "PARAM": | |
| case xa: | |
| case "SOURCE": | |
| case "STYLE": | |
| case "TRACK": | |
| case "WBR": | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @param {string} v | |
| * @return {undefined} | |
| */ | |
| var ii = function(key, v) { | |
| bi(Ph(key), key, arguments, 1); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var ji = function(d) { | |
| var b; | |
| for (; b = d.firstChild;) { | |
| d.removeChild(b); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Node} a | |
| * @return {undefined} | |
| */ | |
| var ki = function(b, a) { | |
| if (a.parentNode) { | |
| a.parentNode.insertBefore(b, a); | |
| } | |
| }; | |
| /** | |
| * @param {?} tag | |
| * @param {!Node} node | |
| * @return {undefined} | |
| */ | |
| var li = function(tag, node) { | |
| if (node.parentNode) { | |
| node.parentNode.insertBefore(tag, node.nextSibling); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var mi = function(value) { | |
| return value && value.parentNode ? value.parentNode.removeChild(value) : null; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var ni = function(a) { | |
| return Jh && void 0 != a.children ? a.children : yf(a.childNodes, function(nodeToInspect) { | |
| return 1 == nodeToInspect.nodeType; | |
| }); | |
| }; | |
| /** | |
| * @param {!HTMLElement} a | |
| * @return {?} | |
| */ | |
| var pi = function(a) { | |
| return xe(a.firstElementChild) ? a.firstElementChild : oi(a.firstChild, true); | |
| }; | |
| /** | |
| * @param {!Node} a | |
| * @return {?} | |
| */ | |
| var qi = function(a) { | |
| return xe(a.nextElementSibling) ? a.nextElementSibling : oi(a.nextSibling, true); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {boolean} dir | |
| * @return {?} | |
| */ | |
| var oi = function(c, dir) { | |
| for (; c && 1 != c.nodeType;) { | |
| c = dir ? c.nextSibling : c.previousSibling; | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @return {?} | |
| */ | |
| var ri = function(context) { | |
| return Ie(context) && 1 == context.nodeType; | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var si = function(el) { | |
| var parent; | |
| if (Lh && !(E && I("9") && !I("10") && z.SVGElement && el instanceof z.SVGElement) && (parent = el.parentElement)) { | |
| return parent; | |
| } | |
| parent = el.parentNode; | |
| return ri(parent) ? parent : null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var ti = function(a, b) { | |
| if (!a || !b) { | |
| return false; | |
| } | |
| if (a.contains && 1 == b.nodeType) { | |
| return a == b || a.contains(b); | |
| } | |
| if ("undefined" != typeof a.compareDocumentPosition) { | |
| return a == b || !!(a.compareDocumentPosition(b) & 16); | |
| } | |
| for (; b && a != b;) { | |
| b = b.parentNode; | |
| } | |
| return b == a; | |
| }; | |
| /** | |
| * @param {!Node} node1 | |
| * @param {!HTMLElement} node2 | |
| * @return {?} | |
| */ | |
| var wi = function(node1, node2) { | |
| if (node1 == node2) { | |
| return 0; | |
| } | |
| if (node1.compareDocumentPosition) { | |
| return node1.compareDocumentPosition(node2) & 2 ? 1 : -1; | |
| } | |
| if (E && !yh(9)) { | |
| if (9 == node1.nodeType) { | |
| return -1; | |
| } | |
| if (9 == node2.nodeType) { | |
| return 1; | |
| } | |
| } | |
| if ("sourceIndex" in node1 || node1.parentNode && "sourceIndex" in node1.parentNode) { | |
| /** @type {boolean} */ | |
| var isElement1 = 1 == node1.nodeType; | |
| /** @type {boolean} */ | |
| var isElement2 = 1 == node2.nodeType; | |
| if (isElement1 && isElement2) { | |
| return node1.sourceIndex - node2.sourceIndex; | |
| } | |
| var parent1 = node1.parentNode; | |
| var parent2 = node2.parentNode; | |
| return parent1 == parent2 ? ui(node1, node2) : !isElement1 && ti(parent1, node2) ? -1 * vi(node1, node2) : !isElement2 && ti(parent2, node1) ? vi(node2, node1) : (isElement1 ? node1.sourceIndex : parent1.sourceIndex) - (isElement2 ? node2.sourceIndex : parent2.sourceIndex); | |
| } | |
| isElement2 = Ph(node1); | |
| isElement1 = isElement2.createRange(); | |
| isElement1.selectNode(node1); | |
| isElement1.collapse(true); | |
| isElement2 = isElement2.createRange(); | |
| isElement2.selectNode(node2); | |
| isElement2.collapse(true); | |
| return isElement1.compareBoundaryPoints(z.Range.START_TO_END, isElement2); | |
| }; | |
| /** | |
| * @param {!HTMLElement} result | |
| * @param {!HTMLElement} id | |
| * @return {?} | |
| */ | |
| var vi = function(result, id) { | |
| var body = result.parentNode; | |
| if (body == id) { | |
| return -1; | |
| } | |
| /** @type {!HTMLElement} */ | |
| var container = id; | |
| for (; container.parentNode != body;) { | |
| container = container.parentNode; | |
| } | |
| return ui(container, result); | |
| }; | |
| /** | |
| * @param {!Node} node | |
| * @param {!HTMLElement} target | |
| * @return {?} | |
| */ | |
| var ui = function(node, target) { | |
| /** @type {!HTMLElement} */ | |
| var currentNode = target; | |
| for (; currentNode = currentNode.previousSibling;) { | |
| if (currentNode == node) { | |
| return -1; | |
| } | |
| } | |
| return 1; | |
| }; | |
| /** | |
| * @param {?} row | |
| * @return {?} | |
| */ | |
| var xi = function(row) { | |
| var i; | |
| /** @type {number} */ | |
| var length = arguments.length; | |
| if (!length) { | |
| return null; | |
| } | |
| if (1 == length) { | |
| return arguments[0]; | |
| } | |
| /** @type {!Array} */ | |
| var d = []; | |
| /** @type {number} */ | |
| var minlen = Infinity; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < length; i++) { | |
| /** @type {!Array} */ | |
| var value = []; | |
| var n = arguments[i]; | |
| for (; n;) { | |
| value.unshift(n); | |
| n = n.parentNode; | |
| } | |
| d.push(value); | |
| /** @type {number} */ | |
| minlen = Math.min(minlen, value.length); | |
| } | |
| /** @type {null} */ | |
| value = null; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < minlen; i++) { | |
| n = d[0][i]; | |
| /** @type {number} */ | |
| var s = 1; | |
| for (; s < length; s++) { | |
| if (n != d[s][i]) { | |
| return value; | |
| } | |
| } | |
| value = n; | |
| } | |
| return value; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var Ph = function(node) { | |
| return 9 == node.nodeType ? node : node.ownerDocument || node.document; | |
| }; | |
| /** | |
| * @param {!Element} d | |
| * @return {?} | |
| */ | |
| var yi = function(d) { | |
| return d.contentDocument || d.contentWindow.document; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var Q = function(node, value) { | |
| if ("textContent" in node) { | |
| /** @type {string} */ | |
| node.textContent = value; | |
| } else { | |
| if (3 == node.nodeType) { | |
| /** @type {string} */ | |
| node.data = value; | |
| } else { | |
| if (node.firstChild && 3 == node.firstChild.nodeType) { | |
| for (; node.lastChild != node.firstChild;) { | |
| node.removeChild(node.lastChild); | |
| } | |
| /** @type {string} */ | |
| node.firstChild.data = value; | |
| } else { | |
| ji(node); | |
| var document = Ph(node); | |
| node.appendChild(document.createTextNode(String(value))); | |
| } | |
| } | |
| } | |
| }; | |
| var zi = { | |
| SCRIPT : 1, | |
| STYLE : 1, | |
| HEAD : 1, | |
| IFRAME : 1, | |
| OBJECT : 1 | |
| }; | |
| var Ai = { | |
| IMG : " ", | |
| BR : "\n" | |
| }; | |
| /** | |
| * @param {!Element} elem | |
| * @param {string} types | |
| * @return {undefined} | |
| */ | |
| var Bi = function(elem, types) { | |
| if (types) { | |
| /** @type {number} */ | |
| elem.tabIndex = 0; | |
| } else { | |
| /** @type {number} */ | |
| elem.tabIndex = -1; | |
| elem.removeAttribute("tabIndex"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| var Ci = function(target) { | |
| target = target.getAttributeNode("tabindex"); | |
| return null != target && target.specified; | |
| }; | |
| /** | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| var Di = function(name) { | |
| name = name.tabIndex; | |
| return Ge(name) && 0 <= name && 32768 > name; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Fi = function(item) { | |
| if (Kh && null !== item && "innerText" in item) { | |
| item = Ue(item.innerText); | |
| } else { | |
| /** @type {!Array} */ | |
| var out = []; | |
| Ei(item, out, true); | |
| /** @type {string} */ | |
| item = out.join(""); | |
| } | |
| item = item.replace(/ \xAD /g, " ").replace(/\xAD/g, ""); | |
| item = item.replace(/\u200B/g, ""); | |
| if (!Kh) { | |
| item = item.replace(/ +/g, " "); | |
| } | |
| if (" " != item) { | |
| item = item.replace(/^\s*/, ""); | |
| } | |
| return item; | |
| }; | |
| /** | |
| * @param {!Object} ast | |
| * @return {?} | |
| */ | |
| var Gi = function(ast) { | |
| /** @type {!Array} */ | |
| var out = []; | |
| Ei(ast, out, false); | |
| return out.join(""); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Array} buf | |
| * @param {string} normalizeWhitespace | |
| * @return {undefined} | |
| */ | |
| var Ei = function(node, buf, normalizeWhitespace) { | |
| if (!(node.nodeName in zi)) { | |
| if (3 == node.nodeType) { | |
| if (normalizeWhitespace) { | |
| buf.push(String(node.nodeValue).replace(/(\r\n|\r|\n)/g, "")); | |
| } else { | |
| buf.push(node.nodeValue); | |
| } | |
| } else { | |
| if (node.nodeName in Ai) { | |
| buf.push(Ai[node.nodeName]); | |
| } else { | |
| node = node.firstChild; | |
| for (; node;) { | |
| Ei(node, buf, normalizeWhitespace); | |
| node = node.nextSibling; | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var ci = function(s) { | |
| if (s && typeof s.length == bd) { | |
| if (Ie(s)) { | |
| return typeof s.item == Bb || typeof s.item == Rd; | |
| } | |
| if (He(s)) { | |
| return typeof s.item == Bb; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {!Object} cX1 | |
| * @return {?} | |
| */ | |
| var Ii = function(cX1) { | |
| return Hi(cX1, function(a) { | |
| return Fe(a.className) && Ef(a.className.split(/\s+/), Sb); | |
| }, void 0); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Function} item | |
| * @param {number} scrollLeft | |
| * @return {?} | |
| */ | |
| var Hi = function(a, item, scrollLeft) { | |
| /** @type {number} */ | |
| var firstColLeft = 0; | |
| for (; a && (null == scrollLeft || firstColLeft <= scrollLeft);) { | |
| if (item(a)) { | |
| return a; | |
| } | |
| a = a.parentNode; | |
| firstColLeft++; | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {string} opt_document | |
| * @return {undefined} | |
| */ | |
| var Oh = function(opt_document) { | |
| this.a = opt_document || z.document || document; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| Oh.prototype.l = function(obj) { | |
| return Fe(obj) ? this.a.getElementById(obj) : obj; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} str | |
| * @return {?} | |
| */ | |
| Oh.prototype.b = function(name, type, str) { | |
| return ai(this.a, arguments); | |
| }; | |
| /** | |
| * @param {(number|string)} elem | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Ji = function(elem, name) { | |
| return elem.a.createElement(String(name)); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var Ki = function(node) { | |
| node = node.a; | |
| return node.parentWindow || node.defaultView; | |
| }; | |
| y = Oh.prototype; | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Object} val | |
| * @return {undefined} | |
| */ | |
| y.appendChild = function(obj, val) { | |
| obj.appendChild(val); | |
| }; | |
| /** @type {function(!Object, string): undefined} */ | |
| y.rg = ii; | |
| /** @type {function(!Object): undefined} */ | |
| y.Rd = ji; | |
| /** @type {function(!Object): ?} */ | |
| y.wg = mi; | |
| /** @type {function(!Object): ?} */ | |
| y.sg = ni; | |
| /** @type {function(!HTMLElement): ?} */ | |
| y.pg = pi; | |
| /** @type {function(!Object): ?} */ | |
| y.Ji = ri; | |
| /** @type {function(string, string): ?} */ | |
| y.contains = ti; | |
| /** @type {function(!Object, string): undefined} */ | |
| y.Sd = Q; | |
| /** @type {function(!Object): ?} */ | |
| y.vg = Fi; | |
| /** | |
| * @param {string} elements | |
| * @return {?} | |
| */ | |
| var Mi = function(elements) { | |
| Li(); | |
| return ug(elements); | |
| }; | |
| var Li = Ae; | |
| /** | |
| * @param {number} left1 | |
| * @param {number} right1 | |
| * @param {number} b | |
| * @param {number} margin | |
| * @return {undefined} | |
| */ | |
| var Ni = function(left1, right1, b, margin) { | |
| /** @type {number} */ | |
| this.top = left1; | |
| /** @type {number} */ | |
| this.right = right1; | |
| /** @type {number} */ | |
| this.bottom = b; | |
| /** @type {number} */ | |
| this.left = margin; | |
| }; | |
| y = Ni.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| return new Ni(this.top, this.right, this.bottom, this.left); | |
| }; | |
| /** | |
| * @param {!Object} other | |
| * @return {?} | |
| */ | |
| y.contains = function(other) { | |
| return this && other ? other instanceof Ni ? other.left >= this.left && other.right <= this.right && other.top >= this.top && other.bottom <= this.bottom : other.x >= this.left && other.x <= this.right && other.y >= this.top && other.y <= this.bottom : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.ceil = function() { | |
| /** @type {number} */ | |
| this.top = Math.ceil(this.top); | |
| /** @type {number} */ | |
| this.right = Math.ceil(this.right); | |
| /** @type {number} */ | |
| this.bottom = Math.ceil(this.bottom); | |
| /** @type {number} */ | |
| this.left = Math.ceil(this.left); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.floor = function() { | |
| /** @type {number} */ | |
| this.top = Math.floor(this.top); | |
| /** @type {number} */ | |
| this.right = Math.floor(this.right); | |
| /** @type {number} */ | |
| this.bottom = Math.floor(this.bottom); | |
| /** @type {number} */ | |
| this.left = Math.floor(this.left); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.round = function() { | |
| /** @type {number} */ | |
| this.top = Math.round(this.top); | |
| /** @type {number} */ | |
| this.right = Math.round(this.right); | |
| /** @type {number} */ | |
| this.bottom = Math.round(this.bottom); | |
| /** @type {number} */ | |
| this.left = Math.round(this.left); | |
| return this; | |
| }; | |
| /** | |
| * @param {number} left | |
| * @param {number} top | |
| * @param {number} width | |
| * @param {number} height | |
| * @return {undefined} | |
| */ | |
| var Oi = function(left, top, width, height) { | |
| /** @type {number} */ | |
| this.left = left; | |
| /** @type {number} */ | |
| this.top = top; | |
| /** @type {number} */ | |
| this.width = width; | |
| /** @type {number} */ | |
| this.height = height; | |
| }; | |
| y = Oi.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| return new Oi(this.left, this.top, this.width, this.height); | |
| }; | |
| /** | |
| * @param {!Object} rect | |
| * @return {?} | |
| */ | |
| y.contains = function(rect) { | |
| return rect instanceof L ? rect.x >= this.left && rect.x <= this.left + this.width && rect.y >= this.top && rect.y <= this.top + this.height : this.left <= rect.left && this.left + this.width >= rect.left + rect.width && this.top <= rect.top && this.top + this.height >= rect.top + rect.height; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.ceil = function() { | |
| /** @type {number} */ | |
| this.left = Math.ceil(this.left); | |
| /** @type {number} */ | |
| this.top = Math.ceil(this.top); | |
| /** @type {number} */ | |
| this.width = Math.ceil(this.width); | |
| /** @type {number} */ | |
| this.height = Math.ceil(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.floor = function() { | |
| /** @type {number} */ | |
| this.left = Math.floor(this.left); | |
| /** @type {number} */ | |
| this.top = Math.floor(this.top); | |
| /** @type {number} */ | |
| this.width = Math.floor(this.width); | |
| /** @type {number} */ | |
| this.height = Math.floor(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.round = function() { | |
| /** @type {number} */ | |
| this.left = Math.round(this.left); | |
| /** @type {number} */ | |
| this.top = Math.round(this.top); | |
| /** @type {number} */ | |
| this.width = Math.round(this.width); | |
| /** @type {number} */ | |
| this.height = Math.round(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @param {?} low | |
| * @return {?} | |
| */ | |
| var Pi = function(low) { | |
| Pi[" "](low); | |
| return low; | |
| }; | |
| Pi[" "] = Ae; | |
| /** | |
| * @param {!Object} morph | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var Qi = function(morph, key) { | |
| try { | |
| return Pi(morph[key]), true; | |
| } catch (c) { | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @param {string} key | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var R = function(x, key, obj) { | |
| if (Fe(key)) { | |
| if (key = Ri(x, key)) { | |
| /** @type {!Object} */ | |
| x.style[key] = obj; | |
| } | |
| } else { | |
| var t; | |
| for (t in key) { | |
| /** @type {!Object} */ | |
| obj = x; | |
| var color = key[t]; | |
| var i = Ri(obj, t); | |
| if (i) { | |
| obj.style[i] = color; | |
| } | |
| } | |
| } | |
| }; | |
| var Si = {}; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} tag | |
| * @return {?} | |
| */ | |
| var Ri = function(data, tag) { | |
| var version = Si[tag]; | |
| if (!version) { | |
| var v2 = tf(tag); | |
| version = v2; | |
| if (void 0 === data.style[v2]) { | |
| v2 = (G ? "Webkit" : ih ? "Moz" : E ? "ms" : fh ? "O" : null) + uf(v2); | |
| if (void 0 !== data.style[v2]) { | |
| version = v2; | |
| } | |
| } | |
| Si[tag] = version; | |
| } | |
| return version; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} p | |
| * @return {?} | |
| */ | |
| var Ti = function(a, p) { | |
| var d = Ph(a); | |
| return d.defaultView && d.defaultView.getComputedStyle && (d = d.defaultView.getComputedStyle(a, null)) ? d[p] || d.getPropertyValue(p) || "" : ""; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @param {string} style | |
| * @return {?} | |
| */ | |
| var Ui = function(element, style) { | |
| return Ti(element, style) || (element.currentStyle ? element.currentStyle[style] : null) || element.style && element.style[style]; | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!Object} t | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var Wi = function(c, t, i) { | |
| var left; | |
| if (t instanceof L) { | |
| left = t.x; | |
| t = t.y; | |
| } else { | |
| /** @type {!Object} */ | |
| left = t; | |
| /** @type {number} */ | |
| t = i; | |
| } | |
| c.style.left = Vi(left, false); | |
| c.style.top = Vi(t, false); | |
| }; | |
| /** | |
| * @param {!Object} parent | |
| * @return {?} | |
| */ | |
| var Xi = function(parent) { | |
| parent = parent ? Ph(parent) : document; | |
| return !E || yh(9) || Wh(Qh(parent).a) ? parent.documentElement : parent.body; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {?} | |
| */ | |
| var Yi = function(element) { | |
| var anchorBoundingBoxViewport; | |
| try { | |
| anchorBoundingBoxViewport = element.getBoundingClientRect(); | |
| } catch (c) { | |
| return { | |
| left : 0, | |
| top : 0, | |
| right : 0, | |
| bottom : 0 | |
| }; | |
| } | |
| if (E && element.ownerDocument.body) { | |
| element = element.ownerDocument; | |
| anchorBoundingBoxViewport.left -= element.documentElement.clientLeft + element.body.clientLeft; | |
| anchorBoundingBoxViewport.top -= element.documentElement.clientTop + element.body.clientTop; | |
| } | |
| return anchorBoundingBoxViewport; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var Zi = function(node) { | |
| if (E && !yh(8)) { | |
| return node.offsetParent; | |
| } | |
| var document = Ph(node); | |
| var target = Ui(node, ld); | |
| /** @type {boolean} */ | |
| var _cur_ctx = "fixed" == target || target == Ga; | |
| node = node.parentNode; | |
| for (; node && node != document; node = node.parentNode) { | |
| if (11 == node.nodeType && node.host && (node = node.host), target = Ui(node, ld), _cur_ctx = _cur_ctx && "static" == target && node != document.documentElement && node != document.body, !_cur_ctx && (node.scrollWidth > node.clientWidth || node.scrollHeight > node.clientHeight || "fixed" == target || target == Ga || "relative" == target)) { | |
| return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var aj = function(a) { | |
| var visibleRect = new Ni(0, Infinity, Infinity, 0); | |
| var data = Qh(a); | |
| var x = data.a.body; | |
| var b = data.a.documentElement; | |
| var offset = Yh(data.a); | |
| for (; a = Zi(a);) { | |
| if (!(E && 0 == a.clientWidth || G && 0 == a.clientHeight && a == x) && a != x && a != b && Ui(a, ed) != me) { | |
| var offset = $i(a); | |
| var options = new L(a.clientLeft, a.clientTop); | |
| offset.x += options.x; | |
| offset.y += options.y; | |
| /** @type {number} */ | |
| visibleRect.top = Math.max(visibleRect.top, offset.y); | |
| /** @type {number} */ | |
| visibleRect.right = Math.min(visibleRect.right, offset.x + a.clientWidth); | |
| /** @type {number} */ | |
| visibleRect.bottom = Math.min(visibleRect.bottom, offset.y + a.clientHeight); | |
| /** @type {number} */ | |
| visibleRect.left = Math.max(visibleRect.left, offset.x); | |
| } | |
| } | |
| x = offset.scrollLeft; | |
| offset = offset.scrollTop; | |
| /** @type {number} */ | |
| visibleRect.left = Math.max(visibleRect.left, x); | |
| /** @type {number} */ | |
| visibleRect.top = Math.max(visibleRect.top, offset); | |
| data = Xh(Ki(data) || window); | |
| /** @type {number} */ | |
| visibleRect.right = Math.min(visibleRect.right, x + data.width); | |
| /** @type {number} */ | |
| visibleRect.bottom = Math.min(visibleRect.bottom, offset + data.height); | |
| return 0 <= visibleRect.top && 0 <= visibleRect.left && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null; | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var $i = function(el) { | |
| var options = Ph(el); | |
| var xhair = new L(0, 0); | |
| var win = Xi(options); | |
| if (el == win) { | |
| return xhair; | |
| } | |
| el = Yi(el); | |
| options = Zh(Qh(options).a); | |
| xhair.x = el.left + options.x; | |
| xhair.y = el.top + options.y; | |
| return xhair; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var cj = function(a, b) { | |
| var dialogGeometry = bj(a); | |
| var containerGeometry = bj(b); | |
| return new L(dialogGeometry.x - containerGeometry.x, dialogGeometry.y - containerGeometry.y); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var dj = function(a) { | |
| a = Yi(a); | |
| return new L(a.left, a.top); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var bj = function(a) { | |
| if (1 == a.nodeType) { | |
| return dj(a); | |
| } | |
| a = a.changedTouches ? a.changedTouches[0] : a; | |
| return new L(a.clientX, a.clientY); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {number} s | |
| * @param {!Audio} v | |
| * @return {undefined} | |
| */ | |
| var ej = function(d, s, v) { | |
| var pt = $i(d); | |
| if (s instanceof L) { | |
| v = s.y; | |
| s = s.x; | |
| } | |
| Wi(d, d.offsetLeft + (s - pt.x), d.offsetTop + (Number(v) - pt.y)); | |
| }; | |
| /** | |
| * @param {!Element} text | |
| * @param {!Object} a | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var fj = function(text, a, value) { | |
| if (a instanceof Gh) { | |
| value = a.height; | |
| a = a.width; | |
| } else { | |
| if (void 0 == value) { | |
| throw Error("missing height argument"); | |
| } | |
| } | |
| text.style.width = Vi(a, true); | |
| text.style.height = Vi(value, true); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Vi = function(a, b) { | |
| if (typeof a == bd) { | |
| a = (b ? Math.round(a) : a) + md; | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var hj = function(a) { | |
| /** @type {function(!Object): ?} */ | |
| var multInv = gj; | |
| if (Ui(a, "display") != ad) { | |
| return multInv(a); | |
| } | |
| var style = a.style; | |
| var oldDisplay = style.display; | |
| var oldVis = style.visibility; | |
| var oPos = style.position; | |
| style.visibility = oc; | |
| style.position = Ga; | |
| /** @type {string} */ | |
| style.display = "inline"; | |
| a = multInv(a); | |
| style.display = oldDisplay; | |
| style.position = oPos; | |
| style.visibility = oldVis; | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var gj = function(a) { | |
| var b = a.offsetWidth; | |
| var liHeight = a.offsetHeight; | |
| var matched = G && !b && !liHeight; | |
| return xe(b) && !matched || !a.getBoundingClientRect ? new Gh(b, liHeight) : (a = Yi(a), new Gh(a.right - a.left, a.bottom - a.top)); | |
| }; | |
| /** | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var ij = function(b) { | |
| var a = $i(b); | |
| b = hj(b); | |
| return new Oi(a.x, a.y, b.width, b.height); | |
| }; | |
| /** | |
| * @param {!Element} a | |
| * @param {(number|string)} c | |
| * @return {undefined} | |
| */ | |
| var jj = function(a, c) { | |
| var style = a.style; | |
| if ("opacity" in style) { | |
| /** @type {(number|string)} */ | |
| style.opacity = c; | |
| } else { | |
| if ("MozOpacity" in style) { | |
| /** @type {(number|string)} */ | |
| style.MozOpacity = c; | |
| } else { | |
| if ("filter" in style) { | |
| /** @type {string} */ | |
| style.filter = "" === c ? "" : "alpha(opacity=" + 100 * Number(c) + ")"; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var S = function(a, b) { | |
| a.style.display = b ? "" : ad; | |
| }; | |
| /** | |
| * @param {!Element} a | |
| * @return {?} | |
| */ | |
| var kj = function(a) { | |
| return a.style.display != ad; | |
| }; | |
| /** | |
| * @param {string} args | |
| * @return {?} | |
| */ | |
| var mj = function(args) { | |
| args = Mi(args); | |
| var d = Qh(void 0); | |
| var c; | |
| var node = d.a; | |
| if (E && node.createStyleSheet) { | |
| c = node.createStyleSheet(); | |
| lj(c, args); | |
| } else { | |
| node = Rh(d.a, "HEAD", void 0, void 0)[0]; | |
| if (!node) { | |
| c = Rh(d.a, "BODY", void 0, void 0)[0]; | |
| node = d.b("HEAD"); | |
| c.parentNode.insertBefore(node, c); | |
| } | |
| c = d.b("STYLE"); | |
| lj(c, args); | |
| d.appendChild(node, c); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Node} d | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var lj = function(d, obj) { | |
| var a; | |
| if (obj instanceof tg && obj.constructor === tg && obj.b === sg) { | |
| a = obj.a; | |
| } else { | |
| Ce(obj); | |
| /** @type {string} */ | |
| a = "type_error:SafeStyleSheet"; | |
| } | |
| if (E && xe(d.cssText)) { | |
| d.cssText = a; | |
| } else { | |
| d.innerHTML = a; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} cell | |
| * @return {?} | |
| */ | |
| var nj = function(cell) { | |
| return sd == Ui(cell, nb); | |
| }; | |
| /** @type {(null|string)} */ | |
| var oj = ih ? "MozUserSelect" : G || gh ? "WebkitUserSelect" : null; | |
| /** | |
| * @param {!Object} i | |
| * @param {string} value | |
| * @param {!Function} x | |
| * @return {undefined} | |
| */ | |
| var pj = function(i, value, x) { | |
| x = x ? null : i.getElementsByTagName("*"); | |
| if (oj) { | |
| if (value = value ? ad : "", i.style && (i.style[oj] = value), x) { | |
| /** @type {number} */ | |
| i = 0; | |
| var descendant; | |
| for (; descendant = x[i]; i++) { | |
| if (descendant.style) { | |
| /** @type {string} */ | |
| descendant.style[oj] = value; | |
| } | |
| } | |
| } | |
| } else { | |
| if (E || fh) { | |
| if (value = value ? "on" : "", i.setAttribute("unselectable", value), x) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; descendant = x[i]; i++) { | |
| descendant.setAttribute("unselectable", value); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} style | |
| * @param {!Object} size | |
| * @param {string} boxSizing | |
| * @return {undefined} | |
| */ | |
| var qj = function(style, size, boxSizing) { | |
| style = style.style; | |
| if (ih) { | |
| /** @type {string} */ | |
| style.MozBoxSizing = boxSizing; | |
| } else { | |
| if (G) { | |
| /** @type {string} */ | |
| style.WebkitBoxSizing = boxSizing; | |
| } else { | |
| /** @type {string} */ | |
| style.boxSizing = boxSizing; | |
| } | |
| } | |
| style.width = Math.max(size.width, 0) + md; | |
| style.height = Math.max(size.height, 0) + md; | |
| }; | |
| /** | |
| * @param {!HTMLElement} element | |
| * @param {string} value | |
| * @param {string} propertyName | |
| * @param {string} prop | |
| * @return {?} | |
| */ | |
| var rj = function(element, value, propertyName, prop) { | |
| if (/^\d+px?$/.test(value)) { | |
| return parseInt(value, 10); | |
| } | |
| var propertyMethodPostfix = element.style[propertyName]; | |
| var componentPropertyValue = element.runtimeStyle[propertyName]; | |
| element.runtimeStyle[propertyName] = element.currentStyle[propertyName]; | |
| /** @type {string} */ | |
| element.style[propertyName] = value; | |
| value = element.style[prop]; | |
| element.style[propertyName] = propertyMethodPostfix; | |
| element.runtimeStyle[propertyName] = componentPropertyValue; | |
| return value; | |
| }; | |
| /** | |
| * @param {!HTMLElement} el | |
| * @param {string} property | |
| * @return {?} | |
| */ | |
| var sj = function(el, property) { | |
| var value = el.currentStyle ? el.currentStyle[property] : null; | |
| return value ? rj(el, value, Pc, "pixelLeft") : 0; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} property | |
| * @return {?} | |
| */ | |
| var tj = function(name, property) { | |
| if (E) { | |
| var c = sj(name, property + "Left"); | |
| var d = sj(name, property + "Right"); | |
| var e = sj(name, property + "Top"); | |
| var f = sj(name, property + "Bottom"); | |
| return new Ni(e, d, f, c); | |
| } | |
| c = Ti(name, property + "Left"); | |
| d = Ti(name, property + "Right"); | |
| e = Ti(name, property + "Top"); | |
| f = Ti(name, property + "Bottom"); | |
| return new Ni(parseFloat(e), parseFloat(d), parseFloat(f), parseFloat(c)); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var uj = function(name) { | |
| return tj(name, "padding"); | |
| }; | |
| var vj = { | |
| thin : 2, | |
| medium : 4, | |
| thick : 6 | |
| }; | |
| /** | |
| * @param {!HTMLElement} elem | |
| * @param {string} prop | |
| * @return {?} | |
| */ | |
| var wj = function(elem, prop) { | |
| if ((elem.currentStyle ? elem.currentStyle[prop + "Style"] : null) == ad) { | |
| return 0; | |
| } | |
| var type = elem.currentStyle ? elem.currentStyle[prop + "Width"] : null; | |
| return type in vj ? vj[type] : rj(elem, type, Pc, "pixelLeft"); | |
| }; | |
| /** | |
| * @param {string} element | |
| * @return {?} | |
| */ | |
| var xj = function(element) { | |
| if (E && !yh(9)) { | |
| var left = wj(element, "borderLeft"); | |
| var right = wj(element, "borderRight"); | |
| var top = wj(element, "borderTop"); | |
| element = wj(element, "borderBottom"); | |
| return new Ni(top, right, element, left); | |
| } | |
| left = Ti(element, "borderLeftWidth"); | |
| right = Ti(element, "borderRightWidth"); | |
| top = Ti(element, "borderTopWidth"); | |
| element = Ti(element, "borderBottomWidth"); | |
| return new Ni(parseFloat(top), parseFloat(right), parseFloat(element), parseFloat(left)); | |
| }; | |
| var yj = ue(); | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| yj.prototype.a = function(name) { | |
| /** @type {!HTMLBodyElement} */ | |
| var body = document.body; | |
| switch(name.mo) { | |
| case "sm": | |
| J(body, "e_sm"); | |
| K(body, "e_md"); | |
| K(body, "e_lg"); | |
| break; | |
| case "lg": | |
| J(body, "e_lg"); | |
| K(body, "e_sm"); | |
| K(body, "e_md"); | |
| break; | |
| default: | |
| J(body, "e_md"); | |
| K(body, "e_sm"); | |
| K(body, "e_lg"); | |
| } | |
| if (body = document.getElementById("contentframe")) { | |
| /** @type {number} */ | |
| var fullName = 0; | |
| /** @type {(Element|null)} */ | |
| var d = document.getElementById("wtgbr"); | |
| var fhTop = tj(d, Rc).top; | |
| name = name.es.h; | |
| var e = M("gt-logo"); | |
| if (null != e) { | |
| name = name + hj(e).height; | |
| } | |
| if (0 == fhTop) { | |
| fullName = fullName + name; | |
| } else { | |
| if (name != -fhTop) { | |
| R(d, Tc, -name + md); | |
| } | |
| } | |
| if (d = document.getElementById("gt-appbar")) { | |
| fullName = fullName + hj(d).height; | |
| } | |
| Wi(body, 0, fullName); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var zj = function() { | |
| /** @type {null} */ | |
| this.j = null; | |
| /** @type {string} */ | |
| this.w = this.C = this.g = this.c = this.H = this.W = this.Ca = this.U = this.Ra = this.K = ""; | |
| /** @type {null} */ | |
| this.b = this.A = this.a = this.O = this.wa = this.P = this.L = this.I = this.N = null; | |
| /** @type {number} */ | |
| this.G = 0; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| /** @type {number} */ | |
| this.F = -1; | |
| /** @type {boolean} */ | |
| this.B = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Aj = function() { | |
| this.Ca = this.Ca; | |
| this.Ra = this.Ra; | |
| }; | |
| /** @type {boolean} */ | |
| Aj.prototype.Ca = false; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aj.prototype.za = function() { | |
| if (!this.Ca) { | |
| /** @type {boolean} */ | |
| this.Ca = true; | |
| this.J(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {?} min | |
| * @return {undefined} | |
| */ | |
| var Cj = function(item, min) { | |
| var v = Oe(Bj, min); | |
| if (item.Ca) { | |
| v.call(void 0); | |
| } else { | |
| if (!item.Ra) { | |
| /** @type {!Array} */ | |
| item.Ra = []; | |
| } | |
| item.Ra.push(xe(void 0) ? A(v, void 0) : v); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aj.prototype.J = function() { | |
| if (this.Ra) { | |
| for (; this.Ra.length;) { | |
| this.Ra.shift()(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| var Bj = function(a) { | |
| if (a && typeof a.za == Bb) { | |
| a.za(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} path | |
| * @return {undefined} | |
| */ | |
| var T = function(type, path) { | |
| /** @type {!Object} */ | |
| this.type = type; | |
| this.a = this.target = path; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| /** @type {boolean} */ | |
| this.ah = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| T.prototype.stopPropagation = function() { | |
| /** @type {boolean} */ | |
| this.g = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| T.prototype.preventDefault = function() { | |
| /** @type {boolean} */ | |
| this.ah = false; | |
| }; | |
| var Dj = !E || yh(9); | |
| var Ej = !E || yh(9); | |
| var Fj = E && !I("9"); | |
| if (!!G) { | |
| I("528"); | |
| } | |
| if (!(ih && I("1.9b") || E && I("8") || fh && I("9.5"))) { | |
| if (G) { | |
| I("528"); | |
| } | |
| } | |
| if (!(ih && !I("8"))) { | |
| if (E) { | |
| I("9"); | |
| } | |
| } | |
| /** @type {string} */ | |
| var Gj = E ? xb : "DOMFocusIn"; | |
| /** @type {string} */ | |
| var Hj = E ? yb : "DOMFocusOut"; | |
| /** | |
| * @param {!Object} event | |
| * @param {number} prop | |
| * @return {undefined} | |
| */ | |
| var Ij = function(event, prop) { | |
| T.call(this, event ? event.type : ""); | |
| /** @type {null} */ | |
| this.c = this.a = this.target = null; | |
| /** @type {number} */ | |
| this.keyCode = this.screenY = this.screenX = this.clientY = this.clientX = 0; | |
| /** @type {boolean} */ | |
| this.m = this.metaKey = this.shiftKey = this.altKey = this.ctrlKey = false; | |
| /** @type {null} */ | |
| this.b = null; | |
| if (event) { | |
| var type = this.type = event.type; | |
| var relevantTouch = event.changedTouches ? event.changedTouches[0] : null; | |
| this.target = event.target || event.srcElement; | |
| /** @type {number} */ | |
| this.a = prop; | |
| var node = event.relatedTarget; | |
| if (node) { | |
| if (ih) { | |
| if (!Qi(node, "nodeName")) { | |
| /** @type {null} */ | |
| node = null; | |
| } | |
| } | |
| } else { | |
| if (type == Yc) { | |
| node = event.fromElement; | |
| } else { | |
| if (type == Xc) { | |
| node = event.toElement; | |
| } | |
| } | |
| } | |
| this.c = node; | |
| if (null === relevantTouch) { | |
| this.clientX = void 0 !== event.clientX ? event.clientX : event.pageX; | |
| this.clientY = void 0 !== event.clientY ? event.clientY : event.pageY; | |
| this.screenX = event.screenX || 0; | |
| this.screenY = event.screenY || 0; | |
| } else { | |
| this.clientX = void 0 !== relevantTouch.clientX ? relevantTouch.clientX : relevantTouch.pageX; | |
| this.clientY = void 0 !== relevantTouch.clientY ? relevantTouch.clientY : relevantTouch.pageY; | |
| this.screenX = relevantTouch.screenX || 0; | |
| this.screenY = relevantTouch.screenY || 0; | |
| } | |
| this.keyCode = event.keyCode || 0; | |
| this.ctrlKey = event.ctrlKey; | |
| this.altKey = event.altKey; | |
| this.shiftKey = event.shiftKey; | |
| this.metaKey = event.metaKey; | |
| this.m = kh ? event.metaKey : event.ctrlKey; | |
| /** @type {!Object} */ | |
| this.b = event; | |
| if (event.defaultPrevented) { | |
| this.preventDefault(); | |
| } | |
| } | |
| }; | |
| C(Ij, T); | |
| /** @type {!Array} */ | |
| var Jj = [1, 4, 2]; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Kj = function(item) { | |
| return (Dj ? 0 == item.b.button : item.type == r ? true : !!(item.b.button & Jj[0])) && !(G && kh && item.ctrlKey); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ij.prototype.stopPropagation = function() { | |
| Ij.v.stopPropagation.call(this); | |
| if (this.b.stopPropagation) { | |
| this.b.stopPropagation(); | |
| } else { | |
| /** @type {boolean} */ | |
| this.b.cancelBubble = true; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ij.prototype.preventDefault = function() { | |
| Ij.v.preventDefault.call(this); | |
| var e = this.b; | |
| if (e.preventDefault) { | |
| e.preventDefault(); | |
| } else { | |
| if (e.returnValue = false, Fj) { | |
| try { | |
| if (e.ctrlKey || 112 <= e.keyCode && 123 >= e.keyCode) { | |
| /** @type {number} */ | |
| e.keyCode = -1; | |
| } | |
| } catch (b) { | |
| } | |
| } | |
| } | |
| }; | |
| /** @type {string} */ | |
| var Lj = "closure_listenable_" + (1E6 * Math.random() | 0); | |
| /** | |
| * @param {!Object} object | |
| * @return {?} | |
| */ | |
| var Mj = function(object) { | |
| return !(!object || !object[Lj]); | |
| }; | |
| /** @type {number} */ | |
| var Nj = 0; | |
| /** | |
| * @param {!Object} callback | |
| * @param {string} link | |
| * @param {!Object} src | |
| * @param {?} bandages | |
| * @param {?} REPLACED | |
| * @return {undefined} | |
| */ | |
| var Oj = function(callback, link, src, bandages, REPLACED) { | |
| /** @type {!Object} */ | |
| this.listener = callback; | |
| /** @type {null} */ | |
| this.a = null; | |
| /** @type {string} */ | |
| this.src = link; | |
| /** @type {!Object} */ | |
| this.type = src; | |
| /** @type {boolean} */ | |
| this.Gd = !!bandages; | |
| this.ke = REPLACED; | |
| /** @type {number} */ | |
| this.key = ++Nj; | |
| /** @type {boolean} */ | |
| this.Sc = this.Fd = false; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var Pj = function(d) { | |
| /** @type {boolean} */ | |
| d.Sc = true; | |
| /** @type {null} */ | |
| d.listener = null; | |
| /** @type {null} */ | |
| d.a = null; | |
| /** @type {null} */ | |
| d.src = null; | |
| /** @type {null} */ | |
| d.ke = null; | |
| }; | |
| /** | |
| * @param {string} src | |
| * @return {undefined} | |
| */ | |
| var Qj = function(src) { | |
| /** @type {string} */ | |
| this.src = src; | |
| this.a = {}; | |
| /** @type {number} */ | |
| this.b = 0; | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @param {string} array | |
| * @param {!Function} d | |
| * @param {boolean} h | |
| * @param {string} e | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| var Sj = function(obj, array, d, h, e, key) { | |
| var type = array.toString(); | |
| array = obj.a[type]; | |
| if (!array) { | |
| /** @type {!Array} */ | |
| array = obj.a[type] = []; | |
| obj.b++; | |
| } | |
| var t = Rj(array, d, e, key); | |
| if (-1 < t) { | |
| obj = array[t]; | |
| if (!h) { | |
| /** @type {boolean} */ | |
| obj.Fd = false; | |
| } | |
| } else { | |
| obj = new Oj(d, obj.src, type, !!e, key); | |
| /** @type {boolean} */ | |
| obj.Fd = h; | |
| array.push(obj); | |
| } | |
| return obj; | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var Tj = function(event, data) { | |
| var type = data.type; | |
| if (!(type in event.a)) { | |
| return false; | |
| } | |
| var renderedHtml = Hf(event.a[type], data); | |
| if (renderedHtml) { | |
| Pj(data); | |
| if (0 == event.a[type].length) { | |
| delete event.a[type]; | |
| event.b--; | |
| } | |
| } | |
| return renderedHtml; | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Uj = function(m, b) { | |
| var cur = b && b.toString(); | |
| /** @type {number} */ | |
| var d = 0; | |
| var i; | |
| for (i in m.a) { | |
| if (!cur || i == cur) { | |
| var month_name = m.a[i]; | |
| /** @type {number} */ | |
| var month_full_i = 0; | |
| for (; month_full_i < month_name.length; month_full_i++) { | |
| ++d; | |
| Pj(month_name[month_full_i]); | |
| } | |
| delete m.a[i]; | |
| m.b--; | |
| } | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @param {!Function} prop | |
| * @param {string} d | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var Vj = function(a, b, prop, d, e) { | |
| a = a.a[b.toString()]; | |
| /** @type {number} */ | |
| b = -1; | |
| if (a) { | |
| b = Rj(a, prop, d, e); | |
| } | |
| return -1 < b ? a[b] : null; | |
| }; | |
| /** | |
| * @param {!Object} input | |
| * @param {!Function} name | |
| * @param {string} reason | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Rj = function(input, name, reason, a) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < input.length; ++i) { | |
| var d = input[i]; | |
| if (!d.Sc && d.listener == name && d.Gd == !!reason && d.ke == a) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| }; | |
| /** @type {string} */ | |
| var Wj = "closure_lm_" + (1E6 * Math.random() | 0); | |
| var Xj = {}; | |
| /** @type {number} */ | |
| var Yj = 0; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} name | |
| * @param {!Function} b | |
| * @param {string} c | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var U = function(a, name, b, c, d) { | |
| if (De(name)) { | |
| /** @type {number} */ | |
| var curPos = 0; | |
| for (; curPos < name.length; curPos++) { | |
| U(a, name[curPos], b, c, d); | |
| } | |
| return null; | |
| } | |
| b = Zj(b); | |
| return Mj(a) ? Sj(a.eb, String(name), b, false, c, d) : ak(a, name, b, false, c, d); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} input | |
| * @param {!Object} e | |
| * @param {!Object} d | |
| * @param {string} t | |
| * @param {!Object} f | |
| * @return {?} | |
| */ | |
| var ak = function(b, input, e, d, t, f) { | |
| if (!input) { | |
| throw Error("Invalid event type"); | |
| } | |
| /** @type {boolean} */ | |
| var cb = !!t; | |
| var c = bk(b); | |
| if (!c) { | |
| b[Wj] = c = new Qj(b); | |
| } | |
| e = Sj(c, input, e, d, t, f); | |
| if (e.a) { | |
| return e; | |
| } | |
| d = ck(); | |
| /** @type {!Object} */ | |
| e.a = d; | |
| /** @type {!Object} */ | |
| d.src = b; | |
| /** @type {!Object} */ | |
| d.listener = e; | |
| if (b.addEventListener) { | |
| b.addEventListener(input.toString(), d, cb); | |
| } else { | |
| if (b.attachEvent) { | |
| b.attachEvent(dk(input.toString()), d); | |
| } else { | |
| throw Error("addEventListener and attachEvent are unavailable."); | |
| } | |
| } | |
| Yj++; | |
| return e; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var ck = function() { | |
| /** @type {function(!Object, string): ?} */ | |
| var proxyCallbackFunction = ek; | |
| /** @type {function(?): ?} */ | |
| var f = Ej ? function(eventObject) { | |
| return proxyCallbackFunction.call(f.src, f.listener, eventObject); | |
| } : function(ch) { | |
| ch = proxyCallbackFunction.call(f.src, f.listener, ch); | |
| if (!ch) { | |
| return ch; | |
| } | |
| }; | |
| return f; | |
| }; | |
| /** | |
| * @param {!Object} model | |
| * @param {string} value | |
| * @param {!Object} status | |
| * @param {string} files | |
| * @param {!Object} folder | |
| * @return {undefined} | |
| */ | |
| var gk = function(model, value, status, files, folder) { | |
| if (De(value)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < value.length; i++) { | |
| gk(model, value[i], status, files, folder); | |
| } | |
| } else { | |
| status = Zj(status); | |
| if (Mj(model)) { | |
| Sj(model.eb, String(value), status, true, files, folder); | |
| } else { | |
| ak(model, value, status, true, files, folder); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} name | |
| * @param {number} p | |
| * @param {boolean} v | |
| * @param {!Object} j | |
| * @return {undefined} | |
| */ | |
| var hk = function(value, name, p, v, j) { | |
| if (De(name)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < name.length; i++) { | |
| hk(value, name[i], p, v, j); | |
| } | |
| } else { | |
| p = Zj(p); | |
| if (Mj(value)) { | |
| value = value.eb; | |
| /** @type {string} */ | |
| name = String(name).toString(); | |
| if (name in value.a) { | |
| i = value.a[name]; | |
| p = Rj(i, p, v, j); | |
| if (-1 < p) { | |
| Pj(i[p]); | |
| Array.prototype.splice.call(i, p, 1); | |
| if (0 == i.length) { | |
| delete value.a[name]; | |
| value.b--; | |
| } | |
| } | |
| } | |
| } else { | |
| if (value && (value = bk(value)) && (p = Vj(value, name, p, !!v, j))) { | |
| ik(p); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var ik = function(data) { | |
| if (Ge(data) || !data || data.Sc) { | |
| return false; | |
| } | |
| var node = data.src; | |
| if (Mj(node)) { | |
| return Tj(node.eb, data); | |
| } | |
| var type = data.type; | |
| var action = data.a; | |
| if (node.removeEventListener) { | |
| node.removeEventListener(type, action, data.Gd); | |
| } else { | |
| if (node.detachEvent) { | |
| node.detachEvent(dk(type), action); | |
| } | |
| } | |
| Yj--; | |
| if (type = bk(node)) { | |
| Tj(type, data); | |
| if (0 == type.b) { | |
| /** @type {null} */ | |
| type.src = null; | |
| /** @type {null} */ | |
| node[Wj] = null; | |
| } | |
| } else { | |
| Pj(data); | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} width | |
| * @param {string} frame | |
| * @return {?} | |
| */ | |
| var jk = function(width, frame) { | |
| if (!width) { | |
| return 0; | |
| } | |
| if (Mj(width)) { | |
| return width.eb ? Uj(width.eb, frame) : 0; | |
| } | |
| var c = bk(width); | |
| if (!c) { | |
| return 0; | |
| } | |
| /** @type {number} */ | |
| var d = 0; | |
| var name = frame && frame.toString(); | |
| var i; | |
| for (i in c.a) { | |
| if (!name || i == name) { | |
| var crossfilterable_layers = c.a[i].concat(); | |
| /** @type {number} */ | |
| var layer_i = 0; | |
| for (; layer_i < crossfilterable_layers.length; ++layer_i) { | |
| if (ik(crossfilterable_layers[layer_i])) { | |
| ++d; | |
| } | |
| } | |
| } | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {string} k | |
| * @return {?} | |
| */ | |
| var dk = function(k) { | |
| return k in Xj ? Xj[k] : Xj[k] = "on" + k; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {string} b | |
| * @param {boolean} directory | |
| * @param {?} value | |
| * @return {?} | |
| */ | |
| var lk = function(a, b, directory, value) { | |
| /** @type {boolean} */ | |
| var params = true; | |
| if (a = bk(a)) { | |
| if (b = a.a[b.toString()]) { | |
| b = b.concat(); | |
| /** @type {number} */ | |
| a = 0; | |
| for (; a < b.length; a++) { | |
| var f = b[a]; | |
| if (f && f.Gd == directory && !f.Sc) { | |
| f = kk(f, value); | |
| /** @type {boolean} */ | |
| params = params && false !== f; | |
| } | |
| } | |
| } | |
| } | |
| return params; | |
| }; | |
| /** | |
| * @param {!Object} listener | |
| * @param {?} e | |
| * @return {?} | |
| */ | |
| var kk = function(listener, e) { | |
| var listenerFn = listener.listener; | |
| var listenerHandler = listener.ke || listener.src; | |
| if (listener.Fd) { | |
| ik(listener); | |
| } | |
| return listenerFn.call(listenerHandler, e); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {string} comments | |
| * @return {?} | |
| */ | |
| var ek = function(e, comments) { | |
| if (e.Sc) { | |
| return true; | |
| } | |
| if (!Ej) { | |
| var data = comments || ze("window.event"); | |
| var d = new Ij(data, this); | |
| /** @type {boolean} */ | |
| var result = true; | |
| if (!(0 > data.keyCode || void 0 != data.returnValue)) { | |
| a: { | |
| /** @type {boolean} */ | |
| var a = false; | |
| if (0 == data.keyCode) { | |
| try { | |
| /** @type {number} */ | |
| data.keyCode = -1; | |
| break a; | |
| } catch (m) { | |
| /** @type {boolean} */ | |
| a = true; | |
| } | |
| } | |
| if (a || void 0 == data.returnValue) { | |
| /** @type {boolean} */ | |
| data.returnValue = true; | |
| } | |
| } | |
| /** @type {!Array} */ | |
| data = []; | |
| a = d.a; | |
| for (; a; a = a.parentNode) { | |
| data.push(a); | |
| } | |
| a = e.type; | |
| /** @type {number} */ | |
| var i = data.length - 1; | |
| for (; !d.g && 0 <= i; i--) { | |
| d.a = data[i]; | |
| var r = lk(data[i], a, true, d); | |
| result = result && r; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; !d.g && i < data.length; i++) { | |
| d.a = data[i]; | |
| r = lk(data[i], a, false, d); | |
| result = result && r; | |
| } | |
| } | |
| return result; | |
| } | |
| return kk(e, new Ij(comments, this)); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var bk = function(value) { | |
| value = value[Wj]; | |
| return value instanceof Qj ? value : null; | |
| }; | |
| /** @type {string} */ | |
| var mk = "__closure_events_fn_" + (1E9 * Math.random() >>> 0); | |
| /** | |
| * @param {!Function} result | |
| * @return {?} | |
| */ | |
| var Zj = function(result) { | |
| if (He(result)) { | |
| return result; | |
| } | |
| if (!result[mk]) { | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| result[mk] = function(event) { | |
| return result.handleEvent(event); | |
| }; | |
| } | |
| return result[mk]; | |
| }; | |
| /** | |
| * @param {string} i_f | |
| * @return {undefined} | |
| */ | |
| var nk = function(i_f) { | |
| Aj.call(this); | |
| /** @type {string} */ | |
| this.F = i_f; | |
| this.o = {}; | |
| }; | |
| C(nk, Aj); | |
| /** @type {!Array} */ | |
| var ok = []; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Object} data | |
| * @param {string} input | |
| * @return {?} | |
| */ | |
| nk.prototype.a = function(name, type, data, input) { | |
| if (!De(type)) { | |
| if (type) { | |
| ok[0] = type.toString(); | |
| } | |
| type = ok; | |
| } | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < type.length; j++) { | |
| var val = U(name, type[j], data || this.handleEvent, input || false, this.F || this); | |
| if (!val) { | |
| break; | |
| } | |
| this.o[val.key] = val; | |
| } | |
| return this; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Object} data | |
| * @param {string} e | |
| * @param {number} x | |
| * @return {?} | |
| */ | |
| nk.prototype.b = function(name, type, data, e, x) { | |
| if (De(type)) { | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < type.length; j++) { | |
| this.b(name, type[j], data, e, x); | |
| } | |
| } else { | |
| data = data || this.handleEvent; | |
| x = x || this.F || this; | |
| data = Zj(data); | |
| /** @type {boolean} */ | |
| e = !!e; | |
| type = Mj(name) ? Vj(name.eb, String(type), data, e, x) : name ? (name = bk(name)) ? Vj(name, type, data, e, x) : null : null; | |
| if (type) { | |
| ik(type); | |
| delete this.o[type.key]; | |
| } | |
| } | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} selector | |
| * @return {undefined} | |
| */ | |
| var pk = function(selector) { | |
| Nf(selector.o, function(testItemData, e) { | |
| if (this.o.hasOwnProperty(e)) { | |
| ik(testItemData); | |
| } | |
| }, selector); | |
| selector.o = {}; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nk.prototype.J = function() { | |
| nk.v.J.call(this); | |
| pk(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| nk.prototype.handleEvent = function() { | |
| throw Error("EventHandler.handleEvent not implemented"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var V = function() { | |
| Aj.call(this); | |
| this.eb = new Qj(this); | |
| this.Ni = this; | |
| /** @type {null} */ | |
| this.Ce = null; | |
| }; | |
| C(V, Aj); | |
| /** @type {boolean} */ | |
| V.prototype[Lj] = true; | |
| y = V.prototype; | |
| y.Md = w("Ce"); | |
| y.Uc = ve("Ce"); | |
| /** | |
| * @param {string} type | |
| * @param {!Array} action | |
| * @param {boolean} el | |
| * @param {!Object} callback | |
| * @return {undefined} | |
| */ | |
| y.removeEventListener = function(type, action, el, callback) { | |
| hk(this, type, action, el, callback); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| y.dispatchEvent = function(value) { | |
| var obj; | |
| var key = this.Md(); | |
| if (key) { | |
| /** @type {!Array} */ | |
| obj = []; | |
| /** @type {number} */ | |
| var data = 1; | |
| for (; key; key = key.Md()) { | |
| obj.push(key); | |
| ++data; | |
| } | |
| } | |
| key = this.Ni; | |
| data = value.type || value; | |
| if (Fe(value)) { | |
| value = new T(value, key); | |
| } else { | |
| if (value instanceof T) { | |
| value.target = value.target || key; | |
| } else { | |
| /** @type {string} */ | |
| var result = value; | |
| value = new T(data, key); | |
| Wf(value, result); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| result = true; | |
| var time; | |
| if (obj) { | |
| /** @type {number} */ | |
| var i = obj.length - 1; | |
| for (; !value.g && 0 <= i; i--) { | |
| time = value.a = obj[i]; | |
| result = qk(time, data, true, value) && result; | |
| } | |
| } | |
| if (!value.g) { | |
| time = value.a = key; | |
| result = qk(time, data, true, value) && result; | |
| if (!value.g) { | |
| result = qk(time, data, false, value) && result; | |
| } | |
| } | |
| if (obj) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; !value.g && i < obj.length; i++) { | |
| time = value.a = obj[i]; | |
| result = qk(time, data, false, value) && result; | |
| } | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| V.v.J.call(this); | |
| if (this.eb) { | |
| Uj(this.eb, void 0); | |
| } | |
| /** @type {null} */ | |
| this.Ce = null; | |
| }; | |
| /** | |
| * @param {!Object} model | |
| * @param {string} event | |
| * @param {boolean} capture | |
| * @param {string} char | |
| * @return {?} | |
| */ | |
| var qk = function(model, event, capture, char) { | |
| event = model.eb.a[String(event)]; | |
| if (!event) { | |
| return true; | |
| } | |
| event = event.concat(); | |
| /** @type {boolean} */ | |
| var b = true; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < event.length; ++k) { | |
| var listener = event[k]; | |
| if (listener && !listener.Sc && listener.Gd == capture) { | |
| var listenerFn = listener.listener; | |
| var listenerHandler = listener.ke || listener.src; | |
| if (listener.Fd) { | |
| Tj(model.eb, listener); | |
| } | |
| /** @type {boolean} */ | |
| b = false !== listenerFn.call(listenerHandler, char) && b; | |
| } | |
| } | |
| return b && 0 != char.ah; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var rk = function() { | |
| return !(D(tc) || D(na) && !D("Mobile") || D("Silk")) && (D(uc) || D("iPhone") || D(na) || D("IEMobile")); | |
| }; | |
| /** | |
| * @param {?} handler | |
| * @param {!Array} value | |
| * @return {?} | |
| */ | |
| var sk = function(handler, value) { | |
| /** @type {!Array} */ | |
| var section = [handler]; | |
| /** @type {number} */ | |
| var i = value.length - 1; | |
| for (; 0 <= i; --i) { | |
| section.push(typeof value[i], value[i]); | |
| } | |
| return section.join("\x0B"); | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @param {string} reflectorHost | |
| * @param {number} metadataResolver | |
| * @return {undefined} | |
| */ | |
| var tk = function(compiler, reflectorHost, metadataResolver) { | |
| /** @type {number} */ | |
| this.j = metadataResolver; | |
| /** @type {number} */ | |
| this.c = compiler; | |
| /** @type {string} */ | |
| this.g = reflectorHost; | |
| /** @type {number} */ | |
| this.b = 0; | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| tk.prototype.get = function() { | |
| var a; | |
| if (0 < this.b) { | |
| this.b--; | |
| a = this.a; | |
| this.a = a.next; | |
| /** @type {null} */ | |
| a.next = null; | |
| } else { | |
| a = this.c(); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| var uk = function(t, n) { | |
| t.g(n); | |
| if (t.b < t.j) { | |
| t.b++; | |
| n.next = t.a; | |
| /** @type {!Object} */ | |
| t.a = n; | |
| } | |
| }; | |
| /** | |
| * @param {?} callback | |
| * @return {undefined} | |
| */ | |
| var vk = function(callback) { | |
| z.setTimeout(function() { | |
| throw callback; | |
| }, 0); | |
| }; | |
| var wk; | |
| /** | |
| * @return {?} | |
| */ | |
| var xk = function() { | |
| var Channel = z.MessageChannel; | |
| if ("undefined" === typeof Channel && "undefined" !== typeof window && window.postMessage && window.addEventListener && !D("Presto")) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| Channel = function() { | |
| /** @type {!Element} */ | |
| var a = document.createElement("IFRAME"); | |
| a.style.display = ad; | |
| /** @type {string} */ | |
| a.src = ""; | |
| document.documentElement.appendChild(a); | |
| var window = a.contentWindow; | |
| a = window.document; | |
| a.open(); | |
| a.write(""); | |
| a.close(); | |
| /** @type {string} */ | |
| var asyncMsg = "callImmediate" + Math.random(); | |
| /** @type {string} */ | |
| var origin = "file:" == window.location.protocol ? "*" : window.location.protocol + "//" + window.location.host; | |
| a = A(function(event) { | |
| if (("*" == origin || event.origin == origin) && event.data == asyncMsg) { | |
| this.port1.onmessage(); | |
| } | |
| }, this); | |
| window.addEventListener("message", a, false); | |
| this.port1 = {}; | |
| this.port2 = { | |
| postMessage : function() { | |
| window.postMessage(asyncMsg, origin); | |
| } | |
| }; | |
| }; | |
| } | |
| if ("undefined" !== typeof Channel && !fg()) { | |
| var channel = new Channel; | |
| var stack = {}; | |
| var previous = stack; | |
| /** | |
| * @return {undefined} | |
| */ | |
| channel.port1.onmessage = function() { | |
| if (xe(stack.next)) { | |
| stack = stack.next; | |
| var length = stack.cg; | |
| /** @type {null} */ | |
| stack.cg = null; | |
| length(); | |
| } | |
| }; | |
| return function(changes) { | |
| previous.next = { | |
| cg : changes | |
| }; | |
| previous = previous.next; | |
| channel.port2.postMessage(0); | |
| }; | |
| } | |
| return "undefined" !== typeof document && "onreadystatechange" in document.createElement(xa) ? function(notify_success) { | |
| /** @type {!Element} */ | |
| var v = document.createElement(xa); | |
| /** | |
| * @return {undefined} | |
| */ | |
| v.onreadystatechange = function() { | |
| /** @type {null} */ | |
| v.onreadystatechange = null; | |
| v.parentNode.removeChild(v); | |
| /** @type {null} */ | |
| v = null; | |
| notify_success(); | |
| /** @type {null} */ | |
| notify_success = null; | |
| }; | |
| document.documentElement.appendChild(v); | |
| } : function(name) { | |
| z.setTimeout(name, 0); | |
| }; | |
| }; | |
| var zk = new tk(function() { | |
| return new yk; | |
| }, function(applyViewModelsSpy) { | |
| applyViewModelsSpy.reset(); | |
| }, 100); | |
| /** | |
| * @return {?} | |
| */ | |
| var Bk = function() { | |
| var face = Ak; | |
| /** @type {null} */ | |
| var a = null; | |
| if (face.a) { | |
| a = face.a; | |
| face.a = face.a.next; | |
| if (!face.a) { | |
| /** @type {null} */ | |
| face.b = null; | |
| } | |
| /** @type {null} */ | |
| a.next = null; | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var yk = function() { | |
| /** @type {null} */ | |
| this.next = this.b = this.a = null; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} obj | |
| * @return {undefined} | |
| */ | |
| yk.prototype.set = function(value, obj) { | |
| /** @type {string} */ | |
| this.a = value; | |
| /** @type {string} */ | |
| this.b = obj; | |
| /** @type {null} */ | |
| this.next = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| yk.prototype.reset = function() { | |
| /** @type {null} */ | |
| this.next = this.b = this.a = null; | |
| }; | |
| /** | |
| * @param {boolean} m | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Fk = function(m, b) { | |
| if (!Ck) { | |
| Dk(); | |
| } | |
| if (!Ek) { | |
| Ck(); | |
| /** @type {boolean} */ | |
| Ek = true; | |
| } | |
| var _ = Ak; | |
| var a = zk.get(); | |
| a.set(m, b); | |
| if (_.b) { | |
| _.b.next = a; | |
| } else { | |
| _.a = a; | |
| } | |
| _.b = a; | |
| }; | |
| var Ck; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Dk = function() { | |
| if (z.Promise && z.Promise.resolve) { | |
| var loadPropPromise = z.Promise.resolve(void 0); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ck = function() { | |
| loadPropPromise.then(Gk); | |
| }; | |
| } else { | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ck = function() { | |
| /** @type {function(): undefined} */ | |
| var f = Gk; | |
| if (!He(z.setImmediate) || z.Window && z.Window.prototype && !D(ra) && z.Window.prototype.setImmediate == z.setImmediate) { | |
| if (!wk) { | |
| wk = xk(); | |
| } | |
| wk(f); | |
| } else { | |
| z.setImmediate(f); | |
| } | |
| }; | |
| } | |
| }; | |
| /** @type {boolean} */ | |
| var Ek = false; | |
| var Ak = new function() { | |
| /** @type {null} */ | |
| this.b = this.a = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Gk = function() { | |
| var a; | |
| for (; a = Bk();) { | |
| try { | |
| a.a.call(a.b); | |
| } catch (setTrailViewOffset) { | |
| vk(setTrailViewOffset); | |
| } | |
| uk(zk, a); | |
| } | |
| /** @type {boolean} */ | |
| Ek = false; | |
| }; | |
| /** | |
| * @param {!Function} ctor | |
| * @return {undefined} | |
| */ | |
| var Hk = function(ctor) { | |
| ctor.prototype.then = ctor.prototype.then; | |
| /** @type {boolean} */ | |
| ctor.prototype.$goog_Thenable = true; | |
| }; | |
| /** | |
| * @param {?} object | |
| * @return {?} | |
| */ | |
| var Ik = function(object) { | |
| if (!object) { | |
| return false; | |
| } | |
| try { | |
| return !!object.$goog_Thenable; | |
| } catch (b) { | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var Kk = function(a, b) { | |
| /** @type {number} */ | |
| this.a = 0; | |
| this.o = void 0; | |
| /** @type {null} */ | |
| this.g = this.b = this.c = null; | |
| /** @type {boolean} */ | |
| this.j = this.m = false; | |
| if (a != Ae) { | |
| try { | |
| var valueProgess = this; | |
| a.call(b, function(mercatorX) { | |
| Jk(valueProgess, 2, mercatorX); | |
| }, function(mercatorX) { | |
| Jk(valueProgess, 3, mercatorX); | |
| }); | |
| } catch (isCreditCard_1) { | |
| Jk(this, 3, isCreditCard_1); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Lk = function() { | |
| /** @type {null} */ | |
| this.next = this.c = this.b = this.g = this.a = null; | |
| /** @type {boolean} */ | |
| this.j = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Lk.prototype.reset = function() { | |
| /** @type {null} */ | |
| this.c = this.b = this.g = this.a = null; | |
| /** @type {boolean} */ | |
| this.j = false; | |
| }; | |
| var Mk = new tk(function() { | |
| return new Lk; | |
| }, function(applyViewModelsSpy) { | |
| applyViewModelsSpy.reset(); | |
| }, 100); | |
| /** | |
| * @param {string} g | |
| * @param {string} b | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var Nk = function(g, b, c) { | |
| var state = Mk.get(); | |
| /** @type {string} */ | |
| state.g = g; | |
| /** @type {string} */ | |
| state.b = b; | |
| /** @type {string} */ | |
| state.c = c; | |
| return state; | |
| }; | |
| /** | |
| * @param {string} f | |
| * @param {boolean} a | |
| * @param {!Object} func | |
| * @return {?} | |
| */ | |
| Kk.prototype.then = function(f, a, func) { | |
| return Ok(this, He(f) ? f : null, He(a) ? a : null, func); | |
| }; | |
| Hk(Kk); | |
| /** | |
| * @param {string} el | |
| * @return {undefined} | |
| */ | |
| Kk.prototype.cancel = function(el) { | |
| if (0 == this.a) { | |
| Fk(function() { | |
| var childIterator = new Pk(el); | |
| Qk(this, childIterator); | |
| }, this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} tension | |
| * @return {undefined} | |
| */ | |
| var Qk = function(a, tension) { | |
| if (0 == a.a) { | |
| if (a.c) { | |
| var c = a.c; | |
| if (c.b) { | |
| /** @type {number} */ | |
| var p = 0; | |
| /** @type {null} */ | |
| var value = null; | |
| /** @type {null} */ | |
| var paths = null; | |
| var b = c.b; | |
| for (; b && (b.j || (p++, b.a == a && (value = b), !(value && 1 < p))); b = b.next) { | |
| if (!value) { | |
| paths = b; | |
| } | |
| } | |
| if (value) { | |
| if (0 == c.a && 1 == p) { | |
| Qk(c, tension); | |
| } else { | |
| if (paths) { | |
| p = paths; | |
| if (p.next == c.g) { | |
| c.g = p; | |
| } | |
| p.next = p.next.next; | |
| } else { | |
| Rk(c); | |
| } | |
| Sk(c, value, 3, tension); | |
| } | |
| } | |
| } | |
| /** @type {null} */ | |
| a.c = null; | |
| } else { | |
| Jk(a, 3, tension); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Uk = function(a, b) { | |
| if (!(a.b || 2 != a.a && 3 != a.a)) { | |
| Tk(a); | |
| } | |
| if (a.g) { | |
| /** @type {string} */ | |
| a.g.next = b; | |
| } else { | |
| /** @type {string} */ | |
| a.b = b; | |
| } | |
| /** @type {string} */ | |
| a.g = b; | |
| }; | |
| /** | |
| * @param {string} f | |
| * @param {!Function} p | |
| * @param {!Function} i | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var Ok = function(f, p, i, v) { | |
| var e = Nk(null, null, null); | |
| e.a = new Kk(function(f, block) { | |
| e.g = p ? function(name) { | |
| try { | |
| var foo = p.call(v, name); | |
| f(foo); | |
| } catch (n) { | |
| block(n); | |
| } | |
| } : f; | |
| e.b = i ? function(name) { | |
| try { | |
| var foo = i.call(v, name); | |
| if (!xe(foo) && name instanceof Pk) { | |
| block(name); | |
| } else { | |
| f(foo); | |
| } | |
| } catch (n) { | |
| block(n); | |
| } | |
| } : block; | |
| }); | |
| /** @type {string} */ | |
| e.a.c = f; | |
| Uk(f, e); | |
| return e.a; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Kk.prototype.C = function(name) { | |
| /** @type {number} */ | |
| this.a = 0; | |
| Jk(this, 2, name); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Kk.prototype.w = function(name) { | |
| /** @type {number} */ | |
| this.a = 0; | |
| Jk(this, 3, name); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} action | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var Jk = function(a, action, x) { | |
| if (0 == a.a) { | |
| if (a === x) { | |
| /** @type {number} */ | |
| action = 3; | |
| /** @type {!TypeError} */ | |
| x = new TypeError("Promise cannot resolve to itself"); | |
| } | |
| /** @type {number} */ | |
| a.a = 1; | |
| var d; | |
| a: { | |
| /** @type {!Object} */ | |
| var e = x; | |
| var f = a.C; | |
| var c = a.w; | |
| if (e instanceof Kk) { | |
| Uk(e, Nk(f || Ae, c || null, a)); | |
| /** @type {boolean} */ | |
| d = true; | |
| } else { | |
| if (Ik(e)) { | |
| e.then(f, c, a); | |
| /** @type {boolean} */ | |
| d = true; | |
| } else { | |
| if (Ie(e)) { | |
| try { | |
| var h = e.then; | |
| if (He(h)) { | |
| Vk(e, h, f, c, a); | |
| /** @type {boolean} */ | |
| d = true; | |
| break a; | |
| } | |
| } catch (gotMessage) { | |
| c.call(a, gotMessage); | |
| /** @type {boolean} */ | |
| d = true; | |
| break a; | |
| } | |
| } | |
| /** @type {boolean} */ | |
| d = false; | |
| } | |
| } | |
| } | |
| if (!d) { | |
| /** @type {!Object} */ | |
| a.o = x; | |
| /** @type {number} */ | |
| a.a = action; | |
| /** @type {null} */ | |
| a.c = null; | |
| Tk(a); | |
| if (!(3 != action || x instanceof Pk)) { | |
| Wk(a, x); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} obj | |
| * @param {!Function} h | |
| * @param {!Function} f | |
| * @param {!Function} c | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| var Vk = function(obj, h, f, c, t) { | |
| /** @type {boolean} */ | |
| var d = false; | |
| /** | |
| * @param {?} name | |
| * @return {undefined} | |
| */ | |
| var opcode = function(name) { | |
| if (!d) { | |
| /** @type {boolean} */ | |
| d = true; | |
| f.call(t, name); | |
| } | |
| }; | |
| /** | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var local = function(cb) { | |
| if (!d) { | |
| /** @type {boolean} */ | |
| d = true; | |
| c.call(t, cb); | |
| } | |
| }; | |
| try { | |
| h.call(obj, opcode, local); | |
| } catch (done) { | |
| local(done); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Tk = function(a) { | |
| if (!a.m) { | |
| /** @type {boolean} */ | |
| a.m = true; | |
| Fk(a.B, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Rk = function(b) { | |
| /** @type {null} */ | |
| var a = null; | |
| if (b.b) { | |
| a = b.b; | |
| b.b = a.next; | |
| /** @type {null} */ | |
| a.next = null; | |
| } | |
| if (!b.b) { | |
| /** @type {null} */ | |
| b.g = null; | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Kk.prototype.B = function() { | |
| var QueryLanguageComponent; | |
| for (; QueryLanguageComponent = Rk(this);) { | |
| Sk(this, QueryLanguageComponent, this.a, this.o); | |
| } | |
| /** @type {boolean} */ | |
| this.m = false; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @param {number} c | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| var Sk = function(a, b, c, t) { | |
| if (3 == c && b.b && !b.j) { | |
| for (; a && a.j; a = a.c) { | |
| /** @type {boolean} */ | |
| a.j = false; | |
| } | |
| } | |
| if (b.a) { | |
| /** @type {null} */ | |
| b.a.c = null; | |
| Xk(b, c, t); | |
| } else { | |
| try { | |
| if (b.j) { | |
| b.g.call(b.c); | |
| } else { | |
| Xk(b, c, t); | |
| } | |
| } catch (bubbled_sets__3355) { | |
| Yk.call(null, bubbled_sets__3355); | |
| } | |
| } | |
| uk(Mk, b); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} result | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Xk = function(a, result, b) { | |
| if (2 == result) { | |
| a.g.call(a.c, b); | |
| } else { | |
| if (a.b) { | |
| a.b.call(a.c, b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {!Object} dim | |
| * @return {undefined} | |
| */ | |
| var Wk = function(val, dim) { | |
| /** @type {boolean} */ | |
| val.j = true; | |
| Fk(function() { | |
| if (val.j) { | |
| Yk.call(null, dim); | |
| } | |
| }); | |
| }; | |
| /** @type {function(?): undefined} */ | |
| var Yk = vk; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var Pk = function(p1__3354_SHARP_) { | |
| Qe.call(this, p1__3354_SHARP_); | |
| }; | |
| C(Pk, Qe); | |
| /** @type {string} */ | |
| Pk.prototype.name = "cancel"; | |
| /** | |
| * @param {number} s | |
| * @param {string} axe | |
| * @return {undefined} | |
| */ | |
| var Zk = function(s, axe) { | |
| V.call(this); | |
| this.g = s || 1; | |
| this.c = axe || z; | |
| this.j = A(this.o, this); | |
| this.m = Pe(); | |
| }; | |
| C(Zk, V); | |
| /** @type {boolean} */ | |
| Zk.prototype.b = false; | |
| /** @type {null} */ | |
| Zk.prototype.a = null; | |
| /** | |
| * @param {!Object} o | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var bl = function(o, c) { | |
| /** @type {number} */ | |
| o.g = c; | |
| if (o.a && o.b) { | |
| $k(o); | |
| al(o); | |
| } else { | |
| if (o.a) { | |
| $k(o); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Zk.prototype.o = function() { | |
| if (this.b) { | |
| /** @type {number} */ | |
| var now = Pe() - this.m; | |
| if (0 < now && now < .8 * this.g) { | |
| this.a = this.c.setTimeout(this.j, this.g - now); | |
| } else { | |
| if (this.a) { | |
| this.c.clearTimeout(this.a); | |
| /** @type {null} */ | |
| this.a = null; | |
| } | |
| this.dispatchEvent("tick"); | |
| if (this.b) { | |
| this.a = this.c.setTimeout(this.j, this.g); | |
| this.m = Pe(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var al = function(self) { | |
| /** @type {boolean} */ | |
| self.b = true; | |
| if (!self.a) { | |
| self.a = self.c.setTimeout(self.j, self.g); | |
| self.m = Pe(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var $k = function(self) { | |
| /** @type {boolean} */ | |
| self.b = false; | |
| if (self.a) { | |
| self.c.clearTimeout(self.a); | |
| /** @type {null} */ | |
| self.a = null; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Zk.prototype.J = function() { | |
| Zk.v.J.call(this); | |
| $k(this); | |
| delete this.c; | |
| }; | |
| /** | |
| * @param {!Function} f | |
| * @param {number} val | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var cl = function(f, val, data) { | |
| if (He(f)) { | |
| if (data) { | |
| f = A(f, data); | |
| } | |
| } else { | |
| if (f && typeof f.handleEvent == Bb) { | |
| f = A(f.handleEvent, f); | |
| } else { | |
| throw Error("Invalid listener argument"); | |
| } | |
| } | |
| return 2147483647 < Number(val) ? -1 : z.setTimeout(f, val || 0); | |
| }; | |
| /** | |
| * @param {?} name | |
| * @return {undefined} | |
| */ | |
| var dl = function(name) { | |
| z.clearTimeout(name); | |
| }; | |
| /** | |
| * @param {?} fn | |
| * @param {?} selector | |
| * @return {undefined} | |
| */ | |
| var el = function(fn, selector) { | |
| T.call(this, "navigate"); | |
| this.F = fn; | |
| this.C = selector; | |
| }; | |
| C(el, T); | |
| /** | |
| * @param {string} id | |
| * @param {!Object} options | |
| * @param {!Object} e | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var kl = function(id, options, e, d) { | |
| V.call(this); | |
| if (id && !options) { | |
| throw Error("Can't use invisible history without providing a blank page."); | |
| } | |
| var x; | |
| if (e) { | |
| /** @type {!Object} */ | |
| x = e; | |
| } else { | |
| x = "history_state" + fl; | |
| var n = Og(wc, { | |
| type : "text", | |
| name : x, | |
| id : x, | |
| style : mg(pb) | |
| }); | |
| document.write(Gg(n)); | |
| x = M(x); | |
| } | |
| this.o = x; | |
| this.b = e ? $h(Ph(e)) : window; | |
| /** @type {!Object} */ | |
| this.F = options; | |
| if (E && !options) { | |
| this.F = "https" == window.location.protocol ? Dg(lg(mg("https:///"))) : Dg(lg(mg('javascript:""'))); | |
| } | |
| this.c = new Zk(150); | |
| Cj(this, this.c); | |
| /** @type {boolean} */ | |
| this.g = !id; | |
| this.a = new nk(this); | |
| if (id || gl) { | |
| var i; | |
| if (d) { | |
| /** @type {!Object} */ | |
| i = d; | |
| } else { | |
| id = "history_iframe" + fl; | |
| d = this.F; | |
| options = { | |
| id : id, | |
| style : mg(pb), | |
| sandbox : void 0 | |
| }; | |
| if (d) { | |
| Bg(d); | |
| } | |
| e = {}; | |
| e.src = d || null; | |
| /** @type {null} */ | |
| e.srcdoc = null; | |
| d = { | |
| sandbox : "" | |
| }; | |
| x = {}; | |
| for (i in e) { | |
| x[i] = e[i]; | |
| } | |
| for (i in d) { | |
| x[i] = d[i]; | |
| } | |
| for (i in options) { | |
| /** @type {string} */ | |
| n = i.toLowerCase(); | |
| if (n in e) { | |
| throw Error('Cannot override "' + n + '" attribute, got "' + i + '" with value "' + options[i] + '"'); | |
| } | |
| if (n in d) { | |
| delete x[n]; | |
| } | |
| x[i] = options[i]; | |
| } | |
| i = Ng("iframe", x, void 0); | |
| document.write(Gg(i)); | |
| i = M(id); | |
| } | |
| this.C = i; | |
| /** @type {boolean} */ | |
| this.K = true; | |
| } | |
| if (gl) { | |
| this.a.a(this.b, "load", this.Vi); | |
| /** @type {boolean} */ | |
| this.A = this.w = false; | |
| } | |
| if (this.g) { | |
| hl(this, il(this), true); | |
| } else { | |
| jl(this, this.o.value); | |
| } | |
| fl++; | |
| }; | |
| C(kl, V); | |
| /** @type {boolean} */ | |
| kl.prototype.B = false; | |
| /** @type {boolean} */ | |
| kl.prototype.m = false; | |
| /** @type {null} */ | |
| kl.prototype.j = null; | |
| var ll = function(f, boardManager) { | |
| var print = boardManager || sk; | |
| return function() { | |
| var freq = this || z; | |
| freq = freq.closure_memoize_cache_ || (freq.closure_memoize_cache_ = {}); | |
| var id = print(Le(f), arguments); | |
| return freq.hasOwnProperty(id) ? freq[id] : freq[id] = f.apply(this, arguments); | |
| }; | |
| }(function() { | |
| return E ? yh(8) : "onhashchange" in z; | |
| }); | |
| var gl = E && !yh(8); | |
| y = kl.prototype; | |
| /** @type {null} */ | |
| y.Qc = null; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| kl.v.J.call(this); | |
| this.a.za(); | |
| this.ba(false); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| y.ba = function(a) { | |
| if (a != this.B) { | |
| if (gl && !this.w) { | |
| /** @type {string} */ | |
| this.A = a; | |
| } else { | |
| if (a) { | |
| if (fh ? this.a.a(this.b.document, ml, this.O) : ih && this.a.a(this.b, "pageshow", this.Zi), ll() && this.g) { | |
| this.a.a(this.b, "hashchange", this.Xi); | |
| /** @type {boolean} */ | |
| this.B = true; | |
| this.dispatchEvent(new el(il(this), false)); | |
| } else { | |
| if (!E || rk() || this.w) { | |
| this.a.a(this.c, "tick", A(this.G, this, true)); | |
| /** @type {boolean} */ | |
| this.B = true; | |
| if (!gl) { | |
| this.j = il(this); | |
| this.dispatchEvent(new el(il(this), false)); | |
| } | |
| al(this.c); | |
| } | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| this.B = false; | |
| pk(this.a); | |
| $k(this.c); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Vi = function() { | |
| /** @type {boolean} */ | |
| this.w = true; | |
| if (this.o.value) { | |
| jl(this, this.o.value, true); | |
| } | |
| this.ba(this.A); | |
| }; | |
| /** | |
| * @param {!Object} settings | |
| * @return {undefined} | |
| */ | |
| y.Zi = function(settings) { | |
| if (settings.b.persisted) { | |
| this.ba(false); | |
| this.ba(true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Xi = function() { | |
| var b = nl(this.b); | |
| if (b != this.j) { | |
| ol(this, b, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var il = function(val) { | |
| return null != val.Qc ? val.Qc : val.g ? nl(val.b) : pl(val) || ""; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var nl = function(value) { | |
| value = value.location.href; | |
| var end = value.indexOf("#"); | |
| return 0 > end ? "" : value.substring(end + 1); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} name | |
| * @param {string} values | |
| * @return {undefined} | |
| */ | |
| var ql = function(node, name, values) { | |
| if (il(node) != name) { | |
| if (node.g) { | |
| hl(node, name, values); | |
| if (!ll()) { | |
| if (E && !rk()) { | |
| jl(node, name, values, void 0); | |
| } | |
| } | |
| if (node.B) { | |
| node.G(false); | |
| } | |
| } else { | |
| jl(node, name, values); | |
| node.Qc = node.j = node.o.value = name; | |
| node.dispatchEvent(new el(name, false)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} loc | |
| * @param {string} id | |
| * @param {string} options | |
| * @return {undefined} | |
| */ | |
| var hl = function(loc, id, options) { | |
| loc = loc.b.location; | |
| var url = loc.href.split("#")[0]; | |
| /** @type {boolean} */ | |
| var dependencies = -1 != loc.href.indexOf("#"); | |
| if (gl || dependencies || id) { | |
| /** @type {string} */ | |
| url = url + ("#" + id); | |
| } | |
| if (url != loc.href) { | |
| if (options) { | |
| loc.replace(url); | |
| } else { | |
| loc.href = url; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {string} c | |
| * @param {string} data | |
| * @param {string} ttl | |
| * @return {undefined} | |
| */ | |
| var jl = function(t, c, data, ttl) { | |
| if (t.K || c != pl(t)) { | |
| if (t.K = false, c = Xe(c), E) { | |
| var x = yi(t.C); | |
| x.open("text/html", data ? "replace" : void 0); | |
| data = Pg(Og(Xd, {}, ttl || t.b.document.title), Og("body", {}, c)); | |
| x.write(Gg(data)); | |
| x.close(); | |
| } else { | |
| if (x = Bg(t.F) + "#" + c, t = t.C.contentWindow) { | |
| if (data) { | |
| t.location.replace(x); | |
| } else { | |
| /** @type {string} */ | |
| t.location.href = x; | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var pl = function(options) { | |
| if (E) { | |
| return options = yi(options.C), options.body ? Ye(options.body.innerHTML) : null; | |
| } | |
| var context = options.C.contentWindow; | |
| if (context) { | |
| var n; | |
| try { | |
| n = Ye(nl(context)); | |
| } catch (d) { | |
| return options.m || (1 != options.m && bl(options.c, 1E4), options.m = true), null; | |
| } | |
| if (options.m) { | |
| if (0 != options.m) { | |
| bl(options.c, 150); | |
| } | |
| /** @type {boolean} */ | |
| options.m = false; | |
| } | |
| return n || null; | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| kl.prototype.G = function(name) { | |
| if (this.g) { | |
| var v2 = nl(this.b); | |
| if (v2 != this.j) { | |
| ol(this, v2, name); | |
| } | |
| } | |
| if (!this.g || gl) { | |
| if (v2 = pl(this) || "", null == this.Qc || v2 == this.Qc) { | |
| /** @type {null} */ | |
| this.Qc = null; | |
| if (v2 != this.j) { | |
| ol(this, v2, name); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @param {string} d | |
| * @param {string} e | |
| * @return {undefined} | |
| */ | |
| var ol = function(p, d, e) { | |
| p.j = p.o.value = d; | |
| if (p.g) { | |
| if (gl) { | |
| jl(p, d); | |
| } | |
| hl(p, d); | |
| } else { | |
| jl(p, d); | |
| } | |
| p.dispatchEvent(new el(il(p), e)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kl.prototype.O = function() { | |
| $k(this.c); | |
| al(this.c); | |
| }; | |
| /** @type {!Array} */ | |
| var ml = [Vc, Ic, Wc]; | |
| /** @type {number} */ | |
| var fl = 0; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var rl = function() { | |
| this.me = new kl; | |
| /** @type {null} */ | |
| this.Rf = null; | |
| /** @type {number} */ | |
| this.a = 0; | |
| U(this.me, "navigate", this.b, false, this); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| rl.prototype.b = function(key) { | |
| if (key.C) { | |
| sl(this, key.F); | |
| } | |
| }; | |
| /** | |
| * @param {?} g | |
| * @param {string} f | |
| * @return {undefined} | |
| */ | |
| var sl = function(g, f) { | |
| var str = Ye(f); | |
| var cur_geocells = str.split(/[|\/]/, 2); | |
| if (2 == cur_geocells.length && (cur_geocells.push(str.substring(cur_geocells[0].length + cur_geocells[1].length + 2)), !Te(pf(cur_geocells[0])) && !Te(pf(cur_geocells[1])))) { | |
| tl(g.Rf, cur_geocells[0], cur_geocells[1], cur_geocells[2], "bh"); | |
| return; | |
| } | |
| tl(g.Rf, "", "", "", "bh"); | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @param {string} tagName | |
| * @param {number} status | |
| * @param {string} e | |
| * @param {string} options | |
| * @return {undefined} | |
| */ | |
| var ul = function(context, tagName, status, e, options) { | |
| /** @type {string} */ | |
| e = (null != tagName ? tagName : Qa) + "/" + (null != status ? status : t) + "/" + Xe(e); | |
| /** @type {number} */ | |
| status = (new Date).getTime(); | |
| if (2E3 < status - context.a) { | |
| ql(context.me, e, false); | |
| } else { | |
| ql(context.me, e, true); | |
| } | |
| /** @type {number} */ | |
| context.a = options ? status : 0; | |
| }; | |
| var vl = D("Firefox"); | |
| var wl = eh() || D(uc); | |
| var xl = D(tc); | |
| var yl = D(na) && !(gg() || D("Firefox") || D(va) || D("Silk")); | |
| var zl = gg(); | |
| var Al = D("Safari") && !(gg() || D("Coast") || D(va) || D(ra) || D("Silk") || D(na)) && !(eh() || D(tc) || D(uc)); | |
| /** | |
| * @param {string} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Cl = function(a, b) { | |
| /** @type {!Array<?>} */ | |
| var keysToSend = Array.prototype.slice.call(arguments); | |
| var module = keysToSend.shift(); | |
| if ("undefined" == typeof module) { | |
| throw Error("[goog.string.format] Template required"); | |
| } | |
| return module.replace(/%([0\- \+]*)(\d+)?(\.(\d+))?([%sfdiu])/g, function(a, b, canCreateDiscussions, isSlidingUp, dontForceConstraints, modelFunctionName, forceExecution, mmCoreSecondsYear) { | |
| if ("%" == modelFunctionName) { | |
| return "%"; | |
| } | |
| var s = keysToSend.shift(); | |
| if ("undefined" == typeof s) { | |
| throw Error("[goog.string.format] Not enough arguments"); | |
| } | |
| arguments[0] = s; | |
| return Bl[modelFunctionName].apply(null, arguments); | |
| }); | |
| }; | |
| var Bl = { | |
| s : function(replacement, str, width) { | |
| return isNaN(width) || "" == width || replacement.length >= Number(width) ? replacement : replacement = -1 < str.indexOf("-", 0) ? replacement + of(" ", Number(width) - replacement.length) : of(" ", Number(width) - replacement.length) + replacement; | |
| }, | |
| f : function(i, name, min, val, c) { | |
| val = i.toString(); | |
| if (!(isNaN(c) || "" == c)) { | |
| /** @type {string} */ | |
| val = parseFloat(i).toFixed(c); | |
| } | |
| var value; | |
| /** @type {string} */ | |
| value = 0 > Number(i) ? "-" : 0 <= name.indexOf("+") ? "+" : 0 <= name.indexOf(" ") ? " " : ""; | |
| if (0 <= Number(i)) { | |
| /** @type {string} */ | |
| val = value + val; | |
| } | |
| if (isNaN(min) || val.length >= Number(min)) { | |
| return val; | |
| } | |
| /** @type {string} */ | |
| val = isNaN(c) ? Math.abs(Number(i)).toString() : Math.abs(Number(i)).toFixed(c); | |
| /** @type {number} */ | |
| i = Number(min) - val.length - value.length; | |
| return val = 0 <= name.indexOf("-", 0) ? value + val + of(" ", i) : value + of(0 <= name.indexOf("0", 0) ? "0" : " ", i) + val; | |
| }, | |
| d : function(item, key, opts, d, cb, n, v, s) { | |
| return Bl.f(parseInt(item, 10), key, opts, d, 0, n, v, s); | |
| } | |
| }; | |
| /** @type {function(?, string, ?, string, ?, ?, ?, ?): ?} */ | |
| Bl.i = Bl.d; | |
| /** @type {function(?, string, ?, string, ?, ?, ?, ?): ?} */ | |
| Bl.u = Bl.d; | |
| var Dl = ue(); | |
| Be(Dl); | |
| /** @type {number} */ | |
| Dl.prototype.a = 0; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var W = function(a) { | |
| V.call(this); | |
| this.a = a || Qh(); | |
| this.Ma = El; | |
| /** @type {null} */ | |
| this.Ga = null; | |
| /** @type {boolean} */ | |
| this.sa = false; | |
| /** @type {null} */ | |
| this.D = null; | |
| this.O = void 0; | |
| /** @type {null} */ | |
| this.G = this.B = this.C = this.wa = null; | |
| /** @type {boolean} */ | |
| this.Gb = false; | |
| }; | |
| C(W, V); | |
| W.prototype.Yc = Dl.M(); | |
| /** @type {null} */ | |
| var El = null; | |
| /** | |
| * @param {number} name | |
| * @param {boolean} value | |
| * @return {?} | |
| */ | |
| var Fl = function(name, value) { | |
| switch(name) { | |
| case 1: | |
| return value ? "disable" : "enable"; | |
| case 2: | |
| return value ? qc : je; | |
| case 4: | |
| return value ? "activate" : "deactivate"; | |
| case 8: | |
| return value ? ud : "unselect"; | |
| case 16: | |
| return value ? "check" : "uncheck"; | |
| case 32: | |
| return value ? wb : Va; | |
| case 64: | |
| return value ? "open" : "close"; | |
| } | |
| throw Error("Invalid component state"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| W.prototype.F = function() { | |
| return this.Ga || (this.Ga = ":" + (this.Yc.a++).toString(36)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Gl = function(a, b) { | |
| if (a.C && a.C.G) { | |
| var mkDirCache = a.C.G; | |
| var d = a.Ga; | |
| if (d in mkDirCache) { | |
| delete mkDirCache[d]; | |
| } | |
| Tf(a.C.G, b, a); | |
| } | |
| /** @type {string} */ | |
| a.Ga = b; | |
| }; | |
| W.prototype.l = w("D"); | |
| /** | |
| * @param {(number|string)} args | |
| * @param {string} array | |
| * @return {?} | |
| */ | |
| var Hl = function(args, array) { | |
| return args.D ? O(array, args.D || args.a.a) : null; | |
| }; | |
| /** | |
| * @param {!Object} elem | |
| * @return {?} | |
| */ | |
| var X = function(elem) { | |
| if (!elem.O) { | |
| elem.O = new nk(elem); | |
| } | |
| return elem.O; | |
| }; | |
| /** | |
| * @param {string} node | |
| * @param {string} parent | |
| * @return {undefined} | |
| */ | |
| var Jl = function(node, parent) { | |
| if (node == parent) { | |
| throw Error(Ea); | |
| } | |
| if (parent && node.C && node.Ga && Il(node.C, node.Ga) && node.C != parent) { | |
| throw Error(Ea); | |
| } | |
| /** @type {string} */ | |
| node.C = parent; | |
| W.v.Uc.call(node, parent); | |
| }; | |
| W.prototype.K = w("C"); | |
| /** | |
| * @param {?} selector | |
| * @return {undefined} | |
| */ | |
| W.prototype.Uc = function(selector) { | |
| if (this.C && this.C != selector) { | |
| throw Error("Method not supported"); | |
| } | |
| W.v.Uc.call(this, selector); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| W.prototype.ra = function() { | |
| this.D = Ji(this.a, k); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| W.prototype.aa = function(key) { | |
| Kl(this, key); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} input | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var Kl = function(options, input, type) { | |
| if (options.sa) { | |
| throw Error(pa); | |
| } | |
| if (!options.D) { | |
| options.ra(); | |
| } | |
| if (input) { | |
| input.insertBefore(options.D, type || null); | |
| } else { | |
| options.a.a.body.appendChild(options.D); | |
| } | |
| if (!(options.C && !options.C.sa)) { | |
| options.V(); | |
| } | |
| }; | |
| y = W.prototype; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| y.R = function(a) { | |
| if (this.sa) { | |
| throw Error(pa); | |
| } | |
| if (a && this.Wd(a)) { | |
| /** @type {boolean} */ | |
| this.Gb = true; | |
| var i = Ph(a); | |
| if (!(this.a && this.a.a == i)) { | |
| this.a = Qh(a); | |
| } | |
| this.Y(a); | |
| this.V(); | |
| } else { | |
| throw Error("Invalid element to decorate"); | |
| } | |
| }; | |
| y.Wd = x(true); | |
| y.Y = ve("D"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| /** @type {boolean} */ | |
| this.sa = true; | |
| Ll(this, function(options) { | |
| if (!options.sa && options.l()) { | |
| options.V(); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ya = function() { | |
| Ll(this, function(v) { | |
| if (v.sa) { | |
| v.Ya(); | |
| } | |
| }); | |
| if (this.O) { | |
| pk(this.O); | |
| } | |
| /** @type {boolean} */ | |
| this.sa = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| if (this.sa) { | |
| this.Ya(); | |
| } | |
| if (this.O) { | |
| this.O.za(); | |
| delete this.O; | |
| } | |
| Ll(this, function(a) { | |
| a.za(); | |
| }); | |
| if (!this.Gb && this.D) { | |
| mi(this.D); | |
| } | |
| /** @type {null} */ | |
| this.C = this.wa = this.D = this.G = this.B = null; | |
| W.v.J.call(this); | |
| }; | |
| /** | |
| * @param {number} val | |
| * @param {boolean} r | |
| * @return {undefined} | |
| */ | |
| y.Ia = function(val, r) { | |
| this.Zc(val, Ml(this), r); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {number} c | |
| * @param {!Object} g | |
| * @return {undefined} | |
| */ | |
| y.Zc = function(o, c, g) { | |
| if (o.sa && (g || !this.sa)) { | |
| throw Error(pa); | |
| } | |
| if (0 > c || c > Ml(this)) { | |
| throw Error("Child component index out of bounds"); | |
| } | |
| if (!(this.G && this.B)) { | |
| this.G = {}; | |
| /** @type {!Array} */ | |
| this.B = []; | |
| } | |
| if (o.K() == this) { | |
| var i = o.F(); | |
| /** @type {!Object} */ | |
| this.G[i] = o; | |
| Hf(this.B, o); | |
| } else { | |
| Tf(this.G, o.F(), o); | |
| } | |
| Jl(o, this); | |
| Mf(this.B, c, 0, o); | |
| if (o.sa && this.sa && o.K() == this) { | |
| g = this.yb(); | |
| c = g.childNodes[c] || null; | |
| if (c != o.l()) { | |
| g.insertBefore(o.l(), c); | |
| } | |
| } else { | |
| if (g) { | |
| if (!this.D) { | |
| this.ra(); | |
| } | |
| c = Nl(this, c + 1); | |
| Kl(o, this.yb(), c ? c.D : null); | |
| } else { | |
| if (this.sa && !o.sa && o.D && o.D.parentNode && 1 == o.D.parentNode.nodeType) { | |
| o.V(); | |
| } | |
| } | |
| } | |
| }; | |
| y.yb = w("D"); | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var Ol = function(options) { | |
| if (null == options.Ma) { | |
| options.Ma = nj(options.sa ? options.D : options.a.a.body); | |
| } | |
| return options.Ma; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Ml = function(obj) { | |
| return obj.B ? obj.B.length : 0; | |
| }; | |
| /** | |
| * @param {!Window} color | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Il = function(color, b) { | |
| var x; | |
| if (color.G && b) { | |
| x = color.G; | |
| x = (null !== x && b in x ? x[b] : void 0) || null; | |
| } else { | |
| /** @type {null} */ | |
| x = null; | |
| } | |
| return x; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Nl = function(obj, i) { | |
| return obj.B ? obj.B[i] || null : null; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Function} i | |
| * @param {!Object} tensor2 | |
| * @return {undefined} | |
| */ | |
| var Ll = function(a, i, tensor2) { | |
| if (a.B) { | |
| xf(a.B, i, tensor2); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} s | |
| * @return {?} | |
| */ | |
| var Pl = function(a, s) { | |
| return a.B && s ? wf(a.B, s) : -1; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @param {boolean} options | |
| * @return {?} | |
| */ | |
| W.prototype.removeChild = function(element, options) { | |
| if (element) { | |
| var target = Fe(element) ? element : element.F(); | |
| element = Il(this, target); | |
| if (target && element) { | |
| var translation = this.G; | |
| if (target in translation) { | |
| delete translation[target]; | |
| } | |
| Hf(this.B, element); | |
| if (options) { | |
| element.Ya(); | |
| if (element.D) { | |
| mi(element.D); | |
| } | |
| } | |
| Jl(element, null); | |
| } | |
| } | |
| if (!element) { | |
| throw Error("Child is not in parent component"); | |
| } | |
| return element; | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {undefined} | |
| */ | |
| var Ql = function(m) { | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| for (; m.B && 0 != m.B.length;) { | |
| newNodeLists.push(m.removeChild(Nl(m, 0), true)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var Sl = function(data) { | |
| /** @type {!Object} */ | |
| var files = data; | |
| if (data instanceof Array) { | |
| /** @type {!Array} */ | |
| files = Array(data.length); | |
| Rl(files, data); | |
| } else { | |
| if (data instanceof Object) { | |
| var nonDuplicateIds = files = {}; | |
| var j; | |
| for (j in data) { | |
| if (data.hasOwnProperty(j)) { | |
| nonDuplicateIds[j] = Sl(data[j]); | |
| } | |
| } | |
| } | |
| } | |
| return files; | |
| }; | |
| /** | |
| * @param {!NodeList} set | |
| * @param {!Object} array | |
| * @return {undefined} | |
| */ | |
| var Rl = function(set, array) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < array.length; ++i) { | |
| if (array.hasOwnProperty(i)) { | |
| set[i] = Sl(array[i]); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} rawPads | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Tl = function(rawPads, i) { | |
| if (!rawPads[i]) { | |
| /** @type {!Array} */ | |
| rawPads[i] = []; | |
| } | |
| return rawPads[i]; | |
| }; | |
| /** | |
| * @param {!NodeList} v | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Y = function(v, i) { | |
| return v[i] ? v[i].length : 0; | |
| }; | |
| /** | |
| * @param {!Object} actual | |
| * @param {!Object} expected | |
| * @return {?} | |
| */ | |
| var Vl = function(actual, expected) { | |
| if (null == actual || null == expected) { | |
| return null == actual == (null == expected); | |
| } | |
| if (actual.constructor != Array && actual.constructor != Object) { | |
| throw Error("Invalid object type passed into JsProto.areObjectsEqual()"); | |
| } | |
| if (actual === expected) { | |
| return true; | |
| } | |
| if (actual.constructor != expected.constructor) { | |
| return false; | |
| } | |
| var p; | |
| for (p in actual) { | |
| if (!(p in expected && Ul(actual[p], expected[p]))) { | |
| return false; | |
| } | |
| } | |
| var x; | |
| for (x in expected) { | |
| if (!(x in actual)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Ul = function(a, b) { | |
| if (a === b || !(true !== a && 1 !== a || true !== b && 1 !== b) || !(false !== a && 0 !== a || false !== b && 0 !== b)) { | |
| return true; | |
| } | |
| if (a instanceof Object && b instanceof Object) { | |
| if (!Vl(a, b)) { | |
| return false; | |
| } | |
| } else { | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} tokType | |
| * @param {string} v | |
| * @return {undefined} | |
| */ | |
| var Wl = function(tokType, v) { | |
| /** @type {!Object} */ | |
| this.type = tokType; | |
| /** @type {string} */ | |
| this.label = v; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| var Xl = function(key) { | |
| new Wl(key, 1); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| var Yl = function(key) { | |
| new Wl(key, 2); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| var Zl = function(key) { | |
| new Wl(key, 3); | |
| }; | |
| Xl("d"); | |
| Yl("d"); | |
| Zl("d"); | |
| Xl("f"); | |
| Yl("f"); | |
| Zl("f"); | |
| Xl("i"); | |
| Yl("i"); | |
| Zl("i"); | |
| Xl("j"); | |
| Yl("j"); | |
| Zl("j"); | |
| Xl("u"); | |
| Yl("u"); | |
| Zl("u"); | |
| Xl("v"); | |
| Yl("v"); | |
| Zl("v"); | |
| Xl("b"); | |
| Yl("b"); | |
| Zl("b"); | |
| Xl("e"); | |
| Yl("e"); | |
| Zl("e"); | |
| Xl("s"); | |
| Yl("s"); | |
| Zl("s"); | |
| Xl("B"); | |
| Yl("B"); | |
| Zl("B"); | |
| Xl("x"); | |
| Yl("x"); | |
| Zl("x"); | |
| Xl("y"); | |
| Yl("y"); | |
| Zl("y"); | |
| Xl("g"); | |
| Yl("g"); | |
| Zl("g"); | |
| Xl("h"); | |
| Yl("h"); | |
| Zl("h"); | |
| Xl("n"); | |
| Yl("n"); | |
| Zl("n"); | |
| Xl("o"); | |
| Yl("o"); | |
| Zl("o"); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var $l = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var am = function(a) { | |
| this.a = a || []; | |
| }; | |
| $l.prototype.b = w("a"); | |
| am.prototype.b = w("a"); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var bm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var cm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var dm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {!Array} text | |
| * @return {undefined} | |
| */ | |
| var em = function(text) { | |
| this.kb = text || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var fm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} height | |
| * @return {undefined} | |
| */ | |
| var gm = function(height) { | |
| this.g = height || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var hm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} callback | |
| * @return {undefined} | |
| */ | |
| var im = function(callback) { | |
| this.g = callback || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var jm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} g | |
| * @return {undefined} | |
| */ | |
| var km = function(g) { | |
| this.g = g || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var lm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var mm = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {number} ast | |
| * @return {undefined} | |
| */ | |
| var nm = function(ast) { | |
| this.Sf = ast || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var om = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var pm = function(a) { | |
| this.a = a || []; | |
| }; | |
| bm.prototype.b = w("a"); | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var qm = function(v) { | |
| v = v.a[0]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} e | |
| * @return {?} | |
| */ | |
| var rm = function(e) { | |
| e = e.a[4]; | |
| return null != e ? e : ""; | |
| }; | |
| /** | |
| * @param {number} e | |
| * @return {?} | |
| */ | |
| var sm = function(e) { | |
| e = e.a[5]; | |
| return null != e ? e : 0; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var tm = function(v) { | |
| return Y(v.a, 2); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {number} direction | |
| * @return {?} | |
| */ | |
| var um = function(v, direction) { | |
| return new cm(Tl(v.a, 2)[direction]); | |
| }; | |
| /** | |
| * @param {(number|string)} obj | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| var vm = function(obj, name) { | |
| return new dm(Tl(obj.a, 3)[name]); | |
| }; | |
| cm.prototype.b = w("a"); | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var wm = function(v) { | |
| v = v.a[0]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {number} val | |
| * @return {?} | |
| */ | |
| var xm = function(val) { | |
| val = val.a[1]; | |
| return null != val ? val : 0; | |
| }; | |
| /** | |
| * @param {string} defaultTagAttributes | |
| * @return {?} | |
| */ | |
| var ym = function(defaultTagAttributes) { | |
| defaultTagAttributes = defaultTagAttributes.a[2]; | |
| return null != defaultTagAttributes ? defaultTagAttributes : false; | |
| }; | |
| dm.prototype.b = w("a"); | |
| /** | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var zm = function(b) { | |
| b = b.a[0]; | |
| return null != b ? b : 0; | |
| }; | |
| /** | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Am = function(b) { | |
| b = b.a[1]; | |
| return null != b ? b : 0; | |
| }; | |
| em.prototype.b = w("kb"); | |
| /** | |
| * @return {?} | |
| */ | |
| em.prototype.Ta = function() { | |
| var city = this.kb[0]; | |
| return null != city ? city : ""; | |
| }; | |
| /** | |
| * @param {string} descr | |
| * @return {?} | |
| */ | |
| var Bm = function(descr) { | |
| descr = descr.kb[1]; | |
| return null != descr ? descr : ""; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var Cm = function(v) { | |
| v = v.kb[3]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {number} c | |
| * @return {?} | |
| */ | |
| var Dm = function(c) { | |
| c = c.kb[4]; | |
| return null != c ? c : 0; | |
| }; | |
| fm.prototype.b = w("a"); | |
| /** | |
| * @param {(number|string)} m | |
| * @param {number} x | |
| * @return {?} | |
| */ | |
| var Em = function(m, x) { | |
| return Tl(m.a, 1)[x]; | |
| }; | |
| gm.prototype.b = w("g"); | |
| /** | |
| * @return {?} | |
| */ | |
| gm.prototype.a = function() { | |
| return Y(this.g, 2); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| gm.prototype.c = function(name) { | |
| return new fm(Tl(this.g, 2)[name]); | |
| }; | |
| hm.prototype.b = w("a"); | |
| im.prototype.b = w("g"); | |
| /** | |
| * @return {?} | |
| */ | |
| im.prototype.a = function() { | |
| return Y(this.g, 1); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| im.prototype.c = function(name) { | |
| return new hm(Tl(this.g, 1)[name]); | |
| }; | |
| jm.prototype.b = w("a"); | |
| /** | |
| * @param {(number|string)} dir | |
| * @param {number} origin | |
| * @return {?} | |
| */ | |
| var Fm = function(dir, origin) { | |
| return Tl(dir.a, 0)[origin]; | |
| }; | |
| km.prototype.b = w("g"); | |
| /** | |
| * @return {?} | |
| */ | |
| km.prototype.a = function() { | |
| return Y(this.g, 1); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| km.prototype.c = function(name) { | |
| return new jm(Tl(this.g, 1)[name]); | |
| }; | |
| lm.prototype.b = w("a"); | |
| mm.prototype.b = w("a"); | |
| nm.prototype.b = w("Sf"); | |
| om.prototype.b = w("a"); | |
| pm.prototype.b = w("a"); | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var Gm = function(v) { | |
| v = v.a[2]; | |
| return null != v ? v : ""; | |
| }; | |
| var Hm = new mm; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Im = function(a) { | |
| return (a = a.a[7]) ? new mm(a) : Hm; | |
| }; | |
| var Jm = new nm; | |
| var Km = new am; | |
| var Lm = new lm; | |
| /** | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| var Mm = function(key) { | |
| return (key = key.a[14]) ? new lm(key) : Lm; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var Nm = function(v) { | |
| return Y(v.a, 0); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {?} str | |
| * @return {?} | |
| */ | |
| var Om = function(v, str) { | |
| return new em(Tl(v.a, 0)[str]); | |
| }; | |
| /** | |
| * @param {(number|string)} to | |
| * @param {number} text | |
| * @return {?} | |
| */ | |
| var Pm = function(to, text) { | |
| return new gm(Tl(to.a, 1)[text]); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var Qm = function(v) { | |
| return Y(v.a, 5); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| var Rm = function(v, name) { | |
| return new bm(Tl(v.a, 5)[name]); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var Sm = function(a, b) { | |
| return new km(Tl(a.a, 11)[b]); | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @param {number} area | |
| * @return {?} | |
| */ | |
| var Tm = function(p, area) { | |
| return new im(Tl(p.a, 12)[area]); | |
| }; | |
| /** | |
| * @param {(number|string)} key | |
| * @return {undefined} | |
| */ | |
| var Xm = function(key) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.c = {}; | |
| /** @type {number} */ | |
| var obj = 0; | |
| for (; obj < Y(key.a, 1); obj++) { | |
| var v = Pm(key, obj); | |
| var name; | |
| name = v.g[0]; | |
| name = null != name ? name : ""; | |
| /** @type {string} */ | |
| var i = ""; | |
| if (null != v.g[3]) { | |
| v = v.g[3]; | |
| i = null != v ? v : ""; | |
| } | |
| if (name in this.c) { | |
| name = this.c[name]; | |
| } else { | |
| v = new Um(name, i); | |
| this.c[name] = v; | |
| this.a.push(v); | |
| name = v; | |
| } | |
| /** @type {number} */ | |
| v = 0; | |
| for (; v < Pm(key, obj).a(); v++) { | |
| var result = Pm(key, obj).c(v); | |
| i = result; | |
| i = 0 == Y(i.a, 2) ? -Le(i) : Tl(i.a, 2)[0]; | |
| var value = name; | |
| if (i in value.b) { | |
| i = value.b[i]; | |
| } else { | |
| var data = new Vm; | |
| value.b[i] = data; | |
| value.a.push(data); | |
| i = data; | |
| } | |
| value = result.a[0]; | |
| value = null != value ? value : ""; | |
| data = result.a[4]; | |
| data = null != data ? data : ""; | |
| var length; | |
| if (null != result.a[3]) { | |
| length = result.a[3]; | |
| length = null != length ? length : 0; | |
| } else { | |
| /** @type {number} */ | |
| length = -1; | |
| } | |
| var res; | |
| /** @type {!Array} */ | |
| res = []; | |
| /** @type {number} */ | |
| var s2 = 0; | |
| for (; s2 < Y(result.a, 1); s2++) { | |
| res.push(Em(result, s2)); | |
| } | |
| result = i; | |
| if (!(value in result.b)) { | |
| data = new Wm(value, data, length, res); | |
| result.b[value] = data; | |
| result.a.push(data); | |
| } | |
| this.b |= 1 < i.a.length; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} a | |
| * @return {?} | |
| */ | |
| var Ym = function(a) { | |
| /** @type {number} */ | |
| var b = 0; | |
| /** @type {number} */ | |
| var x = 0; | |
| for (; x < a.a.length; x++) { | |
| var i = a.a[x]; | |
| /** @type {number} */ | |
| var data = 0; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < i.a.length; j++) { | |
| data = data + i.a[j].a.length; | |
| } | |
| b = b + data; | |
| } | |
| /** @type {number} */ | |
| i = x = 0; | |
| for (; i < a.a.length; i++) { | |
| data = a.a[i]; | |
| /** @type {number} */ | |
| var f = j = 0; | |
| for (; f < data.a.length; f++) { | |
| var face = data.a[f]; | |
| /** @type {number} */ | |
| var dups = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < face.a.length; i++) { | |
| /** @type {number} */ | |
| dups = dups + (face.a[i].visible ? 1 : 0); | |
| } | |
| /** @type {number} */ | |
| j = j + dups; | |
| } | |
| /** @type {number} */ | |
| x = x + j; | |
| } | |
| return b - x; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Zm = function(item) { | |
| /** @type {!Array} */ | |
| var _whitespaceCharClass = []; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < item.a.length; j++) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < item.a[j].a.length; i++) { | |
| Array.prototype.push.apply(_whitespaceCharClass, item.a[j].a[i].a); | |
| } | |
| } | |
| return _whitespaceCharClass; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var $m = function(item) { | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < item.a.length; j++) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < item.a[j].a.length; i++) { | |
| item.a[j].a[i].a.sort(function(a, b) { | |
| return b.a - a.a; | |
| }); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} q | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var Um = function(q, value) { | |
| /** @type {string} */ | |
| this.g = q; | |
| /** @type {number} */ | |
| this.c = value; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.b = {}; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Um.prototype.visible = function() { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| if (this.a[i].visible()) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Vm = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.b = {}; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Vm.prototype.visible = function() { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| if (this.a[i].visible) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {string} t | |
| * @param {number} c | |
| * @param {number} a | |
| * @param {string} scalar | |
| * @return {undefined} | |
| */ | |
| var Wm = function(t, c, a, scalar) { | |
| /** @type {string} */ | |
| this.text = t; | |
| /** @type {number} */ | |
| this.c = c; | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {string} */ | |
| this.g = scalar; | |
| /** @type {boolean} */ | |
| this.visible = false; | |
| /** @type {number} */ | |
| this.b = 0; | |
| }; | |
| var an; | |
| /** @type {!Array<string>} */ | |
| var bn = "combobox grid group listbox menu menubar radiogroup row rowgroup tablist textbox toolbar tree treegrid".split(" "); | |
| /** | |
| * @param {!Object} path | |
| * @param {string} node | |
| * @return {undefined} | |
| */ | |
| var cn = function(path, node) { | |
| if (node) { | |
| path.setAttribute(rd, node); | |
| } else { | |
| path.removeAttribute(rd); | |
| } | |
| }; | |
| /** | |
| * @param {?} _ | |
| * @param {string} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var dn = function(_, name, value) { | |
| if (De(value)) { | |
| value = value.join(" "); | |
| } | |
| /** @type {string} */ | |
| var attributeName = "aria-" + name; | |
| if ("" === value || void 0 == value) { | |
| if (!an) { | |
| an = { | |
| atomic : false, | |
| autocomplete : ad, | |
| dropeffect : ad, | |
| haspopup : false, | |
| live : "off", | |
| multiline : false, | |
| multiselectable : false, | |
| orientation : ke, | |
| readonly : false, | |
| relevant : "additions text", | |
| required : false, | |
| sort : ad, | |
| busy : false, | |
| disabled : false, | |
| hidden : false, | |
| invalid : "false" | |
| }; | |
| } | |
| value = an; | |
| if (name in value) { | |
| _.setAttribute(attributeName, value[name]); | |
| } else { | |
| _.removeAttribute(attributeName); | |
| } | |
| } else { | |
| _.setAttribute(attributeName, value); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @param {string} state | |
| * @return {?} | |
| */ | |
| var en = function(element, state) { | |
| var c = element.getAttribute("aria-" + state); | |
| return null == c || void 0 == c ? "" : String(c); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var fn = function(node) { | |
| var mainDivID = en(node, Ia); | |
| return Ph(node).getElementById(mainDivID); | |
| }; | |
| /** | |
| * @param {?} name | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var gn = function(name, a) { | |
| /** @type {string} */ | |
| var result = ""; | |
| if (a) { | |
| result = a.id; | |
| } | |
| dn(name, Ia, result); | |
| }; | |
| var hn = ue(); | |
| var jn; | |
| Be(hn); | |
| /** | |
| * @return {?} | |
| */ | |
| var ln = function() { | |
| var CSS = new kn; | |
| CSS.S = x("jfk-checkbox"); | |
| return CSS; | |
| }; | |
| var mn = { | |
| button : "pressed", | |
| checkbox : $a, | |
| menuitem : wd, | |
| menuitemcheckbox : $a, | |
| menuitemradio : $a, | |
| radio : $a, | |
| tab : wd, | |
| treeitem : wd | |
| }; | |
| hn.prototype.Rb = ue(); | |
| /** | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| hn.prototype.Pa = function(x) { | |
| return x.a.b(k, nn(this, x).join(" "), x.Aa()); | |
| }; | |
| /** | |
| * @param {!Object} callback | |
| * @return {?} | |
| */ | |
| hn.prototype.hb = function(callback) { | |
| return callback; | |
| }; | |
| /** | |
| * @param {!Object} arg | |
| * @param {string} name | |
| * @param {string} alt | |
| * @return {undefined} | |
| */ | |
| var pn = function(arg, name, alt) { | |
| if (arg = arg.l ? arg.l() : arg) { | |
| /** @type {!Array} */ | |
| var h = [name]; | |
| if (E && !I("7")) { | |
| h = on(Ah(arg), name); | |
| h.push(name); | |
| } | |
| (alt ? Ch : Dh)(arg, h); | |
| } | |
| }; | |
| hn.prototype.Kc = x(true); | |
| /** | |
| * @param {!Object} f | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| hn.prototype.R = function(f, val) { | |
| if (val.id) { | |
| Gl(f, val.id); | |
| } | |
| var xml = this.hb(val); | |
| if (xml && xml.firstChild) { | |
| qn(f, xml.firstChild.nextSibling ? Jf(xml.childNodes) : xml.firstChild); | |
| } else { | |
| /** @type {null} */ | |
| f.sc = null; | |
| } | |
| /** @type {number} */ | |
| var notified = 0; | |
| var name = this.S(); | |
| var target = this.S(); | |
| /** @type {boolean} */ | |
| var isCopyAction = false; | |
| /** @type {boolean} */ | |
| var doAll = false; | |
| /** @type {boolean} */ | |
| var imgCenterW = false; | |
| var v = Jf(Ah(val)); | |
| xf(v, function(key) { | |
| if (isCopyAction || key != name) { | |
| if (doAll || key != target) { | |
| /** @type {number} */ | |
| notified = notified | this.c(key); | |
| } else { | |
| /** @type {boolean} */ | |
| doAll = true; | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| isCopyAction = true; | |
| if (target == name) { | |
| /** @type {boolean} */ | |
| doAll = true; | |
| } | |
| } | |
| if (1 == this.c(key) && Ci(xml) && Di(xml)) { | |
| Bi(xml, false); | |
| } | |
| }, this); | |
| f.bc = notified; | |
| if (!isCopyAction) { | |
| v.push(name); | |
| if (target == name) { | |
| /** @type {boolean} */ | |
| doAll = true; | |
| } | |
| } | |
| if (!doAll) { | |
| v.push(target); | |
| } | |
| var salt = f.sb; | |
| if (salt) { | |
| v.push.apply(v, salt); | |
| } | |
| if (E && !I("7")) { | |
| var handle = on(v); | |
| if (0 < handle.length) { | |
| v.push.apply(v, handle); | |
| /** @type {boolean} */ | |
| imgCenterW = true; | |
| } | |
| } | |
| if (!isCopyAction || !doAll || salt || imgCenterW) { | |
| val.className = v.join(" "); | |
| } | |
| return val; | |
| }; | |
| /** | |
| * @param {!Object} module | |
| * @return {undefined} | |
| */ | |
| hn.prototype.Ag = function(module) { | |
| if (Ol(module)) { | |
| this.jf(module.l(), true); | |
| } | |
| if (module.isEnabled()) { | |
| this.Lc(module, module.isVisible()); | |
| } | |
| }; | |
| /** | |
| * @param {string} el | |
| * @param {!Object} value | |
| * @param {string} elem | |
| * @return {undefined} | |
| */ | |
| var rn = function(el, value, elem) { | |
| if (el = elem || el.Rb()) { | |
| elem = value.getAttribute(rd) || null; | |
| if (el != elem) { | |
| cn(value, el); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} callback | |
| * @param {!Object} obj | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var un = function(callback, obj, type) { | |
| if (!obj.isVisible()) { | |
| dn(type, oc, !obj.isVisible()); | |
| } | |
| if (!obj.isEnabled()) { | |
| callback.Cb(type, 1, !obj.isEnabled()); | |
| } | |
| if (sn(obj, 8)) { | |
| callback.Cb(type, 8, tn(obj, 8)); | |
| } | |
| if (sn(obj, 16)) { | |
| callback.Cb(type, 16, obj.Ea()); | |
| } | |
| if (sn(obj, 64)) { | |
| callback.Cb(type, 64, tn(obj, 64)); | |
| } | |
| }; | |
| y = hn.prototype; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| y.Yd = function(name, type) { | |
| pj(name, !type, !E && !fh); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| y.jf = function(name, type) { | |
| pn(name, this.S() + "-rtl", type); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| y.hf = function(value) { | |
| var m; | |
| return sn(value, 32) && (m = value.l()) ? Ci(m) && Di(m) : false; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| y.Lc = function(name, type) { | |
| var a; | |
| if (sn(name, 32) && (a = name.l())) { | |
| if (!type && tn(name, 32)) { | |
| try { | |
| a.blur(); | |
| } catch (d) { | |
| } | |
| if (tn(name, 32)) { | |
| name.Zd(null); | |
| } | |
| } | |
| if ((Ci(a) && Di(a)) != type) { | |
| Bi(a, type); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(v, id) { | |
| S(v, id); | |
| if (v) { | |
| dn(v, oc, !id); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} args | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| y.rc = function(name, args, n) { | |
| var d = name.l(); | |
| if (d) { | |
| var a = this.a(args); | |
| if (a) { | |
| pn(name, a, n); | |
| } | |
| this.Cb(d, args, n); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @param {string} name | |
| * @param {!Function} str | |
| * @return {undefined} | |
| */ | |
| y.Cb = function(key, name, str) { | |
| if (!jn) { | |
| jn = { | |
| 1 : "disabled", | |
| 8 : wd, | |
| 16 : $a, | |
| 64 : "expanded" | |
| }; | |
| } | |
| name = jn[name]; | |
| var type = key.getAttribute(rd) || null; | |
| if (type) { | |
| type = mn[type] || name; | |
| name = name == $a || name == wd ? type : name; | |
| } | |
| if (name) { | |
| dn(key, name, str); | |
| } | |
| }; | |
| /** | |
| * @param {!Element} property | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| y.zb = function(property, value) { | |
| var obj = this.hb(property); | |
| if (obj && (ji(obj), value)) { | |
| if (Fe(value)) { | |
| Q(obj, value); | |
| } else { | |
| /** | |
| * @param {!Object} val | |
| * @return {undefined} | |
| */ | |
| var e = function(val) { | |
| if (val) { | |
| var s = Ph(obj); | |
| obj.appendChild(Fe(val) ? s.createTextNode(val) : val); | |
| } | |
| }; | |
| if (De(value)) { | |
| xf(value, e); | |
| } else { | |
| if (!Ee(value) || "nodeType" in value) { | |
| e(value); | |
| } else { | |
| xf(Jf(value), e); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| y.S = x("goog-control"); | |
| /** | |
| * @param {(number|string)} point | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| var nn = function(point, x) { | |
| var n = point.S(); | |
| /** @type {!Array} */ | |
| var result = [n]; | |
| var target = point.S(); | |
| if (target != n) { | |
| result.push(target); | |
| } | |
| n = x.bc; | |
| /** @type {!Array} */ | |
| target = []; | |
| for (; n;) { | |
| /** @type {number} */ | |
| var type = n & -n; | |
| target.push(point.a(type)); | |
| /** @type {number} */ | |
| n = n & ~type; | |
| } | |
| result.push.apply(result, target); | |
| if (n = x.sb) { | |
| result.push.apply(result, n); | |
| } | |
| if (E && !I("7")) { | |
| result.push.apply(result, on(result)); | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {!Array} test | |
| * @param {string} one | |
| * @return {?} | |
| */ | |
| var on = function(test, one) { | |
| /** @type {!Array} */ | |
| var exports = []; | |
| if (one) { | |
| test = If(test, [one]); | |
| } | |
| xf([], function(res) { | |
| if (!(!Bf(res, Oe(Ef, test)) || one && !Ef(res, one))) { | |
| exports.push(res.join("_")); | |
| } | |
| }); | |
| return exports; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| hn.prototype.a = function(name) { | |
| if (!this.b) { | |
| vn(this); | |
| } | |
| return this.b[name]; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| hn.prototype.c = function(key) { | |
| if (!this.A) { | |
| if (!this.b) { | |
| vn(this); | |
| } | |
| var b = this.b; | |
| var a = {}; | |
| var i; | |
| for (i in b) { | |
| /** @type {string} */ | |
| a[b[i]] = i; | |
| } | |
| this.A = a; | |
| } | |
| /** @type {number} */ | |
| key = parseInt(this.A[key], 10); | |
| return isNaN(key) ? 0 : key; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var vn = function(value) { | |
| var cls = value.S(); | |
| cls.replace(/\xa0|\s/g, " "); | |
| value.b = { | |
| 1 : cls + da, | |
| 2 : cls + "-hover", | |
| 4 : cls + "-active", | |
| 8 : cls + "-selected", | |
| 16 : cls + "-checked", | |
| 32 : cls + "-focused", | |
| 64 : cls + "-open" | |
| }; | |
| }; | |
| var wn = ue(); | |
| C(wn, hn); | |
| Be(wn); | |
| y = wn.prototype; | |
| y.Rb = x(Xa); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} str | |
| * @return {undefined} | |
| */ | |
| y.Cb = function(name, type, str) { | |
| switch(type) { | |
| case 8: | |
| case 16: | |
| dn(name, "pressed", str); | |
| break; | |
| default: | |
| case 64: | |
| case 1: | |
| wn.v.Cb.call(this, name, type, str); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| y.Pa = function(obj) { | |
| var info = wn.v.Pa.call(this, obj); | |
| xn(info, obj.w); | |
| var c = obj.T(); | |
| if (c) { | |
| this.Ud(info, c); | |
| } | |
| if (sn(obj, 16)) { | |
| this.Cb(info, 16, obj.Ea()); | |
| } | |
| return info; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| y.R = function(a, b) { | |
| b = wn.v.R.call(this, a, b); | |
| var bIdx = this.T(b); | |
| a.Wa = bIdx; | |
| a.w = b.title; | |
| if (sn(a, 16)) { | |
| this.Cb(b, 16, a.Ea()); | |
| } | |
| return b; | |
| }; | |
| y.T = Ae; | |
| y.Ud = Ae; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var xn = function(a, b) { | |
| if (a) { | |
| if (b) { | |
| /** @type {string} */ | |
| a.title = b; | |
| } else { | |
| a.removeAttribute(Xd); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} t | |
| * @param {!Object} b | |
| * @param {number} prune | |
| * @return {undefined} | |
| */ | |
| var zn = function(t, b, prune) { | |
| var val = Ol(b); | |
| var e = t.S() + "-collapse-left"; | |
| t = t.S() + "-collapse-right"; | |
| yn(b, val ? t : e, !!(prune & 1)); | |
| yn(b, val ? e : t, !!(prune & 2)); | |
| }; | |
| wn.prototype.S = x("goog-button"); | |
| /** | |
| * @param {!Event} event | |
| * @return {?} | |
| */ | |
| var An = function(event) { | |
| if (event.altKey && !event.ctrlKey || event.metaKey || 112 <= event.keyCode && 123 >= event.keyCode) { | |
| return false; | |
| } | |
| switch(event.keyCode) { | |
| case 18: | |
| case 20: | |
| case 93: | |
| case 17: | |
| case 40: | |
| case 35: | |
| case 27: | |
| case 36: | |
| case 45: | |
| case 37: | |
| case 224: | |
| case 91: | |
| case 144: | |
| case 12: | |
| case 34: | |
| case 33: | |
| case 19: | |
| case 255: | |
| case 44: | |
| case 39: | |
| case 145: | |
| case 16: | |
| case 38: | |
| case 252: | |
| case 224: | |
| case 92: | |
| return false; | |
| case 0: | |
| return !ih; | |
| default: | |
| return 166 > event.keyCode || 183 < event.keyCode; | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} c | |
| * @param {?} compartmentIndex | |
| * @param {?} $native | |
| * @param {boolean} $primitive | |
| * @return {?} | |
| */ | |
| var Dn = function(a, c, compartmentIndex, $native, $primitive) { | |
| if (!(E || gh || G && I("525"))) { | |
| return true; | |
| } | |
| if (kh && $primitive) { | |
| return Bn(a); | |
| } | |
| if ($primitive && !$native) { | |
| return false; | |
| } | |
| if (Ge(c)) { | |
| c = Cn(c); | |
| } | |
| if (!compartmentIndex && (17 == c || 18 == c || kh && 91 == c)) { | |
| return false; | |
| } | |
| if ((G || gh) && $native && compartmentIndex) { | |
| switch(a) { | |
| case 220: | |
| case 219: | |
| case 221: | |
| case 192: | |
| case 186: | |
| case 189: | |
| case 187: | |
| case 188: | |
| case 190: | |
| case 191: | |
| case 192: | |
| case 222: | |
| return false; | |
| } | |
| } | |
| if (E && $native && c == a) { | |
| return false; | |
| } | |
| switch(a) { | |
| case 13: | |
| return true; | |
| case 27: | |
| return !(G || gh); | |
| } | |
| return Bn(a); | |
| }; | |
| /** | |
| * @param {number} a255 | |
| * @return {?} | |
| */ | |
| var Bn = function(a255) { | |
| if (48 <= a255 && 57 >= a255 || 96 <= a255 && 106 >= a255 || 65 <= a255 && 90 >= a255 || (G || gh) && 0 == a255) { | |
| return true; | |
| } | |
| switch(a255) { | |
| case 32: | |
| case 43: | |
| case 63: | |
| case 64: | |
| case 107: | |
| case 109: | |
| case 110: | |
| case 111: | |
| case 186: | |
| case 59: | |
| case 189: | |
| case 187: | |
| case 61: | |
| case 188: | |
| case 190: | |
| case 191: | |
| case 192: | |
| case 222: | |
| case 219: | |
| case 220: | |
| case 221: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Cn = function(a) { | |
| if (ih) { | |
| a = En(a); | |
| } else { | |
| if (kh && G) { | |
| a: { | |
| switch(a) { | |
| case 93: | |
| /** @type {number} */ | |
| a = 91; | |
| break a; | |
| } | |
| } | |
| } | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {number} strip1 | |
| * @return {?} | |
| */ | |
| var En = function(strip1) { | |
| switch(strip1) { | |
| case 61: | |
| return 187; | |
| case 59: | |
| return 186; | |
| case 173: | |
| return 189; | |
| case 224: | |
| return 91; | |
| case 0: | |
| return 224; | |
| default: | |
| return strip1; | |
| } | |
| }; | |
| /** | |
| * @param {?} blobs | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var Gn = function(blobs, type) { | |
| V.call(this); | |
| if (blobs) { | |
| Fn(this, blobs, type); | |
| } | |
| }; | |
| C(Gn, V); | |
| y = Gn.prototype; | |
| /** @type {null} */ | |
| y.D = null; | |
| /** @type {null} */ | |
| y.qe = null; | |
| /** @type {null} */ | |
| y.vf = null; | |
| /** @type {null} */ | |
| y.re = null; | |
| /** @type {number} */ | |
| y.qb = -1; | |
| /** @type {number} */ | |
| y.ec = -1; | |
| /** @type {boolean} */ | |
| y.Pe = false; | |
| var Hn = { | |
| 3 : 13, | |
| 12 : 144, | |
| 63232 : 38, | |
| 63233 : 40, | |
| 63234 : 37, | |
| 63235 : 39, | |
| 63236 : 112, | |
| 63237 : 113, | |
| 63238 : 114, | |
| 63239 : 115, | |
| 63240 : 116, | |
| 63241 : 117, | |
| 63242 : 118, | |
| 63243 : 119, | |
| 63244 : 120, | |
| 63245 : 121, | |
| 63246 : 122, | |
| 63247 : 123, | |
| 63248 : 44, | |
| 63272 : 46, | |
| 63273 : 36, | |
| 63275 : 35, | |
| 63276 : 33, | |
| 63277 : 34, | |
| 63289 : 144, | |
| 63302 : 45 | |
| }; | |
| var In = { | |
| Up : 38, | |
| Down : 40, | |
| Left : 37, | |
| Right : 39, | |
| Enter : 13, | |
| F1 : 112, | |
| F2 : 113, | |
| F3 : 114, | |
| F4 : 115, | |
| F5 : 116, | |
| F6 : 117, | |
| F7 : 118, | |
| F8 : 119, | |
| F9 : 120, | |
| F10 : 121, | |
| F11 : 122, | |
| F12 : 123, | |
| "U+007F" : 46, | |
| Home : 36, | |
| End : 35, | |
| PageUp : 33, | |
| PageDown : 34, | |
| Insert : 45 | |
| }; | |
| var Jn = E || gh || G && I("525"); | |
| var Kn = kh && ih; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| Gn.prototype.a = function(key) { | |
| if (G || gh) { | |
| if (17 == this.qb && !key.ctrlKey || 18 == this.qb && !key.altKey || kh && 91 == this.qb && !key.metaKey) { | |
| /** @type {number} */ | |
| this.ec = this.qb = -1; | |
| } | |
| } | |
| if (-1 == this.qb) { | |
| if (key.ctrlKey && 17 != key.keyCode) { | |
| /** @type {number} */ | |
| this.qb = 17; | |
| } else { | |
| if (key.altKey && 18 != key.keyCode) { | |
| /** @type {number} */ | |
| this.qb = 18; | |
| } else { | |
| if (key.metaKey && 91 != key.keyCode) { | |
| /** @type {number} */ | |
| this.qb = 91; | |
| } | |
| } | |
| } | |
| } | |
| if (Jn && !Dn(key.keyCode, this.qb, key.shiftKey, key.ctrlKey, key.altKey)) { | |
| this.handleEvent(key); | |
| } else { | |
| this.ec = Cn(key.keyCode); | |
| if (Kn) { | |
| this.Pe = key.altKey; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| Gn.prototype.b = function(key) { | |
| /** @type {number} */ | |
| this.ec = this.qb = -1; | |
| this.Pe = key.altKey; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| Gn.prototype.handleEvent = function(e) { | |
| var event = e.b; | |
| var u; | |
| var a; | |
| var alt = event.altKey; | |
| if (E && e.type == Jc) { | |
| u = this.ec; | |
| } else { | |
| if ((G || gh) && e.type == Jc) { | |
| u = this.ec; | |
| } else { | |
| if (fh && !G) { | |
| u = this.ec; | |
| } else { | |
| u = event.keyCode || this.ec; | |
| a = event.charCode || 0; | |
| if (Kn) { | |
| alt = this.Pe; | |
| } | |
| if (kh && 63 == a && 224 == u) { | |
| /** @type {number} */ | |
| u = 191; | |
| } | |
| } | |
| } | |
| } | |
| a = u = Cn(u); | |
| var id = event.keyIdentifier; | |
| if (u) { | |
| if (63232 <= u && u in Hn) { | |
| a = Hn[u]; | |
| } else { | |
| if (25 == u && e.shiftKey) { | |
| /** @type {number} */ | |
| a = 9; | |
| } | |
| } | |
| } else { | |
| if (id && id in In) { | |
| a = In[id]; | |
| } | |
| } | |
| this.qb = a; | |
| e = new Ln(a, 0, 0, event); | |
| e.altKey = alt; | |
| this.dispatchEvent(e); | |
| }; | |
| Gn.prototype.l = w("D"); | |
| /** | |
| * @param {!Object} self | |
| * @param {?} options | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var Fn = function(self, options, name) { | |
| if (self.re) { | |
| Mn(self); | |
| } | |
| self.D = options; | |
| self.qe = U(self.D, Jc, self, name); | |
| self.vf = U(self.D, Ic, self.a, name, self); | |
| self.re = U(self.D, Kc, self.b, name, self); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var Mn = function(self) { | |
| if (self.qe) { | |
| ik(self.qe); | |
| ik(self.vf); | |
| ik(self.re); | |
| /** @type {null} */ | |
| self.qe = null; | |
| /** @type {null} */ | |
| self.vf = null; | |
| /** @type {null} */ | |
| self.re = null; | |
| } | |
| /** @type {null} */ | |
| self.D = null; | |
| /** @type {number} */ | |
| self.qb = -1; | |
| /** @type {number} */ | |
| self.ec = -1; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gn.prototype.J = function() { | |
| Gn.v.J.call(this); | |
| Mn(this); | |
| }; | |
| /** | |
| * @param {string} keyCode | |
| * @param {?} event | |
| * @param {?} characterId | |
| * @param {?} mode | |
| * @return {undefined} | |
| */ | |
| var Ln = function(keyCode, event, characterId, mode) { | |
| Ij.call(this, mode); | |
| this.type = Hc; | |
| /** @type {string} */ | |
| this.keyCode = keyCode; | |
| }; | |
| C(Ln, Ij); | |
| /** | |
| * @param {string} obj | |
| * @param {!Function} n | |
| * @return {undefined} | |
| */ | |
| var On = function(obj, n) { | |
| if (!obj) { | |
| throw Error("Invalid class name " + obj); | |
| } | |
| if (!He(n)) { | |
| throw Error("Invalid decorator function " + n); | |
| } | |
| /** @type {!Function} */ | |
| Nn[obj] = n; | |
| }; | |
| var Pn = {}; | |
| var Nn = {}; | |
| /** | |
| * @param {!Object} y | |
| * @param {!Object} value | |
| * @param {?} input | |
| * @return {undefined} | |
| */ | |
| var Qn = function(y, value, input) { | |
| W.call(this, input); | |
| if (!value) { | |
| value = this.constructor; | |
| var time; | |
| for (; value;) { | |
| time = Le(value); | |
| if (time = Pn[time]) { | |
| break; | |
| } | |
| value = value.v ? value.v.constructor : null; | |
| } | |
| value = time ? He(time.M) ? time.M() : new time : null; | |
| } | |
| /** @type {!Object} */ | |
| this.c = value; | |
| this.sc = xe(y) ? y : null; | |
| }; | |
| C(Qn, W); | |
| y = Qn.prototype; | |
| /** @type {null} */ | |
| y.sc = null; | |
| /** @type {number} */ | |
| y.bc = 0; | |
| /** @type {number} */ | |
| y.vd = 39; | |
| /** @type {number} */ | |
| y.Ib = 255; | |
| /** @type {number} */ | |
| y.ud = 0; | |
| /** @type {boolean} */ | |
| y.$d = true; | |
| /** @type {null} */ | |
| y.sb = null; | |
| /** @type {boolean} */ | |
| y.ie = true; | |
| /** @type {boolean} */ | |
| y.Bd = false; | |
| /** @type {null} */ | |
| y.lf = null; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} hash | |
| * @return {undefined} | |
| */ | |
| var Sn = function(data, hash) { | |
| if (data.sa && hash != data.ie) { | |
| Rn(data, hash); | |
| } | |
| /** @type {string} */ | |
| data.ie = hash; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} list | |
| * @return {undefined} | |
| */ | |
| var Tn = function(options, list) { | |
| if (list) { | |
| if (options.sb) { | |
| if (!Ef(options.sb, list)) { | |
| options.sb.push(list); | |
| } | |
| } else { | |
| /** @type {!Array} */ | |
| options.sb = [list]; | |
| } | |
| pn(options, list, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {string} o | |
| * @param {boolean} dizhi | |
| * @return {undefined} | |
| */ | |
| var yn = function(e, o, dizhi) { | |
| if (dizhi) { | |
| Tn(e, o); | |
| } else { | |
| if (o && e.sb && Hf(e.sb, o)) { | |
| if (0 == e.sb.length) { | |
| /** @type {null} */ | |
| e.sb = null; | |
| } | |
| pn(e, o, false); | |
| } | |
| } | |
| }; | |
| y = Qn.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| var foo = this.c.Pa(this); | |
| this.D = foo; | |
| rn(this.c, foo, this.kd()); | |
| if (!this.Bd) { | |
| this.c.Yd(foo, false); | |
| } | |
| if (!this.isVisible()) { | |
| this.c.setVisible(foo, false); | |
| } | |
| }; | |
| y.kd = w("lf"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.yb = function() { | |
| return this.c.hb(this.l()); | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @return {?} | |
| */ | |
| y.Wd = function(result) { | |
| return this.c.Kc(result); | |
| }; | |
| /** | |
| * @param {!Object} y | |
| * @return {undefined} | |
| */ | |
| y.Y = function(y) { | |
| this.D = y = this.c.R(this, y); | |
| rn(this.c, y, this.kd()); | |
| if (!this.Bd) { | |
| this.c.Yd(y, false); | |
| } | |
| /** @type {boolean} */ | |
| this.$d = y.style.display != ad; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| Qn.v.V.call(this); | |
| un(this.c, this, this.D); | |
| this.c.Ag(this); | |
| if (this.vd & -2 && (this.ie && Rn(this, true), sn(this, 32))) { | |
| var a = this.l(); | |
| if (a) { | |
| var target = this.H || (this.H = new Gn); | |
| Fn(target, a); | |
| X(this).a(target, Hc, this.Ka).a(a, wb, this.Xh).a(a, Va, this.Zd); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} ring | |
| * @return {undefined} | |
| */ | |
| var Rn = function(node, ring) { | |
| var t = X(node); | |
| var a = node.l(); | |
| if (ring) { | |
| t.a(a, Yc, node.kf).a(a, Vc, node.Za).a(a, Zc, node.ib).a(a, Xc, node.sf); | |
| if (node.md != Ae) { | |
| t.a(a, eb, node.md); | |
| } | |
| if (E) { | |
| if (!I(9)) { | |
| t.a(a, "dblclick", node.Gg); | |
| } | |
| if (!node.L) { | |
| node.L = new Un(node); | |
| Cj(node, node.L); | |
| } | |
| } | |
| } else { | |
| t.b(a, Yc, node.kf).b(a, Vc, node.Za).b(a, Zc, node.ib).b(a, Xc, node.sf); | |
| if (node.md != Ae) { | |
| t.b(a, eb, node.md); | |
| } | |
| if (E) { | |
| if (!I(9)) { | |
| t.b(a, "dblclick", node.Gg); | |
| } | |
| Bj(node.L); | |
| /** @type {null} */ | |
| node.L = null; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Qn.prototype.Ya = function() { | |
| Qn.v.Ya.call(this); | |
| if (this.H) { | |
| Mn(this.H); | |
| } | |
| if (this.isVisible() && this.isEnabled()) { | |
| this.c.Lc(this, false); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Qn.prototype.J = function() { | |
| Qn.v.J.call(this); | |
| if (this.H) { | |
| this.H.za(); | |
| delete this.H; | |
| } | |
| delete this.c; | |
| /** @type {null} */ | |
| this.L = this.sb = this.sc = null; | |
| }; | |
| Qn.prototype.Aa = w("sc"); | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Qn.prototype.g = function(name) { | |
| this.c.zb(this.l(), name); | |
| /** @type {string} */ | |
| this.sc = name; | |
| }; | |
| /** | |
| * @param {!Object} link | |
| * @param {!Node} label | |
| * @return {undefined} | |
| */ | |
| var qn = function(link, label) { | |
| /** @type {!Node} */ | |
| link.sc = label; | |
| }; | |
| y = Qn.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Na = function() { | |
| var item = this.Aa(); | |
| if (!item) { | |
| return ""; | |
| } | |
| item = Fe(item) ? item : De(item) ? zf(item, Gi).join("") : Fi(item); | |
| return Ve(item); | |
| }; | |
| y.isVisible = w("$d"); | |
| /** | |
| * @param {boolean} value | |
| * @param {string} bool | |
| * @return {?} | |
| */ | |
| y.setVisible = function(value, bool) { | |
| if (bool || this.$d != value && this.dispatchEvent(value ? Ad : pc)) { | |
| var x = this.l(); | |
| if (x) { | |
| this.c.setVisible(x, value); | |
| } | |
| if (this.isEnabled()) { | |
| this.c.Lc(this, value); | |
| } | |
| /** @type {boolean} */ | |
| this.$d = value; | |
| return true; | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.isEnabled = function() { | |
| return !tn(this, 1); | |
| }; | |
| /** | |
| * @param {boolean} y | |
| * @return {undefined} | |
| */ | |
| y.ba = function(y) { | |
| var BrowserCache = this.K(); | |
| if (!(BrowserCache && typeof BrowserCache.isEnabled == Bb && !BrowserCache.isEnabled() || !Vn(this, 1, !y))) { | |
| if (!y) { | |
| Wn(this, false); | |
| Xn(this, false); | |
| } | |
| if (this.isVisible()) { | |
| this.c.Lc(this, y); | |
| } | |
| Yn(this, 1, !y, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {boolean} index | |
| * @return {undefined} | |
| */ | |
| var Xn = function(name, index) { | |
| if (Vn(name, 2, index)) { | |
| Yn(name, 2, index); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {boolean} index | |
| * @return {undefined} | |
| */ | |
| var Wn = function(name, index) { | |
| if (Vn(name, 4, index)) { | |
| Yn(name, 4, index); | |
| } | |
| }; | |
| y = Qn.prototype; | |
| /** | |
| * @param {boolean} V | |
| * @return {undefined} | |
| */ | |
| y.Kf = function(V) { | |
| if (Vn(this, 8, V)) { | |
| Yn(this, 8, V); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Ea = function() { | |
| return tn(this, 16); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| y.ma = function(a) { | |
| if (Vn(this, 16, a)) { | |
| Yn(this, 16, a); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} c | |
| * @return {undefined} | |
| */ | |
| y.hc = function(c) { | |
| if (Vn(this, 32, c)) { | |
| Yn(this, 32, c); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| y.Ja = function(a) { | |
| if (Vn(this, 64, a)) { | |
| Yn(this, 64, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {number} count | |
| * @return {?} | |
| */ | |
| var tn = function(node, count) { | |
| return !!(node.bc & count); | |
| }; | |
| /** | |
| * @param {!Object} arg | |
| * @param {number} type | |
| * @param {boolean} index | |
| * @param {string} enableTimer | |
| * @return {undefined} | |
| */ | |
| var Yn = function(arg, type, index, enableTimer) { | |
| if (enableTimer || 1 != type) { | |
| if (sn(arg, type) && index != tn(arg, type)) { | |
| arg.c.rc(arg, type, index); | |
| /** @type {number} */ | |
| arg.bc = index ? arg.bc | type : arg.bc & ~type; | |
| } | |
| } else { | |
| arg.ba(!index); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} tagName | |
| * @param {number} data | |
| * @return {?} | |
| */ | |
| var sn = function(tagName, data) { | |
| return !!(tagName.vd & data); | |
| }; | |
| /** | |
| * @param {number} n | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| Qn.prototype.Ba = function(n, b) { | |
| if (this.sa && tn(this, n) && !b) { | |
| throw Error(pa); | |
| } | |
| if (!b && tn(this, n)) { | |
| Yn(this, n, false); | |
| } | |
| /** @type {number} */ | |
| this.vd = b ? this.vd | n : this.vd & ~n; | |
| }; | |
| /** | |
| * @param {!Object} span | |
| * @param {number} code | |
| * @return {?} | |
| */ | |
| var Zn = function(span, code) { | |
| return !!(span.Ib & code) && sn(span, code); | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @param {number} type | |
| * @param {?} e | |
| * @return {?} | |
| */ | |
| var Vn = function(target, type, e) { | |
| return sn(target, type) && tn(target, type) != e && (!(target.ud & type) || target.dispatchEvent(Fl(type, e))) && !target.Ca; | |
| }; | |
| y = Qn.prototype; | |
| /** | |
| * @param {!Object} arg | |
| * @return {undefined} | |
| */ | |
| y.kf = function(arg) { | |
| if ((!arg.c || !ti(this.l(), arg.c)) && this.dispatchEvent("enter") && this.isEnabled() && Zn(this, 2)) { | |
| Xn(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| y.sf = function(x) { | |
| if (!(x.c && ti(this.l(), x.c) || !this.dispatchEvent("leave"))) { | |
| if (Zn(this, 4)) { | |
| Wn(this, false); | |
| } | |
| if (Zn(this, 2)) { | |
| Xn(this, false); | |
| } | |
| } | |
| }; | |
| y.md = Ae; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| y.Za = function(key) { | |
| if (this.isEnabled()) { | |
| if (Zn(this, 2)) { | |
| Xn(this, true); | |
| } | |
| if (Kj(key)) { | |
| if (Zn(this, 4)) { | |
| Wn(this, true); | |
| } | |
| if (this.c && this.c.hf(this)) { | |
| this.l().focus(); | |
| } | |
| } | |
| } | |
| if (!this.Bd && Kj(key)) { | |
| key.preventDefault(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {undefined} | |
| */ | |
| y.ib = function(node) { | |
| if (this.isEnabled()) { | |
| if (Zn(this, 2)) { | |
| Xn(this, true); | |
| } | |
| if (tn(this, 4) && this.Wb(node) && Zn(this, 4)) { | |
| Wn(this, false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} webcal | |
| * @return {undefined} | |
| */ | |
| y.Gg = function(webcal) { | |
| if (this.isEnabled()) { | |
| this.Wb(webcal); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| y.Wb = function(event) { | |
| if (Zn(this, 16)) { | |
| this.ma(!this.Ea()); | |
| } | |
| if (Zn(this, 8)) { | |
| this.Kf(true); | |
| } | |
| if (Zn(this, 64)) { | |
| this.Ja(!tn(this, 64)); | |
| } | |
| var e = new T(p, this); | |
| if (event) { | |
| e.altKey = event.altKey; | |
| e.ctrlKey = event.ctrlKey; | |
| e.metaKey = event.metaKey; | |
| e.shiftKey = event.shiftKey; | |
| e.m = event.m; | |
| } | |
| return this.dispatchEvent(e); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Xh = function() { | |
| if (Zn(this, 32)) { | |
| this.hc(true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Zd = function() { | |
| if (Zn(this, 4)) { | |
| Wn(this, false); | |
| } | |
| if (Zn(this, 32)) { | |
| this.hc(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} key | |
| * @return {?} | |
| */ | |
| y.Ka = function(key) { | |
| return this.isVisible() && this.isEnabled() && this.tc(key) ? (key.preventDefault(), key.stopPropagation(), true) : false; | |
| }; | |
| /** | |
| * @param {!Event} key | |
| * @return {?} | |
| */ | |
| y.tc = function(key) { | |
| return 13 == key.keyCode && this.Wb(key); | |
| }; | |
| if (!He(Qn)) { | |
| throw Error("Invalid component class " + Qn); | |
| } | |
| if (!He(hn)) { | |
| throw Error("Invalid renderer class " + hn); | |
| } | |
| var $n = Le(Qn); | |
| Pn[$n] = hn; | |
| On("goog-control", function() { | |
| return new Qn(null); | |
| }); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var Un = function(a) { | |
| Aj.call(this); | |
| /** @type {string} */ | |
| this.b = a; | |
| /** @type {boolean} */ | |
| this.a = false; | |
| this.c = new nk(this); | |
| Cj(this, this.c); | |
| a = this.b.D; | |
| this.c.a(a, Vc, this.j).a(a, Zc, this.m).a(a, r, this.g); | |
| }; | |
| C(Un, Aj); | |
| var ao = !E || yh(9); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Un.prototype.j = function() { | |
| /** @type {boolean} */ | |
| this.a = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Un.prototype.m = function() { | |
| /** @type {boolean} */ | |
| this.a = true; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var bo = function(options, type) { | |
| if (!ao) { | |
| return options.button = 0, options.type = type, options; | |
| } | |
| /** @type {(Event|null)} */ | |
| var event = document.createEvent("MouseEvents"); | |
| event.initMouseEvent(type, options.bubbles, options.cancelable, options.view || null, options.detail, options.screenX, options.screenY, options.clientX, options.clientY, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, options.relatedTarget || null); | |
| return event; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Un.prototype.g = function(key) { | |
| if (this.a) { | |
| /** @type {boolean} */ | |
| this.a = false; | |
| } else { | |
| var event = key.b; | |
| var button = event.button; | |
| var explicitType = event.type; | |
| var detailsText = bo(event, Vc); | |
| this.b.Za(new Ij(detailsText, key.a)); | |
| detailsText = bo(event, Zc); | |
| this.b.ib(new Ij(detailsText, key.a)); | |
| if (!ao) { | |
| event.button = button; | |
| event.type = explicitType; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Un.prototype.J = function() { | |
| /** @type {null} */ | |
| this.b = null; | |
| Un.v.J.call(this); | |
| }; | |
| var co = ue(); | |
| C(co, wn); | |
| Be(co); | |
| y = co.prototype; | |
| y.Rb = ue(); | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| y.Pa = function(obj) { | |
| Sn(obj, false); | |
| obj.Ib &= -256; | |
| obj.Ba(32, false); | |
| return obj.a.b(oa, { | |
| "class" : nn(this, obj).join(" "), | |
| disabled : !obj.isEnabled(), | |
| title : obj.w || "", | |
| value : obj.T() || "" | |
| }, obj.Na() || ""); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| y.Kc = function(a) { | |
| return a.tagName == oa || a.tagName == ta && (a.type == Xa || "submit" == a.type || "reset" == a.type); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| y.R = function(b, n) { | |
| Sn(b, false); | |
| b.Ib &= -256; | |
| b.Ba(32, false); | |
| if (n.disabled) { | |
| var a = this.a(1); | |
| J(n, a); | |
| } | |
| return co.v.R.call(this, b, n); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| y.Ag = function(value) { | |
| X(value).a(value.l(), r, value.Wb); | |
| }; | |
| y.Yd = Ae; | |
| y.jf = Ae; | |
| /** | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| y.hf = function(b) { | |
| return b.isEnabled(); | |
| }; | |
| y.Lc = Ae; | |
| /** | |
| * @param {!Object} args | |
| * @param {number} typeName | |
| * @param {boolean} name | |
| * @return {undefined} | |
| */ | |
| y.rc = function(args, typeName, name) { | |
| co.v.rc.call(this, args, typeName, name); | |
| if ((args = args.l()) && 1 == typeName) { | |
| /** @type {boolean} */ | |
| args.disabled = name; | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| y.T = function(name) { | |
| return name.value; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| y.Ud = function(key, name) { | |
| if (key) { | |
| /** @type {string} */ | |
| key.value = name; | |
| } | |
| }; | |
| y.Cb = Ae; | |
| /** | |
| * @param {?} activityId | |
| * @param {?} name | |
| * @param {?} entry__3995__auto__ | |
| * @return {undefined} | |
| */ | |
| var eo = function(activityId, name, entry__3995__auto__) { | |
| Qn.call(this, activityId, name || co.M(), entry__3995__auto__); | |
| }; | |
| C(eo, Qn); | |
| y = eo.prototype; | |
| y.T = w("Wa"); | |
| /** | |
| * @param {boolean} factor | |
| * @return {undefined} | |
| */ | |
| y.Vd = function(factor) { | |
| /** @type {boolean} */ | |
| this.Wa = factor; | |
| this.c.Ud(this.l(), factor); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| eo.v.J.call(this); | |
| delete this.Wa; | |
| delete this.w; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| eo.v.V.call(this); | |
| if (sn(this, 32)) { | |
| var type = this.l(); | |
| if (type) { | |
| X(this).a(type, Kc, this.tc); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| y.tc = function(key) { | |
| return 13 == key.keyCode && key.type == Hc || 32 == key.keyCode && key.type == Kc ? this.Wb(key) : 32 == key.keyCode; | |
| }; | |
| On("goog-button", function() { | |
| return new eo(null); | |
| }); | |
| var fo = ue(); | |
| C(fo, wn); | |
| Be(fo); | |
| y = fo.prototype; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| y.Pa = function(a) { | |
| var b = nn(this, a); | |
| b = a.a.b(k, { | |
| "class" : Hb + b.join(" ") | |
| }, this.Id(a.Aa(), a.a)); | |
| xn(b, a.w); | |
| return b; | |
| }; | |
| y.Rb = x(Xa); | |
| /** | |
| * @param {!Object} element | |
| * @return {?} | |
| */ | |
| y.hb = function(element) { | |
| return element && element.firstChild && element.firstChild.firstChild; | |
| }; | |
| /** | |
| * @param {undefined} id | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| y.Id = function(id, n) { | |
| return n.b(k, Hb + (this.S() + "-outer-box"), n.b(k, Hb + (this.S() + "-inner-box"), id)); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| y.Kc = function(data) { | |
| return data.tagName == k; | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| y.R = function(args, n) { | |
| go(n, true); | |
| go(n, false); | |
| var target; | |
| a: { | |
| target = args.a.pg(n); | |
| var d = this.S() + "-outer-box"; | |
| if (target && Bh(target, d) && (target = args.a.pg(target), d = this.S() + "-inner-box", target && Bh(target, d))) { | |
| /** @type {boolean} */ | |
| target = true; | |
| break a; | |
| } | |
| /** @type {boolean} */ | |
| target = false; | |
| } | |
| if (!target) { | |
| n.appendChild(this.Id(n.childNodes, args.a)); | |
| } | |
| Ch(n, [Gb, this.S()]); | |
| return fo.v.R.call(this, args, n); | |
| }; | |
| y.S = x("goog-custom-button"); | |
| /** | |
| * @param {!HTMLElement} element | |
| * @param {boolean} fromStart | |
| * @return {undefined} | |
| */ | |
| var go = function(element, fromStart) { | |
| if (element) { | |
| var node = fromStart ? element.firstChild : element.lastChild; | |
| var next; | |
| for (; node && node.parentNode == element;) { | |
| next = fromStart ? node.nextSibling : node.previousSibling; | |
| if (3 == node.nodeType) { | |
| var path = node.nodeValue; | |
| if ("" == We(path)) { | |
| element.removeChild(node); | |
| } else { | |
| node.nodeValue = fromStart ? path.replace(/^[\s\xa0]+/, "") : path.replace(/[\s\xa0]+$/, ""); | |
| break; | |
| } | |
| } else { | |
| break; | |
| } | |
| node = next; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} val | |
| * @param {?} cx | |
| * @param {?} text | |
| * @return {undefined} | |
| */ | |
| var ho = function(val, cx, text) { | |
| eo.call(this, val, cx || fo.M(), text); | |
| this.Ba(16, true); | |
| }; | |
| C(ho, eo); | |
| On("goog-toggle-button", function() { | |
| return new ho(null); | |
| }); | |
| /** | |
| * @param {string} req | |
| * @param {string} res | |
| * @param {number} socket | |
| * @return {undefined} | |
| */ | |
| var io = function(req, res, socket) { | |
| Aj.call(this); | |
| /** @type {string} */ | |
| this.a = req; | |
| this.j = res || 0; | |
| /** @type {number} */ | |
| this.c = socket; | |
| this.g = A(this.b, this); | |
| }; | |
| C(io, Aj); | |
| /** @type {number} */ | |
| io.prototype.Ga = 0; | |
| /** | |
| * @return {undefined} | |
| */ | |
| io.prototype.J = function() { | |
| io.v.J.call(this); | |
| jo(this); | |
| delete this.a; | |
| delete this.c; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {number} n | |
| * @return {undefined} | |
| */ | |
| var ko = function(e, n) { | |
| jo(e); | |
| e.Ga = cl(e.g, xe(n) ? n : e.j); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var jo = function(value) { | |
| if (0 != value.Ga) { | |
| dl(value.Ga); | |
| } | |
| /** @type {number} */ | |
| value.Ga = 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| io.prototype.b = function() { | |
| /** @type {number} */ | |
| this.Ga = 0; | |
| if (this.a) { | |
| this.a.call(this.c); | |
| } | |
| }; | |
| /** | |
| * @param {string} str | |
| * @return {?} | |
| */ | |
| var no = function(str) { | |
| return lf(We(str.replace(lo, function(a, text) { | |
| return mo.test(text) ? "" : " "; | |
| }).replace(/[\t\n ]+/g, " "))); | |
| }; | |
| /** @type {!RegExp} */ | |
| var mo = /^(?:abbr|acronym|address|b|em|i|small|strong|su[bp]|u)$/i; | |
| /** @type {!RegExp} */ | |
| var lo = /<[!\/]?([a-z0-9]+)([\/ ][^>]*)?>/gi; | |
| /** | |
| * @param {number} m | |
| * @param {number} l | |
| * @param {string} target | |
| * @param {!Object} type | |
| * @param {!Object} c | |
| * @param {string} t | |
| * @param {number} seed | |
| * @param {string} index | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| var ro = function(m, l, target, type, c, t, seed, index, n) { | |
| var rect = oo(target); | |
| var r = ij(m); | |
| var a = aj(m); | |
| if (a) { | |
| var p = new Oi(a.left, a.top, a.right - a.left, a.bottom - a.top); | |
| /** @type {number} */ | |
| a = Math.max(r.left, p.left); | |
| /** @type {number} */ | |
| var elem = Math.min(r.left + r.width, p.left + p.width); | |
| if (a <= elem) { | |
| /** @type {number} */ | |
| var h = Math.max(r.top, p.top); | |
| /** @type {number} */ | |
| p = Math.min(r.top + r.height, p.top + p.height); | |
| if (h <= p) { | |
| /** @type {number} */ | |
| r.left = a; | |
| /** @type {number} */ | |
| r.top = h; | |
| /** @type {number} */ | |
| r.width = elem - a; | |
| /** @type {number} */ | |
| r.height = p - h; | |
| } | |
| } | |
| } | |
| a = Qh(m); | |
| h = Qh(target); | |
| if (a.a != h.a) { | |
| elem = a.a.body; | |
| h = Ki(h); | |
| p = new L(0, 0); | |
| var currentWin = $h(Ph(elem)); | |
| if (Qi(currentWin, "parent")) { | |
| var currentEl = elem; | |
| do { | |
| var pc = currentWin == h ? $i(currentEl) : dj(currentEl); | |
| p.x += pc.x; | |
| p.y += pc.y; | |
| } while (currentWin && currentWin != h && currentWin != currentWin.parent && (currentEl = currentWin.frameElement) && (currentWin = currentWin.parent)); | |
| } | |
| elem = Fh(p, $i(elem)); | |
| if (!(!E || yh(9) || Wh(a.a))) { | |
| elem = Fh(elem, Zh(a.a)); | |
| } | |
| r.left += elem.x; | |
| r.top += elem.y; | |
| } | |
| m = po(m, l); | |
| l = r.left; | |
| if (m & 4) { | |
| l = l + r.width; | |
| } else { | |
| if (m & 2) { | |
| l = l + r.width / 2; | |
| } | |
| } | |
| r = new L(l, r.top + (m & 1 ? r.height : 0)); | |
| r = Fh(r, rect); | |
| if (c) { | |
| r.x += (m & 4 ? -1 : 1) * c.x; | |
| r.y += (m & 1 ? -1 : 1) * c.y; | |
| } | |
| var position; | |
| if (seed) { | |
| if (n) { | |
| /** @type {!Object} */ | |
| position = n; | |
| } else { | |
| if (position = aj(target)) { | |
| position.top -= rect.y; | |
| position.right -= rect.x; | |
| position.bottom -= rect.y; | |
| position.left -= rect.x; | |
| } | |
| } | |
| } | |
| return qo(r, target, type, t, position, seed, index); | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| var oo = function(target) { | |
| var finalConf; | |
| if (target = target.offsetParent) { | |
| /** @type {boolean} */ | |
| var id = "HTML" == target.tagName || "BODY" == target.tagName; | |
| if (!(id && "static" == Ui(target, ld))) { | |
| finalConf = $i(target); | |
| if (!id) { | |
| id = (id = nj(target)) && ih ? -target.scrollLeft : !id || hh && I("8") || Ui(target, "overflowX") == me ? target.scrollLeft : target.scrollWidth - target.clientWidth - target.scrollLeft; | |
| finalConf = Fh(finalConf, new L(id, target.scrollTop)); | |
| } | |
| } | |
| } | |
| return finalConf || new L; | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @param {!Object} p | |
| * @param {?} size | |
| * @param {!Object} e | |
| * @param {!Object} pos | |
| * @param {number} a | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var qo = function(el, p, size, e, pos, a, data) { | |
| el = el.clone(); | |
| var view = po(p, size); | |
| size = hj(p); | |
| data = data ? data.clone() : size.clone(); | |
| el = el.clone(); | |
| data = data.clone(); | |
| /** @type {number} */ | |
| var end = 0; | |
| if (e || 0 != view) { | |
| if (view & 4) { | |
| el.x -= data.width + (e ? e.right : 0); | |
| } else { | |
| if (view & 2) { | |
| el.x -= data.width / 2; | |
| } else { | |
| if (e) { | |
| el.x += e.left; | |
| } | |
| } | |
| } | |
| if (view & 1) { | |
| el.y -= data.height + (e ? e.bottom : 0); | |
| } else { | |
| if (e) { | |
| el.y += e.top; | |
| } | |
| } | |
| } | |
| if (a) { | |
| if (pos) { | |
| /** @type {!Object} */ | |
| e = el; | |
| /** @type {!Object} */ | |
| view = data; | |
| /** @type {number} */ | |
| end = 0; | |
| if (65 == (a & 65) && (e.x < pos.left || e.x >= pos.right)) { | |
| /** @type {number} */ | |
| a = a & -2; | |
| } | |
| if (132 == (a & 132) && (e.y < pos.top || e.y >= pos.bottom)) { | |
| /** @type {number} */ | |
| a = a & -5; | |
| } | |
| if (e.x < pos.left && a & 1) { | |
| e.x = pos.left; | |
| /** @type {number} */ | |
| end = end | 1; | |
| } | |
| if (a & 16) { | |
| var x = e.x; | |
| if (e.x < pos.left) { | |
| e.x = pos.left; | |
| /** @type {number} */ | |
| end = end | 4; | |
| } | |
| if (e.x + view.width > pos.right) { | |
| /** @type {number} */ | |
| view.width = Math.min(pos.right - e.x, x + view.width - pos.left); | |
| /** @type {number} */ | |
| view.width = Math.max(view.width, 0); | |
| /** @type {number} */ | |
| end = end | 4; | |
| } | |
| } | |
| if (e.x + view.width > pos.right && a & 1) { | |
| /** @type {number} */ | |
| e.x = Math.max(pos.right - view.width, pos.left); | |
| /** @type {number} */ | |
| end = end | 1; | |
| } | |
| if (a & 2) { | |
| /** @type {number} */ | |
| end = end | ((e.x < pos.left ? 16 : 0) | (e.x + view.width > pos.right ? 32 : 0)); | |
| } | |
| if (e.y < pos.top && a & 4) { | |
| e.y = pos.top; | |
| /** @type {number} */ | |
| end = end | 2; | |
| } | |
| if (a & 32) { | |
| x = e.y; | |
| if (e.y < pos.top) { | |
| e.y = pos.top; | |
| /** @type {number} */ | |
| end = end | 8; | |
| } | |
| if (e.y + view.height > pos.bottom) { | |
| /** @type {number} */ | |
| view.height = Math.min(pos.bottom - e.y, x + view.height - pos.top); | |
| /** @type {number} */ | |
| view.height = Math.max(view.height, 0); | |
| /** @type {number} */ | |
| end = end | 8; | |
| } | |
| } | |
| if (e.y + view.height > pos.bottom && a & 4) { | |
| /** @type {number} */ | |
| e.y = Math.max(pos.bottom - view.height, pos.top); | |
| /** @type {number} */ | |
| end = end | 2; | |
| } | |
| if (a & 8) { | |
| /** @type {number} */ | |
| end = end | ((e.y < pos.top ? 64 : 0) | (e.y + view.height > pos.bottom ? 128 : 0)); | |
| } | |
| /** @type {number} */ | |
| pos = end; | |
| } else { | |
| /** @type {number} */ | |
| pos = 256; | |
| } | |
| /** @type {!Object} */ | |
| end = pos; | |
| } | |
| a = new Oi(0, 0, 0, 0); | |
| a.left = el.x; | |
| a.top = el.y; | |
| a.width = data.width; | |
| a.height = data.height; | |
| /** @type {number} */ | |
| pos = end; | |
| if (pos & 496) { | |
| return pos; | |
| } | |
| Wi(p, new L(a.left, a.top)); | |
| data = new Gh(a.width, a.height); | |
| if (!Hh(size, data)) { | |
| /** @type {!Object} */ | |
| size = data; | |
| data = Ph(p); | |
| el = Wh(Qh(data).a); | |
| if (!E || I("10") || el && I("8")) { | |
| qj(p, size, Wa); | |
| } else { | |
| data = p.style; | |
| if (el) { | |
| el = uj(p); | |
| p = xj(p); | |
| /** @type {number} */ | |
| data.pixelWidth = size.width - p.left - el.left - el.right - p.right; | |
| /** @type {number} */ | |
| data.pixelHeight = size.height - p.top - el.top - el.bottom - p.bottom; | |
| } else { | |
| data.pixelWidth = size.width; | |
| data.pixelHeight = size.height; | |
| } | |
| } | |
| } | |
| return pos; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {number} type | |
| * @return {?} | |
| */ | |
| var po = function(v, type) { | |
| return (type & 8 && nj(v) ? type ^ 4 : type) & -9; | |
| }; | |
| var so = ue(); | |
| so.prototype.a = ue(); | |
| /** | |
| * @param {string} c | |
| * @param {?} kind | |
| * @return {undefined} | |
| */ | |
| var to = function(c, kind) { | |
| /** @type {string} */ | |
| this.g = c; | |
| /** @type {boolean} */ | |
| this.o = !!kind; | |
| this.m = { | |
| 0 : this.g + "-arrowright", | |
| 1 : this.g + "-arrowup", | |
| 2 : this.g + "-arrowdown", | |
| 3 : this.g + "-arrowleft" | |
| }; | |
| }; | |
| C(to, so); | |
| y = to.prototype; | |
| /** @type {boolean} */ | |
| y.oe = false; | |
| /** @type {number} */ | |
| y.Re = 2; | |
| /** @type {number} */ | |
| y.Wf = 20; | |
| /** @type {number} */ | |
| y.Te = 3; | |
| /** @type {number} */ | |
| y.Af = -5; | |
| /** @type {boolean} */ | |
| y.Ne = false; | |
| /** | |
| * @param {?} context | |
| * @param {number} firstTime | |
| * @param {number} result | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| var uo = function(context, firstTime, result, data) { | |
| if (null != firstTime) { | |
| /** @type {number} */ | |
| context.Te = firstTime; | |
| } | |
| if (null != result) { | |
| /** @type {number} */ | |
| context.Re = result; | |
| } | |
| if (Ge(void 0)) { | |
| /** @type {number} */ | |
| context.Wf = Math.max(void 0, 15); | |
| } | |
| if (Ge(data)) { | |
| /** @type {string} */ | |
| context.Af = data; | |
| } | |
| }; | |
| /** | |
| * @param {number} name | |
| * @param {string} type | |
| * @param {!Function} str | |
| * @return {undefined} | |
| */ | |
| to.prototype.a = function(name, type, str) { | |
| name = this.Re; | |
| if (2 == name) { | |
| /** @type {number} */ | |
| name = 0; | |
| } | |
| vo(this, this.Te, name, 2 == this.Re ? wo(this.Te) ? this.c.offsetHeight / 2 : this.c.offsetWidth / 2 : this.Wf, 0, str); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} m | |
| * @param {number} e | |
| * @param {number} buffer | |
| * @param {number} number | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| var vo = function(a, m, e, buffer, number, i) { | |
| if (a.b) { | |
| var x = xo(m, e); | |
| var t; | |
| var n = a.b; | |
| t = hj(n); | |
| /** @type {number} */ | |
| t = (wo(m) ? t.height / 2 : t.width / 2) - buffer; | |
| var b = po(n, x); | |
| var o; | |
| if (o = aj(n)) { | |
| n = ij(n); | |
| n = new Ni(n.top, n.left + n.width, n.top + n.height, n.left); | |
| if (wo(m)) { | |
| if (n.top < o.top && !(b & 1)) { | |
| /** @type {number} */ | |
| t = t - (o.top - n.top); | |
| } else { | |
| if (n.bottom > o.bottom && b & 1) { | |
| /** @type {number} */ | |
| t = t - (n.bottom - o.bottom); | |
| } | |
| } | |
| } else { | |
| if (n.left < o.left && !(b & 4)) { | |
| /** @type {number} */ | |
| t = t - (o.left - n.left); | |
| } else { | |
| if (n.right > o.right && b & 4) { | |
| /** @type {number} */ | |
| t = t - (n.right - o.right); | |
| } | |
| } | |
| } | |
| } | |
| t = wo(m) ? new L(a.Af, t) : new L(t, a.Af); | |
| /** @type {number} */ | |
| b = wo(m) ? 6 : 9; | |
| if (a.Ne && 2 == number) { | |
| /** @type {number} */ | |
| b = wo(m) ? 4 : 1; | |
| } | |
| /** @type {number} */ | |
| o = m ^ 3; | |
| if (wo(m) && a.b.dir == sd) { | |
| /** @type {number} */ | |
| o = m; | |
| } | |
| x = ro(a.b, xo(o, e), a.c, x, t, i, a.oe ? b : 0, void 0, null); | |
| if (2 != number && x & 496) { | |
| vo(a, m ^ 3, e, buffer, a.Ne && 0 == number ? 1 : 2, i); | |
| return; | |
| } | |
| if (!(!a.o || x & 496)) { | |
| /** @type {number} */ | |
| number = parseFloat(a.c.style.left); | |
| /** @type {number} */ | |
| i = parseFloat(a.c.style.top); | |
| if (!(isFinite(number) && 0 == number % 1 && isFinite(i) && 0 == i % 1)) { | |
| Wi(a.c, Math.round(number), Math.round(i)); | |
| } | |
| } | |
| } | |
| yo(a, m, e, buffer); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} i | |
| * @param {number} n | |
| * @param {number} d | |
| * @return {undefined} | |
| */ | |
| var yo = function(a, i, n, d) { | |
| var c = a.j; | |
| Nf(a.m, function(a) { | |
| Eh(c, a, false); | |
| }, a); | |
| J(c, a.m[i]); | |
| /** @type {string} */ | |
| c.style.top = c.style.left = c.style.right = c.style.bottom = ""; | |
| if (a.b) { | |
| n = cj(a.b, a.c); | |
| d = zo(a.b, i); | |
| if (wo(i)) { | |
| c.style.top = Ao(n.y + d.y, a.c.offsetHeight - 15) + md; | |
| } else { | |
| c.style.left = Ao(n.x + d.x, a.c.offsetWidth - 15) + md; | |
| } | |
| } else { | |
| c.style[0 == n ? wo(i) ? "top" : Pc : wo(i) ? "bottom" : qd] = d + md; | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {number} opt_max | |
| * @return {?} | |
| */ | |
| var Ao = function(a, opt_max) { | |
| return 15 > opt_max ? 15 : Math.min(Math.max(a, 15), opt_max); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var xo = function(a, b) { | |
| switch(a) { | |
| case 2: | |
| return 0 == b ? 1 : 5; | |
| case 1: | |
| return 0 == b ? 0 : 4; | |
| case 0: | |
| return 0 == b ? 12 : 13; | |
| default: | |
| return 0 == b ? 8 : 9; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {number} bidx | |
| * @return {?} | |
| */ | |
| var zo = function(b, bidx) { | |
| /** @type {number} */ | |
| var width = 0; | |
| /** @type {number} */ | |
| var height = 0; | |
| var reply = hj(b); | |
| switch(bidx) { | |
| case 2: | |
| /** @type {number} */ | |
| width = reply.width / 2; | |
| break; | |
| case 1: | |
| /** @type {number} */ | |
| width = reply.width / 2; | |
| height = reply.height; | |
| break; | |
| case 0: | |
| /** @type {number} */ | |
| height = reply.height / 2; | |
| break; | |
| case 3: | |
| width = reply.width; | |
| /** @type {number} */ | |
| height = reply.height / 2; | |
| } | |
| return new L(width, height); | |
| }; | |
| /** | |
| * @param {number} method | |
| * @return {?} | |
| */ | |
| var wo = function(method) { | |
| return 0 == method || 3 == method; | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Bo = function(b) { | |
| Aj.call(this); | |
| this.b = b || Qh(); | |
| }; | |
| C(Bo, Aj); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Bo.prototype.j = function() { | |
| cn(this.l(), "tooltip"); | |
| dn(this.l(), "live", "polite"); | |
| }; | |
| /** | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| var Do = function(value) { | |
| Bo.call(this, value); | |
| this.a = this.b.b(qb, Co() + "-contentId"); | |
| this.c = this.b.b(qb, Co() + "-arrow", this.b.b(qb, Co() + "-arrowimplbefore"), this.b.b(qb, Co() + "-arrowimplafter")); | |
| this.g = this.b.b(qb, { | |
| "class" : Co(), | |
| role : "tooltip" | |
| }, this.a, this.c); | |
| this.j(); | |
| }; | |
| C(Do, Bo); | |
| var Co = x("jfk-tooltip"); | |
| Do.prototype.l = w("g"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Do.prototype.J = function() { | |
| if (this.g) { | |
| mi(this.g); | |
| } | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var Eo = function(p1__3354_SHARP_) { | |
| Do.call(this, p1__3354_SHARP_); | |
| }; | |
| C(Eo, Do); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Eo.prototype.j = function() { | |
| cn(this.l(), "tooltip"); | |
| }; | |
| /** | |
| * @param {!Object} callback | |
| * @param {string} path | |
| * @return {undefined} | |
| */ | |
| var Go = function(callback, path) { | |
| Fo(callback, path, void 0); | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| var Ho = function(n) { | |
| var QueryLanguageComponent = n.getAttribute(Xd); | |
| if (QueryLanguageComponent) { | |
| Fo(n, QueryLanguageComponent); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {!Object} r | |
| * @return {undefined} | |
| */ | |
| var Fo = function(a, b, r) { | |
| if (!r) { | |
| r = b instanceof Fg ? no(Gg(b)) : b; | |
| } | |
| a.removeAttribute(Xd); | |
| a.removeAttribute(ib); | |
| a.removeAttribute(fb); | |
| if (b) { | |
| if (b instanceof Fg) { | |
| /** @type {string} */ | |
| a.b = b; | |
| } else { | |
| a.setAttribute(fb, b); | |
| /** @type {null} */ | |
| a.b = null; | |
| } | |
| a.setAttribute("aria-label", r); | |
| } else { | |
| /** @type {null} */ | |
| a.b = null; | |
| a.removeAttribute("aria-label"); | |
| } | |
| a = Qh(a) || Qh(); | |
| b = Le(a.a); | |
| if (!Io[b]) { | |
| Io[b] = new Jo(a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} ctx | |
| * @return {undefined} | |
| */ | |
| var Ko = function(ctx) { | |
| ctx.setAttribute(hb, "t,c"); | |
| }; | |
| /** | |
| * @param {boolean} isIron | |
| * @return {undefined} | |
| */ | |
| var Lo = function(isIron) { | |
| var s = M(bc); | |
| if (isIron) { | |
| s.setAttribute(jb, ie); | |
| } else { | |
| s.removeAttribute(jb); | |
| } | |
| }; | |
| var Io = {}; | |
| /** | |
| * @param {string} z | |
| * @return {undefined} | |
| */ | |
| var Jo = function(z) { | |
| nk.call(this); | |
| /** @type {string} */ | |
| this.G = z; | |
| this.K = new io(this.P, 0, this); | |
| Cj(this, this.K); | |
| var attr = $h(); | |
| this.B = He(attr.MutationObserver) ? new attr.MutationObserver(A(this.I, this)) : null; | |
| z = z.a; | |
| this.a(z, [Xc, Vc, r, Va, Hj, Ic], this.H, true); | |
| this.a(z, [Yc, wb, Gj], this.N, true); | |
| }; | |
| C(Jo, nk); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Jo.prototype.J = function() { | |
| Mo(this); | |
| Jo.v.J.call(this); | |
| }; | |
| /** | |
| * @param {?} query | |
| * @param {string} fn | |
| * @return {undefined} | |
| */ | |
| var No = function(query, fn) { | |
| switch(fn.type) { | |
| case Vc: | |
| case Yc: | |
| case Xc: | |
| case r: | |
| /** @type {boolean} */ | |
| query.A = false; | |
| break; | |
| case Ic: | |
| /** @type {boolean} */ | |
| query.A = true; | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Jo.prototype.N = function(key) { | |
| if (this.B) { | |
| this.B.disconnect(); | |
| } | |
| No(this, key); | |
| var node = key.target; | |
| /** @type {boolean} */ | |
| key = key.type == wb || key.type == Gj; | |
| var c = this.c && ti(this.c.a, node); | |
| if (this.A || !key || c) { | |
| /** @type {string} */ | |
| this.L = key; | |
| if (key = node && node.getAttribute && this.B) { | |
| key = node.getAttribute(rd) || null; | |
| key = Ef(bn, key); | |
| } | |
| if (key) { | |
| this.B.observe(node, { | |
| attributes : true | |
| }); | |
| if (key = fn(node)) { | |
| /** @type {string} */ | |
| node = key; | |
| } | |
| } | |
| this.j = node; | |
| } else { | |
| /** @type {null} */ | |
| this.j = null; | |
| } | |
| Oo(this); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Jo.prototype.H = function(key) { | |
| No(this, key); | |
| var id = key.target; | |
| /** @type {boolean} */ | |
| key = key.type == Vc || key.type == r; | |
| id = this.c && ti(this.c.a, id); | |
| if (!(key && id)) { | |
| /** @type {null} */ | |
| this.j = null; | |
| Oo(this); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Jo.prototype.I = function(name) { | |
| xf(name, A(function(event) { | |
| var b = fn(event.target); | |
| if (b && event.attributeName == Na) { | |
| this.j = b; | |
| Oo(this); | |
| } | |
| }, this)); | |
| }; | |
| /** | |
| * @param {!Object} global | |
| * @return {undefined} | |
| */ | |
| var Oo = function(global) { | |
| Mo(global); | |
| ko(global.K, global.g ? 50 : 300); | |
| }; | |
| /** | |
| * @param {!Object} global | |
| * @return {undefined} | |
| */ | |
| var Mo = function(global) { | |
| if (global.C) { | |
| dl(global.C); | |
| /** @type {number} */ | |
| global.C = 0; | |
| /** @type {null} */ | |
| global.g = null; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Jo.prototype.P = function() { | |
| if (!this.j) { | |
| Po(this); | |
| /** @type {null} */ | |
| this.g = null; | |
| } else { | |
| if (!(this.g && this.c && ti(this.c.l(), this.j)) || this.g.getAttribute("data-tooltip-unhoverable")) { | |
| var t = Hi(this.j, function(b) { | |
| return b.getAttribute && (b.getAttribute(ib) || b.getAttribute(fb) || b.b) && !b.getAttribute(jb); | |
| }); | |
| /** @type {boolean} */ | |
| var g = false; | |
| if (this.g && this.g != t) { | |
| Po(this); | |
| /** @type {null} */ | |
| this.g = null; | |
| /** @type {boolean} */ | |
| g = true; | |
| } | |
| if (!this.g && t && (this.g = t, Qo(this, t))) { | |
| var j = Qg; | |
| if (t.getAttribute(ib)) { | |
| var c = Th("jfk-tooltip-data", t); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < c.length; i++) { | |
| if (c[i].parentNode == t) { | |
| j = c[i].cloneNode(true); | |
| break; | |
| } | |
| } | |
| } else { | |
| j = t.b ? t.b : Jg(t.getAttribute(fb)); | |
| } | |
| c = t.getAttribute(hb); | |
| i = t.getAttribute("data-tooltip-class"); | |
| var key = t.getAttribute("data-tooltip-offset"); | |
| /** @type {number} */ | |
| key = Te(pf(key)) ? -1 : Number(key); | |
| if (!g && (t = t.getAttribute("data-tooltip-delay"), t = Math.max(0, t - 300))) { | |
| this.C = cl(Oe(this.O, this.g, j, c, key, i), t, this); | |
| return; | |
| } | |
| this.O(this.g, j, c, key, i); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} value | |
| * @param {!Element} elem | |
| * @return {?} | |
| */ | |
| var Qo = function(value, elem) { | |
| return elem.getAttribute("data-tooltip-only-on-overflow") && elem.offsetWidth >= elem.scrollWidth && elem.offsetHeight >= elem.scrollHeight || value.L && "mouse" == elem.getAttribute("data-tooltip-trigger") ? false : true; | |
| }; | |
| /** | |
| * @param {string} bstr | |
| * @return {?} | |
| */ | |
| var Ro = function(bstr) { | |
| if (bstr) { | |
| switch(bstr.toLowerCase().split(",")[0]) { | |
| case "l": | |
| return 0; | |
| case "t": | |
| return 2; | |
| case "r": | |
| return 3; | |
| } | |
| } | |
| return 1; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {!Object} name | |
| * @param {string} b | |
| * @param {string} input | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| Jo.prototype.O = function(key, name, b, input, x) { | |
| /** @type {number} */ | |
| this.C = 0; | |
| if (!this.c) { | |
| this.c = new Eo(this.G); | |
| Po(this); | |
| this.G.a.body.appendChild(this.c.l()); | |
| Cj(this, this.c); | |
| this.m = new to(Co(), true); | |
| /** @type {boolean} */ | |
| this.m.oe = true; | |
| /** @type {boolean} */ | |
| this.m.Ne = true; | |
| var c = this.m; | |
| var j = this.c.c; | |
| c.c = this.c.l(); | |
| c.j = j; | |
| } | |
| a: { | |
| if (b) { | |
| switch(b.toLowerCase().split(",")[1]) { | |
| case "l": | |
| /** @type {number} */ | |
| c = 0; | |
| break a; | |
| case "r": | |
| /** @type {number} */ | |
| c = 1; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| c = 2; | |
| } | |
| uo(this.m, Ro(b), c, input); | |
| K(this.c.l(), Gc); | |
| if (this.w != x) { | |
| if (this.w && !Te(pf(this.w))) { | |
| K(this.c.l(), this.w); | |
| } | |
| if (!Te(pf(x))) { | |
| J(this.c.l(), x); | |
| } | |
| /** @type {number} */ | |
| this.w = x; | |
| } | |
| Wi(this.c.l(), 0, 0); | |
| if (name instanceof Fg) { | |
| Nh(this.c.a, name); | |
| } else { | |
| ji(this.c.a); | |
| for (; b = name.firstChild;) { | |
| this.c.a.appendChild(b); | |
| } | |
| } | |
| /** @type {string} */ | |
| this.m.b = key; | |
| this.m.a(null, 0); | |
| }; | |
| /** | |
| * @param {!Object} color | |
| * @return {undefined} | |
| */ | |
| var Po = function(color) { | |
| if (color.c) { | |
| J(color.c.l(), Gc); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {string} b | |
| * @param {?} result | |
| * @param {?} entry__3995__auto__ | |
| * @return {undefined} | |
| */ | |
| var So = function(a, b, result, entry__3995__auto__) { | |
| ho.call(this, a, result || wn.M(), entry__3995__auto__); | |
| this.A = a; | |
| this.b = b || null; | |
| }; | |
| C(So, ho); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| So.prototype.ma = function(a) { | |
| So.v.ma.call(this, a); | |
| if (null != this.b) { | |
| this.g(this.Ea() ? this.b : this.A); | |
| } | |
| }; | |
| /** | |
| * @param {?} time | |
| * @param {?} el | |
| * @param {?} property | |
| * @param {?} opt | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| var To = function(time, el, property, opt, value) { | |
| So.call(this, time, property, opt, value); | |
| this.I = el; | |
| }; | |
| C(To, So); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| To.prototype.ma = function(a) { | |
| To.v.ma.call(this, a); | |
| S(this.I, this.Ea()); | |
| }; | |
| var Uo = ve("g"); | |
| C(Uo, wn); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| Uo.prototype.Pa = function(a) { | |
| var document = a.a.b(qb, nn(this, a).join(" ")); | |
| var version = a.a.b(Hd); | |
| var d = a.a.b(Hd); | |
| if (this.g) { | |
| J(document, this.g); | |
| } | |
| J(document, Ec); | |
| d.className = Cc; | |
| version.className = Bc; | |
| document.appendChild(version); | |
| if (a.Aa()) { | |
| document.appendChild(d); | |
| this.zb(document, a.Aa()); | |
| } else { | |
| J(document, Dc); | |
| } | |
| return document; | |
| }; | |
| /** | |
| * @param {!Node} node | |
| * @param {string} selector | |
| * @return {undefined} | |
| */ | |
| Uo.prototype.zb = function(node, selector) { | |
| if (node) { | |
| var element = xe(node.lastElementChild) ? node.lastElementChild : oi(node.lastChild, false); | |
| if (element) { | |
| Q(element, selector); | |
| } | |
| } | |
| }; | |
| Uo.prototype.S = x("jfk-button"); | |
| /** | |
| * @param {!Object} a | |
| * @param {!HTMLElement} b | |
| * @return {?} | |
| */ | |
| Uo.prototype.R = function(a, b) { | |
| var c = a.a.b(Hd); | |
| var d = a.a.b(Hd); | |
| if (this.g) { | |
| J(b, this.g); | |
| } | |
| J(b, Ec); | |
| d.className = Cc; | |
| c.className = Bc; | |
| ji(b); | |
| b.appendChild(c); | |
| if (a.Aa()) { | |
| b.appendChild(d); | |
| this.zb(b, a.Aa()); | |
| } else { | |
| J(b, Dc); | |
| } | |
| return b = Uo.v.R.call(this, a, b); | |
| }; | |
| /** | |
| * @param {string} g | |
| * @param {string} margin | |
| * @return {undefined} | |
| */ | |
| var Vo = function(g, margin) { | |
| /** @type {string} */ | |
| this.g = g; | |
| this.j = margin || false; | |
| }; | |
| C(Vo, wn); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| Vo.prototype.Pa = function(a) { | |
| var document = a.a.b(qb, nn(this, a).join(" ") + " goog-inline-block"); | |
| var version = a.a.b(Hd); | |
| if (this.g) { | |
| J(document, this.g); | |
| } | |
| version.className = Bc; | |
| document.appendChild(version); | |
| if (a.Aa()) { | |
| this.zb(document, a.Aa()); | |
| } | |
| return document; | |
| }; | |
| /** | |
| * @param {!Element} a | |
| * @param {string} fn | |
| * @return {undefined} | |
| */ | |
| Vo.prototype.zb = function(a, fn) { | |
| if (a && !this.j) { | |
| Go(a, fn); | |
| Ko(a); | |
| } | |
| }; | |
| Vo.prototype.S = x("goog-toolbar-button"); | |
| /** | |
| * @param {!Object} a | |
| * @param {!HTMLElement} b | |
| * @return {?} | |
| */ | |
| Vo.prototype.R = function(a, b) { | |
| var c = a.a.b(Hd); | |
| if (this.g) { | |
| J(b, this.g); | |
| } | |
| c.className = Bc; | |
| ji(b); | |
| b.appendChild(c); | |
| if (a.Aa()) { | |
| this.zb(b, a.Aa()); | |
| } | |
| return b = Vo.v.R.call(this, a, b); | |
| }; | |
| /** | |
| * @param {number} startIndex | |
| * @return {?} | |
| */ | |
| var Wo = function(startIndex) { | |
| return 32 >= startIndex || 4096 <= startIndex && (8192 <= startIndex && 8198 >= startIndex || 8200 <= startIndex && 8203 >= startIndex || 5760 == startIndex || 6158 == startIndex || 8232 == startIndex || 8233 == startIndex || 8287 == startIndex || 12288 == startIndex); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Zo = function(a) { | |
| /** @type {function(?, number): ?} */ | |
| var linkSourceIsNode = Xo; | |
| if (15 > a.length) { | |
| return a; | |
| } | |
| /** @type {!Array} */ | |
| var gallerysb = []; | |
| /** @type {number} */ | |
| var d = 0; | |
| /** @type {number} */ | |
| var b = 0; | |
| /** @type {number} */ | |
| var f = 0; | |
| /** @type {number} */ | |
| var g = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; i++) { | |
| var m = g; | |
| g = a.charCodeAt(i); | |
| /** @type {boolean} */ | |
| m = 768 <= g && !linkSourceIsNode(m, g, true); | |
| if (15 <= d && !Wo(g) && !m) { | |
| gallerysb.push(a.substring(f, i), Yo); | |
| /** @type {number} */ | |
| f = i; | |
| /** @type {number} */ | |
| d = 0; | |
| } | |
| if (b) { | |
| if (62 == g && 60 == b) { | |
| /** @type {number} */ | |
| b = 0; | |
| } else { | |
| if (59 == g && 38 == b) { | |
| /** @type {number} */ | |
| b = 0; | |
| d++; | |
| } | |
| } | |
| } else { | |
| if (60 == g || 38 == g) { | |
| b = g; | |
| } else { | |
| if (Wo(g)) { | |
| /** @type {number} */ | |
| d = 0; | |
| } else { | |
| if (!(8204 <= g && 8207 >= g || 8234 <= g && 8238 >= g)) { | |
| d++; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| gallerysb.push(a.substr(f)); | |
| return gallerysb.join(""); | |
| }; | |
| /** | |
| * @param {?} prop | |
| * @param {number} val | |
| * @return {?} | |
| */ | |
| var Xo = function(prop, val) { | |
| return 1024 <= val && 1315 > val; | |
| }; | |
| var $o = E && I(8); | |
| /** @type {string} */ | |
| var Yo = G ? "<wbr></wbr>" : fh ? "­" : $o ? "​" : "<wbr>"; | |
| var ap = {}; | |
| var bp = {}; | |
| var cp = {}; | |
| /** | |
| * @return {?} | |
| */ | |
| var dp = function() { | |
| throw Error("Do not instantiate directly"); | |
| }; | |
| /** @type {null} */ | |
| dp.prototype.ad = null; | |
| dp.prototype.Aa = w("content"); | |
| dp.prototype.toString = w("content"); | |
| /** | |
| * @param {string} data | |
| * @return {?} | |
| */ | |
| var ep = function(data) { | |
| if (data.Kb === cp) { | |
| return Ig(data.toString()); | |
| } | |
| if (data.Kb !== ap) { | |
| throw Error("Sanitized content was not of kind TEXT or HTML."); | |
| } | |
| var i = mg("Soy SanitizedContent of kind HTML produces SafeHtml-contract-compliant value."); | |
| var valueProgess = data.toString(); | |
| data = data.ad; | |
| lg(i); | |
| lg(i); | |
| return Hg(valueProgess, data || null); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var fp = function() { | |
| dp.call(this); | |
| }; | |
| C(fp, dp); | |
| /** | |
| * @param {!Function} Constructor | |
| * @param {?} object | |
| * @return {?} | |
| */ | |
| var ip = function(Constructor, object) { | |
| var clonedI = Qh(); | |
| var args = Constructor(object || gp, void 0, void 0); | |
| var margs = hp(args); | |
| if (args instanceof dp) { | |
| args = ep(args); | |
| } else { | |
| Li(); | |
| args = Hg(margs, null); | |
| } | |
| return fi(clonedI.a, args); | |
| }; | |
| /** | |
| * @param {string} p | |
| * @param {?} value | |
| * @param {!Object} d | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| var jp = function(p, value, d, c) { | |
| a: { | |
| if (p = p(value || gp, void 0, d), c = Ji(c || Qh(), k), p = hp(p), c.innerHTML = p, 1 == c.childNodes.length && (p = c.firstChild, 1 == p.nodeType)) { | |
| /** @type {string} */ | |
| c = p; | |
| break a; | |
| } | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var hp = function(val) { | |
| if (!Ie(val)) { | |
| return String(val); | |
| } | |
| if (val instanceof dp) { | |
| if (val.Kb === ap) { | |
| return val.Aa(); | |
| } | |
| if (val.Kb === cp) { | |
| return hf(val.Aa()); | |
| } | |
| } | |
| return "zSoyz"; | |
| }; | |
| var gp = {}; | |
| /** | |
| * @param {string} result | |
| * @return {?} | |
| */ | |
| var kp = function(result) { | |
| if (null != result) { | |
| switch(result.ad) { | |
| case 1: | |
| return 1; | |
| case -1: | |
| return -1; | |
| case 0: | |
| return 0; | |
| } | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var lp = function() { | |
| dp.call(this); | |
| }; | |
| C(lp, dp); | |
| lp.prototype.Kb = ap; | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| var Z = function(obj) { | |
| return null != obj && obj.Kb === ap ? obj : obj instanceof Fg ? mp(Gg(obj), obj.oc()) : mp(hf(String(String(obj))), kp(obj)); | |
| }; | |
| /** | |
| * @param {?} template | |
| * @param {string} isBounding | |
| * @return {undefined} | |
| */ | |
| var np = function(template, isBounding) { | |
| /** @type {string} */ | |
| this.content = String(template); | |
| this.ad = null != isBounding ? isBounding : null; | |
| }; | |
| C(np, fp); | |
| np.prototype.Kb = cp; | |
| var mp = function(WebSocket) { | |
| /** | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| function ws(text) { | |
| /** @type {string} */ | |
| this.content = text; | |
| } | |
| ws.prototype = WebSocket.prototype; | |
| return function(slackName, context) { | |
| var callback = new ws(String(slackName)); | |
| if (void 0 !== context) { | |
| /** @type {string} */ | |
| callback.ad = context; | |
| } | |
| return callback; | |
| }; | |
| }(lp); | |
| /** | |
| * @param {!Function} op | |
| * @param {?} callback | |
| * @return {?} | |
| */ | |
| var op = function(op, callback) { | |
| return jp(op, callback, void 0, new Oh(void 0)); | |
| }; | |
| (function(WebSocket) { | |
| /** | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| function ws(text) { | |
| /** @type {string} */ | |
| this.content = text; | |
| } | |
| ws.prototype = WebSocket.prototype; | |
| return function(a, val) { | |
| /** @type {string} */ | |
| var url = String(a); | |
| if (!url) { | |
| return ""; | |
| } | |
| url = new ws(url); | |
| if (void 0 !== val) { | |
| /** @type {string} */ | |
| url.ad = val; | |
| } | |
| return url; | |
| }; | |
| })(lp); | |
| /** | |
| * @param {?} msg | |
| * @return {?} | |
| */ | |
| var tp = function(msg) { | |
| return null != msg && msg.Kb === ap ? String(String(msg.Aa()).replace(pp, "").replace(qp, "<")).replace(rp, sp) : hf(String(msg)); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var xp = function(value) { | |
| if (null != value && value.Kb === bp) { | |
| return value.Aa().replace(/([^"'\s])$/, "$1 "); | |
| } | |
| /** @type {string} */ | |
| value = String(value); | |
| /** @type {string} */ | |
| value = up.test(value) ? value : "zSoyz"; | |
| return value; | |
| }; | |
| /** | |
| * @param {?} data | |
| * @return {?} | |
| */ | |
| var yp = function(data) { | |
| return null != data && data.Kb === cp ? (data.Aa(), "zSoyz") : data; | |
| }; | |
| var zp = { | |
| "\x00" : "�", | |
| "\t" : "	", | |
| "\n" : " ", | |
| "\x0B" : "", | |
| "\f" : "", | |
| "\r" : " ", | |
| " " : " ", | |
| '"' : """, | |
| "&" : "&", | |
| "'" : "'", | |
| "-" : "-", | |
| "/" : "/", | |
| "<" : "<", | |
| "=" : "=", | |
| ">" : ">", | |
| "`" : "`", | |
| "\u0085" : "…", | |
| "\u00a0" : " ", | |
| "\u2028" : "
", | |
| "\u2029" : "
" | |
| }; | |
| /** | |
| * @param {?} s | |
| * @return {?} | |
| */ | |
| var sp = function(s) { | |
| return zp[s]; | |
| }; | |
| /** @type {!RegExp} */ | |
| var rp = /[\x00\x22\x27\x3c\x3e]/g; | |
| /** @type {!RegExp} */ | |
| var up = /^(?!on|src|(?:style|action|archive|background|cite|classid|codebase|data|dsync|href|longdesc|usemap)\s*$)(?:[a-z0-9_$:-]*)$/i; | |
| /** @type {!RegExp} */ | |
| var pp = /<(?:!|\/?([a-zA-Z][a-zA-Z0-9:\-]*))(?:[^>'"]|"[^"]*"|'[^']*')*>/g; | |
| /** @type {!RegExp} */ | |
| var qp = /</g; | |
| /** | |
| * @param {?} sf | |
| * @return {?} | |
| */ | |
| var Ap = function(sf) { | |
| return '<div id="gt-apb-pb" style="display:none"><div id="gt-pb-tt">' + Z(sf.Df) + '</div><div id="gt-apb-pb-r"><input id="gt-pb-sb" type="text"><div id="pb-back-c" class="goog-inline-block"></div><button id="gt-pb-sbt" class="jfk-button jfk-button-action"><span class="jfk-button-img"></span></button><div id="gt-pb-sw2" class="goog-inline-block"></div></div></div>'; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var Bp = function(a) { | |
| return '<div id="gt-pb-c" style="display:none"><div id="gt-pb"><div id="gt-pb-pt">' + Z(a.Df) + '</div><div id="pb-tool" class="goog-toolbar"><div id="pb-cb-a" class="goog-inline-block"></div><div id="pb-dd" class="goog-inline-block"><div id="pb-ls"></div><div class="goog-toolbar-separator goog-inline-block"></div><div id="pb-st"></div></div><div id="pb-sh" class="goog-inline-block" style="display:none"></div><div class="goog-toolbar-separator goog-inline-block" id="pb-sp-del" style="display:none"></div><div id="pb-del-c" class="goog-inline-block"></div><div id="pb-tool-r" class="goog-inline-block"></div></div><div id="pb-tb-c" class="jfk-scrollbar-borderless"><div id="gt-pb-spin" style="display:none"></div><div id="pb-empty"></div><table id="gt-pb-tb"><colgroup><col><col><col width="50%"><col><col width="50%"></colgroup><table></div></div></div>'; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var Cp = function(a) { | |
| return '<div class="st-stp1"><div class="st-stp1-text"><div>' + Z(a.Si) + '</div></div><div id="st-buttons"></div></div>'; | |
| }; | |
| /** | |
| * @param {?} loc | |
| * @return {?} | |
| */ | |
| var Dp = function(loc) { | |
| return '<div class="pt-icon goog-inline-block"></div><div class="pt-text goog-inline-block"><div class="pt-act">' + Z(loc.Dh) + '</div><div class="pt-desc">' + Z(loc.$e) + "</div></div>"; | |
| }; | |
| var Ep = x('<div class="gt-hats-t"><div class="gt-hats-x clear-button"><div class="jfk-button-img"></div></div><div class="gt-hats-tt"></div></div><div class="gt-hats-c"></div>'); | |
| /** | |
| * @param {?} h | |
| * @return {?} | |
| */ | |
| var Fp = function(h) { | |
| return '<div class="gt-hats-af">' + Z(h.Eh) + '</div><a href="javascript:void(0);" class="gt-hats-link">' + Z(h.qd) + "</a>"; | |
| }; | |
| var Gp = x('<div class="gt-cc-t"><span class="gt-cc-tc"></span><span class="gt-cc-bc"></span></div><div class="gt-cc"><div class="gt-cc-l"><div class="gt-cc-l-i"></div><div class="gt-cc-exp" style="display:none"><div class="cd-exp-ar"></div></div></div><div class="gt-cc-r"><div class="gt-cc-r-i"></div></div></div>'); | |
| var Hp = x('<div class="gt-cd-t"><div class="gt-cd-tl"></div><div class="gt-cd-tr"></div></div><div class="gt-cd-c"></div><div class="cd-expand-button"><span class="jfk-button-img"></span><span class="cd-expand-label"></span></div>'); | |
| var Ip = x('<span class="gt-ct-text"></span><span class="gt-ct-translit" style="display:none"></span><div class="gt-ct-tts goog-inline-block"></div>'); | |
| /** | |
| * @param {?} n | |
| * @return {?} | |
| */ | |
| var Jp = function(n) { | |
| return '<div class="gt-ex-info"><div class="gt-ex-top"><div class="gt-ex-text" dir="' + Z(n.uj) + '">' + yp(n.fh) + '</div></div><div class="gt-ex-mt" style="display:none"><span class="gt-cd-mt" dir="' + Z(n.Tf) + '"></span><br><span class="gt-cd-mt-label">' + Z(n.Mj) + '</span><span class="gt-ex-credit"><a class="gt-ex-link" target="_blank" href="' + Z(n.yf) + '">' + Z(n.Li) + "</a></span></div></div>"; | |
| }; | |
| /** | |
| * @param {?} info | |
| * @return {?} | |
| */ | |
| var Kp = function(info) { | |
| /** @type {string} */ | |
| var val = '<div class="gt-def-info"><div class="gt-def-row">' + Z(info.Oh) + '<div class="gt-mt-md" style="display:none"><span class="gt-cd-mt"></span></div></div>' + (info.kg ? '<div class="gt-def-example"><q>' + Z(info.kg) + '</q><div class="gt-mt-ex" style="display:none"><q class="gt-cd-mt" dir="' + Z(info.Tf) + '"></q></div></div>' : ""); | |
| if (0 < info.ih.length) { | |
| /** @type {string} */ | |
| val = val + ('<div class="gt-def-synonym"><span class="gt-def-synonym-title">' + Z(info.xj) + ': </span><span class="gt-def-synonyms-group"></span><span class="gt-def-synonyms-group"></span>'); | |
| var files = info.ih; | |
| var count = files.length; | |
| /** @type {number} */ | |
| var index = 0; | |
| for (; index < count; index++) { | |
| var array = files[index]; | |
| var length = array.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < length; i++) { | |
| var first = array[i]; | |
| /** @type {string} */ | |
| val = val + ((info.Mh ? '<span class="gt-cd-cl">' + Z(first) + "</span>" : "<span>" + Z(first) + "</span>") + (i != length - 1 ? ", " : index != count - 1 ? "; " : "")); | |
| } | |
| } | |
| val = val + la; | |
| } | |
| return val + la; | |
| }; | |
| /** | |
| * @param {!Object} pSample | |
| * @return {?} | |
| */ | |
| var Lp = function(pSample) { | |
| return '<div><div class="speech-mic"><div class="gt-speech-l1"></div><div class="gt-speech-l2"></div><div class="gt-speech-l3"></div><div class="gt-speech-l4"></div></div><div class="speech-mic-label">' + Z(pSample.label) + "</div></div>"; | |
| }; | |
| var Mp = x('<div class="gt-ee-container"></div>'); | |
| /** | |
| * @param {?} n | |
| * @return {?} | |
| */ | |
| var Np = function(n) { | |
| return '<a href="' + Z(n.yf) + '"></a>'; | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| var Op = function(c) { | |
| return '<div class="share-panel goog-menu-nocheckbox"><h3>' + Z(c.sj) + '</h3><ul><li><a href="mailto:?body=' + Z(c.ph) + '" target="_top" class="email"><span class="share-link-icon"></span><span> ' + Z(c.rj) + ' </span></a></li><li><a href="https://twitter.com/intent/tweet?text=' + Z(c.ph) + '" target="_blank" class="twitter"><span class="share-link-icon"></span><span> Twitter </span></a></li><li><a href="https://plus.google.com/share?url=' + Z(c.url) + '" target="_blank" class="gplus"><span class="share-link-icon"></span><span> Google+ </span></a></li></ul></div>'; | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @return {?} | |
| */ | |
| var Pp = function(result) { | |
| var records; | |
| result = result || {}; | |
| var toString = mp; | |
| /** @type {string} */ | |
| var d = '<div role="button"' + (result.id ? ' id="' + tp(result.id) + '"' : "") + ' class="'; | |
| var current; | |
| var _ref; | |
| current = result || {}; | |
| /** @type {string} */ | |
| var g0 = "goog-inline-block jfk-button "; | |
| switch(Ie(_ref = current.style) ? _ref.toString() : _ref) { | |
| case 0: | |
| g0 = g0 + Ec; | |
| break; | |
| case 2: | |
| g0 = g0 + Ac; | |
| break; | |
| case 3: | |
| /** @type {string} */ | |
| g0 = g0 + "jfk-button-primary"; | |
| break; | |
| case 1: | |
| /** @type {string} */ | |
| g0 = g0 + "jfk-button-default"; | |
| break; | |
| case 4: | |
| /** @type {string} */ | |
| g0 = g0 + "jfk-button-flat"; | |
| break; | |
| case 5: | |
| /** @type {string} */ | |
| g0 = g0 + "jfk-button-mini"; | |
| break; | |
| case 6: | |
| /** @type {string} */ | |
| g0 = g0 + "jfk-button-contrast"; | |
| break; | |
| default: | |
| g0 = g0 + Ec; | |
| } | |
| /** @type {string} */ | |
| g0 = g0 + ((1 == current.width ? " jfk-button-narrow" : "") + (current.checked ? " jfk-button-checked" : "") + (current.Ue ? " " + current.Ue : "") + (current.disabled ? " jfk-button-disabled" : "")); | |
| return toString(d + tp(new np(g0, void 0)) + '"' + (result.disabled ? ' aria-disabled="true"' : ' tabindex="' + (result.Of ? tp(result.Of) : "0") + '"') + (result.title ? " " + (result.Oj ? fb : Xd) + '="' + tp(result.title) + '"' : "") + (result.value ? ' value="' + tp(result.value) + '"' : "") + (result.attributes ? " " + xp(result.attributes) : "") + ">" + Z(null == (records = result.content) ? "" : records) + la); | |
| }; | |
| /** | |
| * @param {?} event | |
| * @param {?} a | |
| * @param {string} b | |
| * @param {string} variableNames | |
| * @return {undefined} | |
| */ | |
| var Rp = function(event, a, b, variableNames) { | |
| eo.call(this, event, Qp.M(), a); | |
| this.b = b || 0; | |
| this.A = variableNames || 0; | |
| /** @type {boolean} */ | |
| this.pb = false; | |
| }; | |
| C(Rp, eo); | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Tp = function(a, b) { | |
| if (a.b != b) { | |
| /** @type {number} */ | |
| a.b = b; | |
| Sp(a); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} fn | |
| * @return {undefined} | |
| */ | |
| Rp.prototype.ba = function(fn) { | |
| if (this.isEnabled() != fn) { | |
| Rp.v.ba.call(this, fn); | |
| Sp(this); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} c | |
| * @return {undefined} | |
| */ | |
| Rp.prototype.hc = function(c) { | |
| Rp.v.hc.call(this, c); | |
| Up(this, false); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Rp.prototype.Za = function(name) { | |
| Rp.v.Za.call(this, name); | |
| if (this.isEnabled()) { | |
| Up(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {undefined} | |
| */ | |
| Rp.prototype.ib = function(node) { | |
| Rp.v.ib.call(this, node); | |
| if (this.isEnabled()) { | |
| Up(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {boolean} handle | |
| * @return {undefined} | |
| */ | |
| var Up = function(item, handle) { | |
| if (item.l()) { | |
| Eh(item.l(), "jfk-button-clear-outline", handle); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| var Sp = function(name) { | |
| if (name.l()) { | |
| Vp(name.c, name); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Qp = function() { | |
| this.G = this.S() + "-standard"; | |
| this.g = this.S() + "-action"; | |
| this.F = this.S() + "-primary"; | |
| this.o = this.S() + "-default"; | |
| this.B = this.S() + "-flat"; | |
| this.w = this.S() + "-narrow"; | |
| this.C = this.S() + "-mini"; | |
| this.m = this.S() + "-contrast"; | |
| }; | |
| C(Qp, wn); | |
| Be(Qp); | |
| y = Qp.prototype; | |
| /** | |
| * @param {undefined} lines | |
| * @param {boolean} value | |
| * @param {!Object} input | |
| * @return {undefined} | |
| */ | |
| y.jc = function(lines, value, input) { | |
| if (lines) { | |
| Tp(input, lines); | |
| } | |
| if (value && input.A != value) { | |
| /** @type {boolean} */ | |
| input.A = value; | |
| Sp(input); | |
| } | |
| }; | |
| y.S = x("jfk-button"); | |
| /** | |
| * @param {!Object} self | |
| * @return {?} | |
| */ | |
| y.Pa = function(self) { | |
| var m = self.a; | |
| var c = jp(Pp, { | |
| disabled : !self.isEnabled(), | |
| checked : self.Ea(), | |
| style : self.b, | |
| title : self.w, | |
| Oj : self.pb, | |
| value : self.T(), | |
| width : self.A | |
| }, void 0, m); | |
| m.rg(c, self.Aa()); | |
| this.R(self, c); | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} state | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| y.R = function(state, val) { | |
| Qp.v.R.call(this, state, val); | |
| if (!this.j) { | |
| this.j = Xf(this.G, Oe(this.jc, 0, null), this.g, Oe(this.jc, 2, null), this.F, Oe(this.jc, 3, null), this.o, Oe(this.jc, 1, null), this.B, Oe(this.jc, 4, null), this.C, Oe(this.jc, 5, null), this.m, Oe(this.jc, 6, null), this.w, Oe(this.jc, null, 1)); | |
| } | |
| var s = Ah(val); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < s.length; ++i) { | |
| var set = this.j[s[i]]; | |
| if (set) { | |
| set(state); | |
| } | |
| } | |
| if (s = val.getAttribute(fb)) { | |
| state.w = s; | |
| /** @type {boolean} */ | |
| state.pb = true; | |
| } | |
| return val; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| y.T = function(key) { | |
| return key.getAttribute("value") || ""; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| y.Ud = function(key, name) { | |
| if (key) { | |
| key.setAttribute("value", name); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} exports | |
| * @param {!Object} module | |
| * @return {undefined} | |
| */ | |
| var Vp = function(exports, module) { | |
| /** | |
| * @param {boolean} a | |
| * @param {string} fn | |
| * @return {undefined} | |
| */ | |
| function map(a, fn) { | |
| (a ? f : i).push(fn); | |
| } | |
| /** @type {!Array} */ | |
| var f = []; | |
| /** @type {!Array} */ | |
| var i = []; | |
| var cb = module.b; | |
| map(0 == cb, exports.G); | |
| map(2 == cb, exports.g); | |
| map(3 == cb, exports.F); | |
| map(4 == cb, exports.B); | |
| map(5 == cb, exports.C); | |
| map(1 == cb, exports.o); | |
| map(6 == cb, exports.m); | |
| map(1 == module.A, exports.w); | |
| map(!module.isEnabled(), exports.S() + da); | |
| Dh(module.l(), i); | |
| Ch(module.l(), f); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Wp = function() { | |
| /** @type {!Array} */ | |
| this.g = []; | |
| this.b = {}; | |
| this.a = {}; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| /** @type {number} */ | |
| this.Ef = 1; | |
| this.$c = {}; | |
| /** @type {string} */ | |
| this.j = ""; | |
| U(window, Ua, this.C, false, this); | |
| }; | |
| Be(Wp); | |
| /** | |
| * @param {string} a | |
| * @param {string} val | |
| * @param {string} list | |
| * @return {?} | |
| */ | |
| var Xp = function(a, val, list) { | |
| if (null == val) { | |
| return "1"; | |
| } | |
| switch(Ce(val)) { | |
| case Rd: | |
| return a = val, !(64 < a.length) || null != list && list || (a = a.substr(0, 64)), Xe(a); | |
| case bd: | |
| return "" + val; | |
| case "boolean": | |
| return val ? "1" : "0"; | |
| case Oa: | |
| /** @type {!Array} */ | |
| var results = []; | |
| var i; | |
| for (i in val) { | |
| results.push(Xp(a, val[i], list)); | |
| } | |
| return results.join(","); | |
| case cd: | |
| /** @type {!Array} */ | |
| results = []; | |
| for (i in val) { | |
| results.push(Yp(a, i, val[i], list)); | |
| } | |
| return results.join(","); | |
| default: | |
| return ""; | |
| } | |
| }; | |
| /** | |
| * @param {string} b | |
| * @param {string} a | |
| * @param {string} func | |
| * @param {string} element | |
| * @return {?} | |
| */ | |
| var Yp = function(b, a, func, element) { | |
| return [Xe(a), Xp(b, func, element || "smtalt" == a)].join("="); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Wp.prototype.log = function(name, value) { | |
| this.g.push([name, value]); | |
| if (!this.m) { | |
| /** @type {boolean} */ | |
| this.m = true; | |
| cl(this.o, 0, this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {string} type | |
| * @param {string} name | |
| * @param {string} arr | |
| * @return {undefined} | |
| */ | |
| var aq = function(a, b, type, name, arr) { | |
| /** @type {string} */ | |
| b = a.j + ga + Yp(a, type, name) + "&" + Yp(a, ab, b, true); | |
| if (arr) { | |
| /** @type {string} */ | |
| b = b + Zp(a, arr); | |
| } | |
| $p(a, b); | |
| }; | |
| /** | |
| * @param {!Object} hex | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var Zp = function(hex, a) { | |
| /** @type {string} */ | |
| var pix_color = ""; | |
| if (xe(a)) { | |
| Nf(a, function(a, cX1) { | |
| if (a instanceof Array) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; i++) { | |
| /** @type {string} */ | |
| pix_color = pix_color + ("&" + Yp(this, cX1, a[i])); | |
| } | |
| } else { | |
| pix_color = pix_color + ("&" + Yp(this, cX1, a)); | |
| } | |
| }, hex); | |
| } | |
| return pix_color; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Wp.prototype.o = function() { | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < this.g.length; key++) { | |
| var keySave = this.g[key]; | |
| $p(this, this.j + ga + Yp(this, keySave[0], keySave[1])); | |
| } | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| }; | |
| /** | |
| * @param {!Object} component | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| var $p = function(component, key) { | |
| /** @type {!Image} */ | |
| var i = new Image; | |
| /** @type {number} */ | |
| var j = component.Ef++; | |
| /** @type {!Image} */ | |
| component.$c[j] = i; | |
| /** @type {function(): undefined} */ | |
| i.onload = i.onerror = function() { | |
| delete Wp.M().$c[j]; | |
| }; | |
| /** @type {string} */ | |
| i.src = key; | |
| /** @type {null} */ | |
| i = null; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} x | |
| * @param {?} context | |
| * @param {string} path | |
| * @return {undefined} | |
| */ | |
| var cq = function(options, x, context, path) { | |
| /** @type {null} */ | |
| var t = null; | |
| if (x in options.b) { | |
| t = options.b[x]; | |
| } | |
| options.b[x] = bq(t, context, path); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} x | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| Wp.prototype.c = function(name, type, x, data) { | |
| dq(this, name, x, data); | |
| dl(this.a[name][0]); | |
| type = cl(A(this.B, this, name), type); | |
| /** @type {string} */ | |
| this.a[name][0] = type; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Wp.prototype.B = function(name) { | |
| $p(this, this.j + ga + Yp(this, name, this.a[name][1])); | |
| eq(this, name); | |
| }; | |
| /** | |
| * @param {(number|string)} cls | |
| * @param {string} name | |
| * @param {!Function} n | |
| * @param {string} context | |
| * @return {undefined} | |
| */ | |
| var dq = function(cls, name, n, context) { | |
| /** @type {number} */ | |
| var attr = 0; | |
| /** @type {null} */ | |
| var value = null; | |
| if (name in cls.a) { | |
| value = cls.a[name]; | |
| attr = value[0]; | |
| value = value[1]; | |
| } | |
| value = bq(value, n, context); | |
| /** @type {!Array} */ | |
| cls.a[name] = [attr, value]; | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {number} i | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var fq = function(b, i, value) { | |
| if (!(null != i)) { | |
| /** @type {number} */ | |
| i = 1; | |
| } | |
| if (value == Ha) { | |
| if (isNaN(b)) { | |
| /** @type {number} */ | |
| b = parseInt(b, 10); | |
| } | |
| if (isNaN(i)) { | |
| /** @type {number} */ | |
| i = parseInt(i, 10); | |
| } | |
| b = b + i; | |
| } else { | |
| /** @type {number} */ | |
| b = i; | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Array} args | |
| * @param {!Array} i | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| var bq = function(args, i, options) { | |
| if (Ce(i) == cd) { | |
| if (Ce(args) != cd) { | |
| args = {}; | |
| } | |
| var k; | |
| for (k in i) { | |
| args[k] = fq(k in args ? args[k] : null, i[k], options); | |
| } | |
| } else { | |
| args = fq(args, i, options); | |
| } | |
| return args; | |
| }; | |
| /** | |
| * @param {(number|string)} elem | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var eq = function(elem, name) { | |
| if (name in elem.a) { | |
| dl(elem.a[name][0]); | |
| delete elem.a[name]; | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var gq = function(a) { | |
| /** @type {!Array} */ | |
| var ret = []; | |
| var f; | |
| for (f in a.b) { | |
| ret.push(Yp(a, f, a.b[f])); | |
| } | |
| a.b = {}; | |
| return ret.join("&"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Wp.prototype.C = function() { | |
| this.o(); | |
| var b; | |
| for (b in this.a) { | |
| if (0 != this.a[b]) { | |
| this.B(b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} a$jscomp$655 | |
| * @return {?} | |
| */ | |
| var hq = function(a$jscomp$655) { | |
| /** @type {string} */ | |
| a$jscomp$655 = String(a$jscomp$655); | |
| if (/^\s*$/.test(a$jscomp$655) ? 0 : /^[\],:{}\s\u2028\u2029]*$/.test(a$jscomp$655.replace(/\\["\\\/bfnrtu]/g, "@").replace(/(?:"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)[\s\u2028\u2029]*(?=:|,|]|}|$)/g, "]").replace(/(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g, ""))) { | |
| try { | |
| return eval("(" + a$jscomp$655 + ")"); | |
| } catch (b) { | |
| } | |
| } | |
| throw Error("Invalid JSON string: " + a$jscomp$655); | |
| }; | |
| /** | |
| * @param {string} a$jscomp$656 | |
| * @return {?} | |
| */ | |
| var iq = function(a$jscomp$656) { | |
| return eval("(" + a$jscomp$656 + ")"); | |
| }; | |
| /** | |
| * @param {boolean} target | |
| * @return {?} | |
| */ | |
| var lq = function(target) { | |
| /** @type {!Array} */ | |
| var row2 = []; | |
| jq(new kq, target, row2); | |
| return row2.join(""); | |
| }; | |
| var kq = ue(); | |
| /** | |
| * @param {?} el | |
| * @param {string} value | |
| * @param {!Array} out | |
| * @return {undefined} | |
| */ | |
| var jq = function(el, value, out) { | |
| if (null == value) { | |
| out.push("null"); | |
| } else { | |
| if (typeof value == cd) { | |
| if (De(value)) { | |
| /** @type {string} */ | |
| var name = value; | |
| value = name.length; | |
| out.push("["); | |
| /** @type {string} */ | |
| var e = ""; | |
| /** @type {number} */ | |
| var item = 0; | |
| for (; item < value; item++) { | |
| out.push(e); | |
| jq(el, name[item], out); | |
| /** @type {string} */ | |
| e = ","; | |
| } | |
| out.push("]"); | |
| return; | |
| } | |
| if (value instanceof String || value instanceof Number || value instanceof Boolean) { | |
| /** @type {*} */ | |
| value = value.valueOf(); | |
| } else { | |
| out.push("{"); | |
| /** @type {string} */ | |
| e = ""; | |
| for (name in value) { | |
| if (Object.prototype.hasOwnProperty.call(value, name)) { | |
| item = value[name]; | |
| if (typeof item != Bb) { | |
| out.push(e); | |
| mq(name, out); | |
| out.push(":"); | |
| jq(el, item, out); | |
| /** @type {string} */ | |
| e = ","; | |
| } | |
| } | |
| } | |
| out.push("}"); | |
| return; | |
| } | |
| } | |
| switch(typeof value) { | |
| case Rd: | |
| mq(value, out); | |
| break; | |
| case bd: | |
| out.push(isFinite(value) && !isNaN(value) ? String(value) : "null"); | |
| break; | |
| case "boolean": | |
| out.push(String(value)); | |
| break; | |
| case Bb: | |
| out.push("null"); | |
| break; | |
| default: | |
| throw Error("Unknown type: " + typeof value); | |
| } | |
| } | |
| }; | |
| var nq = { | |
| '"' : '\\"', | |
| "\\" : "\\\\", | |
| "/" : "\\/", | |
| "\b" : "\\b", | |
| "\f" : "\\f", | |
| "\n" : "\\n", | |
| "\r" : "\\r", | |
| "\t" : "\\t", | |
| "\x0B" : "\\u000b" | |
| }; | |
| /** @type {!RegExp} */ | |
| var oq = /\uffff/.test("\uffff") ? /[\\"\x00-\x1f\x7f-\uffff]/g : /[\\"\x00-\x1f\x7f-\xff]/g; | |
| /** | |
| * @param {string} query | |
| * @param {!Array} source | |
| * @return {undefined} | |
| */ | |
| var mq = function(query, source) { | |
| source.push('"', query.replace(oq, function(c) { | |
| var fbo = nq[c]; | |
| if (!fbo) { | |
| /** @type {string} */ | |
| fbo = "\\u" + (c.charCodeAt(0) | 65536).toString(16).substr(1); | |
| /** @type {string} */ | |
| nq[c] = fbo; | |
| } | |
| return fbo; | |
| }), '"'); | |
| }; | |
| /** @type {!RegExp} */ | |
| var pq = /^(?:([^:/?#.]+):)?(?:\/\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\?([^#]*))?(?:#(.*))?$/; | |
| /** | |
| * @param {string} url | |
| * @param {!Function} callback | |
| * @return {undefined} | |
| */ | |
| var qq = function(url, callback) { | |
| if (url) { | |
| var items = url.split("&"); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < items.length; i++) { | |
| var m = items[i].indexOf("="); | |
| var out; | |
| /** @type {null} */ | |
| var err = null; | |
| if (0 <= m) { | |
| out = items[i].substring(0, m); | |
| err = items[i].substring(m + 1); | |
| } else { | |
| out = items[i]; | |
| } | |
| callback(out, err ? Ye(err) : ""); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} opts | |
| * @param {string} data | |
| * @param {!Array} el | |
| * @return {undefined} | |
| */ | |
| var rq = function(opts, data, el) { | |
| if (De(data)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < data.length; i++) { | |
| rq(opts, String(data[i]), el); | |
| } | |
| } else { | |
| if (null != data) { | |
| el.push("&", opts, "" === data ? "" : "=", Xe(data)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @return {?} | |
| */ | |
| var sq = function(a) { | |
| /** @type {!Array} */ | |
| var b = []; | |
| var c; | |
| for (c in a) { | |
| rq(c, a[c], b); | |
| } | |
| /** @type {string} */ | |
| b[0] = ""; | |
| return b.join(""); | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @param {string} url | |
| * @return {?} | |
| */ | |
| var tq = function(event, url) { | |
| if (Se(event, "/")) { | |
| event = event.substr(0, event.length - 1); | |
| } | |
| if (0 == url.lastIndexOf("/", 0)) { | |
| url = url.substr(1); | |
| } | |
| return qf(event, "/", url); | |
| }; | |
| var uq = ue(); | |
| /** @type {null} */ | |
| uq.prototype.a = null; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var wq = function(data) { | |
| var a; | |
| if (!(a = data.a)) { | |
| a = {}; | |
| if (vq(data)) { | |
| /** @type {boolean} */ | |
| a[0] = true; | |
| /** @type {boolean} */ | |
| a[1] = true; | |
| } | |
| a = data.a = a; | |
| } | |
| return a; | |
| }; | |
| var xq; | |
| var yq = ue(); | |
| C(yq, uq); | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var zq = function(name) { | |
| return (name = vq(name)) ? new ActiveXObject(name) : new XMLHttpRequest; | |
| }; | |
| /** | |
| * @param {!Object} property | |
| * @return {?} | |
| */ | |
| var vq = function(property) { | |
| if (!property.b && "undefined" == typeof XMLHttpRequest && "undefined" != typeof ActiveXObject) { | |
| /** @type {!Array} */ | |
| var returnedData = ["MSXML2.XMLHTTP.6.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP"]; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < returnedData.length; i++) { | |
| var p = returnedData[i]; | |
| try { | |
| return new ActiveXObject(p), property.b = p; | |
| } catch (e) { | |
| } | |
| } | |
| throw Error("Could not create ActiveXObject. ActiveX might be disabled, or MSXML might not be installed"); | |
| } | |
| return property.b; | |
| }; | |
| xq = new yq; | |
| /** | |
| * @param {string} width | |
| * @return {undefined} | |
| */ | |
| var Aq = function(width) { | |
| V.call(this); | |
| this.L = new Wg; | |
| this.w = width || null; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {null} */ | |
| this.C = this.a = null; | |
| /** @type {string} */ | |
| this.o = this.N = this.g = ""; | |
| /** @type {boolean} */ | |
| this.c = this.G = this.m = this.F = false; | |
| /** @type {number} */ | |
| this.j = 0; | |
| /** @type {null} */ | |
| this.B = null; | |
| /** @type {string} */ | |
| this.O = ""; | |
| /** @type {boolean} */ | |
| this.A = this.H = false; | |
| }; | |
| C(Aq, V); | |
| /** @type {!RegExp} */ | |
| var Bq = /^https?$/i; | |
| /** @type {!Array} */ | |
| var Cq = [wa, "PUT"]; | |
| /** @type {!Array} */ | |
| var Dq = []; | |
| /** | |
| * @param {string} n | |
| * @param {!Function} d | |
| * @param {string} key | |
| * @param {!Function} val | |
| * @param {!Object} expr | |
| * @param {number} ms | |
| * @return {undefined} | |
| */ | |
| var Fq = function(n, d, key, val, expr, ms) { | |
| var $ = new Aq; | |
| Dq.push($); | |
| if (d) { | |
| Sj($.eb, db, d, false, void 0, void 0); | |
| } | |
| Sj($.eb, "ready", $.I, true, void 0, void 0); | |
| if (ms) { | |
| /** @type {number} */ | |
| $.j = Math.max(0, ms); | |
| } | |
| Eq($, n, key, val, expr); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aq.prototype.I = function() { | |
| this.za(); | |
| Hf(Dq, this); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} data | |
| * @param {string} type | |
| * @param {string} left | |
| * @param {!Object} right | |
| * @return {undefined} | |
| */ | |
| var Eq = function(options, data, type, left, right) { | |
| if (options.a) { | |
| throw Error("[goog.net.XhrIo] Object is active with another request=" + options.g + "; newUri=" + data); | |
| } | |
| type = type ? type.toUpperCase() : "GET"; | |
| /** @type {!Object} */ | |
| options.g = data; | |
| /** @type {string} */ | |
| options.o = ""; | |
| /** @type {string} */ | |
| options.N = type; | |
| /** @type {boolean} */ | |
| options.F = false; | |
| /** @type {boolean} */ | |
| options.b = true; | |
| options.a = options.w ? zq(options.w) : zq(xq); | |
| options.C = options.w ? wq(options.w) : wq(xq); | |
| options.a.onreadystatechange = A(options.K, options); | |
| try { | |
| /** @type {boolean} */ | |
| options.G = true; | |
| options.a.open(type, String(data), true); | |
| /** @type {boolean} */ | |
| options.G = false; | |
| } catch (QueryLanguageComponent) { | |
| Gq(options, QueryLanguageComponent); | |
| return; | |
| } | |
| data = left || ""; | |
| var x = options.L.clone(); | |
| if (right) { | |
| bh(right, function(a, b) { | |
| x.set(b, a); | |
| }); | |
| } | |
| right = Df(x.tb(), Hq); | |
| left = z.FormData && data instanceof z.FormData; | |
| if (!(!Ef(Cq, type) || right || left)) { | |
| x.set("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); | |
| } | |
| x.forEach(function(b, n) { | |
| this.a.setRequestHeader(n, b); | |
| }, options); | |
| if (options.O) { | |
| options.a.responseType = options.O; | |
| } | |
| if ("withCredentials" in options.a && options.a.withCredentials !== options.H) { | |
| options.a.withCredentials = options.H; | |
| } | |
| try { | |
| Iq(options); | |
| if (0 < options.j) { | |
| options.A = Jq(options.a); | |
| if (options.A) { | |
| options.a.timeout = options.j; | |
| options.a.ontimeout = A(options.ic, options); | |
| } else { | |
| options.B = cl(options.ic, options.j, options); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| options.m = true; | |
| options.a.send(data); | |
| /** @type {boolean} */ | |
| options.m = false; | |
| } catch (QueryLanguageComponent) { | |
| Gq(options, QueryLanguageComponent); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} sweep | |
| * @return {?} | |
| */ | |
| var Jq = function(sweep) { | |
| return E && I(9) && Ge(sweep.timeout) && xe(sweep.ontimeout); | |
| }; | |
| /** | |
| * @param {string} p_Interval | |
| * @return {?} | |
| */ | |
| var Hq = function(p_Interval) { | |
| return "content-type" == p_Interval.toLowerCase(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aq.prototype.ic = function() { | |
| if ("undefined" != typeof we && this.a) { | |
| /** @type {string} */ | |
| this.o = "Timed out after " + this.j + "ms, aborting"; | |
| this.dispatchEvent("timeout"); | |
| if (this.a && this.b) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {boolean} */ | |
| this.c = true; | |
| this.a.abort(); | |
| /** @type {boolean} */ | |
| this.c = false; | |
| this.dispatchEvent(db); | |
| this.dispatchEvent("abort"); | |
| Kq(this); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {(Object|string)} b | |
| * @return {undefined} | |
| */ | |
| var Gq = function(a, b) { | |
| /** @type {boolean} */ | |
| a.b = false; | |
| if (a.a) { | |
| /** @type {boolean} */ | |
| a.c = true; | |
| a.a.abort(); | |
| /** @type {boolean} */ | |
| a.c = false; | |
| } | |
| /** @type {(Object|string)} */ | |
| a.o = b; | |
| Lq(a); | |
| Kq(a); | |
| }; | |
| /** | |
| * @param {!Object} exports | |
| * @return {undefined} | |
| */ | |
| var Lq = function(exports) { | |
| if (!exports.F) { | |
| /** @type {boolean} */ | |
| exports.F = true; | |
| exports.dispatchEvent(db); | |
| exports.dispatchEvent("error"); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aq.prototype.J = function() { | |
| if (this.a) { | |
| if (this.b) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {boolean} */ | |
| this.c = true; | |
| this.a.abort(); | |
| /** @type {boolean} */ | |
| this.c = false; | |
| } | |
| Kq(this, true); | |
| } | |
| Aq.v.J.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aq.prototype.K = function() { | |
| if (!this.Ca) { | |
| if (this.G || this.m || this.c) { | |
| Mq(this); | |
| } else { | |
| this.P(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Aq.prototype.P = function() { | |
| Mq(this); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var Mq = function(self) { | |
| if (self.b && "undefined" != typeof we && (!self.C[1] || 4 != Nq(self) || 2 != Oq(self))) { | |
| if (self.m && 4 == Nq(self)) { | |
| cl(self.K, 0, self); | |
| } else { | |
| if (self.dispatchEvent("readystatechange"), 4 == Nq(self)) { | |
| /** @type {boolean} */ | |
| self.b = false; | |
| try { | |
| if (Pq(self)) { | |
| self.dispatchEvent(db); | |
| self.dispatchEvent("success"); | |
| } else { | |
| var subTemplate; | |
| try { | |
| subTemplate = 2 < Nq(self) ? self.a.statusText : ""; | |
| } catch (c) { | |
| /** @type {string} */ | |
| subTemplate = ""; | |
| } | |
| /** @type {string} */ | |
| self.o = subTemplate + " [" + Oq(self) + "]"; | |
| Lq(self); | |
| } | |
| } finally { | |
| Kq(self); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {boolean} isTangent | |
| * @return {undefined} | |
| */ | |
| var Kq = function(c, isTangent) { | |
| if (c.a) { | |
| Iq(c); | |
| var t = c.a; | |
| var result = c.C[0] ? Ae : null; | |
| /** @type {null} */ | |
| c.a = null; | |
| /** @type {null} */ | |
| c.C = null; | |
| if (!isTangent) { | |
| c.dispatchEvent("ready"); | |
| } | |
| try { | |
| t.onreadystatechange = result; | |
| } catch (e) { | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var Iq = function(o) { | |
| if (o.a && o.A) { | |
| /** @type {null} */ | |
| o.a.ontimeout = null; | |
| } | |
| if (Ge(o.B)) { | |
| dl(o.B); | |
| /** @type {null} */ | |
| o.B = null; | |
| } | |
| }; | |
| /** | |
| * @param {string} p | |
| * @return {?} | |
| */ | |
| var Pq = function(p) { | |
| var v = Oq(p); | |
| var validationVM; | |
| a: { | |
| switch(v) { | |
| case 200: | |
| case 201: | |
| case 202: | |
| case 204: | |
| case 206: | |
| case 304: | |
| case 1223: | |
| /** @type {boolean} */ | |
| validationVM = true; | |
| break a; | |
| default: | |
| /** @type {boolean} */ | |
| validationVM = false; | |
| } | |
| } | |
| if (!validationVM) { | |
| if (v = 0 === v) { | |
| /** @type {(null|string)} */ | |
| p = String(p.g).match(pq)[1] || null; | |
| if (!p && z.self && z.self.location) { | |
| p = z.self.location.protocol; | |
| p = p.substr(0, p.length - 1); | |
| } | |
| /** @type {boolean} */ | |
| v = !Bq.test(p ? p.toLowerCase() : ""); | |
| } | |
| /** @type {boolean} */ | |
| validationVM = v; | |
| } | |
| return validationVM; | |
| }; | |
| /** | |
| * @param {!Object} link | |
| * @return {?} | |
| */ | |
| var Nq = function(link) { | |
| return link.a ? link.a.readyState : 0; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Oq = function(a) { | |
| try { | |
| return 2 < Nq(a) ? a.a.status : -1; | |
| } catch (b) { | |
| return -1; | |
| } | |
| }; | |
| /** | |
| * @param {string} response | |
| * @return {?} | |
| */ | |
| var Qq = function(response) { | |
| try { | |
| return response.a ? response.a.responseText : ""; | |
| } catch (b) { | |
| return ""; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} handler | |
| * @return {?} | |
| */ | |
| var Rq = function(handler) { | |
| if (handler.a) { | |
| return hq(handler.a.responseText); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {undefined} c | |
| * @return {undefined} | |
| */ | |
| var Sq = function(a, c) { | |
| /** @type {string} */ | |
| this.c = this.B = this.b = ""; | |
| /** @type {null} */ | |
| this.o = null; | |
| /** @type {string} */ | |
| this.m = this.j = ""; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| var BROWSER_ENGINES; | |
| if (a instanceof Sq) { | |
| this.g = xe(c) ? c : a.g; | |
| Tq(this, a.b); | |
| this.B = a.B; | |
| this.c = a.c; | |
| Uq(this, a.o); | |
| this.j = a.j; | |
| Vq(this, a.a.clone()); | |
| this.m = a.m; | |
| } else { | |
| if (a && (BROWSER_ENGINES = String(a).match(pq))) { | |
| /** @type {boolean} */ | |
| this.g = !!c; | |
| Tq(this, BROWSER_ENGINES[1] || "", true); | |
| this.B = Wq(BROWSER_ENGINES[2] || ""); | |
| this.c = Wq(BROWSER_ENGINES[3] || "", true); | |
| Uq(this, BROWSER_ENGINES[4]); | |
| this.j = Wq(BROWSER_ENGINES[5] || "", true); | |
| Vq(this, BROWSER_ENGINES[6] || "", true); | |
| this.m = Wq(BROWSER_ENGINES[7] || ""); | |
| } else { | |
| /** @type {boolean} */ | |
| this.g = !!c; | |
| this.a = new Xq(null, 0, this.g); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Sq.prototype.toString = function() { | |
| /** @type {!Array} */ | |
| var t = []; | |
| var pattern = this.b; | |
| if (pattern) { | |
| t.push(Yq(pattern, Zq, true), ":"); | |
| } | |
| var d = this.c; | |
| if (d || "file" == pattern) { | |
| t.push("//"); | |
| if (pattern = this.B) { | |
| t.push(Yq(pattern, Zq, true), "@"); | |
| } | |
| t.push(Xe(d).replace(/%25([0-9a-fA-F]{2})/g, "%$1")); | |
| d = this.o; | |
| if (null != d) { | |
| t.push(":", String(d)); | |
| } | |
| } | |
| if (d = this.j) { | |
| if (this.c && "/" != d.charAt(0)) { | |
| t.push("/"); | |
| } | |
| t.push(Yq(d, "/" == d.charAt(0) ? $q : ar, true)); | |
| } | |
| if (d = this.a.toString()) { | |
| t.push("?", d); | |
| } | |
| if (d = this.m) { | |
| t.push("#", Yq(d, br)); | |
| } | |
| return t.join(""); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Sq.prototype.clone = function() { | |
| return new Sq(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {boolean} asc | |
| * @return {undefined} | |
| */ | |
| var Tq = function(a, b, asc) { | |
| a.b = asc ? Wq(b, true) : b; | |
| if (a.b) { | |
| a.b = a.b.replace(/:$/, ""); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} message | |
| * @param {number} e | |
| * @return {undefined} | |
| */ | |
| var Uq = function(message, e) { | |
| if (e) { | |
| /** @type {number} */ | |
| e = Number(e); | |
| if (isNaN(e) || 0 > e) { | |
| throw Error("Bad port number " + e); | |
| } | |
| /** @type {number} */ | |
| message.o = e; | |
| } else { | |
| /** @type {null} */ | |
| message.o = null; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {boolean} undefOnly | |
| * @return {undefined} | |
| */ | |
| var Vq = function(a, b, undefOnly) { | |
| if (b instanceof Xq) { | |
| /** @type {string} */ | |
| a.a = b; | |
| cr(a.a, a.g); | |
| } else { | |
| if (!undefOnly) { | |
| b = Yq(b, dr); | |
| } | |
| a.a = new Xq(b, 0, a.g); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Wq = function(a, b) { | |
| return a ? b ? decodeURI(a.replace(/%25/g, "%2525")) : decodeURIComponent(a) : ""; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {!RegExp} obj | |
| * @param {boolean} item | |
| * @return {?} | |
| */ | |
| var Yq = function(a, obj, item) { | |
| return Fe(a) ? (a = encodeURI(a).replace(obj, er), item && (a = a.replace(/%25([0-9a-fA-F]{2})/g, "%$1")), a) : null; | |
| }; | |
| /** | |
| * @param {(number|string)} item | |
| * @return {?} | |
| */ | |
| var er = function(item) { | |
| item = item.charCodeAt(0); | |
| return "%" + (item >> 4 & 15).toString(16) + (item & 15).toString(16); | |
| }; | |
| /** @type {!RegExp} */ | |
| var Zq = /[#\/\?@]/g; | |
| /** @type {!RegExp} */ | |
| var ar = /[#\?:]/g; | |
| /** @type {!RegExp} */ | |
| var $q = /[#\?]/g; | |
| /** @type {!RegExp} */ | |
| var dr = /[#\?@]/g; | |
| /** @type {!RegExp} */ | |
| var br = /#/g; | |
| /** | |
| * @param {string} c | |
| * @param {?} name | |
| * @param {?} prefixAgnostic | |
| * @return {undefined} | |
| */ | |
| var Xq = function(c, name, prefixAgnostic) { | |
| /** @type {null} */ | |
| this.b = this.a = null; | |
| this.c = c || null; | |
| /** @type {boolean} */ | |
| this.j = !!prefixAgnostic; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| var gr = function(v) { | |
| if (!v.a) { | |
| v.a = new Wg; | |
| /** @type {number} */ | |
| v.b = 0; | |
| if (v.c) { | |
| qq(v.c, function(cssProperyName, oldEventMap) { | |
| fr(v, Ye(cssProperyName), oldEventMap); | |
| }); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @param {string} key | |
| * @param {string} arg | |
| * @return {undefined} | |
| */ | |
| var fr = function(n, key, arg) { | |
| gr(n); | |
| /** @type {null} */ | |
| n.c = null; | |
| key = hr(n, key); | |
| var values = n.a.get(key); | |
| if (!values) { | |
| n.a.set(key, values = []); | |
| } | |
| values.push(arg); | |
| n.b = n.b + 1; | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| var ir = function(f, val) { | |
| gr(f); | |
| val = hr(f, val); | |
| if (Zg(f.a, val)) { | |
| /** @type {null} */ | |
| f.c = null; | |
| /** @type {number} */ | |
| f.b = f.b - f.a.get(val).length; | |
| $g(f.a, val); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xq.prototype.clear = function() { | |
| /** @type {null} */ | |
| this.a = this.c = null; | |
| /** @type {number} */ | |
| this.b = 0; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} fn | |
| * @return {?} | |
| */ | |
| var jr = function(item, fn) { | |
| gr(item); | |
| fn = hr(item, fn); | |
| return Zg(item.a, fn); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Xq.prototype.tb = function() { | |
| gr(this); | |
| var effectInstances = this.a.Va(); | |
| var keys = this.a.tb(); | |
| /** @type {!Array} */ | |
| var f = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < keys.length; i++) { | |
| var e = effectInstances[i]; | |
| /** @type {number} */ | |
| var g = 0; | |
| for (; g < e.length; g++) { | |
| f.push(keys[i]); | |
| } | |
| } | |
| return f; | |
| }; | |
| /** | |
| * @param {string} y | |
| * @return {?} | |
| */ | |
| Xq.prototype.Va = function(y) { | |
| gr(this); | |
| /** @type {!Array} */ | |
| var left = []; | |
| if (Fe(y)) { | |
| if (jr(this, y)) { | |
| left = If(left, this.a.get(hr(this, y))); | |
| } | |
| } else { | |
| y = this.a.Va(); | |
| /** @type {number} */ | |
| var iy = 0; | |
| for (; iy < y.length; iy++) { | |
| left = If(left, y[iy]); | |
| } | |
| } | |
| return left; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| Xq.prototype.set = function(name, obj) { | |
| gr(this); | |
| /** @type {null} */ | |
| this.c = null; | |
| name = hr(this, name); | |
| if (jr(this, name)) { | |
| /** @type {number} */ | |
| this.b = this.b - this.a.get(name).length; | |
| } | |
| this.a.set(name, [obj]); | |
| this.b = this.b + 1; | |
| return this; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} fn | |
| * @return {?} | |
| */ | |
| Xq.prototype.get = function(a, fn) { | |
| var b = a ? this.Va(a) : []; | |
| return 0 < b.length ? String(b[0]) : fn; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} val | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var kr = function(a, val, data) { | |
| ir(a, val); | |
| if (0 < data.length) { | |
| /** @type {null} */ | |
| a.c = null; | |
| a.a.set(hr(a, val), Jf(data)); | |
| a.b = a.b + data.length; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Xq.prototype.toString = function() { | |
| if (this.c) { | |
| return this.c; | |
| } | |
| if (!this.a) { | |
| return ""; | |
| } | |
| /** @type {!Array} */ | |
| var newClassList = []; | |
| var dependencies = this.a.tb(); | |
| /** @type {number} */ | |
| var indexDep = 0; | |
| for (; indexDep < dependencies.length; indexDep++) { | |
| var d = dependencies[indexDep]; | |
| var e = Xe(d); | |
| d = this.Va(d); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < d.length; i++) { | |
| var c = e; | |
| if ("" !== d[i]) { | |
| /** @type {string} */ | |
| c = c + ("=" + Xe(d[i])); | |
| } | |
| newClassList.push(c); | |
| } | |
| } | |
| return this.c = newClassList.join("&"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Xq.prototype.clone = function() { | |
| var matrix = new Xq; | |
| matrix.c = this.c; | |
| if (this.a) { | |
| matrix.a = this.a.clone(); | |
| matrix.b = this.b; | |
| } | |
| return matrix; | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {string} node | |
| * @return {?} | |
| */ | |
| var hr = function(val, node) { | |
| /** @type {string} */ | |
| var c = String(node); | |
| if (val.j) { | |
| /** @type {string} */ | |
| c = c.toLowerCase(); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {number} item | |
| * @return {undefined} | |
| */ | |
| var cr = function(f, item) { | |
| if (item && !f.j) { | |
| gr(f); | |
| /** @type {null} */ | |
| f.c = null; | |
| f.a.forEach(function(children, i) { | |
| var attrs = i.toLowerCase(); | |
| if (i != attrs) { | |
| ir(this, i); | |
| kr(this, attrs, children); | |
| } | |
| }, f); | |
| } | |
| /** @type {number} */ | |
| f.j = item; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Xq.prototype.g = function(name) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < arguments.length; i++) { | |
| bh(arguments[i], function(oldEventMap, derTrigger) { | |
| fr(this, derTrigger, oldEventMap); | |
| }, this); | |
| } | |
| }; | |
| /** @type {boolean} */ | |
| var lr = null != window.COMPARE_PROD_TRANS; | |
| /** @type {boolean} */ | |
| var mr = null != window.MSG_HUMAN_TRANSLATION_ACTION; | |
| /** @type {boolean} */ | |
| var nr = null != window.MSG_CHANGE_ITA; | |
| /** @type {boolean} */ | |
| var or = null != window.KNOWLEDGE_PANEL; | |
| /** @type {boolean} */ | |
| var pr = null != window.MSG_HATS_TITLE; | |
| /** @type {boolean} */ | |
| var qr = null != window.MSG_SHOW_PB; | |
| /** @type {boolean} */ | |
| var rr = null != window.PHRASEBOOK_REORDERING; | |
| /** @type {boolean} */ | |
| var sr = null != window.MSG_SPEECH_INPUT_TURN_ON; | |
| /** @type {boolean} */ | |
| var tr = null != window.SK_WP; | |
| /** @type {boolean} */ | |
| var ur = null != window.TTS_PACE_CONTROL; | |
| /** @type {boolean} */ | |
| var vr = null != window.WEBFONT; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var wr = function(a) { | |
| return function() { | |
| return a; | |
| }; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {string} fn | |
| * @return {?} | |
| */ | |
| var xr = function(a, fn) { | |
| /** @type {number} */ | |
| var idx = 0; | |
| for (; idx < fn.length - 2; idx = idx + 3) { | |
| var b = fn.charAt(idx + 2); | |
| /** @type {number} */ | |
| b = "a" <= b ? b.charCodeAt(0) - 87 : Number(b); | |
| /** @type {number} */ | |
| b = "+" == fn.charAt(idx + 1) ? a >>> b : a << b; | |
| /** @type {number} */ | |
| a = "+" == fn.charAt(idx) ? a + b & 4294967295 : a ^ b; | |
| } | |
| return a; | |
| }; | |
| /** @type {null} */ | |
| var yr = null; | |
| /** | |
| * @param {number} c | |
| * @return {?} | |
| */ | |
| var zr = function(c) { | |
| var d; | |
| if (null !== yr) { | |
| d = yr; | |
| } else { | |
| d = wr(String.fromCharCode(84)); | |
| var parseFloat = wr(String.fromCharCode(75)); | |
| /** @type {!Array} */ | |
| d = [d(), d()]; | |
| d[1] = parseFloat(); | |
| d = (yr = window[d.join(parseFloat())] || "") || ""; | |
| } | |
| var b = wr(String.fromCharCode(116)); | |
| parseFloat = wr(String.fromCharCode(107)); | |
| /** @type {!Array} */ | |
| b = [b(), b()]; | |
| b[1] = parseFloat(); | |
| /** @type {string} */ | |
| parseFloat = "&" + b.join("") + "="; | |
| b = d.split("."); | |
| /** @type {number} */ | |
| d = Number(b[0]) || 0; | |
| /** @type {!Array} */ | |
| var args = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var index = 0; | |
| for (; index < c.length; index++) { | |
| var l = c.charCodeAt(index); | |
| if (128 > l) { | |
| args[i++] = l; | |
| } else { | |
| if (2048 > l) { | |
| /** @type {number} */ | |
| args[i++] = l >> 6 | 192; | |
| } else { | |
| if (55296 == (l & 64512) && index + 1 < c.length && 56320 == (c.charCodeAt(index + 1) & 64512)) { | |
| /** @type {number} */ | |
| l = 65536 + ((l & 1023) << 10) + (c.charCodeAt(++index) & 1023); | |
| /** @type {number} */ | |
| args[i++] = l >> 18 | 240; | |
| /** @type {number} */ | |
| args[i++] = l >> 12 & 63 | 128; | |
| } else { | |
| /** @type {number} */ | |
| args[i++] = l >> 12 | 224; | |
| } | |
| /** @type {number} */ | |
| args[i++] = l >> 6 & 63 | 128; | |
| } | |
| /** @type {number} */ | |
| args[i++] = l & 63 | 128; | |
| } | |
| } | |
| /** @type {number} */ | |
| c = d; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < args.length; i++) { | |
| c = c + args[i]; | |
| c = xr(c, "+-a^+6"); | |
| } | |
| c = xr(c, "+-3^+b+-f"); | |
| /** @type {number} */ | |
| c = c ^ (Number(b[1]) || 0); | |
| if (0 > c) { | |
| /** @type {number} */ | |
| c = (c & 2147483647) + 2147483648; | |
| } | |
| /** @type {number} */ | |
| c = c % 1E6; | |
| return parseFloat + (c.toString() + "." + (c ^ d)); | |
| }; | |
| /** | |
| * @param {number} c | |
| * @param {number} val | |
| * @return {undefined} | |
| */ | |
| var Ar = function(c, val) { | |
| /** @type {number} */ | |
| this.c = c; | |
| /** @type {string} */ | |
| this.a = ""; | |
| if (val) { | |
| /** @type {number} */ | |
| this.a = val; | |
| } | |
| /** @type {number} */ | |
| this.b = 0; | |
| }; | |
| var Br = { | |
| Vj : "at", | |
| Wj : "bd", | |
| Xj : "ex", | |
| Zj : "kr", | |
| $j : "ld", | |
| ak : "md", | |
| bk : "qc", | |
| ck : "qca", | |
| dk : "rw", | |
| ek : "rm", | |
| fk : "ss", | |
| Fe : "t" | |
| }; | |
| /** | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| var Cr = function(name) { | |
| name = name.Va("q").join(""); | |
| return zr(name); | |
| }; | |
| /** | |
| * @param {!Object} vm | |
| * @param {string} str | |
| * @param {string} name | |
| * @param {number} url | |
| * @param {string} e | |
| * @return {undefined} | |
| */ | |
| var Dr = function(vm, str, name, url, e) { | |
| name = name.toString(); | |
| name = name + Cr(url); | |
| url = url.toString(); | |
| var type = wa; | |
| /** @type {string} */ | |
| str = str + ("?" + name); | |
| if (2E3 > str.length + url.length) { | |
| /** @type {string} */ | |
| type = "GET"; | |
| /** @type {string} */ | |
| str = str + ("&" + url); | |
| /** @type {string} */ | |
| url = ""; | |
| } | |
| ++vm.b; | |
| Fq(str, function(context) { | |
| --vm.b; | |
| e(context); | |
| }, type, url, void 0); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {string} context | |
| * @param {undefined} template | |
| * @param {undefined} plugin | |
| * @param {string} v | |
| * @param {?} data | |
| * @param {string} fn | |
| * @param {undefined} key | |
| * @return {undefined} | |
| */ | |
| var Er = function(c, context, template, plugin, v, data, fn, key) { | |
| /** @type {string} */ | |
| var STATIC_CHIPS_TEMPLATE = c.a + "/translate_a/t"; | |
| var _ = new Xq; | |
| var tag = new Xq; | |
| _.set(ab, c.c); | |
| _.set("sl", context); | |
| _.set("tl", template); | |
| _.set("hl", plugin); | |
| _.set("v", "1.0"); | |
| if (null != fn) { | |
| _.set(Fd, fn); | |
| } | |
| if (key) { | |
| _.g(key); | |
| } | |
| if (context = !De(v) || De(v) && 1 == v.length) { | |
| tag.set("q", v); | |
| } else { | |
| kr(tag, "q", v); | |
| } | |
| v = A(c.j, c, context, data); | |
| Dr(c, STATIC_CHIPS_TEMPLATE, _, tag, v); | |
| }; | |
| /** | |
| * @param {!Object} r | |
| * @param {string} o | |
| * @param {string} prop | |
| * @param {string} target | |
| * @param {!Object} n | |
| * @param {!Array} children | |
| * @param {string} context | |
| * @param {!Object} config | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| var Fr = function(r, o, prop, target, n, children, context, config, key) { | |
| var STATIC_CHIPS_TEMPLATE = r.a + ka; | |
| var self = new Xq; | |
| var u = new Xq; | |
| self.set(ab, r.c); | |
| self.set("sl", o); | |
| self.set("tl", prop); | |
| self.set("hl", target); | |
| kr(self, "dt", children); | |
| if (null != config) { | |
| self.set("ie", config); | |
| self.set("oe", config); | |
| } | |
| if (key) { | |
| self.g(key); | |
| } | |
| u.set("q", n); | |
| Dr(r, STATIC_CHIPS_TEMPLATE, self, u, A(r.g, r, context)); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {string} n | |
| * @param {string} m | |
| * @param {string} center | |
| * @param {string} options | |
| * @param {string} expandedInfo | |
| * @param {boolean} data | |
| * @param {!Object} name | |
| * @param {string} tpl | |
| * @return {undefined} | |
| */ | |
| var Gr = function(s, n, m, center, options, expandedInfo, data, name, tpl) { | |
| /** @type {!Array<string>} */ | |
| var item = "at bd ex ld md qc rw rm ss t".split(" "); | |
| if (data) { | |
| /** @type {!Array<string>} */ | |
| item = "at bd ex ld md qca rw rm ss t".split(" "); | |
| } | |
| if (or) { | |
| item.push("kr"); | |
| } | |
| Fr(s, n, m, center, options, item, expandedInfo, name, tpl); | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Ar.prototype.m = function(type, name) { | |
| var n = name.target; | |
| if (Hr(n)) { | |
| Qq(n); | |
| n = Ir(n, "handleTransliterationResult_"); | |
| n = new pm(n); | |
| if (0 < Nm(n)) { | |
| type(Cm(Om(n, 0))); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Ar.prototype.g = function(key, name) { | |
| var i = name.target; | |
| if (Hr(i)) { | |
| i = Ir(i, "handleSingleResult_"); | |
| if (De(i)) { | |
| i = new pm(i); | |
| } | |
| key(i); | |
| } else { | |
| Jr(i); | |
| key(null); | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @param {!Function} v | |
| * @return {undefined} | |
| */ | |
| Ar.prototype.j = function(key, name, v) { | |
| v = v.target; | |
| if (Pq(v)) { | |
| v = Ir(v, "handleTextResult_"); | |
| /** @type {!Array} */ | |
| var a = []; | |
| if (key) { | |
| a.push(De(v) ? v[0] : v); | |
| } else { | |
| if (De(v)) { | |
| /** @type {number} */ | |
| key = 0; | |
| for (; key < v.length; ++key) { | |
| a.push(De(v[key]) ? v[key][0] : v[key]); | |
| } | |
| } | |
| } | |
| name(a); | |
| } else { | |
| Jr(v); | |
| name(null); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} fn | |
| * @return {?} | |
| */ | |
| var Ir = function(a, fn) { | |
| var s; | |
| var v = Qq(a); | |
| var p = { | |
| "class" : "trans.common.TranslationAPI", | |
| func : fn, | |
| url : String(a.g) | |
| }; | |
| try { | |
| s = iq(v); | |
| } catch (res) { | |
| throw s = Wp.M(), p.js = v, p.error = res.message, s.log("jsonParseErr", p), res; | |
| } | |
| return s; | |
| }; | |
| /** | |
| * @param {string} x | |
| * @return {?} | |
| */ | |
| var Hr = function(x) { | |
| return Pq(x) && ("[" == Qq(x)[0] || "{" == Qq(x)[0]); | |
| }; | |
| /** | |
| * @param {string} result | |
| * @return {undefined} | |
| */ | |
| var Jr = function(result) { | |
| var client = Wp.M(); | |
| /** @type {string} */ | |
| var left_res = String(result.g); | |
| result = Qq(result); | |
| client.log("invalidResponse", { | |
| q : left_res.substring(0, 500), | |
| ql : left_res.length, | |
| r : result.substring(0, 500), | |
| rl : result.length | |
| }); | |
| }; | |
| Ar.prototype.o = w("b"); | |
| /** | |
| * @param {!Array} val | |
| * @param {?} opt_validate | |
| * @return {undefined} | |
| */ | |
| var Kr = function(val, opt_validate) { | |
| W.call(this); | |
| this.U = opt_validate; | |
| /** @type {!Array} */ | |
| this.m = val; | |
| /** @type {string} */ | |
| this.Ed = this.text = this.j = this.g = ""; | |
| /** @type {null} */ | |
| this.data = null; | |
| this.Wa = Wp.M(); | |
| }; | |
| C(Kr, W); | |
| y = Kr.prototype; | |
| /** | |
| * @param {!Object} t | |
| * @param {string} a | |
| * @param {number} b | |
| * @param {!Object} object | |
| * @return {?} | |
| */ | |
| y.update = function(t, a, b, object) { | |
| /** @type {!Object} */ | |
| this.text = t; | |
| /** @type {string} */ | |
| this.g = a; | |
| /** @type {number} */ | |
| this.j = b; | |
| /** @type {!Object} */ | |
| this.data = object; | |
| this.setVisible(false); | |
| return false; | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(id) { | |
| var body = this.l(); | |
| if (body) { | |
| S(body, id); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.isVisible = function() { | |
| var b = this.l(); | |
| return b ? kj(b) : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.qg = function() { | |
| return {}; | |
| }; | |
| y.Ua = w("U"); | |
| /** | |
| * @param {string} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| y.log = function(name, value) { | |
| var data = {}; | |
| data.dt = this.U; | |
| data.sl = this.g; | |
| data.tl = this.j; | |
| data.hl = this.m; | |
| data.q = this.text; | |
| /** @type {string} */ | |
| data.e = name; | |
| if (null != value) { | |
| Wf(data, value); | |
| } | |
| Wf(data, this.qg()); | |
| this.Wa.log("lexicon", data); | |
| data = this.g; | |
| var testSuiteName = this.j; | |
| if (window.__gaTracker) { | |
| __gaTracker("set", "dimension1", this.m); | |
| __gaTracker("set", "dimension2", data + "|" + testSuiteName); | |
| __gaTracker("set", "dimension3", data); | |
| __gaTracker("set", "dimension4", testSuiteName); | |
| } | |
| if (window.__gaTracker) { | |
| __gaTracker("send", "event", "lexicon", this.U + ":" + name, "", 1); | |
| } | |
| }; | |
| /** | |
| * @param {?} deque | |
| * @param {?} f | |
| * @param {!Array} p | |
| * @param {?} v | |
| * @return {undefined} | |
| */ | |
| var Lr = function(deque, f, p, v) { | |
| Kr.call(this, deque, f); | |
| /** @type {null} */ | |
| this.w = this.b = null; | |
| /** @type {!Array} */ | |
| this.P = p; | |
| this.bb = v; | |
| /** @type {null} */ | |
| this.N = this.o = null; | |
| /** @type {boolean} */ | |
| this.I = false; | |
| /** @type {string} */ | |
| this.W = "More"; | |
| /** @type {boolean} */ | |
| this.bd = false; | |
| /** @type {string} */ | |
| this.Z = "Less"; | |
| /** @type {!Array} */ | |
| this.$ = []; | |
| /** @type {boolean} */ | |
| this.Qe = false; | |
| }; | |
| C(Lr, Kr); | |
| y = Lr.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| Lr.v.ra.call(this); | |
| this.Y(di(k)); | |
| }; | |
| /** | |
| * @param {string} selector | |
| * @return {undefined} | |
| */ | |
| y.Y = function(selector) { | |
| Lr.v.Y.call(this, selector); | |
| J(this.l(), "gt-cd"); | |
| J(this.l(), "gt-cd-" + this.U); | |
| this.l().appendChild(ip(Hp)); | |
| this.w = O("gt-cd-tl", this.l()); | |
| this.b = O("gt-cd-c", this.l()); | |
| this.o = O("cd-expand-button", this.l()); | |
| this.N = O("cd-expand-label", this.l()); | |
| S(this.o, false); | |
| }; | |
| /** | |
| * @param {?} text | |
| * @param {string} a | |
| * @param {?} n | |
| * @param {!Array} d | |
| * @return {?} | |
| */ | |
| y.update = function(text, a, n, d) { | |
| Lr.v.update.call(this, text, a, n, d); | |
| /** @type {boolean} */ | |
| this.I = this.bd = false; | |
| mi(null); | |
| S(this.o, false); | |
| K(this.o, bb); | |
| Mr(this, text); | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| Lr.v.V.call(this); | |
| X(this).a(this.o, r, this.Aj, false); | |
| X(this).a(this, "a", A(this.Sg, this, "clks"), false); | |
| X(this).a(this, "b", A(this.Sg, this, "clkt"), false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Aj = function() { | |
| /** @type {boolean} */ | |
| this.I = !this.I; | |
| this.H(this.I); | |
| if (this.I) { | |
| J(this.o, bb); | |
| Q(this.N, this.Z); | |
| this.log("expand"); | |
| } else { | |
| K(this.o, bb); | |
| Q(this.N, this.W); | |
| this.log(bb); | |
| } | |
| }; | |
| /** | |
| * @param {string} m | |
| * @param {!Event} b | |
| * @return {undefined} | |
| */ | |
| y.Sg = function(m, b) { | |
| var c = Fi(b.target); | |
| this.log(m, { | |
| clk : c | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Lf = function() { | |
| if (this.w) { | |
| Q(this.w, this.bb); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {boolean} point | |
| * @return {undefined} | |
| */ | |
| var Mr = function(node, point) { | |
| var a = P(k); | |
| var c = node.P.indexOf(aa); | |
| if (-1 != c) { | |
| var d = node.P.slice(0, c); | |
| c = node.P.slice(c + 4, node.P.length); | |
| if (d) { | |
| ii(a, d); | |
| } | |
| d = P(za, { | |
| "class" : "gt-card-ttl-txt" | |
| }); | |
| R(d, nb, ag(node.g) ? sd : Qc); | |
| Q(d, point); | |
| a.appendChild(d); | |
| if (c) { | |
| ii(a, c); | |
| } | |
| if (node.w) { | |
| ji(node.w); | |
| node.w.appendChild(a); | |
| } | |
| } else { | |
| node.Lf(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {number} uri | |
| * @param {?} d | |
| * @return {undefined} | |
| */ | |
| var Nr = function(item, uri, d) { | |
| /** @type {boolean} */ | |
| item.bd = true; | |
| S(item.o, true); | |
| if (null != uri) { | |
| /** @type {number} */ | |
| item.W = uri; | |
| } | |
| if (null != d) { | |
| item.Z = d; | |
| } | |
| Q(item.N, item.W); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Lr.prototype.H = function(name) { | |
| var x; | |
| var r; | |
| var their_pieces = Th(Vb, this.l()); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < their_pieces.length; i++) { | |
| x = their_pieces[i]; | |
| r = x.firstChild; | |
| var cr = tj(r, Rc); | |
| r = hj(r).height + cr.top + cr.bottom; | |
| R(x, "max-height", name ? r + md : 0); | |
| } | |
| }; | |
| /** | |
| * @param {?} name | |
| * @param {?} value | |
| * @return {?} | |
| */ | |
| var Or = function(name, value) { | |
| return value ? name : P(k, { | |
| "class" : Vb | |
| }, name); | |
| }; | |
| /** | |
| * @param {?} version | |
| * @param {!Array} matrix | |
| * @param {boolean} type | |
| * @param {string} data | |
| * @param {?} defer_sort | |
| * @return {undefined} | |
| */ | |
| var Pr = function(version, matrix, type, data, defer_sort) { | |
| /** @type {string} */ | |
| var id = "bd"; | |
| if (null != data && data) { | |
| /** @type {string} */ | |
| id = "m" + id; | |
| } | |
| Lr.call(this, version, id, MSG_TRANSLATIONS_OF, ""); | |
| /** @type {string} */ | |
| this.va = ""; | |
| this.va = data ? "gt-baf-cell gt-baf-word" : type ? Ub : "gt-baf-word"; | |
| this.qa = type && !data ? Qb : null; | |
| /** @type {null} */ | |
| this.A = null; | |
| /** @type {boolean} */ | |
| this.X = false; | |
| /** @type {boolean} */ | |
| this.ob = type; | |
| this.c = null != data ? data : false; | |
| this.Fa = null != defer_sort ? defer_sort : true; | |
| this.L = {}; | |
| this.L[1] = matrix[2]; | |
| this.L[2] = matrix[1]; | |
| this.L[3] = matrix[0]; | |
| this.Da = matrix[3].replace(aa, "%d"); | |
| }; | |
| C(Pr, Lr); | |
| /** | |
| * @param {!Object} f | |
| * @param {string} a | |
| * @param {number} i | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| Pr.prototype.update = function(f, a, i, v) { | |
| Pr.v.update.call(this, f, a, i, v); | |
| if (!v || 0 == Y(v.a, 1)) { | |
| return false; | |
| } | |
| ji(this.b); | |
| this.A = new Xm(v); | |
| Qr(this, this.A); | |
| if (this.c) { | |
| f = P(k); | |
| } else { | |
| f = P("TBODY"); | |
| var n = P("TABLE", { | |
| "class" : "gt-baf-table" | |
| }, f); | |
| } | |
| a = this.A.a; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < a.length; i++) { | |
| var b = a[i]; | |
| var container; | |
| var value = b; | |
| container = value.visible(); | |
| var c = value.c; | |
| var n = value.g; | |
| value = P(k, { | |
| "class" : "gt-baf-cell gt-baf-pos-head" | |
| }); | |
| if (c) { | |
| this.Ed = c; | |
| Mr(this, c); | |
| } | |
| if ("" !== n) { | |
| c = P(za, { | |
| "class" : Zb | |
| }, n); | |
| value.appendChild(c); | |
| } | |
| container = Or(value, container); | |
| if (this.c) { | |
| container = P(k, null, container); | |
| } else { | |
| container = P("TD", { | |
| colspan : 4 | |
| }, container); | |
| container = P("TR", null, container); | |
| } | |
| f.appendChild(container); | |
| if (this.c) { | |
| var p = P(k, "gt-baf-pos-section"); | |
| if (i != a.length - 1 && null != a[i + 1] && a[i + 1].visible()) { | |
| R(p, "margin-bottom", "32px"); | |
| } | |
| f.appendChild(p); | |
| } | |
| b = b.a; | |
| /** @type {number} */ | |
| c = container = 0; | |
| for (; c < b.length; c++) { | |
| value = b[c]; | |
| if (!this.c && this.A.b && 0 < c) { | |
| /** @type {!Object} */ | |
| n = f; | |
| var c; | |
| c = value.visible(); | |
| var name = P(k, { | |
| "class" : "gt-baf-cell gt-baf-sep" | |
| }); | |
| c = Or(name, c); | |
| if (!this.c) { | |
| c = P("TD", { | |
| colspan : 4 | |
| }, c); | |
| c = P("TR", null, c); | |
| } | |
| n.appendChild(c); | |
| } | |
| value = value.a; | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < value.length; n++) { | |
| name = value[n]; | |
| c = Om(v, 0).Ta(); | |
| var t = name; | |
| /** @type {number} */ | |
| var d = container; | |
| name = t.text; | |
| var m = t.c; | |
| var args; | |
| var a = t.g; | |
| /** @type {!Array} */ | |
| args = []; | |
| /** @type {number} */ | |
| var e = 0; | |
| for (; e < a.length; e++) { | |
| var i = P(za, null, a[e]); | |
| if (null != this.qa) { | |
| J(i, this.qa); | |
| } | |
| args.push(i); | |
| if (e < a.length - 1) { | |
| args.push(ei(", ")); | |
| } | |
| } | |
| a = t.visible; | |
| e = t.b; | |
| if (this.X && this.Fa) { | |
| var s = e; | |
| e = a; | |
| i = P(k, { | |
| "class" : "gt-baf-cell gt-baf-marker-container", | |
| title : this.L[s] | |
| }); | |
| s = Cl("width: %dpx", 8 * s); | |
| s = P(k, { | |
| "class" : "gt-baf-cts", | |
| style : s | |
| }); | |
| i.appendChild(s); | |
| e = Or(i, e); | |
| } else { | |
| e = P(k, { | |
| "class" : Rb | |
| }); | |
| e = Or(e, a); | |
| } | |
| e = P("TD", null, e); | |
| /** @type {null} */ | |
| i = null; | |
| if (m) { | |
| i = this.c ? true : a; | |
| s = P(this.c ? za : k, { | |
| "class" : "gt-baf-cell gt-baf-previous-word" | |
| }); | |
| if (this.c) { | |
| J(s, "gt-baf-previous-word-mobile"); | |
| } | |
| Q(s, m); | |
| i = Or(s, i); | |
| i = this.c ? i : P("TD", null, i); | |
| } | |
| s = this.c ? true : a; | |
| if (ag(this.j) != ag(this.m)) { | |
| var useStyleString = Cl(ob, ag(this.j) ? sd : Qc); | |
| } | |
| var p = P(za, this.va, name); | |
| var color = P(k, Rb, p); | |
| p = Or(this.c ? p : color, s); | |
| if (!s) { | |
| J(p, Xb); | |
| } | |
| m = this.c ? p : P("TD", m ? null : { | |
| colspan : 2, | |
| style : useStyleString | |
| }, p); | |
| if (ag(this.g) != ag(this.m)) { | |
| var gjStyle = Cl(ob, ag(this.g) ? sd : Qc); | |
| } | |
| args = P(k, { | |
| "class" : "gt-baf-cell gt-baf-translations", | |
| style : gjStyle | |
| }, args); | |
| if (this.c) { | |
| J(args, "gt-baf-translations-mobile"); | |
| } | |
| a = Or(args, a); | |
| a = this.c ? a : P("TD", { | |
| style : "width: 100%" | |
| }, a); | |
| if (this.c) { | |
| d = P(za, "", i, m); | |
| if (ag(this.j) != ag(this.m)) { | |
| var useStyleString = Cl(ob, ag(this.j) ? sd : Qc); | |
| } | |
| m = P(k, { | |
| "class" : Rb, | |
| style : useStyleString | |
| }, d); | |
| R(m, Tc, "17px"); | |
| t = Or(m, t.visible); | |
| m = this.ob && this.c ? P(k, Sb) : P(k, "gt-baf-entry"); | |
| m.appendChild(t); | |
| m.appendChild(a); | |
| R(d, "padding-right", "4px"); | |
| if (name == c) { | |
| J(d, "gt-baf-word-selected"); | |
| } | |
| c = m; | |
| } else { | |
| c = P("TR", null, e, i, m, a); | |
| if (ag(this.g) != ag(this.m) && 1 == d % 2) { | |
| J(c, "gt-baf-translations-alt"); | |
| } | |
| } | |
| if (this.c) { | |
| p.appendChild(c); | |
| } else { | |
| f.appendChild(c); | |
| } | |
| container++; | |
| } | |
| } | |
| if (this.c) { | |
| this.b.appendChild(f); | |
| } else { | |
| this.b.appendChild(n); | |
| } | |
| if (0 < Ym(this.A)) { | |
| b = Cl(this.Da, Ym(this.A)); | |
| Nr(this, b, MSG_FEWER_TRANSLATIONS_LABEL); | |
| } | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Pr.prototype.V = function() { | |
| Pr.v.V.call(this); | |
| J(this.l(), "gt-cd-baf"); | |
| X(this).a(this.l(), r, this.pb); | |
| X(this).a(this.l(), Yc, this.Qa); | |
| X(this).a(this.l(), Xc, this.Ha); | |
| }; | |
| /** | |
| * @param {?} scope | |
| * @param {!Object} element | |
| * @return {undefined} | |
| */ | |
| var Qr = function(scope, element) { | |
| var features = Zm(element); | |
| features = features.sort(function(a, b) { | |
| return b.a - a.a; | |
| }); | |
| /** @type {number} */ | |
| var next_tick_ts = 0; | |
| /** @type {boolean} */ | |
| scope.X = false; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < features.length; i++) { | |
| var f = features[i]; | |
| if (-1 < f.a) { | |
| /** @type {boolean} */ | |
| scope.X = true; | |
| } | |
| /** @type {number} */ | |
| f.b = .05 <= f.a ? 3 : .0025 <= f.a ? 2 : 1; | |
| /** @type {boolean} */ | |
| f.visible = 12 > i || 3 == f.b; | |
| /** @type {number} */ | |
| next_tick_ts = next_tick_ts + (f.visible ? 0 : 1); | |
| } | |
| if (4 >= next_tick_ts) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < features.length; i++) { | |
| /** @type {boolean} */ | |
| features[i].visible = true; | |
| } | |
| } | |
| if (element.b) { | |
| $m(element); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Pr.prototype.H = function(name) { | |
| Pr.v.H.call(this, name); | |
| var notActiveCursors = Th(Xb, this.l()); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < notActiveCursors.length; i++) { | |
| var key = notActiveCursors[i]; | |
| var input = O(Rb, key); | |
| var options = tj(input, Rc); | |
| input = input.scrollWidth + options.left + options.right + 1; | |
| R(key, Uc, name ? input + md : 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| Pr.prototype.pb = function(value) { | |
| var id; | |
| id = Ii(value.target); | |
| if (null != id) { | |
| value = O("gt-baf-word", id); | |
| if (null != value) { | |
| this.dispatchEvent(new T("b", value)); | |
| } | |
| } else { | |
| if (Bh(value.target, Ub)) { | |
| this.dispatchEvent(new T("b", value.target)); | |
| } else { | |
| if (Bh(value.target, Qb)) { | |
| this.dispatchEvent(new T("a", value.target)); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!MouseEvent} mutationEvent | |
| * @return {undefined} | |
| */ | |
| Pr.prototype.Qa = function(mutationEvent) { | |
| if (Bh(mutationEvent.target, Qb)) { | |
| var crossfilterable_layers = Sh(null, Qb, this.l()); | |
| mutationEvent = Fi(mutationEvent.target); | |
| /** @type {number} */ | |
| var layer_i = 0; | |
| for (; layer_i < crossfilterable_layers.length; layer_i++) { | |
| if (Fi(crossfilterable_layers[layer_i]) == mutationEvent) { | |
| J(crossfilterable_layers[layer_i], Tb); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Pr.prototype.Ha = function() { | |
| var children = Sh(null, Tb, this.l()); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < children.length; i++) { | |
| K(children[i], Tb); | |
| } | |
| }; | |
| /** | |
| * @param {string} text | |
| * @param {number} a | |
| * @param {number} b | |
| * @param {!Object} typedArray | |
| * @return {undefined} | |
| */ | |
| var Rr = function(text, a, b, typedArray) { | |
| /** @type {string} */ | |
| this.text = text; | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {number} */ | |
| this.b = b; | |
| /** @type {!Object} */ | |
| this.data = typedArray; | |
| }; | |
| /** | |
| * @param {string} q | |
| * @param {number} value | |
| * @param {!Array} m | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Sr = function(q, value, m, b) { | |
| /** @type {string} */ | |
| this.g = q; | |
| /** @type {number} */ | |
| this.c = value; | |
| /** @type {!Array} */ | |
| this.m = m; | |
| /** @type {number} */ | |
| this.j = b; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| this.b = -1; | |
| U(this.g, p, this.dj, false, this); | |
| U(this.c, p, this.Ri, false, this); | |
| U(this.m, p, this.Lh, false, this); | |
| }; | |
| y = Sr.prototype; | |
| /** | |
| * @param {string} value | |
| * @param {string} msg | |
| * @param {string} c | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| y.push = function(value, msg, c, t) { | |
| this.a.splice(++this.b); | |
| this.a.push(new Rr(value, msg, c, t)); | |
| Tr(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.reset = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| this.b = -1; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.dj = function() { | |
| if (0 < this.b) { | |
| --this.b; | |
| Tr(this); | |
| } | |
| Wp.M().log("lxprev"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ri = function() { | |
| if (this.b < this.a.length - 1) { | |
| ++this.b; | |
| Tr(this); | |
| } | |
| Wp.M().log("lxnext"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Lh = function() { | |
| if (1 < this.a.length) { | |
| this.a.splice(1); | |
| /** @type {number} */ | |
| this.b = 0; | |
| Tr(this); | |
| } | |
| Wp.M().log("lxclear"); | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @return {undefined} | |
| */ | |
| var Tr = function(that) { | |
| var req = that.a[that.b]; | |
| that.j.update(req.text, req.a, req.b, req.data); | |
| that.g.ba(1 < that.b); | |
| that.c.ba(that.b < that.a.length - 1); | |
| }; | |
| /** @type {boolean} */ | |
| var Ur = false; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var Vr = function(a) { | |
| if (a = a.match(/[\d]+/g)) { | |
| /** @type {number} */ | |
| a.length = 3; | |
| } | |
| }; | |
| (function() { | |
| if (navigator.plugins && navigator.plugins.length) { | |
| /** @type {!Plugin} */ | |
| var mimeType = navigator.plugins["Shockwave Flash"]; | |
| if (mimeType && (Ur = true, mimeType.description)) { | |
| Vr(mimeType.description); | |
| return; | |
| } | |
| if (navigator.plugins["Shockwave Flash 2.0"]) { | |
| /** @type {boolean} */ | |
| Ur = true; | |
| return; | |
| } | |
| } | |
| if (navigator.mimeTypes && navigator.mimeTypes.length && (mimeType = navigator.mimeTypes["application/x-shockwave-flash"], Ur = !(!mimeType || !mimeType.enabledPlugin))) { | |
| Vr(mimeType.enabledPlugin.description); | |
| return; | |
| } | |
| try { | |
| var axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7"); | |
| /** @type {boolean} */ | |
| Ur = true; | |
| Vr(axo.GetVariable("$version")); | |
| return; | |
| } catch (c) { | |
| } | |
| try { | |
| axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6"); | |
| /** @type {boolean} */ | |
| Ur = true; | |
| return; | |
| } catch (c) { | |
| } | |
| try { | |
| axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash"); | |
| /** @type {boolean} */ | |
| Ur = true; | |
| Vr(axo.GetVariable("$version")); | |
| } catch (c) { | |
| } | |
| })(); | |
| /** @type {boolean} */ | |
| var Wr = Ur; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Xr = function() { | |
| /** @type {number} */ | |
| this.b = 0; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| }; | |
| Be(Xr); | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Xr.prototype.c = function(name) { | |
| /** @type {!Image} */ | |
| var obj = new Image; | |
| /** @type {number} */ | |
| var i = this.b++; | |
| /** @type {!Image} */ | |
| this.a[i] = obj; | |
| /** @type {function(): undefined} */ | |
| obj.onload = obj.onerror = function() { | |
| delete Xr.M().a[i]; | |
| }; | |
| /** @type {string} */ | |
| obj.src = name; | |
| /** @type {null} */ | |
| obj = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Yr = function() { | |
| V.call(this); | |
| /** @type {string} */ | |
| this.url = ""; | |
| }; | |
| C(Yr, V); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Yr.prototype.Vc = function() { | |
| this.dispatchEvent(new Zr(this.url)); | |
| }; | |
| Yr.prototype.play = ve("url"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Yr.prototype.c = function() { | |
| this.dispatchEvent(new $r(this.url)); | |
| }; | |
| /** | |
| * @param {string} u | |
| * @return {undefined} | |
| */ | |
| var as = function(u) { | |
| T.call(this, Ed); | |
| /** @type {string} */ | |
| this.url = u; | |
| }; | |
| C(as, T); | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var bs = function(url) { | |
| T.call(this, Cd); | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| C(bs, T); | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var Zr = function(url) { | |
| T.call(this, Dd); | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| C(Zr, T); | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var $r = function(url) { | |
| T.call(this, Bd); | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| C($r, T); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var cs = function() { | |
| Yr.call(this); | |
| /** @type {function(new:Audio, string=): ?} */ | |
| this.m = Audio; | |
| /** @type {!Audio} */ | |
| this.a = new this.m; | |
| this.b = {}; | |
| }; | |
| C(cs, Yr); | |
| /** | |
| * @return {?} | |
| */ | |
| cs.prototype.Qf = function() { | |
| return !this.a.paused; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cs.prototype.Vc = function() { | |
| cs.v.Vc.call(this); | |
| this.a.pause(); | |
| }; | |
| /** | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| cs.prototype.play = function(i) { | |
| cs.v.play.call(this, i); | |
| ds(this, this.a); | |
| /** @type {null} */ | |
| this.a = null; | |
| if (null != this.b[i]) { | |
| this.a = this.b[i]; | |
| /** @type {null} */ | |
| this.b[i] = null; | |
| this.a.play(); | |
| } else { | |
| this.a = es(this, i); | |
| /** @type {boolean} */ | |
| this.a.autoplay = true; | |
| } | |
| }; | |
| /** | |
| * @param {string} show | |
| * @return {undefined} | |
| */ | |
| cs.prototype.rh = function(show) { | |
| z.setTimeout(A(this.o, this, show), 1E3); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} t | |
| * @return {?} | |
| */ | |
| var es = function(b, t) { | |
| var c = new b.m; | |
| c.setAttribute("src", t); | |
| U(c, kd, b.j, false, b); | |
| U(c, "ended", b.g, false, b); | |
| U(c, "error", b.c, false, b); | |
| c.load(); | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var ds = function(f, a) { | |
| hk(a, kd, f.j); | |
| hk(a, "ended", f.g); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| cs.prototype.o = function(name) { | |
| if (null != this.b[name]) { | |
| ds(this, this.b[name]); | |
| /** @type {null} */ | |
| this.b[name] = null; | |
| } | |
| this.b[name] = es(this, name); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cs.prototype.j = function() { | |
| hk(this.a, kd, this.j); | |
| this.dispatchEvent(new as(this.url)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cs.prototype.g = function() { | |
| hk(this.a, "ended", this.g); | |
| this.dispatchEvent(new bs(this.url)); | |
| }; | |
| /** | |
| * @param {number} arg | |
| * @return {undefined} | |
| */ | |
| var fs = function(arg) { | |
| Yr.call(this); | |
| /** @type {number} */ | |
| this.a = arg; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| }; | |
| C(fs, Yr); | |
| y = fs.prototype; | |
| y.Qf = w("b"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Vc = function() { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| if (null != this.a.stopPlayingSound) { | |
| this.a.stopPlayingSound(); | |
| } | |
| gs(); | |
| fs.v.Vc.call(this); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| y.play = function(a) { | |
| fs.v.play.call(this, a); | |
| z.setTimeout(A(this.jj, this), 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.jj = function() { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| var data = A(this.Bj, this); | |
| z.SoundStopCB_ = data; | |
| if (null != this.a.setSoundStopCB) { | |
| this.a.setSoundStopCB("SoundStopCB_"); | |
| } | |
| try { | |
| if (null != this.a.setSound) { | |
| this.a.setSound(this.qh()); | |
| } else { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| gs(); | |
| this.c(); | |
| return; | |
| } | |
| var data = A(this.qh, this); | |
| z._TTSSoundFile = data; | |
| } catch (c) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| gs(); | |
| this.c(); | |
| return; | |
| } | |
| if (null != this.a.startPlayingSound) { | |
| this.a.startPlayingSound(); | |
| } else { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| gs(); | |
| this.c(); | |
| } | |
| }; | |
| /** | |
| * @param {string} show | |
| * @return {undefined} | |
| */ | |
| y.rh = function(show) { | |
| var w = Xr.M(); | |
| z.setTimeout(A(w.c, w, show), 1E3); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.qh = function() { | |
| return this.url.substring(1); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Bj = function() { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| gs(); | |
| this.dispatchEvent(new bs(this.url)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var gs = function() { | |
| /** @type {null} */ | |
| z.SoundStopCB_ = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hs = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| /** @type {null} */ | |
| this.c = null; | |
| }; | |
| Be(hs); | |
| /** | |
| * @return {?} | |
| */ | |
| hs.prototype.get = function() { | |
| if (null != this.a && 0 != this.a.length) { | |
| var type = M(this.a); | |
| if (!this.g && (is("audio/mpeg") ? (this.b = new cs, type = "html5") : null != type && "OBJECT" == type.tagName && Wr ? (this.b = new fs(type), type = "flash") : (this.b = null, type = ad), this.g = true, !this.j && this.c)) { | |
| /** @type {boolean} */ | |
| this.j = true; | |
| /** @type {number} */ | |
| var mp3 = is("audio/mpeg") ? 1 : 0; | |
| /** @type {number} */ | |
| var ogg = is("audio/ogg") ? 1 : 0; | |
| /** @type {number} */ | |
| var wav = is("audio/wav") ? 1 : 0; | |
| var vol; | |
| a: { | |
| try { | |
| var elem = P("audio"); | |
| if (null != elem && null != elem.volume) { | |
| vol = elem.volume; | |
| break a; | |
| } | |
| } catch (g) { | |
| } | |
| /** @type {number} */ | |
| vol = -1; | |
| } | |
| this.c.log("ttsaudio", { | |
| mp3 : mp3, | |
| ogg : ogg, | |
| wav : wav, | |
| vol : vol, | |
| type : type | |
| }); | |
| } | |
| } | |
| return this.b; | |
| }; | |
| /** | |
| * @param {string} i | |
| * @return {?} | |
| */ | |
| var is = function(i) { | |
| try { | |
| var audio = P("audio"); | |
| return null != audio && null != audio.canPlayType && null != audio.load && null != audio.play && null != audio.paused && null != audio.pause && "no" != audio.canPlayType(i) && "" != audio.canPlayType(i); | |
| } catch (c) { | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @param {number} value | |
| * @param {number} v | |
| * @return {undefined} | |
| */ | |
| var js = function(value, v) { | |
| V.call(this); | |
| /** @type {number} */ | |
| this.C = v; | |
| this.o = hs.M(); | |
| /** @type {number} */ | |
| this.o.a = value; | |
| /** @type {number} */ | |
| this.o.c = v; | |
| this.a = this.o.get(); | |
| /** @type {null} */ | |
| this.j = null; | |
| /** @type {number} */ | |
| this.b = 0; | |
| this.c = {}; | |
| /** @type {number} */ | |
| this.g = 0; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| }; | |
| C(js, V); | |
| /** | |
| * @param {number} name | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| js.prototype.set = function(name, obj) { | |
| /** @type {number} */ | |
| this.j = name; | |
| if (null != obj) { | |
| this.c = Uf(obj); | |
| } | |
| this.c.total = name.length; | |
| ks(this); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var ns = function(obj) { | |
| if (obj.j && obj.a.Qf()) { | |
| var e = Uf(obj.c); | |
| e.idx = obj.b; | |
| /** @type {number} */ | |
| e.time = (new Date).getTime() - obj.g; | |
| ls(obj, "ttsstop", e); | |
| ks(obj); | |
| obj.a.Vc(); | |
| obj.dispatchEvent(new ms); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var ks = function(o) { | |
| /** @type {number} */ | |
| o.b = 0; | |
| /** @type {boolean} */ | |
| o.m = false; | |
| hk(o.a, Ed, o.G, false, o); | |
| hk(o.a, Cd, o.F, false, o); | |
| hk(o.a, Dd, o.B, false, o); | |
| hk(o.a, Bd, o.w, false, o); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} end | |
| * @param {string} func | |
| * @return {undefined} | |
| */ | |
| var ls = function(options, end, func) { | |
| if (options.C) { | |
| options.C.log(end, func); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| js.prototype.G = function() { | |
| if (!this.m) { | |
| this.dispatchEvent(new os); | |
| var c = Uf(this.c); | |
| c.idx = this.b; | |
| /** @type {number} */ | |
| c.time = (new Date).getTime() - this.g; | |
| ls(this, "ttsplaystart", c); | |
| /** @type {boolean} */ | |
| this.m = true; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| js.prototype.F = function() { | |
| this.b += 1; | |
| if (this.b < this.j.length) { | |
| this.a.play(this.j[this.b]); | |
| ps(this); | |
| } else { | |
| this.dispatchEvent(new ms); | |
| ks(this); | |
| var c = Uf(this.c); | |
| c.idx = this.b; | |
| /** @type {number} */ | |
| c.time = (new Date).getTime() - this.g; | |
| ls(this, "ttsfinish", c); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| js.prototype.B = function() { | |
| var c = Uf(this.c); | |
| c.idx = this.b; | |
| /** @type {number} */ | |
| c.time = (new Date).getTime() - this.g; | |
| ls(this, "ttsinterrupted", c); | |
| this.dispatchEvent(new ms); | |
| ks(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| js.prototype.w = function() { | |
| var c = Uf(this.c); | |
| c.idx = this.b; | |
| /** @type {number} */ | |
| c.time = (new Date).getTime() - this.g; | |
| ls(this, "ttserror", c); | |
| this.dispatchEvent(new ms); | |
| ks(this); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| var ps = function(s) { | |
| var newAllowOptions = s.j[s.b + 1]; | |
| if (null != newAllowOptions) { | |
| s.a.rh(newAllowOptions); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var os = function() { | |
| T.call(this, "play_start_playlist"); | |
| }; | |
| C(os, T); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var ms = function() { | |
| T.call(this, Qd); | |
| }; | |
| C(ms, T); | |
| var qs = ve("a"); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} val | |
| * @return {undefined} | |
| */ | |
| qs.prototype.j = function(name, type, val) { | |
| rs(name, type, val, A(this.c, this), A(this.g, this)); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} context | |
| * @param {!Function} x | |
| * @param {number} key | |
| * @param {?} func | |
| * @return {undefined} | |
| */ | |
| var rs = function(node, context, x, key, func) { | |
| /** @type {!Array} */ | |
| var keys = []; | |
| key(keys, context); | |
| /** @type {string} */ | |
| context = ""; | |
| /** @type {number} */ | |
| key = 0; | |
| for (; key < keys.length; key++) { | |
| var next = We(context + keys[key]); | |
| if (next.length <= x) { | |
| /** @type {string} */ | |
| context = context + keys[key]; | |
| } else { | |
| if (!Te(context)) { | |
| node.push(We(context)); | |
| /** @type {string} */ | |
| context = ""; | |
| } | |
| next = We(keys[key]); | |
| if (next.length <= x) { | |
| context = keys[key]; | |
| } else { | |
| func(node, next, x); | |
| } | |
| } | |
| } | |
| if (!Te(context)) { | |
| node.push(We(context)); | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| qs.prototype.g = function(key, name, a) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < name.length; i = i + a) { | |
| key.push(name.substr(i, a)); | |
| } | |
| }; | |
| /** @type {!RegExp} */ | |
| var ss = RegExp(" ", "g"); | |
| /** @type {!RegExp} */ | |
| var ts = RegExp("([?.,;:!][ ]+)|([\u3001\u3002\uff01\uff08\uff09\uff0c\uff0e\uff1a\uff1b\uff1f][ ]?)", "g"); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| qs.prototype.c = function(name, type) { | |
| us(name, type, ss); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| qs.prototype.b = function(name, type) { | |
| us(name, type, ts); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < name.length; i++) { | |
| var b = { | |
| length : name[i].length | |
| }; | |
| if (this.a) { | |
| this.a.log("tbphrase", b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} context | |
| * @param {string} s | |
| * @param {!RegExp} x | |
| * @return {undefined} | |
| */ | |
| var us = function(context, s, x) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; x.test(s);) { | |
| var l = x.lastIndex; | |
| if (l > i) { | |
| context.push(s.substr(i, l - i)); | |
| } | |
| i = l; | |
| } | |
| if (s.length > i) { | |
| context.push(s.substr(i)); | |
| } | |
| }; | |
| /** @type {!Array} */ | |
| var vs = [0, 200]; | |
| var ws = { | |
| af : 1, | |
| ar : 1, | |
| bn : 1, | |
| bs : 1, | |
| ca : 1, | |
| cs : 1, | |
| cy : 1, | |
| da : 1, | |
| de : 1, | |
| el : 1, | |
| en : 1, | |
| eo : 1, | |
| es : 1, | |
| fi : 1, | |
| fr : 1, | |
| hi : 1, | |
| hr : 1, | |
| hu : 1, | |
| hy : 1, | |
| id : 1, | |
| is : 1, | |
| it : 1, | |
| ja : 1, | |
| ko : 1, | |
| la : 1, | |
| lv : 1, | |
| mk : 1, | |
| nl : 1, | |
| no : 1, | |
| pl : 1, | |
| pt : 1, | |
| ro : 1, | |
| ru : 1, | |
| sk : 1, | |
| sq : 1, | |
| sr : 1, | |
| sv : 1, | |
| sw : 1, | |
| ta : 1, | |
| th : 1, | |
| tr : 1, | |
| vi : 1, | |
| zh : 1, | |
| "zh-cn" : 1, | |
| "zh-tw" : 1 | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {?} L | |
| * @param {?} n | |
| * @return {undefined} | |
| */ | |
| var xs = function(b, L, n) { | |
| Aj.call(this); | |
| /** @type {number} */ | |
| this.j = b; | |
| this.I = new qs(Wp.M()); | |
| this.L = L; | |
| /** @type {string} */ | |
| this.w = this.K = this.c = this.g = ""; | |
| /** @type {number} */ | |
| this.A = 0; | |
| /** @type {boolean} */ | |
| this.F = false; | |
| this.a = new js("tts", Wp.M()); | |
| /** @type {boolean} */ | |
| this.O = null != this.a.a; | |
| this.o = xl || wl; | |
| U(this.a, Qd, this.C, false, this); | |
| U(this.j, p, this.H, false, this); | |
| /** @type {(null|string)} */ | |
| this.G = (b = /(sa=[^#&]+)/.exec(window.location.href)) ? b[0] : null; | |
| /** @type {(null|string)} */ | |
| this.B = (b = /ttsspeed=([^&]+)/.exec(window.location.href)) ? b[0] : null; | |
| /** @type {number} */ | |
| this.b = 0; | |
| /** @type {boolean} */ | |
| this.N = !!n; | |
| /** @type {string} */ | |
| this.m = ""; | |
| }; | |
| C(xs, Aj); | |
| /** | |
| * @return {undefined} | |
| */ | |
| xs.prototype.J = function() { | |
| xs.v.J.call(this); | |
| hk(this.a, Qd, this.C, false, this); | |
| hk(this.j, p, this.H, false, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xs.prototype.C = function() { | |
| this.j.ma(false); | |
| }; | |
| /** | |
| * @param {?} g | |
| * @param {!Array} b | |
| * @param {?} areMutuallyExclusive | |
| * @param {number} parentType1 | |
| * @param {?} selectionSet1 | |
| * @param {?} v23 | |
| * @return {?} | |
| */ | |
| var ys = function(g, b, areMutuallyExclusive, parentType1, selectionSet1, v23) { | |
| return qf("/translate_tts?ie=UTF-8&q=", Xe(b), "&tl=", areMutuallyExclusive, "&total=", parentType1, "&idx=", selectionSet1, "&textlen=", b.length, zr(b), g.L, v23); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| xs.prototype.update = function(a, b, s) { | |
| /** @type {!RegExp} */ | |
| var regex = RegExp("([^?.,;:!\"#$%&'()*+\\-/<=>?@[\\]^_`{|}~\u3001\u3002\uff01\uff08\uff09\uff0c\uff0e\uff1a\uff1b\uff1f])"); | |
| /** @type {string} */ | |
| this.m = ""; | |
| if (null != s) { | |
| /** @type {number} */ | |
| var dx = 0; | |
| for (; dx < Qm(s); dx++) { | |
| var f = Rm(s, dx); | |
| var url = zm(vm(f, 0)); | |
| var hash_pos = Am(vm(f, 0)); | |
| url = rm(f).substring(url, hash_pos); | |
| f = wm(um(f, 0)); | |
| if (url == f && regex.test(url)) { | |
| this.m = Gm(s); | |
| break; | |
| } | |
| } | |
| } | |
| /** @type {number} */ | |
| this.b = 0; | |
| if (this.O) { | |
| if (a != this.g || b != this.c) { | |
| /** @type {string} */ | |
| this.g = a; | |
| /** @type {string} */ | |
| this.c = b; | |
| /** @type {boolean} */ | |
| s = false; | |
| } else { | |
| /** @type {boolean} */ | |
| s = true; | |
| } | |
| if (!s) { | |
| ns(this.a); | |
| /** @type {boolean} */ | |
| this.F = !this.O || !b || Te(a) || this.o && a.length > vs[ws[b.toLowerCase()]] ? false : b.toLowerCase() in ws; | |
| } | |
| zs(this, this.F); | |
| } else { | |
| zs(this, false); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xs.prototype.play = function() { | |
| if (this.g != this.K || this.c != this.w || this.b != this.A) { | |
| var data; | |
| if (this.o) { | |
| /** @type {!Array} */ | |
| data = [this.g]; | |
| } else { | |
| data = vs[ws[this.c.toLowerCase()]]; | |
| /** @type {!Array} */ | |
| var a = []; | |
| var c = this.I; | |
| var index = this.g.replace(/[ \u3000\n\r\t\s]+/g, " "); | |
| rs(a, index, data, A(c.b, c), A(c.j, c)); | |
| /** @type {!Array} */ | |
| data = a; | |
| } | |
| /** @type {!Array} */ | |
| a = []; | |
| /** @type {string} */ | |
| c = ""; | |
| if (null != this.G) { | |
| /** @type {string} */ | |
| c = c + ("&" + this.G); | |
| } | |
| if (null != this.B) { | |
| /** @type {string} */ | |
| c = c + ("&ttsspeed=" + this.B); | |
| } else { | |
| if (0 != this.b) { | |
| /** @type {string} */ | |
| c = c + ("&ttsspeed=" + this.b); | |
| } | |
| } | |
| if (this.m) { | |
| /** @type {string} */ | |
| c = c + ("&hint=" + this.m); | |
| } | |
| /** @type {number} */ | |
| index = 0; | |
| for (; index < data.length; index++) { | |
| a.push(ys(this, data[index], this.c, data.length, index, c)); | |
| } | |
| this.a.set(a, { | |
| textlen : this.g.length, | |
| tl : this.c | |
| }); | |
| this.K = this.g; | |
| this.w = this.c; | |
| this.A = this.b; | |
| } | |
| data = this.a; | |
| if (data.a.Qf()) { | |
| data.a.Vc(); | |
| } | |
| U(data.a, Ed, data.G, false, data); | |
| U(data.a, Cd, data.F, false, data); | |
| U(data.a, Dd, data.B, false, data); | |
| U(data.a, Bd, data.w, false, data); | |
| /** @type {number} */ | |
| data.g = (new Date).getTime(); | |
| ls(data, "ttsstart", data.c); | |
| data.a.play(data.j[data.b]); | |
| ps(data); | |
| if (this.N) { | |
| /** @type {number} */ | |
| this.b = 0 == this.b ? .24 : 0; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xs.prototype.H = function() { | |
| if (this.j.Ea()) { | |
| this.play(); | |
| } else { | |
| ns(this.a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} me | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| var zs = function(me, value) { | |
| me.j.setVisible(value); | |
| if (!value) { | |
| ns(me.a); | |
| } | |
| }; | |
| /** | |
| * @param {?} descriptor | |
| * @return {undefined} | |
| */ | |
| var As = function(descriptor) { | |
| Kr.call(this, descriptor, "ttl"); | |
| /** @type {null} */ | |
| this.b = this.c = null; | |
| this.o = new So(MSG_LISTEN, void 0, new Vo(be)); | |
| this.w = new xs(this.o, "&client=t&prev=lc"); | |
| }; | |
| C(As, Kr); | |
| /** | |
| * @return {undefined} | |
| */ | |
| As.prototype.ra = function() { | |
| As.v.ra.call(this); | |
| this.Y(di(k)); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| As.prototype.Y = function(v) { | |
| As.v.Y.call(this, v); | |
| this.l().appendChild(ip(Ip)); | |
| this.c = O("gt-ct-text", this.l()); | |
| v = O("gt-ct-tts", this.l()); | |
| this.b = O("gt-ct-translit", this.l()); | |
| this.o.R(v); | |
| }; | |
| /** | |
| * @param {string} t | |
| * @param {string} id | |
| * @param {?} i | |
| * @param {!Array} d | |
| * @return {?} | |
| */ | |
| As.prototype.update = function(t, id, i, d) { | |
| As.v.update.call(this, t, id, i, d); | |
| Q(this.c, t); | |
| this.w.update(t, id); | |
| if (this.data) { | |
| /** @type {!Array} */ | |
| t = []; | |
| if (0 < Nm(this.data)) { | |
| /** @type {number} */ | |
| id = 0; | |
| for (; id < Nm(this.data); id++) { | |
| i = Om(this.data, id); | |
| if (null != i.kb[3] && "" != Cm(i)) { | |
| t.push(Cm(i)); | |
| } | |
| } | |
| } | |
| if (0 < t.length) { | |
| Q(this.b, t.join(" ")); | |
| S(this.b, true); | |
| } else { | |
| S(this.b, false); | |
| } | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @param {?} descriptor | |
| * @param {!Array} config | |
| * @param {?} other | |
| * @return {undefined} | |
| */ | |
| var Bs = function(descriptor, config, other) { | |
| Kr.call(this, descriptor, "cm"); | |
| /** @type {!Array} */ | |
| this.X = config; | |
| this.I = new As(descriptor); | |
| /** @type {null} */ | |
| this.H = null; | |
| this.Z = other; | |
| this.b = new W; | |
| this.Ia(this.b); | |
| this.w = new W; | |
| this.Ia(this.w); | |
| /** @type {null} */ | |
| this.c = this.A = this.L = this.N = this.P = null; | |
| /** @type {!Array} */ | |
| this.o = []; | |
| }; | |
| C(Bs, Kr); | |
| y = Bs.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| Bs.v.ra.call(this); | |
| this.Y(di(k)); | |
| }; | |
| /** | |
| * @param {!Object} selector | |
| * @return {undefined} | |
| */ | |
| y.Y = function(selector) { | |
| Bs.v.Y.call(this, selector); | |
| this.l().appendChild(ip(Gp)); | |
| this.I.R(O("gt-cc-tc", this.l())); | |
| this.H = O("gt-cc-t", this.l()); | |
| S(this.H, false); | |
| this.b.R(O("gt-cc-l-i", this.l())); | |
| this.w.R(O("gt-cc-r-i", this.l())); | |
| selector = O("gt-cc-bc", this.l()); | |
| this.P = new eo("", new Vo("prev-button")); | |
| this.P.aa(selector); | |
| this.N = new eo("", new Vo("next-button")); | |
| this.N.aa(selector); | |
| this.L = new eo("", new Vo("big-clear-button")); | |
| this.L.aa(selector); | |
| this.A = O("gt-cc-exp", this.l()); | |
| this.c = new Sr(this.P, this.N, this.L, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| Bs.v.V.call(this); | |
| X(this).a(this, "a", this.Fi); | |
| X(this).a(this, "b", this.Gi); | |
| X(this).a(this.A, r, this.oi); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.oi = function() { | |
| S(this.A, false); | |
| xf(this.o, function(varTable) { | |
| varTable.setVisible(true); | |
| }); | |
| var cssText = {}; | |
| Ll(this.b, function(rule) { | |
| if (rule.isVisible()) { | |
| /** @type {string} */ | |
| cssText[rule.Ua()] = rule.bd ? "e" : "ne"; | |
| } | |
| }); | |
| this.log("expand", cssText); | |
| }; | |
| /** | |
| * @param {!Function} a | |
| * @return {undefined} | |
| */ | |
| y.Fi = function(a) { | |
| a = Fi(a.target); | |
| Cs(this, this.g, this.j, a, false, "clks"); | |
| }; | |
| /** | |
| * @param {!Function} a | |
| * @return {undefined} | |
| */ | |
| y.Gi = function(a) { | |
| a = Fi(a.target); | |
| Cs(this, this.j, this.g, a, false, "clkt"); | |
| }; | |
| /** | |
| * @param {!Object} inputService | |
| * @return {undefined} | |
| */ | |
| y.Eg = function(inputService) { | |
| var tParentMatrix = this.c.a[0]; | |
| Cs(this, tParentMatrix.b, tParentMatrix.a, inputService.text, true, "selalt"); | |
| }; | |
| /** | |
| * @param {?} message | |
| * @return {undefined} | |
| */ | |
| y.Ci = function(message) { | |
| var messageText = message.text; | |
| if (!(50 < messageText.length)) { | |
| var tParentMatrix = this.c.a[0]; | |
| if (message.w) { | |
| Cs(this, tParentMatrix.b, tParentMatrix.a, messageText, true, "sel"); | |
| } else { | |
| Cs(this, tParentMatrix.a, tParentMatrix.b, messageText, true, "sel"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {string} target | |
| * @param {string} mode | |
| * @param {string} value | |
| * @param {boolean} expand | |
| * @param {string} pane | |
| * @return {undefined} | |
| */ | |
| var Cs = function(e, target, mode, value, expand, pane) { | |
| if (value != e.text || target != e.g) { | |
| if (target == qe) { | |
| target = pe; | |
| } | |
| if (expand) { | |
| Q(e.I.c, "..."); | |
| Gr(e.X, target, mode, e.m, value, A(e.W, e, value, target, mode), false, "UTF-8", new Xq("source=" + pane)); | |
| } else { | |
| tl(e.Z, target, mode, value, pane); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} data | |
| * @param {string} id | |
| * @param {?} index | |
| * @param {!Array} b | |
| * @return {?} | |
| */ | |
| Bs.prototype.update = function(data, id, index, b) { | |
| Bs.v.update.call(this, data, id, index, b); | |
| S(this.H, 1 != this.c.a.length); | |
| /** @type {number} */ | |
| var $2 = 0; | |
| /** @type {number} */ | |
| var $3 = 0; | |
| /** @type {boolean} */ | |
| var g = true; | |
| /** @type {!Array} */ | |
| this.o = []; | |
| Ll(this.b, function(e) { | |
| var result = e.update(data, id, index, b); | |
| /** @type {number} */ | |
| $2 = $2 | result; | |
| if (result) { | |
| if (g) { | |
| /** @type {boolean} */ | |
| g = false; | |
| } else { | |
| if (!e.Qe) { | |
| e.setVisible(false); | |
| this.o.push(e); | |
| } | |
| } | |
| } | |
| }, this); | |
| Ds(this, this.b); | |
| /** @type {boolean} */ | |
| var e = 0 < this.o.length; | |
| S(this.A, e); | |
| Ll(this.w, function(callbacks) { | |
| /** @type {number} */ | |
| $3 = $3 | callbacks.update(data, id, index, b); | |
| }, this); | |
| var value = $2 || $3; | |
| this.setVisible(value); | |
| this.I.update(data, id, index, b); | |
| if (value) { | |
| var cssText = {}; | |
| Ll(this.b, function(rule) { | |
| if (rule.isVisible()) { | |
| /** @type {string} */ | |
| cssText[rule.Ua()] = rule.bd ? "e" : "ne"; | |
| } | |
| }); | |
| Ll(this.w, function(rule) { | |
| if (rule.isVisible()) { | |
| /** @type {string} */ | |
| cssText[rule.Ua()] = rule.bd ? "e" : "ne"; | |
| } | |
| }); | |
| /** @type {string} */ | |
| cssText[this.Ua()] = e ? "e" : "ne"; | |
| this.log(Ad, cssText); | |
| } | |
| return value; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @param {!Function} d | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| Bs.prototype.W = function(key, name, d, a) { | |
| this.c.push(key, name, d, a); | |
| if (!this.isVisible()) { | |
| key = this.c; | |
| if (1 < key.a.length) { | |
| key.a.splice(key.a.length - 1); | |
| /** @type {number} */ | |
| key.b = key.a.length - 1; | |
| Tr(key); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} a_val | |
| * @return {undefined} | |
| */ | |
| var Ds = function(b, a_val) { | |
| /** @type {!Array} */ | |
| var c = []; | |
| Ll(a_val, function(res) { | |
| if (res.isVisible() || Ef(this.o, res)) { | |
| var a = res.Ed || res.text; | |
| if (Ef(c, a)) { | |
| res.Lf(); | |
| } else { | |
| c.push(a); | |
| } | |
| } | |
| }, b); | |
| }; | |
| /** | |
| * @param {!Object} h | |
| * @return {?} | |
| */ | |
| var Es = function(h) { | |
| return '<div id="' + Z(h.id) + '" class="cp-promo" style="display:none"><div class="cp-promo-c"><div class="cp-dismiss"></div><a href="' + Z(h.url) + '"><div class="cp-promo-graphic"></div><div class="cp-promo-text-c"><div class="cp-promo-text"><div class="cp-promo-title">' + Z(h.zj) + '</div><div class="cp-promo-subtext">' + Z(h.wj) + '</div></div></div><div class="cp-promo-bottom"><div class="cp-promo-link"><div class="cp-promo-link-badge"></div><div class="cp-promo-link-arrow"></div><div class="cp-promo-link-text">' + | |
| Z(h.qd) + '</div><div class="cp-promo-link-subtext">' + Z(h.Mi) + "</div></div></div></a></div></div>"; | |
| }; | |
| /** | |
| * @param {!Object} h | |
| * @return {?} | |
| */ | |
| var Fs = function(h) { | |
| return '<div id="' + Z(h.id) + '" class="verified-translation"><div class="vt-description">' + Z(h.$e) + '</div><div class="vt-buttons"><div class="vt-link"><a class="vt-link-text" href="' + Z(h.url) + '">' + Z(h.qd) + '</a></div><div class="vt-dismiss">' + Z(h.Qh) + "</div></div></div>"; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {!Array} b | |
| * @param {number} h | |
| * @param {(Object|string)} o | |
| * @param {?} t | |
| * @param {number} s | |
| * @return {undefined} | |
| */ | |
| var Gs = function(a, b, h, o, t, s) { | |
| W.call(this); | |
| this.c = Wp.M(); | |
| this.A = a; | |
| /** @type {!Array} */ | |
| this.m = b; | |
| /** @type {number} */ | |
| this.w = h; | |
| /** @type {(Object|string)} */ | |
| this.o = o; | |
| this.H = t; | |
| /** @type {number} */ | |
| this.b = s; | |
| /** @type {boolean} */ | |
| this.j = false; | |
| }; | |
| C(Gs, W); | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| Gs.prototype.setVisible = function(id) { | |
| if (id && !this.j) { | |
| this.c.log(cb, "show-" + this.b); | |
| S(this.g, true); | |
| } else { | |
| S(this.g, false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| Gs.prototype.Y = function(s) { | |
| Gs.v.Y.call(this, s); | |
| this.g = ip(Es, { | |
| qd : this.A, | |
| Mi : this.m, | |
| zj : this.w, | |
| wj : this.o, | |
| url : this.H, | |
| id : this.b | |
| }); | |
| s.appendChild(this.g); | |
| var a = O("cp-dismiss", s); | |
| X(this).a(a, r, this.I); | |
| s = O("cp-promo-link", s); | |
| X(this).a(s, r, this.L); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gs.prototype.I = function() { | |
| this.c.log(cb, "dismiss-" + this.b); | |
| $p(this.c, ha + this.b); | |
| this.setVisible(false); | |
| /** @type {boolean} */ | |
| this.j = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gs.prototype.L = function() { | |
| this.c.log(cb, "click-" + this.b); | |
| }; | |
| /** | |
| * @param {?} promiseOrResolver | |
| * @param {?} name | |
| * @param {?} prefixAgnostic | |
| * @return {undefined} | |
| */ | |
| var Hs = function(promiseOrResolver, name, prefixAgnostic) { | |
| /** @type {string} */ | |
| var id = "md"; | |
| if (null != prefixAgnostic && prefixAgnostic) { | |
| /** @type {string} */ | |
| id = "m" + id; | |
| } | |
| Lr.call(this, promiseOrResolver, id, MSG_DEFINITIONS_OF, ""); | |
| this.L = null != name ? name : true; | |
| }; | |
| C(Hs, Lr); | |
| /** | |
| * @param {number} a | |
| * @param {string} id | |
| * @param {number} x | |
| * @param {!Object} p | |
| * @return {?} | |
| */ | |
| Hs.prototype.update = function(a, id, x, p) { | |
| Hs.v.update.call(this, a, id, x, p); | |
| if (!p || 0 == Y(p.a, 12) && 0 == Y(p.a, 15)) { | |
| return false; | |
| } | |
| ji(this.b); | |
| /** @type {number} */ | |
| this.c = 0; | |
| a = Y(p.a, 12); | |
| /** @type {boolean} */ | |
| id = 3 > a; | |
| /** @type {number} */ | |
| var i = x = 0; | |
| for (; i < Y(p.a, 12); i++) { | |
| x = x + Tm(p, i).a(); | |
| } | |
| x = 5 > x ? x : 3; | |
| /** @type {number} */ | |
| i = this.A = 0; | |
| for (; i < a; ++i) { | |
| var v = Tm(p, i); | |
| var m; | |
| m = Tm(p, i).g[2]; | |
| m = null != m ? m : ""; | |
| var value = P(k, { | |
| "class" : Zb | |
| }); | |
| this.b.appendChild(value); | |
| var node = v.g[0]; | |
| Q(value, null != node ? node : ""); | |
| /** @type {!Object} */ | |
| value = p; | |
| /** @type {string} */ | |
| node = id; | |
| /** @type {number} */ | |
| var r = x; | |
| /** @type {number} */ | |
| var label = Math.ceil(r / a); | |
| var d = P(k, { | |
| "class" : "gt-def-list" | |
| }); | |
| var pos = ag(this.g) ? sd : Qc; | |
| R(d, { | |
| direction : pos | |
| }); | |
| /** @type {number} */ | |
| pos = 0; | |
| for (; pos < v.a(); ++pos) { | |
| var style = v.c(pos); | |
| var el; | |
| el = style.a[0]; | |
| el = null != el ? el : ""; | |
| var city; | |
| city = style.a[2]; | |
| city = null != city ? city : ""; | |
| var val = value; | |
| /** @type {!Array} */ | |
| var def = []; | |
| /** @type {number} */ | |
| var QueryLanguageComponent = 0; | |
| for (; QueryLanguageComponent < Y(val.a, 11); ++QueryLanguageComponent) { | |
| var super$0 = Sm(val, QueryLanguageComponent); | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < super$0.a(); ++key) { | |
| var v = super$0.c(key); | |
| var url = style.a[1]; | |
| var cssClassName = v.a[1]; | |
| if ((null != url ? url : "") == (null != cssClassName ? cssClassName : "")) { | |
| /** @type {!Array} */ | |
| url = []; | |
| /** @type {number} */ | |
| cssClassName = 0; | |
| for (; cssClassName < Y(v.a, 0); ++cssClassName) { | |
| Gf(url, Fm(v, cssClassName)); | |
| } | |
| Gf(def, url); | |
| } | |
| } | |
| } | |
| /** @type {!Array} */ | |
| style = def; | |
| if (val = 1 > pos || node && pos < label && this.A < r) { | |
| this.A += 1; | |
| } | |
| def = ag(this.j) ? sd : Qc; | |
| style = jp(Kp, { | |
| Oh : el, | |
| kg : city, | |
| xj : MSG_SYNONYMS_LOWERCASE, | |
| ih : style, | |
| Tf : def, | |
| Mh : this.L | |
| }); | |
| def = O("gt-mt-md", style); | |
| this.$.push([def, el]); | |
| if (el = O("gt-ex-mt", style)) { | |
| this.$.push([el, city]); | |
| } | |
| if ((el = O("gt-def-synonym-title", style)) && ag(this.m) != ag(this.g)) { | |
| city = ag(this.m); | |
| R(el, nb, city ? sd : Qc); | |
| R(el, "padding-" + (city ? Pc : qd), "8px"); | |
| el.style[E ? "styleFloat" : "cssFloat"] = city ? qd : Pc; | |
| } | |
| el = Or(style, val); | |
| d.appendChild(el); | |
| this.c += 1; | |
| } | |
| this.b.appendChild(d); | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < Y(p.a, 15); i++) { | |
| /** @type {number} */ | |
| value = i; | |
| value = new om(Tl(p.a, 15)[value]); | |
| v = value.a[1]; | |
| r = null != v ? v : ""; | |
| v = value.a[2]; | |
| v = null != v ? v : ""; | |
| node = P(k, { | |
| "class" : "gt-def-row" | |
| }); | |
| r = P(k, { | |
| "class" : "gt-kp-desc" | |
| }, r); | |
| label = P("A"); | |
| value = value.a[3]; | |
| label.setAttribute("href", null != value ? value : ""); | |
| label.setAttribute("target", "_blank"); | |
| value = P(sa, { | |
| "class" : "gt-kp-image" | |
| }); | |
| value.setAttribute("src", v); | |
| label.appendChild(value); | |
| node.appendChild(label); | |
| node.appendChild(r); | |
| this.b.appendChild(node); | |
| } | |
| if (m) { | |
| this.Ed = m; | |
| Mr(this, m); | |
| } | |
| if (!id && this.c > 1 * a || id && this.c > x) { | |
| p = MSG_N_MORE_DEFINITIONS_LABEL.replace(aa, this.c - this.A); | |
| Nr(this, p, MSG_FEWER_DEFINITIONS_LABEL); | |
| } else { | |
| p = Th(Vb, this.l()); | |
| /** @type {number} */ | |
| m = 0; | |
| for (; m < p.length; m++) { | |
| a = p[m]; | |
| if (O("gt-def-synonym", a)) { | |
| K(a, Vb); | |
| } | |
| } | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Hs.prototype.V = function() { | |
| Hs.v.V.call(this); | |
| X(this).a(this.l(), r, this.X); | |
| }; | |
| /** | |
| * @param {string} selector | |
| * @return {undefined} | |
| */ | |
| Hs.prototype.Y = function(selector) { | |
| Hs.v.Y.call(this, selector); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Hs.prototype.X = function(key) { | |
| if (Bh(key.target, Yb)) { | |
| this.dispatchEvent(new T("a", key.target)); | |
| } | |
| }; | |
| var Is = ue(); | |
| Is.prototype.m = x(""); | |
| /** | |
| * @param {number} g | |
| * @param {number} b | |
| * @param {number} c | |
| * @param {!Object} d | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| var Js = function(g, b, c, d, e) { | |
| /** @type {number} */ | |
| this.g = g; | |
| /** @type {number} */ | |
| this.j = b; | |
| /** @type {number} */ | |
| this.c = c; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| g = 0; | |
| for (; g < d.length; ++g) { | |
| this.a.push(d[g].toLowerCase()); | |
| } | |
| /** @type {!Array} */ | |
| this.b = []; | |
| /** @type {number} */ | |
| g = 0; | |
| for (; g < e.length; ++g) { | |
| this.b.push(e[g].toLowerCase()); | |
| } | |
| }; | |
| C(Js, Is); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {string} data | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| Js.prototype.m = function(name, type, data, value) { | |
| if ("" != this.c && this.c != data) { | |
| return ""; | |
| } | |
| data = Ks(name, type, value, this.g, this.j, this.a, this.b); | |
| return "" != data ? data : Ks(name, type, value, this.j, this.g, this.b, this.a); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {string} b | |
| * @param {!Object} start | |
| * @param {?} one | |
| * @param {string} two | |
| * @param {!Object} path | |
| * @param {!Object} g | |
| * @return {?} | |
| */ | |
| var Ks = function(a, b, start, one, two, path, g) { | |
| if (a == one && b == two) { | |
| /** @type {number} */ | |
| a = 0; | |
| for (; a < Nm(start); a++) { | |
| b = Om(start, a); | |
| one = Bm(b).toLowerCase(); | |
| if (0 <= wf(path, one)) { | |
| return one; | |
| } | |
| b = b.Ta().toLowerCase(); | |
| if (0 <= wf(g, b)) { | |
| return b; | |
| } | |
| } | |
| } | |
| return ""; | |
| }; | |
| /** @type {!Array} */ | |
| var Ls = [{ | |
| oa : new Js(v, t, v, ["\u0434\u0430\u043c\u0430", "\u0441\u043e\u0431\u0430\u043a\u0430", "\u0441\u043e\u0431\u0430\u0447\u043a\u0430", "\u0434\u0430\u043c\u0430 \u0441 \u0441\u043e\u0431\u0430\u0447\u043a\u043e\u0439"], ["lady", "dog", "dog", "lady with a dog"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/annasergeevna.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043c\u0438\u043b\u044b\u0439", "\u0433\u0440\u0435\u0448\u043d\u0438\u043a", "\u0433\u0440\u0435\u0445", "\u0433\u0440\u0435\u0448\u043d\u0438\u0446\u0430"], ["sweet", "sinner", "sin", "sinner"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/annasergeevna_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0447\u0435\u043b\u043e\u0432\u0435\u043a", "\u0444\u0443\u0442\u043b\u044f\u0440", "\u043e\u0431\u043e\u043b\u043e\u0447\u043a\u0430", "\u0441\u043a\u043e\u0440\u043b\u0443\u043f\u0430"], ["man", "case", "shell", "shell"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/belikov.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043d\u0435\u0442"], ["no"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/belikov_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0441\u0435\u0441\u0442\u0440\u0430", "\u0442\u0440\u0438 \u0441\u0435\u0441\u0442\u0440\u044b"], ["sister", "three sisters"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/chekhov_1.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0434\u043e\u043c", "\u043c\u0435\u0437\u043e\u043d\u0438\u043d", "\u0434\u043e\u043c \u0441 \u043c\u0435\u0437\u043e\u043d\u0438\u043d\u043e\u043c"], ["house", "mezzanine", "house with mezzanine"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/chekhov_2.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0437\u043b\u043e\u0439", "\u043c\u0430\u043b\u044c\u0447\u0438\u043a", "\u0437\u043b\u043e\u0439 \u043c\u0430\u043b\u044c\u0447\u0438\u043a"], ["evil", "boy", "evil boy"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/chekhov_3.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043d\u0435\u0432\u0435\u0441\u0442\u0430"], ["bride"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/chekhov_4.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0441\u043a\u0443\u0447\u043d\u044b\u0439", "\u0441\u043a\u0443\u043a\u0430", "\u0441\u043a\u0443\u0447\u043d\u0430\u044f \u0438\u0441\u0442\u043e\u0440\u0438\u044f"], ["boring", "boredom", "boring story"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/chekhov_5.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0446\u0432\u0435\u0442\u044b", "\u0437\u0430\u043f\u043e\u0437\u0434\u0430\u043b\u044b\u0439", "\u0446\u0432\u0435\u0442\u044b \u0437\u0430\u043f\u043e\u0437\u0434\u0430\u043b\u044b\u0435", "\u043f\u043e\u0437\u0434\u043d\u043e", "\u043f\u043e\u0437\u0434\u043d\u0438\u0439"], ["flowers", "belated", "belated flowers", "late"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/chekhov_6.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043e\u0432\u0440\u0430\u0433", "\u0432 \u043e\u0432\u0440\u0430\u0433\u0435"], ["ravine", "in a ravine"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/grigoiriytsibukin.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u044f \u043d\u0435 \u0437\u043d\u0430\u044e"], ["i do not know"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/grigoiriytsibukin_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0446\u0438\u043d\u0438\u043a", "\u0446\u0438\u043d\u0438\u0437\u043c"], ["cynic", "cynism"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/grigoiriytsibukin_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, "\u0432\u043a\u0443\u0441\u043d\u043e \u043a\u043b\u0443\u0431\u043d\u0438\u043a\u0430 \u044f\u0433\u043e\u0434\u0430 \u0444\u0440\u0443\u043a\u0442 \u0430\u0440\u0431\u0443\u0437 \u0435\u0434\u0430".split(" "), "tasty strawberry berry fruit watermelon food".split(" ")), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/gurov.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043f\u0440\u0438\u044f\u0442\u043d\u043e\u0433\u043e \u0430\u043f\u043f\u0435\u0442\u0438\u0442\u0430"], ["bon appetit"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/gurov_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043f\u0440\u043e\u0441\u0432\u0435\u0442\u0432\u043b\u0435\u043d\u043d\u044b\u0439"], ["enlightened"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/gurov_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0442\u043e\u0441\u043a\u0430", "\u0433\u0440\u0443\u0441\u0442\u044c", "\u043f\u0435\u0447\u0430\u043b\u044c", "\u043f\u0435\u0447\u0430\u043b\u044c", "\u043f\u0435\u0447\u0430\u043b\u044c\u043d\u044b\u0439"], ["yearning", "sorrow", "sadness", "sadness", "sad"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/iona.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0436\u0435\u0440\u0442\u0432\u0430", "\u0441\u0442\u0440\u0430\u0434\u0430\u0442\u044c", "\u0441\u0442\u0440\u0430\u0434\u0430\u043b\u0438\u0446\u0430", "\u0441\u0442\u0440\u0430\u0434\u0430\u043b\u0435\u0446", "\u0432\u0435\u0447\u043d\u044b\u0439"], ["victim", "suffer", "sufferer", "eternal"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/iona_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0447\u0430\u0439\u043a\u0430", "\u043f\u0442\u0438\u0446\u0430"], ["seagull", "bird"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/konstantintreplev.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0441\u0442\u0440\u0430\u043d\u043d\u0438\u043a", "\u0431\u0440\u043e\u0434\u044f\u0433\u0430"], ["wanderer", "tramp"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/konstantintreplev_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0440\u043e\u0437\u0430", "\u0433\u043e\u0434", "\u0442\u0440\u0438 \u0433\u043e\u0434\u0430"], ["rose", "year", "three years"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/laptev.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, "\u043b\u044e\u0431\u043b\u044e;\u043b\u044e\u0431\u0438\u0442\u044c;\u044f \u0442\u0435\u0431\u044f \u043b\u044e\u0431\u043b\u044e;\u043b\u044e\u0431\u043e\u0432\u044c;\u043d\u0440\u0430\u0432\u0438\u0442\u0441\u044f;\u043d\u0440\u0430\u0432\u0438\u0442\u044c\u0441\u044f".split(";"), "love;love;i love you;love;artist;please".split(";")), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/laptev_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0440\u043e\u043c\u0430\u043d\u0442\u0438\u043a", "\u043f\u043e\u0441\u043b\u0435\u0434\u043d\u0438\u0439"], ["romantic", "latest"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/laptev_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0431\u0438\u0437\u043d\u0435\u0441", "\u0434\u0435\u043b\u043e", "\u0432\u0438\u0448\u043d\u044f", "\u0441\u0430\u0434", "\u0432\u0438\u0448\u043d\u0435\u0432\u044b\u0439 \u0441\u0430\u0434"], ["business", "business", "cherry", "garden", "the cherry orchard"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/lopakhin.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0434\u0430"], ["yes"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/lopakhin_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0440\u0430\u0431\u043e\u0442\u0430"], ["work"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/lopakhin_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0436\u0438\u0437\u043d\u044c", "\u043c\u043e\u044f \u0436\u0438\u0437\u043d\u044c"], ["life", "my life"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/masha.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, "\u043f\u0440\u0438\u0432\u0435\u0442;\u0434\u043e\u0431\u0440\u044b\u0439 \u0434\u0435\u043d\u044c;\u0434\u043e\u0431\u0440\u044b\u0439 \u0432\u0435\u0447\u0435\u0440;\u0434\u043e\u0431\u0440\u043e\u0435 \u0443\u0442\u0440\u043e;\u0437\u0434\u0440\u0430\u0432\u0441\u0442\u0432\u0443\u0439;\u0437\u0434\u0440\u0430\u0432\u0441\u0442\u0432\u0443\u0439\u0442\u0435;\u043a\u0430\u043a \u0434\u0435\u043b\u0430;\u0447\u0442\u043e \u0434\u0435\u043b\u0430\u0435\u0448\u044c;\u0447\u0442\u043e \u043d\u043e\u0432\u043e\u0433\u043e;\u043a\u0430\u043a \u0436\u0438\u0437\u043d\u044c;\u043a\u0430\u043a \u0442\u044b".split(";"), | |
| "hello;good afternoon;good evening;good morning;how are you;what are you doing;what's new;what's up".split(";")), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/masha_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0445\u0438\u0449\u043d\u0438\u043a", "\u0432\u0430\u043c\u043f\u0438\u0440", "\u043e\u0445\u043e\u0442\u0430"], ["predator", "vampire", "hunting"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/masha_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, "\u043a\u043d\u0438\u0433\u0430 \u043b\u0438\u0442\u0435\u0440\u0430\u0442\u0443\u0440\u0430 \u043f\u0440\u043e\u0438\u0437\u0432\u0435\u0434\u0435\u043d\u0438\u0435 \u0438\u0441\u0442\u043e\u0440\u0438\u044f \u0440\u0430\u0441\u0441\u043a\u0430\u0437 \u0438\u0441\u043a\u0443\u0441\u0441\u0442\u0432\u043e \u043a\u043b\u0430\u0441\u0441\u0438\u043a\u0430 \u0430\u0432\u0442\u043e\u0440 \u043f\u0438\u0441\u0430\u0442\u0435\u043b\u044c \u043f\u044c\u0435\u0441\u0430".split(" "), | |
| ["book", "literature", "composition", "history", "story", "art", "classic", "author", "writer", kd]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/petyatrofimov_callout.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0441\u0442\u0443\u0434\u0435\u043d\u0442", "\u0441\u0442\u0443\u0434\u0435\u043d\u0442\u043a\u0430"], ["student", "student"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/petyatrofimov_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, "\u043f\u0430\u043b\u0430\u0442\u0430;\u043f\u0430\u043b\u0430\u0442\u0430 \u21166;\u043f\u0441\u0438\u0445\u0438\u0430\u0442\u0440\u0438\u044f;\u043f\u0441\u0438\u0445\u0438\u0430\u0442\u0440\u0438\u0447\u0435\u0441\u043a\u0430\u044f \u0431\u043e\u043b\u044c\u043d\u0438\u0446\u0430;\u043f\u0441\u0438\u0445\u0443\u0448\u043a\u0430;\u0431\u043e\u043b\u044c\u043d\u0438\u0446\u0430;\u0434\u0443\u0440\u0434\u043e\u043c".split(";"), "ward;ward No6;psychiatry;mental hospital;nuthouse;hospital;loony bin".split(";")), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/ragin.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u043f\u043e\u0431\u0435\u0436\u0434\u0435\u043d\u043d\u044b\u0439", "\u043f\u043e\u0440\u0430\u0436\u0435\u043d\u0438\u0435", "\u043f\u0440\u043e\u0438\u0433\u0440\u044b\u0448"], ["defeated", "defeat", "loss"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/ragin_type.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0434\u044f\u0434\u044f"], ["uncle"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/sonya.gif" | |
| }, | |
| ea : true | |
| }, { | |
| oa : new Js(v, t, v, ["\u0430\u043b\u044c\u0442\u0440\u0443\u0438\u0441\u0442", "\u0434\u043e\u0431\u0440\u043e", "\u0445\u043e\u0440\u043e\u0448\u0438\u0439"], ["altruist", "good", "good"]), | |
| target : sc, | |
| ia : sa, | |
| attributes : { | |
| src : "//ssl.gstatic.com/translate/ee/sonya_type.gif" | |
| }, | |
| ea : true | |
| }]; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var Ms = function(p1__3354_SHARP_) { | |
| Lr.call(this, p1__3354_SHARP_, "ee", "", ""); | |
| /** @type {boolean} */ | |
| this.Qe = true; | |
| }; | |
| C(Ms, Lr); | |
| /** @type {!Array} */ | |
| var Ns = []; | |
| /** | |
| * @param {!Object} v | |
| * @param {string} a | |
| * @param {!Function} n | |
| * @param {string} d | |
| * @return {?} | |
| */ | |
| Ms.prototype.update = function(v, a, n, d) { | |
| Ms.v.update.call(this, v, a, n, d); | |
| ji(this.b); | |
| var vertices = Ns; | |
| if (EGGS_RU_CHEKHOV) { | |
| vertices = vertices.concat(Ls); | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < vertices.length; i++) { | |
| v = vertices[i]; | |
| var p = v.oa.m(a, n, this.m, d); | |
| if ("" != p) { | |
| return n = a = jp(Mp), v.target && (d = v.target, v.ea && (d = d + p), p = jp(Np, { | |
| yf : d | |
| }), n.appendChild(p), n = p), n.appendChild(P.apply(null, [v.ia, v.attributes])), this.b.appendChild(a), this.setVisible(true), true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ms.prototype.Lf = function() { | |
| if (this.w) { | |
| Q(this.w, ""); | |
| } | |
| }; | |
| /** | |
| * @param {?} i | |
| * @param {?} objSource | |
| * @param {string} objDestination | |
| * @param {!Array} other | |
| * @param {!Object} options | |
| * @param {?} url | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var Ps = function(i, objSource, objDestination, other, options, url, c) { | |
| W.call(this); | |
| this.Z = i; | |
| this.Fa = objSource; | |
| /** @type {string} */ | |
| this.Ha = objDestination; | |
| /** @type {!Object} */ | |
| this.$ = options; | |
| this.Da = url; | |
| /** @type {!Array} */ | |
| this.X = other; | |
| this.U = new Ar(Os(this)); | |
| /** @type {number} */ | |
| this.g = c; | |
| /** @type {string} */ | |
| this.j = ""; | |
| /** @type {number} */ | |
| this.w = c; | |
| /** @type {null} */ | |
| this.P = null; | |
| this.I = Wp.M(); | |
| }; | |
| C(Ps, W); | |
| /** | |
| * @param {?} node | |
| * @return {?} | |
| */ | |
| var Os = function(node) { | |
| return node.X ? "webapp" : "t"; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var Qs = function(item) { | |
| var i = P(k, { | |
| id : "gt-res-formal" | |
| }); | |
| item.l().appendChild(i); | |
| var node = new Rp(""); | |
| node.Ba(16, true); | |
| node.aa(i); | |
| node.g(item.Fa); | |
| zn(node.c, node, 2); | |
| if (0 == item.w) { | |
| node.ma(true); | |
| } | |
| U(node, p, item.qa, false, item); | |
| item.L = node; | |
| i = P(k, { | |
| id : "gt-res-informal" | |
| }); | |
| item.l().appendChild(i); | |
| node = new Rp(""); | |
| node.Ba(16, true); | |
| node.aa(i); | |
| node.g(item.Ha); | |
| zn(node.c, node, 1); | |
| if (1 == item.w) { | |
| node.ma(true); | |
| } | |
| U(node, p, item.va, false, item); | |
| item.N = node; | |
| item.setVisible(false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ps.prototype.qa = function() { | |
| if (this.m) { | |
| if (this.L.Ea()) { | |
| this.N.ma(false); | |
| /** @type {number} */ | |
| this.g = 0; | |
| aq(this.I, Os(this), zb, "formal", { | |
| hl : this.b, | |
| sl : this.c, | |
| tl : this.na, | |
| source : this.m, | |
| trans : this.j, | |
| changed : this.A != this.j | |
| }); | |
| } else { | |
| /** @type {number} */ | |
| this.g = 2; | |
| aq(this.I, Os(this), zb, "unpressformal", { | |
| hl : this.b, | |
| sl : this.c, | |
| tl : this.na, | |
| source : this.m, | |
| trans : this.j, | |
| changed : this.o != this.j | |
| }); | |
| } | |
| /** @type {boolean} */ | |
| this.P = true; | |
| tl(this.Z, "", "", this.m, "fmcl"); | |
| Rs(this); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ps.prototype.va = function() { | |
| if (this.m) { | |
| if (this.N.Ea()) { | |
| this.L.ma(false); | |
| /** @type {number} */ | |
| this.g = 1; | |
| aq(this.I, Os(this), zb, "informal", { | |
| hl : this.b, | |
| sl : this.c, | |
| tl : this.na, | |
| source : this.m, | |
| trans : this.j, | |
| changed : this.H != this.j | |
| }); | |
| } else { | |
| /** @type {number} */ | |
| this.g = 2; | |
| aq(this.I, Os(this), zb, "unpressinformal", { | |
| hl : this.b, | |
| sl : this.c, | |
| tl : this.na, | |
| source : this.m, | |
| trans : this.j, | |
| changed : this.o != this.j | |
| }); | |
| } | |
| /** @type {boolean} */ | |
| this.P = true; | |
| tl(this.Z, "", "", this.m, "fmcl"); | |
| Rs(this); | |
| } | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} id | |
| * @param {string} p | |
| * @param {!Array} m | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| Ps.prototype.update = function(value, id, p, m, a) { | |
| /** @type {!Array} */ | |
| this.m = m; | |
| /** @type {!Object} */ | |
| this.j = a; | |
| /** @type {string} */ | |
| this.b = p; | |
| /** @type {string} */ | |
| this.c = value; | |
| /** @type {string} */ | |
| this.na = id; | |
| if (this.P) { | |
| /** @type {boolean} */ | |
| this.P = false; | |
| } else { | |
| /** @type {null} */ | |
| this.H = this.A = this.o = null; | |
| switch(this.g) { | |
| case 0: | |
| /** @type {!Object} */ | |
| this.A = a; | |
| break; | |
| case 1: | |
| /** @type {!Object} */ | |
| this.H = a; | |
| break; | |
| case 2: | |
| /** @type {!Object} */ | |
| this.o = a; | |
| } | |
| if (this.$ && value == t && "de" == id) { | |
| if (0 != this.g) { | |
| /** @type {number} */ | |
| p = 0; | |
| a = new Xq; | |
| fr(a, "tco", p); | |
| a.set(Fd, "fmcp"); | |
| var error = Br; | |
| Fr(this.U, value, id, t, m, [error.Fe], A(this.W, this, p), void 0, a); | |
| } | |
| if (1 != this.g) { | |
| /** @type {number} */ | |
| p = 1; | |
| a = new Xq; | |
| fr(a, "tco", p); | |
| a.set(Fd, "fmcp"); | |
| error = Br; | |
| Fr(this.U, value, id, t, m, [error.Fe], A(this.W, this, p), void 0, a); | |
| } | |
| if (2 != this.g) { | |
| /** @type {number} */ | |
| p = 2; | |
| a = new Xq; | |
| fr(a, "tco", p); | |
| a.set(Fd, "fmcp"); | |
| error = Br; | |
| Fr(this.U, value, id, t, m, [error.Fe], A(this.W, this, p), void 0, a); | |
| } | |
| } else { | |
| this.setVisible(false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| Ps.prototype.W = function(name, type) { | |
| if (null != type) { | |
| /** @type {!Array} */ | |
| var value = []; | |
| if (0 < Nm(type)) { | |
| /** @type {number} */ | |
| var templateUrl = 0; | |
| for (; templateUrl < Nm(type); templateUrl++) { | |
| var params = Om(type, templateUrl); | |
| if (null != params.kb[0]) { | |
| value.push(params.Ta()); | |
| } | |
| } | |
| } | |
| if (0 == name) { | |
| /** @type {string} */ | |
| this.A = value.join(""); | |
| } else { | |
| if (1 == name) { | |
| /** @type {string} */ | |
| this.H = value.join(""); | |
| } else { | |
| if (2 == name) { | |
| /** @type {string} */ | |
| this.o = value.join(""); | |
| } | |
| } | |
| } | |
| if (null != this.A && null != this.H && null != this.o) { | |
| if (value = this.A != this.H) { | |
| aq(this.I, Os(this), zb, Ad, { | |
| hl : this.b, | |
| sl : this.c, | |
| tl : this.na, | |
| source : this.m, | |
| trans : this.j, | |
| changed : this.j != this.o | |
| }); | |
| } else { | |
| Ss(this); | |
| } | |
| this.setVisible(value); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {undefined} | |
| */ | |
| var Ss = function(p) { | |
| if (!p.Da) { | |
| p.L.ma(false); | |
| p.N.ma(false); | |
| p.g = p.w; | |
| if (0 == p.w) { | |
| p.L.ma(true); | |
| } else { | |
| if (1 == p.w) { | |
| p.N.ma(true); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| Ps.prototype.setVisible = function(id) { | |
| S(this.l(), id); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| var Rs = function(s) { | |
| if (!(s.b != t || s.Yb)) { | |
| /** @type {!Element} */ | |
| s.Yb = document.createElement("script"); | |
| s.Yb.setAttribute("async", ""); | |
| s.Yb.setAttribute("defer", ""); | |
| if (.5 > Math.random()) { | |
| if (s.X) { | |
| s.Yb.setAttribute("src", "//www.google.com/insights/consumersurveys/async_survey?site=drqa77owbzzvrx2eybe2mmchse"); | |
| } else { | |
| s.Yb.setAttribute("src", "//www.google.com/insights/consumersurveys/async_survey?site=7yga3yj2jydgysdmekrlxqfowu"); | |
| } | |
| } | |
| document.head.appendChild(s.Yb); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Ts = function(a, b) { | |
| Aj.call(this); | |
| /** @type {number} */ | |
| this.g = this.c = 0; | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {number} */ | |
| this.j = b; | |
| this.b = new io(A(this.m, this), 0, this); | |
| }; | |
| C(Ts, Aj); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ts.prototype.J = function() { | |
| this.b.za(); | |
| delete this.a; | |
| delete this.j; | |
| Ts.v.J.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ts.prototype.m = function() { | |
| if (!this.a.call(this.j)) { | |
| if (0 > this.g) { | |
| ko(this.b, this.c); | |
| } else { | |
| /** @type {number} */ | |
| var dtStep = this.g - Pe(); | |
| if (!(0 >= dtStep)) { | |
| ko(this.b, Math.min(this.c, dtStep)); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {undefined} a | |
| * @return {undefined} | |
| */ | |
| var Vs = function(a) { | |
| V.call(this); | |
| this.D = a; | |
| this.b = this.D.value; | |
| this.a = new nk(this); | |
| this.g = Pe(); | |
| if (Us) { | |
| this.a.a(a, hd, this.Hc); | |
| } else { | |
| this.a.a(a, [Ic, Va, wb, Yc, wc], this.ni); | |
| } | |
| this.c = new Ts(A(this.dg, this)); | |
| }; | |
| C(Vs, V); | |
| var Us = G || E || gh || ih && I("1.9"); | |
| y = Vs.prototype; | |
| /** @type {string} */ | |
| y.ac = vc; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| Vs.v.J.call(this); | |
| this.a.za(); | |
| /** @type {null} */ | |
| this.a = null; | |
| this.c.za(); | |
| /** @type {null} */ | |
| this.c = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.dg = function() { | |
| if (this.b == this.D.value) { | |
| return false; | |
| } | |
| this.dispatchEvent("after_paste"); | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| y.Hc = function(obj) { | |
| obj = new Ij(obj.b); | |
| obj.type = hd; | |
| this.dispatchEvent(obj); | |
| cl(function() { | |
| if (!this.dg()) { | |
| var c1 = this.c; | |
| jo(c1.b); | |
| /** @type {number} */ | |
| c1.c = Math.max(50, 0); | |
| c1.g = Pe() + 200; | |
| ko(c1.b, Math.min(c1.c, 200)); | |
| } | |
| }, 0, this); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| y.ni = function(options) { | |
| switch(this.ac) { | |
| case vc: | |
| switch(options.type) { | |
| case Va: | |
| this.ac = vc; | |
| break; | |
| case wb: | |
| /** @type {string} */ | |
| this.ac = "focused"; | |
| break; | |
| case Yc: | |
| this.ac = vc; | |
| if (this.D.value != this.b) { | |
| this.Hc(options); | |
| } | |
| }break; | |
| case "focused": | |
| switch(options.type) { | |
| case wc: | |
| var b = this.g + 400; | |
| if (Pe() > b || this.j == wb) { | |
| this.Hc(options); | |
| } | |
| break; | |
| case Va: | |
| this.ac = vc; | |
| break; | |
| case Ic: | |
| if (kh && fh && 0 == options.keyCode || kh && fh && 17 == options.keyCode) { | |
| break; | |
| } | |
| /** @type {string} */ | |
| this.ac = "typing"; | |
| break; | |
| case Yc: | |
| if (this.D.value != this.b) { | |
| this.Hc(options); | |
| } | |
| }break; | |
| case "typing": | |
| switch(options.type) { | |
| case wc: | |
| /** @type {string} */ | |
| this.ac = "focused"; | |
| break; | |
| case Va: | |
| this.ac = vc; | |
| break; | |
| case Ic: | |
| if (options.ctrlKey && 86 == options.keyCode || options.shiftKey && 45 == options.keyCode || options.metaKey && 86 == options.keyCode) { | |
| this.Hc(options); | |
| } | |
| break; | |
| case Yc: | |
| if (this.D.value != this.b) { | |
| this.Hc(options); | |
| } | |
| } | |
| } | |
| this.g = Pe(); | |
| this.b = this.D.value; | |
| this.j = options.type; | |
| }; | |
| var Ws = ue(); | |
| C(Ws, hn); | |
| Be(Ws); | |
| y = Ws.prototype; | |
| y.Rb = ue(); | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| y.R = function(a, b) { | |
| Sn(a, false); | |
| a.Ib &= -256; | |
| a.Ba(32, false); | |
| Ws.v.R.call(this, a, b); | |
| a.g(b.value); | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| y.Pa = function(obj) { | |
| Sn(obj, false); | |
| obj.Ib &= -256; | |
| obj.Ba(32, false); | |
| return obj.a.b(Da, { | |
| "class" : nn(this, obj).join(" "), | |
| disabled : !obj.isEnabled() | |
| }, obj.Aa() || ""); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| y.Kc = function(a) { | |
| return a.tagName == Da; | |
| }; | |
| y.jf = Ae; | |
| /** | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| y.hf = function(b) { | |
| return b.isEnabled(); | |
| }; | |
| y.Lc = Ae; | |
| /** | |
| * @param {!Object} args | |
| * @param {number} typeName | |
| * @param {boolean} name | |
| * @return {undefined} | |
| */ | |
| y.rc = function(args, typeName, name) { | |
| Ws.v.rc.call(this, args, typeName, name); | |
| if ((args = args.l()) && 1 == typeName) { | |
| /** @type {boolean} */ | |
| args.disabled = name; | |
| } | |
| }; | |
| y.Cb = Ae; | |
| /** | |
| * @param {!HTMLElement} a | |
| * @param {string} user | |
| * @return {undefined} | |
| */ | |
| y.zb = function(a, user) { | |
| if (a) { | |
| /** @type {string} */ | |
| a.value = user; | |
| } | |
| }; | |
| y.S = x("goog-textarea"); | |
| /** | |
| * @param {string} name | |
| * @param {string} x | |
| * @param {?} y | |
| * @return {undefined} | |
| */ | |
| var Xs = function(name, x, y) { | |
| Qn.call(this, name, x || Ws.M(), y); | |
| Sn(this, false); | |
| /** @type {boolean} */ | |
| this.Bd = true; | |
| if (x = this.l()) { | |
| this.c.Yd(x, true); | |
| } | |
| /** @type {boolean} */ | |
| this.Nc = "" != name; | |
| if (!name) { | |
| /** @type {string} */ | |
| this.sc = ""; | |
| } | |
| }; | |
| C(Xs, Qn); | |
| /** @type {boolean} */ | |
| var Ys = !(E && !yh(11)); | |
| y = Xs.prototype; | |
| /** @type {boolean} */ | |
| y.Oc = false; | |
| /** @type {boolean} */ | |
| y.le = false; | |
| /** @type {boolean} */ | |
| y.Nc = false; | |
| /** @type {number} */ | |
| y.Tb = 0; | |
| /** @type {number} */ | |
| y.zf = 0; | |
| /** @type {boolean} */ | |
| y.Kg = false; | |
| /** @type {boolean} */ | |
| y.ve = false; | |
| /** @type {boolean} */ | |
| y.If = false; | |
| /** @type {boolean} */ | |
| y.Hf = false; | |
| /** @type {string} */ | |
| y.Rc = ""; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var Zs = function(o) { | |
| return o.A.top + o.A.bottom + o.W.top + o.W.bottom; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var $s = function(a) { | |
| var c = a.zf; | |
| var b = a.l(); | |
| if (c && b && a.ve) { | |
| /** @type {number} */ | |
| c = c - Zs(a); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} input | |
| * @return {undefined} | |
| */ | |
| var bt = function(input) { | |
| /** @type {number} */ | |
| input.zf = 105; | |
| at(input); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.b = function(name) { | |
| this.g(String(name)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Xs.prototype.T = function() { | |
| return this.l().value != this.Rc || ct(this) || this.Nc ? this.l().value : ""; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.g = function(name) { | |
| Xs.v.g.call(this, name); | |
| /** @type {boolean} */ | |
| this.Nc = "" != name; | |
| at(this); | |
| }; | |
| /** | |
| * @param {boolean} enable | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.ba = function(enable) { | |
| Xs.v.ba.call(this, enable); | |
| /** @type {boolean} */ | |
| this.l().disabled = !enable; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var at = function(data) { | |
| if (data.l()) { | |
| data.I(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} msg | |
| * @return {?} | |
| */ | |
| var ct = function(msg) { | |
| return "placeholder" in msg.l(); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var dt = function(d) { | |
| if (d.Rc) { | |
| if (ct(d)) { | |
| d.l().placeholder = d.Rc; | |
| } else { | |
| if (!(!d.l() || d.Nc || d.le)) { | |
| J(d.l(), Ud); | |
| d.l().value = d.Rc; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.V = function() { | |
| Xs.v.V.call(this); | |
| var a = this.l(); | |
| R(a, { | |
| overflowY : oc, | |
| overflowX : Qa, | |
| boxSizing : Wa, | |
| MsBoxSizing : Wa, | |
| WebkitBoxSizing : Wa, | |
| MozBoxSizing : Wa | |
| }); | |
| this.A = uj(a); | |
| this.W = xj(a); | |
| X(this).a(a, td, this.I).a(a, wb, this.I).a(a, Kc, this.I).a(a, Zc, this.Qa).a(a, Va, this.Da); | |
| dt(this); | |
| at(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var et = function(a) { | |
| if (!a.Kg) { | |
| var div = a.l().cloneNode(false); | |
| R(div, { | |
| position : Ga, | |
| height : Qa, | |
| top : "-9999px", | |
| margin : "0", | |
| padding : "1px", | |
| border : "1px solid #000", | |
| overflow : oc | |
| }); | |
| a.a.a.body.appendChild(div); | |
| var h = div.scrollHeight; | |
| /** @type {string} */ | |
| div.style.padding = "10px"; | |
| var b = div.scrollHeight; | |
| /** @type {boolean} */ | |
| a.If = b > h; | |
| /** @type {string} */ | |
| div.style.borderWidth = "10px"; | |
| /** @type {boolean} */ | |
| a.Hf = div.scrollHeight > b; | |
| /** @type {string} */ | |
| div.style.height = "100px"; | |
| if (100 != div.offsetHeight) { | |
| /** @type {boolean} */ | |
| a.ve = true; | |
| } | |
| mi(div); | |
| /** @type {boolean} */ | |
| a.Kg = true; | |
| } | |
| div = a.l(); | |
| if (isNaN(a.A.top)) { | |
| a.A = uj(div); | |
| a.W = xj(div); | |
| } | |
| h = a.l().scrollHeight; | |
| var p = a.l(); | |
| /** @type {number} */ | |
| b = p.offsetHeight - p.clientHeight; | |
| if (!a.If) { | |
| var m = a.A; | |
| /** @type {number} */ | |
| b = b - (m.top + m.bottom); | |
| } | |
| if (!a.Hf) { | |
| p = xj(p); | |
| /** @type {number} */ | |
| b = b - (p.top + p.bottom); | |
| } | |
| h = h + (0 < b ? b : 0); | |
| if (a.ve) { | |
| /** @type {number} */ | |
| h = h - Zs(a); | |
| } else { | |
| if (!a.If) { | |
| b = a.A; | |
| h = h + (b.top + b.bottom); | |
| } | |
| if (!a.Hf) { | |
| a = xj(div); | |
| h = h + (a.top + a.bottom); | |
| } | |
| } | |
| return h; | |
| }; | |
| /** | |
| * @param {!Object} input | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var ft = function(input, name) { | |
| if (input.Tb != name) { | |
| /** @type {string} */ | |
| input.Tb = name; | |
| input.l().style.height = name + md; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} other | |
| * @return {undefined} | |
| */ | |
| var gt = function(other) { | |
| var b = other.l(); | |
| b.style.height = Qa; | |
| var expRecords = b.value.match(/\n/g) || []; | |
| b.rows = expRecords.length + 1; | |
| /** @type {number} */ | |
| other.Tb = 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.Da = function() { | |
| if (!ct(this)) { | |
| /** @type {boolean} */ | |
| this.le = false; | |
| if ("" == this.l().value) { | |
| /** @type {boolean} */ | |
| this.Nc = false; | |
| dt(this); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.I = function(name) { | |
| if (!this.Oc) { | |
| var target = this.l(); | |
| if (!ct(this) && name && name.type == wb) { | |
| if (target.value == this.Rc && this.Rc && !this.le) { | |
| K(target, Ud); | |
| /** @type {string} */ | |
| target.value = ""; | |
| } | |
| /** @type {boolean} */ | |
| this.le = true; | |
| /** @type {boolean} */ | |
| this.Nc = "" != target.value; | |
| } | |
| /** @type {boolean} */ | |
| var index = false; | |
| /** @type {boolean} */ | |
| this.Oc = true; | |
| name = this.Tb; | |
| if (target.scrollHeight) { | |
| /** @type {boolean} */ | |
| var b = false; | |
| /** @type {boolean} */ | |
| var j = false; | |
| var i = et(this); | |
| var start = target.offsetHeight; | |
| var comments = $s(this); | |
| var count; | |
| /** @type {number} */ | |
| count = 0; | |
| var l = this.l(); | |
| if (count && l && this.ve) { | |
| /** @type {number} */ | |
| count = count - Zs(this); | |
| } | |
| if (comments && i < comments) { | |
| ft(this, comments); | |
| /** @type {boolean} */ | |
| b = true; | |
| } else { | |
| if (count && i > count) { | |
| ft(this, count); | |
| /** @type {string} */ | |
| target.style.overflowY = ""; | |
| /** @type {boolean} */ | |
| j = true; | |
| } else { | |
| if (start != i) { | |
| ft(this, i); | |
| } else { | |
| if (!this.Tb) { | |
| this.Tb = i; | |
| } | |
| } | |
| } | |
| } | |
| if (!(b || j || !Ys)) { | |
| /** @type {boolean} */ | |
| index = true; | |
| } | |
| } else { | |
| gt(this); | |
| } | |
| /** @type {boolean} */ | |
| this.Oc = false; | |
| if (index) { | |
| target = this.l(); | |
| if (!this.Oc) { | |
| /** @type {boolean} */ | |
| this.Oc = true; | |
| if (j = target.scrollHeight) { | |
| i = et(this); | |
| index = $s(this); | |
| if (!(index && i <= index)) { | |
| b = this.A; | |
| target.style.paddingBottom = b.bottom + 1 + md; | |
| if (et(this) == i) { | |
| target.style.paddingBottom = b.bottom + j + md; | |
| /** @type {number} */ | |
| target.scrollTop = 0; | |
| /** @type {number} */ | |
| j = et(this) - j; | |
| if (j >= index) { | |
| ft(this, j); | |
| } else { | |
| ft(this, index); | |
| } | |
| } | |
| target.style.paddingBottom = b.bottom + md; | |
| } | |
| } else { | |
| gt(this); | |
| } | |
| /** @type {boolean} */ | |
| this.Oc = false; | |
| } | |
| } | |
| if (name != this.Tb) { | |
| this.dispatchEvent(od); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xs.prototype.Qa = function() { | |
| var self = this.l(); | |
| var x = self.offsetHeight; | |
| if (self.filters && self.filters.length && (self = self.filters.item("DXImageTransform.Microsoft.DropShadow"))) { | |
| /** @type {number} */ | |
| x = x - self.offX; | |
| } | |
| if (x != this.Tb) { | |
| this.Tb = this.zf = x; | |
| } | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var ht = function(p1__3354_SHARP_) { | |
| Xs.call(this, p1__3354_SHARP_); | |
| /** @type {string} */ | |
| this.va = ""; | |
| /** @type {null} */ | |
| this.qa = null; | |
| /** @type {number} */ | |
| this.P = 0; | |
| /** @type {boolean} */ | |
| this.Z = this.$ = false; | |
| }; | |
| C(ht, Xs); | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| ht.prototype.b = function(name) { | |
| ht.v.b.call(this, name); | |
| this.U("set"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ht.prototype.V = function() { | |
| ht.v.V.call(this); | |
| U(this.l(), "compositionstart", A(this.Ha, this), false, this); | |
| U(this.l(), "compositionend", A(this.Fa, this), false, this); | |
| U(new Gn(this.l()), Hc, function(event) { | |
| it(this, Hc, { | |
| keyCode : event.keyCode | |
| }); | |
| }, false, this); | |
| U(this.l(), wc, function() { | |
| it(this, wc); | |
| }, false, this); | |
| U(new Vs(this.l()), hd, function() { | |
| /** @type {boolean} */ | |
| this.$ = true; | |
| it(this, hd); | |
| }, false, this); | |
| U(this.l(), "drop", function() { | |
| it(this, "drop"); | |
| }, false, this); | |
| this.qa = new Zk(1E3); | |
| U(this.qa, "tick", function() { | |
| this.U("timer"); | |
| }, false, this); | |
| al(this.qa); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ht.prototype.Ha = function() { | |
| /** @type {boolean} */ | |
| this.Z = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ht.prototype.Fa = function() { | |
| /** @type {boolean} */ | |
| this.Z = false; | |
| it(this, wc); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} name | |
| * @param {?} categories | |
| * @return {undefined} | |
| */ | |
| var it = function(options, name, categories) { | |
| cl(A(options.U, options, name, categories), 0, options); | |
| }; | |
| /** | |
| * @param {number} type | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| ht.prototype.U = function(type, name) { | |
| if (!this.Z) { | |
| var event = this.T(); | |
| if (event != this.va) { | |
| this.P += 1; | |
| this.va = event; | |
| event = new T(Ya); | |
| if (this.$) { | |
| /** @type {boolean} */ | |
| this.$ = false; | |
| type = hd; | |
| } | |
| /** @type {number} */ | |
| event.j = type; | |
| if (null != name) { | |
| Wf(event, name); | |
| } | |
| this.dispatchEvent(event); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} Element | |
| * @return {?} | |
| */ | |
| var jt = function(Element) { | |
| var P = Element.P; | |
| /** @type {number} */ | |
| Element.P = 0; | |
| return P; | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @return {undefined} | |
| */ | |
| var lt = function(context) { | |
| V.call(this); | |
| /** @type {!Object} */ | |
| this.D = context; | |
| U(context, kt, this.b, false, this); | |
| U(context, r, this.a, false, this); | |
| }; | |
| C(lt, V); | |
| /** @type {string} */ | |
| var kt = ih ? Jc : Ic; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| lt.prototype.b = function(key) { | |
| if (13 == key.keyCode || G && 3 == key.keyCode) { | |
| mt(this, key); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| lt.prototype.a = function(name) { | |
| mt(this, name); | |
| }; | |
| /** | |
| * @param {!EventTarget} callback | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| var mt = function(callback, event) { | |
| var evt = new nt(event); | |
| if (callback.dispatchEvent(evt)) { | |
| evt = new ot(event); | |
| try { | |
| callback.dispatchEvent(evt); | |
| } finally { | |
| event.stopPropagation(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| lt.prototype.J = function() { | |
| lt.v.J.call(this); | |
| hk(this.D, kt, this.b, false, this); | |
| hk(this.D, r, this.a, false, this); | |
| delete this.D; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var ot = function(a) { | |
| Ij.call(this, a.b); | |
| this.type = p; | |
| }; | |
| C(ot, Ij); | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var nt = function(a) { | |
| Ij.call(this, a.b); | |
| /** @type {string} */ | |
| this.type = "beforeaction"; | |
| }; | |
| C(nt, Ij); | |
| /** | |
| * @param {?} value | |
| * @param {?} elem | |
| * @return {undefined} | |
| */ | |
| var pt = function(value, elem) { | |
| V.call(this); | |
| this.mc = value; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| if (null != elem) { | |
| this.Uc(elem); | |
| } | |
| }; | |
| C(pt, V); | |
| /** | |
| * @param {!Object} val | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| pt.prototype.update = function(val, a) { | |
| /** @type {number} */ | |
| var i = this.a.length = 0; | |
| for (; i < val.length; ++i) { | |
| this.a.push(val[i]); | |
| } | |
| this.dispatchEvent({ | |
| type : this.mc, | |
| data : this.a, | |
| selected : null != a ? a : null | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var qt = function() { | |
| V.call(this); | |
| /** @type {string} */ | |
| this.j = this.b = this.a = ""; | |
| this.C = new pt(Md, this); | |
| this.w = new pt(Od, this); | |
| this.F = new pt(Pd, this); | |
| /** @type {!Array} */ | |
| this.O = []; | |
| this.N = new pt(Kd, this); | |
| this.I = new pt(Vd, this); | |
| /** @type {number} */ | |
| this.L = this.H = 0; | |
| /** @type {!Array} */ | |
| this.c = []; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {!Array} */ | |
| this.A = []; | |
| /** @type {!Array} */ | |
| this.K = []; | |
| /** @type {boolean} */ | |
| this.G = false; | |
| /** @type {string} */ | |
| this.B = ""; | |
| }; | |
| C(qt, V); | |
| /** | |
| * @param {!Object} m | |
| * @param {!Object} match | |
| * @return {undefined} | |
| */ | |
| var rt = function(m, match) { | |
| /** @type {!Array} */ | |
| var text = []; | |
| var y; | |
| if (match) { | |
| y = m.a == Qa ? m.j : m.a; | |
| /** @type {number} */ | |
| var commonIndex = -1; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < match.length; ++i) { | |
| if (match[i] == y) { | |
| if (m.a != Qa) { | |
| /** @type {number} */ | |
| commonIndex = i; | |
| } | |
| } else { | |
| text.push(match[i]); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| y = -1 != commonIndex && 3 > commonIndex; | |
| } else { | |
| /** @type {boolean} */ | |
| y = false; | |
| } | |
| if (!(y || m.G)) { | |
| m.C.update(text ? text.slice(0, 3) : []); | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} n | |
| * @param {!NodeList} keys | |
| * @param {?} v | |
| * @param {boolean} x | |
| * @return {undefined} | |
| */ | |
| var st = function(n, keys, v, x) { | |
| var obj = {}; | |
| /** @type {!Array} */ | |
| var a = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < keys.length && 3 > a.length; i++) { | |
| a.push(keys[i]); | |
| /** @type {boolean} */ | |
| obj[keys[i]] = true; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < n.length && 3 > a.length; i++) { | |
| if (null == obj[n[i]]) { | |
| /** @type {boolean} */ | |
| obj[n[i]] = true; | |
| a.push(n[i]); | |
| } | |
| } | |
| v.update(a, x); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {?} type | |
| * @return {undefined} | |
| */ | |
| qt.prototype.m = function(name, type) { | |
| var t = null != type ? type : 0; | |
| if (3 == t || 4 == t || 5 == t) { | |
| /** @type {boolean} */ | |
| this.G = true; | |
| } | |
| if (6 == t) { | |
| /** @type {string} */ | |
| this.B = name; | |
| } | |
| if (name == qe) { | |
| name = pe; | |
| } | |
| if (name != Qa) { | |
| tt(this, ""); | |
| } | |
| ut(this.w, name, this.c); | |
| if (this.a != name) { | |
| var value = this.a; | |
| /** @type {string} */ | |
| this.a = name; | |
| value = value == Qa ? void 0 : A(this.o, this, value, 6); | |
| this.H = t; | |
| vt(this, this.a, Ld, t, value); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {?} type | |
| * @return {undefined} | |
| */ | |
| qt.prototype.o = function(name, type) { | |
| var t = null != type ? type : 0; | |
| if (!(6 != t && 5 != t || name != pe || this.B != qe)) { | |
| name = qe; | |
| } | |
| if (5 == t) { | |
| this.B = this.b; | |
| } | |
| ut(this.F, name, this.g); | |
| if (this.b != name) { | |
| var previous = this.b; | |
| /** @type {string} */ | |
| this.b = name; | |
| this.L = t; | |
| vt(this, this.b, Wd, t, A(this.m, this, previous, 6)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} id | |
| * @param {!Object} text | |
| * @return {undefined} | |
| */ | |
| var ut = function(a, id, text) { | |
| var d = Jf(a.a); | |
| /** @type {boolean} */ | |
| var data = id != Qa; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < d.length; i++) { | |
| if (id == d[i]) { | |
| /** @type {boolean} */ | |
| data = false; | |
| break; | |
| } | |
| } | |
| if (data) { | |
| data = {}; | |
| if (0 < text.length) { | |
| /** @type {boolean} */ | |
| data[text[0]] = true; | |
| } | |
| if (1 < text.length) { | |
| /** @type {boolean} */ | |
| data[text[1]] = true; | |
| } | |
| /** @type {number} */ | |
| i = d.length - 1; | |
| for (; 0 <= i; i--) { | |
| if (!data[d[i]]) { | |
| /** @type {string} */ | |
| d[i] = id; | |
| break; | |
| } | |
| } | |
| } | |
| a.update(d, id); | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var tt = function(context, value) { | |
| if (value == Qa) { | |
| /** @type {string} */ | |
| value = ""; | |
| } | |
| if (context.j != value) { | |
| /** @type {number} */ | |
| context.j = value; | |
| context.dispatchEvent({ | |
| type : lb, | |
| data : context.j | |
| }); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {undefined} | |
| */ | |
| var xt = function(target) { | |
| wt(target.a, target.c); | |
| wt(target.b, target.g); | |
| }; | |
| /** | |
| * @param {?} global | |
| * @return {undefined} | |
| */ | |
| var yt = function(global) { | |
| /** @type {!Array} */ | |
| global.A = []; | |
| /** @type {!Array} */ | |
| global.K = []; | |
| var e = window.DEFAULT_SOURCES || []; | |
| var userlinks = window.DEFAULT_TARGETS || []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < e.length; i++) { | |
| Gf(global.A, e[i]); | |
| } | |
| /** @type {number} */ | |
| e = 0; | |
| for (; e < userlinks.length; e++) { | |
| Gf(global.K, userlinks[e]); | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} times | |
| * @return {?} | |
| */ | |
| var zt = function(times) { | |
| if (!times || 0 == times.length) { | |
| return ""; | |
| } | |
| /** @type {!Array} */ | |
| var ls = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < times.length; ++i) { | |
| ls.push(times[i]); | |
| } | |
| return ls.join("|"); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {!Object} table | |
| * @param {string} error | |
| * @param {number} t | |
| * @param {string} e | |
| * @return {undefined} | |
| */ | |
| var vt = function(s, table, error, t, e) { | |
| s.dispatchEvent({ | |
| type : error, | |
| data : table, | |
| Zf : 6 == t | |
| }); | |
| if (e && (3 == t || 4 == t) && s.a == s.b && s.a != pe) { | |
| e(); | |
| } | |
| if (!(4 != t && 3 != t)) { | |
| s.dispatchEvent(Nc); | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} s | |
| * @param {number} tag | |
| * @return {?} | |
| */ | |
| var At = function(s, tag) { | |
| /** @type {!Array} */ | |
| var scheduledContent = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < s.length && !(s[i] != tag && scheduledContent.push(s[i]), 3 <= scheduledContent.length); ++i) { | |
| } | |
| return scheduledContent; | |
| }; | |
| /** | |
| * @param {string} id | |
| * @param {!Array} obj | |
| * @return {undefined} | |
| */ | |
| var wt = function(id, obj) { | |
| if (id != Qa) { | |
| /** @type {number} */ | |
| var index = 0; | |
| for (; index < obj.length && obj[index] != id; ++index) { | |
| } | |
| if (index == obj.length) { | |
| obj.unshift(id); | |
| if (10 < obj.length) { | |
| obj.pop(); | |
| } | |
| } else { | |
| obj.splice(index, 1); | |
| obj.unshift(id); | |
| } | |
| } | |
| }; | |
| var Bt = ue(); | |
| C(Bt, wn); | |
| Be(Bt); | |
| y = Bt.prototype; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| y.Pa = function(a) { | |
| var b = nn(this, a); | |
| b = a.a.b(k, { | |
| "class" : Hb + b.join(" ") | |
| }, a.Aa()); | |
| xn(b, a.w); | |
| return b; | |
| }; | |
| y.Rb = x(Xa); | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| y.Kc = function(data) { | |
| return data.tagName == k; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| y.R = function(a, b) { | |
| J(b, Gb); | |
| return Bt.v.R.call(this, a, b); | |
| }; | |
| y.T = x(""); | |
| y.S = x(Db); | |
| On(Db, function() { | |
| return new eo(null, Bt.M()); | |
| }); | |
| var Ct = ve("b"); | |
| Be(Ct); | |
| /** | |
| * @param {!Element} a | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var Dt = function(a, b) { | |
| if (a) { | |
| /** @type {number} */ | |
| a.tabIndex = b ? 0 : -1; | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Ct.prototype.m = function(name) { | |
| return name.a.b(k, Et(this, name).join(" ")); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Ct.prototype.g = function(name) { | |
| return name; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| Ct.prototype.a = function(key) { | |
| return key.tagName == k; | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| Ct.prototype.R = function(f, val) { | |
| if (val.id) { | |
| Gl(f, val.id); | |
| } | |
| var bl = this.S(); | |
| /** @type {boolean} */ | |
| var d = false; | |
| var code = Ah(val); | |
| if (code) { | |
| xf(code, function(side) { | |
| if (side == bl) { | |
| /** @type {boolean} */ | |
| d = true; | |
| } else { | |
| if (side) { | |
| if (side == bl + da) { | |
| f.ba(false); | |
| } else { | |
| if (side == bl + "-horizontal") { | |
| Ft(f, rc); | |
| } else { | |
| if (side == bl + "-vertical") { | |
| Ft(f, ke); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, this); | |
| } | |
| if (!d) { | |
| J(val, bl); | |
| } | |
| Gt(this, f, this.g(val)); | |
| return val; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} b | |
| * @param {!Node} p | |
| * @return {undefined} | |
| */ | |
| var Gt = function(a, b, p) { | |
| if (p) { | |
| var d = p.firstChild; | |
| var w; | |
| for (; d && d.parentNode == p;) { | |
| w = d.nextSibling; | |
| if (1 == d.nodeType) { | |
| var data = a.c(d); | |
| if (data) { | |
| data.D = d; | |
| if (!b.isEnabled()) { | |
| data.ba(false); | |
| } | |
| b.Ia(data); | |
| data.R(d); | |
| } | |
| } else { | |
| if (!(d.nodeValue && "" != We(d.nodeValue))) { | |
| p.removeChild(d); | |
| } | |
| } | |
| d = w; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Ct.prototype.c = function(name) { | |
| a: { | |
| var item; | |
| name = Ah(name); | |
| /** @type {number} */ | |
| var i = 0; | |
| var length = name.length; | |
| for (; i < length; i++) { | |
| if (item = name[i], item = item in Nn ? Nn[item]() : null) { | |
| name = item; | |
| break a; | |
| } | |
| } | |
| /** @type {null} */ | |
| name = null; | |
| } | |
| return name; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Ct.prototype.j = function(name) { | |
| name = name.l(); | |
| pj(name, true, ih); | |
| if (E) { | |
| /** @type {boolean} */ | |
| name.hideFocus = true; | |
| } | |
| var b = this.b; | |
| if (b) { | |
| cn(name, b); | |
| } | |
| }; | |
| Ct.prototype.S = x("goog-container"); | |
| /** | |
| * @param {?} data | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Et = function(data, b) { | |
| var name = data.S(); | |
| /** @type {!Array} */ | |
| var fields = [name, b.xc == rc ? name + "-horizontal" : name + "-vertical"]; | |
| if (!b.isEnabled()) { | |
| fields.push(name + da); | |
| } | |
| return fields; | |
| }; | |
| var Ht = x(ke); | |
| /** | |
| * @param {string} eventStr | |
| * @param {string} a | |
| * @param {?} dist | |
| * @return {undefined} | |
| */ | |
| var It = function(eventStr, a, dist) { | |
| W.call(this, dist); | |
| this.Pb = a || Ct.M(); | |
| this.xc = eventStr || Ht(); | |
| }; | |
| C(It, W); | |
| y = It.prototype; | |
| /** @type {null} */ | |
| y.Pc = null; | |
| /** @type {null} */ | |
| y.jd = null; | |
| /** @type {null} */ | |
| y.Pb = null; | |
| /** @type {null} */ | |
| y.xc = null; | |
| /** @type {boolean} */ | |
| y.Qb = true; | |
| /** @type {boolean} */ | |
| y.qc = true; | |
| /** @type {boolean} */ | |
| y.nc = true; | |
| /** @type {number} */ | |
| y.xa = -1; | |
| /** @type {null} */ | |
| y.La = null; | |
| /** @type {boolean} */ | |
| y.Ub = false; | |
| /** @type {null} */ | |
| y.Jb = null; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var Jt = function(el) { | |
| return el.Pc || el.l(); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} layer | |
| * @return {undefined} | |
| */ | |
| var Mt = function(data, layer) { | |
| if (data.nc) { | |
| var profilerTokenSerial = Jt(data); | |
| var arcOffset = data.sa; | |
| /** @type {string} */ | |
| data.Pc = layer; | |
| var opts = Jt(data); | |
| if (arcOffset) { | |
| data.Pc = profilerTokenSerial; | |
| Kt(data, false); | |
| /** @type {string} */ | |
| data.Pc = layer; | |
| Fn(Lt(data), opts); | |
| Kt(data, true); | |
| } | |
| } else { | |
| throw Error("Can't set key event target for container that doesn't support keyboard focus!"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} scope | |
| * @return {?} | |
| */ | |
| var Lt = function(scope) { | |
| return scope.jd || (scope.jd = new Gn(Jt(scope))); | |
| }; | |
| y = It.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| this.D = this.Pb.m(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.yb = function() { | |
| return this.Pb.g(this.l()); | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| y.Wd = function(type) { | |
| return this.Pb.a(type); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| y.Y = function(t) { | |
| this.D = this.Pb.R(this, t); | |
| if (t.style.display == ad) { | |
| /** @type {boolean} */ | |
| this.Qb = false; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| It.v.V.call(this); | |
| Ll(this, function(tr) { | |
| if (tr.sa) { | |
| Nt(this, tr); | |
| } | |
| }, this); | |
| var a = this.l(); | |
| this.Pb.j(this); | |
| this.setVisible(this.Qb, true); | |
| X(this).a(this, "enter", this.qf).a(this, qc, this.fd).a(this, je, this.gf).a(this, "open", this.zi).a(this, "close", this.Vh).a(a, Vc, this.Wh).a(Ph(a), Zc, this.gi).a(a, [Vc, Zc, Yc, Xc, eb], this.Zh); | |
| if (this.nc) { | |
| Kt(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {boolean} _ | |
| * @return {undefined} | |
| */ | |
| var Kt = function(node, _) { | |
| var cb = X(node); | |
| var a = Jt(node); | |
| if (_) { | |
| cb.a(a, wb, node.zg).a(a, Va, node.Xd).a(Lt(node), Hc, node.Ka); | |
| } else { | |
| cb.b(a, wb, node.zg).b(a, Va, node.Xd).b(Lt(node), Hc, node.Ka); | |
| } | |
| }; | |
| y = It.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ya = function() { | |
| this.Hb(-1); | |
| if (this.La) { | |
| this.La.Ja(false); | |
| } | |
| /** @type {boolean} */ | |
| this.Ub = false; | |
| It.v.Ya.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| It.v.J.call(this); | |
| if (this.jd) { | |
| this.jd.za(); | |
| /** @type {null} */ | |
| this.jd = null; | |
| } | |
| /** @type {null} */ | |
| this.Pb = this.La = this.Jb = this.Pc = null; | |
| }; | |
| y.qf = x(true); | |
| /** | |
| * @param {!Event} $obj | |
| * @return {undefined} | |
| */ | |
| y.fd = function($obj) { | |
| var dataElementsCount = Pl(this, $obj.target); | |
| if (-1 < dataElementsCount && dataElementsCount != this.xa) { | |
| var th = Ot(this); | |
| if (th) { | |
| Xn(th, false); | |
| } | |
| this.xa = dataElementsCount; | |
| th = Ot(this); | |
| if (this.Ub) { | |
| Wn(th, true); | |
| } | |
| if (this.La && th != this.La) { | |
| if (sn(th, 64)) { | |
| th.Ja(true); | |
| } else { | |
| this.La.Ja(false); | |
| } | |
| } | |
| } | |
| dataElementsCount = this.l(); | |
| if (null != $obj.target.l()) { | |
| dn(dataElementsCount, Ia, $obj.target.l().id); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} a | |
| * @return {undefined} | |
| */ | |
| y.gf = function(a) { | |
| if (a.target == Ot(this)) { | |
| /** @type {number} */ | |
| this.xa = -1; | |
| } | |
| this.l().removeAttribute(Na); | |
| }; | |
| /** | |
| * @param {?} n | |
| * @return {undefined} | |
| */ | |
| y.zi = function(n) { | |
| if ((n = n.target) && n != this.La && n.K() == this) { | |
| if (this.La) { | |
| this.La.Ja(false); | |
| } | |
| this.La = n; | |
| } | |
| }; | |
| /** | |
| * @param {!Event} $obj | |
| * @return {undefined} | |
| */ | |
| y.Vh = function($obj) { | |
| if ($obj.target == this.La) { | |
| /** @type {null} */ | |
| this.La = null; | |
| } | |
| var l = this.l(); | |
| var r = $obj.target.l(); | |
| if (l && tn($obj.target, 2) && r) { | |
| gn(l, r); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| y.Wh = function(event) { | |
| if (this.qc) { | |
| /** @type {boolean} */ | |
| this.Ub = true; | |
| } | |
| var t = Jt(this); | |
| if (t && Ci(t) && Di(t)) { | |
| t.focus(); | |
| } else { | |
| event.preventDefault(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.gi = function() { | |
| /** @type {boolean} */ | |
| this.Ub = false; | |
| }; | |
| /** | |
| * @param {string} tag | |
| * @return {undefined} | |
| */ | |
| y.Zh = function(tag) { | |
| var node; | |
| a: { | |
| node = tag.target; | |
| if (this.Jb) { | |
| var rte = this.l(); | |
| for (; node && node !== rte;) { | |
| var pattern = node.id; | |
| if (pattern in this.Jb) { | |
| node = this.Jb[pattern]; | |
| break a; | |
| } | |
| node = node.parentNode; | |
| } | |
| } | |
| /** @type {null} */ | |
| node = null; | |
| } | |
| if (node) { | |
| switch(tag.type) { | |
| case Vc: | |
| node.Za(tag); | |
| break; | |
| case Zc: | |
| node.ib(tag); | |
| break; | |
| case Yc: | |
| node.kf(tag); | |
| break; | |
| case Xc: | |
| node.sf(tag); | |
| break; | |
| case eb: | |
| node.md(tag); | |
| } | |
| } | |
| }; | |
| y.zg = ue(); | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Xd = function() { | |
| this.Hb(-1); | |
| /** @type {boolean} */ | |
| this.Ub = false; | |
| if (this.La) { | |
| this.La.Ja(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} key | |
| * @return {?} | |
| */ | |
| y.Ka = function(key) { | |
| return this.isEnabled() && this.isVisible() && (0 != Ml(this) || this.Pc) && this.hd(key) ? (key.preventDefault(), key.stopPropagation(), true) : false; | |
| }; | |
| /** | |
| * @param {!Event} data | |
| * @return {?} | |
| */ | |
| y.hd = function(data) { | |
| var compValue = Ot(this); | |
| if (compValue && typeof compValue.Ka == Bb && compValue.Ka(data) || this.La && this.La != compValue && typeof this.La.Ka == Bb && this.La.Ka(data)) { | |
| return true; | |
| } | |
| if (data.shiftKey || data.ctrlKey || data.metaKey || data.altKey) { | |
| return false; | |
| } | |
| switch(data.keyCode) { | |
| case 27: | |
| if (this.nc) { | |
| Jt(this).blur(); | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 36: | |
| Pt(this); | |
| break; | |
| case 35: | |
| Qt(this); | |
| break; | |
| case 38: | |
| if (this.xc == ke) { | |
| Rt(this); | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 37: | |
| if (this.xc == rc) { | |
| if (Ol(this)) { | |
| St(this); | |
| } else { | |
| Rt(this); | |
| } | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 40: | |
| if (this.xc == ke) { | |
| St(this); | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 39: | |
| if (this.xc == rc) { | |
| if (Ol(this)) { | |
| Rt(this); | |
| } else { | |
| St(this); | |
| } | |
| } else { | |
| return false; | |
| } | |
| break; | |
| default: | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {?} context | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| var Nt = function(context, f) { | |
| var id = f.l(); | |
| id = id.id || (id.id = f.F()); | |
| if (!context.Jb) { | |
| context.Jb = {}; | |
| } | |
| /** @type {!Object} */ | |
| context.Jb[id] = f; | |
| }; | |
| /** | |
| * @param {number} obj | |
| * @param {boolean} except | |
| * @return {undefined} | |
| */ | |
| It.prototype.Ia = function(obj, except) { | |
| It.v.Ia.call(this, obj, except); | |
| }; | |
| /** | |
| * @param {number} data | |
| * @param {?} end | |
| * @param {boolean} marker | |
| * @return {undefined} | |
| */ | |
| It.prototype.Zc = function(data, end, marker) { | |
| data.ud |= 2; | |
| data.ud |= 64; | |
| data.Ba(32, false); | |
| Sn(data, false); | |
| var pathOrData = data.K() == this ? Pl(this, data) : -1; | |
| It.v.Zc.call(this, data, end, marker); | |
| if (data.sa && this.sa) { | |
| Nt(this, data); | |
| } | |
| data = pathOrData; | |
| if (-1 == data) { | |
| data = Ml(this); | |
| } | |
| if (data == this.xa) { | |
| /** @type {number} */ | |
| this.xa = Math.min(Ml(this) - 1, end); | |
| } else { | |
| if (data > this.xa && end <= this.xa) { | |
| this.xa++; | |
| } else { | |
| if (data < this.xa && end > this.xa) { | |
| this.xa--; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {boolean} arg | |
| * @return {?} | |
| */ | |
| It.prototype.removeChild = function(value, arg) { | |
| if (value = Fe(value) ? Il(this, value) : value) { | |
| var m = Pl(this, value); | |
| if (-1 != m) { | |
| if (m == this.xa) { | |
| Xn(value, false); | |
| /** @type {number} */ | |
| this.xa = -1; | |
| } else { | |
| if (m < this.xa) { | |
| this.xa--; | |
| } | |
| } | |
| } | |
| var token = value.l(); | |
| if (token && token.id && this.Jb) { | |
| m = this.Jb; | |
| token = token.id; | |
| if (token in m) { | |
| delete m[token]; | |
| } | |
| } | |
| } | |
| value = It.v.removeChild.call(this, value, arg); | |
| Sn(value, true); | |
| return value; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} id | |
| * @return {undefined} | |
| */ | |
| var Ft = function(a, id) { | |
| if (a.l()) { | |
| throw Error(pa); | |
| } | |
| /** @type {string} */ | |
| a.xc = id; | |
| }; | |
| It.prototype.isVisible = w("Qb"); | |
| /** | |
| * @param {boolean} id | |
| * @param {string} isVisible | |
| * @return {?} | |
| */ | |
| It.prototype.setVisible = function(id, isVisible) { | |
| if (isVisible || this.Qb != id && this.dispatchEvent(id ? Ad : pc)) { | |
| /** @type {boolean} */ | |
| this.Qb = id; | |
| var body = this.l(); | |
| if (body) { | |
| S(body, id); | |
| if (this.nc) { | |
| Dt(Jt(this), this.qc && this.Qb); | |
| } | |
| if (!isVisible) { | |
| this.dispatchEvent(this.Qb ? "aftershow" : "afterhide"); | |
| } | |
| } | |
| return true; | |
| } | |
| return false; | |
| }; | |
| It.prototype.isEnabled = w("qc"); | |
| /** | |
| * @param {boolean} enable | |
| * @return {undefined} | |
| */ | |
| It.prototype.ba = function(enable) { | |
| if (this.qc != enable && this.dispatchEvent(enable ? "enable" : "disable")) { | |
| if (enable) { | |
| /** @type {boolean} */ | |
| this.qc = true; | |
| Ll(this, function(data) { | |
| if (data.uh) { | |
| delete data.uh; | |
| } else { | |
| data.ba(true); | |
| } | |
| }); | |
| } else { | |
| Ll(this, function(data) { | |
| if (data.isEnabled()) { | |
| data.ba(false); | |
| } else { | |
| /** @type {boolean} */ | |
| data.uh = true; | |
| } | |
| }); | |
| /** @type {boolean} */ | |
| this.Ub = this.qc = false; | |
| } | |
| if (this.nc) { | |
| Dt(Jt(this), enable && this.Qb); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @param {boolean} code | |
| * @return {undefined} | |
| */ | |
| var Tt = function(key, code) { | |
| if (code != key.nc && key.sa) { | |
| Kt(key, code); | |
| } | |
| /** @type {boolean} */ | |
| key.nc = code; | |
| if (key.qc && key.Qb) { | |
| Dt(Jt(key), code); | |
| } | |
| }; | |
| /** | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| It.prototype.Hb = function(i) { | |
| if (i = Nl(this, i)) { | |
| Xn(i, true); | |
| } else { | |
| if (-1 < this.xa) { | |
| Xn(Ot(this), false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var Ot = function(d) { | |
| return Nl(d, d.xa); | |
| }; | |
| /** | |
| * @param {!Object} y | |
| * @return {undefined} | |
| */ | |
| var Pt = function(y) { | |
| Ut(y, function(i, len) { | |
| return (i + 1) % len; | |
| }, Ml(y) - 1); | |
| }; | |
| /** | |
| * @param {!Object} mom | |
| * @return {undefined} | |
| */ | |
| var Qt = function(mom) { | |
| Ut(mom, function(maxy, south) { | |
| maxy--; | |
| return 0 > maxy ? south - 1 : maxy; | |
| }, 0); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var St = function(d) { | |
| Ut(d, function(i, len) { | |
| return (i + 1) % len; | |
| }, d.xa); | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {undefined} | |
| */ | |
| var Rt = function(val) { | |
| Ut(val, function(maxy, south) { | |
| maxy--; | |
| return 0 > maxy ? south - 1 : maxy; | |
| }, val.xa); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {!Function} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Ut = function(m, a, b) { | |
| b = 0 > b ? Pl(m, m.La) : b; | |
| var i = Ml(m); | |
| b = a.call(m, b, i); | |
| /** @type {number} */ | |
| var chance = 0; | |
| for (; chance <= i;) { | |
| var fn = Nl(m, b); | |
| if (fn && m.ag(fn)) { | |
| return m.Hb(b), true; | |
| } | |
| chance++; | |
| b = a.call(m, b, i); | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| It.prototype.ag = function(obj) { | |
| return obj.isVisible() && obj.isEnabled() && sn(obj, 2); | |
| }; | |
| var Vt = ue(); | |
| C(Vt, hn); | |
| Be(Vt); | |
| Vt.prototype.S = x(Kb); | |
| /** | |
| * @param {?} data | |
| * @param {?} xhr | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| var Wt = function(data, xhr, options) { | |
| Qn.call(this, data, options || Vt.M(), xhr); | |
| this.Ba(1, false); | |
| this.Ba(2, false); | |
| this.Ba(4, false); | |
| this.Ba(32, false); | |
| /** @type {number} */ | |
| this.bc = 1; | |
| }; | |
| C(Wt, Qn); | |
| On(Kb, function() { | |
| return new Wt(null); | |
| }); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Xt = function() { | |
| /** @type {!Array} */ | |
| this.g = []; | |
| }; | |
| C(Xt, hn); | |
| Be(Xt); | |
| /** | |
| * @param {string} value | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Yt = function(value, i) { | |
| var id = value.g[i]; | |
| if (!id) { | |
| switch(i) { | |
| case 0: | |
| id = value.S() + "-highlight"; | |
| break; | |
| case 1: | |
| id = value.S() + "-checkbox"; | |
| break; | |
| case 2: | |
| id = value.S() + ca; | |
| } | |
| value.g[i] = id; | |
| } | |
| return id; | |
| }; | |
| y = Xt.prototype; | |
| y.Rb = x("menuitem"); | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| y.Pa = function(obj) { | |
| var m = obj.a.b(k, nn(this, obj).join(" "), Zt(this, obj.Aa(), obj.a)); | |
| $t(this, obj, m, sn(obj, 8) || sn(obj, 16)); | |
| return m; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| y.hb = function(b) { | |
| return b && b.firstChild; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| y.R = function(a, b) { | |
| var idx = pi(b); | |
| var currentChr = Yt(this, 2); | |
| if (!(idx && Bh(idx, currentChr))) { | |
| b.appendChild(Zt(this, b.childNodes, a.a)); | |
| } | |
| if (Bh(b, Ob)) { | |
| a.Ba(16, true); | |
| if (a && b) { | |
| $t(this, a, b, true); | |
| } | |
| } | |
| return Xt.v.R.call(this, a, b); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} fn | |
| * @return {undefined} | |
| */ | |
| y.zb = function(a, fn) { | |
| var node = this.hb(a); | |
| var d = au(this, a) ? node.firstChild : null; | |
| Xt.v.zb.call(this, a, fn); | |
| if (d && !au(this, a)) { | |
| node.insertBefore(d, node.firstChild || null); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} s | |
| * @param {undefined} a | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var Zt = function(s, a, d) { | |
| s = Yt(s, 2); | |
| return d.b(k, s, a); | |
| }; | |
| /** | |
| * @param {string} config | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| var au = function(config, target) { | |
| var svg = config.hb(target); | |
| if (svg) { | |
| svg = svg.firstChild; | |
| var d = Yt(config, 1); | |
| return !!svg && ri(svg) && Bh(svg, d); | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {boolean} options | |
| * @param {!Object} message | |
| * @param {!Object} t | |
| * @param {boolean} scale | |
| * @return {undefined} | |
| */ | |
| var $t = function(options, message, t, scale) { | |
| rn(options, t, message.kd()); | |
| un(options, message, t); | |
| if (scale != au(options, t)) { | |
| Eh(t, Ob, scale); | |
| t = options.hb(t); | |
| if (scale) { | |
| options = Yt(options, 1); | |
| t.insertBefore(message.a.b(k, options), t.firstChild || null); | |
| } else { | |
| t.removeChild(t.firstChild); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Xt.prototype.a = function(name) { | |
| switch(name) { | |
| case 2: | |
| return Yt(this, 0); | |
| case 16: | |
| case 8: | |
| return Pb; | |
| default: | |
| return Xt.v.a.call(this, name); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Xt.prototype.c = function(name) { | |
| var handleEventAtTarget = Yt(this, 0); | |
| switch(name) { | |
| case Pb: | |
| return 16; | |
| case handleEventAtTarget: | |
| return 2; | |
| default: | |
| return Xt.v.c.call(this, name); | |
| } | |
| }; | |
| Xt.prototype.S = x("goog-menuitem"); | |
| /** | |
| * @param {?} category | |
| * @param {?} letter | |
| * @param {?} image | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| var bu = function(category, letter, image, options) { | |
| Qn.call(this, category, options || Xt.M(), image); | |
| this.wa = letter; | |
| }; | |
| C(bu, Qn); | |
| y = bu.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.T = function() { | |
| var a = this.wa; | |
| return null != a ? a : this.Na(); | |
| }; | |
| /** | |
| * @param {number} view | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| y.Ba = function(view, a) { | |
| bu.v.Ba.call(this, view, a); | |
| switch(view) { | |
| case 8: | |
| if (this.Ea() && !a) { | |
| this.ma(false); | |
| } | |
| var l = this.l(); | |
| if (l && this && l) { | |
| $t(this.c, this, l, a); | |
| } | |
| break; | |
| case 16: | |
| if ((l = this.l()) && this && l) { | |
| $t(this.c, this, l, a); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Na = function() { | |
| var result = this.Aa(); | |
| return De(result) ? (result = zf(result, function(body) { | |
| return ri(body) && (Bh(body, "goog-menuitem-accel") || Bh(body, "goog-menuitem-mnemonic-separator")) ? "" : Gi(body); | |
| }).join(""), Ve(result)) : bu.v.Na.call(this); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {undefined} | |
| */ | |
| y.ib = function(node) { | |
| var b = this.K(); | |
| if (b) { | |
| var a = b.W; | |
| /** @type {null} */ | |
| b.W = null; | |
| if (b = a && Ge(node.clientX)) { | |
| b = new L(node.clientX, node.clientY); | |
| /** @type {boolean} */ | |
| b = a == b ? true : a && b ? a.x == b.x && a.y == b.y : false; | |
| } | |
| if (b) { | |
| return; | |
| } | |
| } | |
| bu.v.ib.call(this, node); | |
| }; | |
| /** | |
| * @param {!Event} key | |
| * @return {?} | |
| */ | |
| y.tc = function(key) { | |
| return key.keyCode == this.Ug && this.Wb(key) ? true : bu.v.tc.call(this, key); | |
| }; | |
| y.Uh = w("Ug"); | |
| On("goog-menuitem", function() { | |
| return new bu(null); | |
| }); | |
| /** | |
| * @return {?} | |
| */ | |
| bu.prototype.kd = function() { | |
| return sn(this, 16) ? "menuitemcheckbox" : sn(this, 8) ? "menuitemradio" : bu.v.kd.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| bu.prototype.K = function() { | |
| return Qn.prototype.K.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| bu.prototype.Md = function() { | |
| return Qn.prototype.Md.call(this); | |
| }; | |
| var cu = ue(); | |
| C(cu, hn); | |
| Be(cu); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| cu.prototype.Pa = function(a) { | |
| return a.a.b(k, this.S()); | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| cu.prototype.R = function(x, a) { | |
| if (a.id) { | |
| Gl(x, a.id); | |
| } | |
| if ("HR" == a.tagName) { | |
| /** @type {!Object} */ | |
| var aValue = a; | |
| a = this.Pa(x); | |
| ki(a, aValue); | |
| mi(aValue); | |
| } else { | |
| J(a, this.S()); | |
| } | |
| return a; | |
| }; | |
| cu.prototype.zb = ue(); | |
| cu.prototype.S = x(Nb); | |
| /** | |
| * @param {?} p | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var du = function(p, cb) { | |
| Qn.call(this, null, p || cu.M(), cb); | |
| this.Ba(1, false); | |
| this.Ba(2, false); | |
| this.Ba(4, false); | |
| this.Ba(32, false); | |
| /** @type {number} */ | |
| this.bc = 1; | |
| }; | |
| C(du, Qn); | |
| /** | |
| * @return {undefined} | |
| */ | |
| du.prototype.V = function() { | |
| du.v.V.call(this); | |
| cn(this.l(), xd); | |
| }; | |
| On(Nb, function() { | |
| return new du; | |
| }); | |
| /** | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var eu = function(b) { | |
| this.b = b || "menu"; | |
| }; | |
| C(eu, Ct); | |
| Be(eu); | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| eu.prototype.a = function(name) { | |
| return "UL" == name.tagName || eu.v.a.call(this, name); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| eu.prototype.c = function(name) { | |
| return "HR" == name.tagName ? new du : eu.v.c.call(this, name); | |
| }; | |
| eu.prototype.S = x(Ib); | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| eu.prototype.j = function(name) { | |
| eu.v.j.call(this, name); | |
| dn(name.l(), mc, ie); | |
| }; | |
| /** | |
| * @param {?} refC | |
| * @return {undefined} | |
| */ | |
| var fu = function(refC) { | |
| du.call(this, cu.M(), refC); | |
| }; | |
| C(fu, du); | |
| On(Nb, function() { | |
| return new du; | |
| }); | |
| /** | |
| * @param {?} scope | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| var gu = function(scope, options) { | |
| It.call(this, ke, options || eu.M(), scope); | |
| Tt(this, false); | |
| }; | |
| C(gu, It); | |
| /** @type {boolean} */ | |
| gu.prototype.L = true; | |
| /** | |
| * @return {?} | |
| */ | |
| gu.prototype.S = function() { | |
| return this.Pb.S(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} f | |
| * @return {?} | |
| */ | |
| var hu = function(a, f) { | |
| if (ti(a.l(), f)) { | |
| return true; | |
| } | |
| /** @type {number} */ | |
| var sl = 0; | |
| var s = Ml(a); | |
| for (; sl < s; sl++) { | |
| var n = Nl(a, sl); | |
| if (typeof n.mf == Bb && n.mf(f)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| y = gu.prototype; | |
| /** | |
| * @param {boolean} b | |
| * @param {string} v | |
| * @param {!Event} a | |
| * @return {?} | |
| */ | |
| y.setVisible = function(b, v, a) { | |
| if ((v = gu.v.setVisible.call(this, b, v)) && b && this.sa && this.L) { | |
| Jt(this).focus(); | |
| } | |
| if (b && a && Ge(a.clientX)) { | |
| this.W = new L(a.clientX, a.clientY); | |
| } else { | |
| /** @type {null} */ | |
| this.W = null; | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {?} string | |
| * @return {?} | |
| */ | |
| y.qf = function(string) { | |
| if (this.L) { | |
| Jt(this).focus(); | |
| } | |
| return gu.v.qf.call(this, string); | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @return {?} | |
| */ | |
| y.Mg = function(i) { | |
| /** @type {!RegExp} */ | |
| var child = new RegExp("^" + nf(i), "i"); | |
| return Ut(this, function(key, type) { | |
| var parent = 0 > key ? 0 : key; | |
| /** @type {boolean} */ | |
| var womb = false; | |
| do { | |
| ++key; | |
| if (key == type) { | |
| /** @type {number} */ | |
| key = 0; | |
| /** @type {boolean} */ | |
| womb = true; | |
| } | |
| var environment = Nl(this, key).Na(); | |
| if (environment && environment.match(child)) { | |
| return key; | |
| } | |
| } while (!womb || key != parent); | |
| return this.xa; | |
| }, this.xa); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| y.ag = function(obj) { | |
| return obj.isEnabled() && obj.isVisible() && sn(obj, 2); | |
| }; | |
| /** | |
| * @param {!Object} y | |
| * @return {undefined} | |
| */ | |
| y.Y = function(y) { | |
| var val = this.Pb; | |
| var c = Rh(this.a.a, k, val.S() + ca, y); | |
| var cl = c.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < cl; i++) { | |
| Gt(val, this, c[i]); | |
| } | |
| gu.v.Y.call(this, y); | |
| }; | |
| /** | |
| * @param {!Event} data | |
| * @return {?} | |
| */ | |
| y.hd = function(data) { | |
| var r = gu.v.hd.call(this, data); | |
| if (!r) { | |
| Ll(this, function(key) { | |
| if (!r && key.Uh && key.Ug == data.keyCode) { | |
| if (this.isEnabled()) { | |
| this.Hb(Pl(this, key)); | |
| } | |
| r = key.Ka(data); | |
| } | |
| }, this); | |
| } | |
| return r; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| y.Hb = function(b) { | |
| gu.v.Hb.call(this, b); | |
| var item = Nl(this, b); | |
| if (item) { | |
| b = this.l() || Yh(document); | |
| item = item.l(); | |
| var c = b || Yh(document); | |
| var p = $i(item); | |
| var s = $i(c); | |
| var x = xj(c); | |
| if (c == Yh(document)) { | |
| /** @type {number} */ | |
| var i = p.x - c.scrollLeft; | |
| /** @type {number} */ | |
| p = p.y - c.scrollTop; | |
| if (E && !yh(10)) { | |
| i = i + x.left; | |
| p = p + x.top; | |
| } | |
| } else { | |
| /** @type {number} */ | |
| i = p.x - s.x - x.left; | |
| /** @type {number} */ | |
| p = p.y - s.y - x.top; | |
| } | |
| /** @type {number} */ | |
| x = c.clientHeight - item.offsetHeight; | |
| s = c.scrollLeft; | |
| var y = c.scrollTop; | |
| s = s + Math.min(i, Math.max(i - (c.clientWidth - item.offsetWidth), 0)); | |
| y = y + Math.min(p, Math.max(p - x, 0)); | |
| item = new L(s, y); | |
| b.scrollLeft = item.x; | |
| b.scrollTop = item.y; | |
| } | |
| }; | |
| /** | |
| * @param {number} p | |
| * @param {string} g | |
| * @param {(Array|number|string)} b | |
| * @return {undefined} | |
| */ | |
| var iu = function(p, g, b) { | |
| /** @type {number} */ | |
| this.b = p; | |
| /** @type {string} */ | |
| this.g = g; | |
| /** @type {(Array|number|string)} */ | |
| this.B = b; | |
| }; | |
| C(iu, so); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} a | |
| * @return {undefined} | |
| */ | |
| iu.prototype.a = function(name, type, a) { | |
| ro(this.b, this.g, name, type, void 0, a, this.B); | |
| }; | |
| /** | |
| * @param {?} obj | |
| * @param {?} cb | |
| * @param {boolean} data | |
| * @param {string} urlPartConfig | |
| * @return {undefined} | |
| */ | |
| var ju = function(obj, cb, data, urlPartConfig) { | |
| iu.call(this, obj, cb); | |
| /** @type {number} */ | |
| this.j = data ? 5 : 0; | |
| this.m = urlPartConfig || void 0; | |
| }; | |
| C(ju, iu); | |
| ju.prototype.o = w("j"); | |
| ju.prototype.c = ve("j"); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} data | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| ju.prototype.a = function(name, type, data, s) { | |
| var val = ro(this.b, this.g, name, type, null, data, 10, s, this.m); | |
| if (val & 496) { | |
| var min = ku(val, this.g); | |
| type = ku(val, type); | |
| val = ro(this.b, min, name, type, null, data, 10, s, this.m); | |
| if (val & 496) { | |
| min = ku(val, min); | |
| type = ku(val, type); | |
| ro(this.b, min, name, type, null, data, this.j, s, this.m); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} keys | |
| * @param {number} val | |
| * @return {?} | |
| */ | |
| var ku = function(keys, val) { | |
| if (keys & 48) { | |
| /** @type {number} */ | |
| val = val ^ 4; | |
| } | |
| if (keys & 192) { | |
| /** @type {number} */ | |
| val = val ^ 1; | |
| } | |
| return val; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {boolean} opt_adjust | |
| * @param {boolean} opt_resize | |
| * @return {undefined} | |
| */ | |
| var lu = function(a, b, opt_adjust, opt_resize) { | |
| ju.call(this, a, b, opt_adjust || opt_resize); | |
| if (opt_adjust || opt_resize) { | |
| this.c(65 | (opt_resize ? 32 : 132)); | |
| } | |
| }; | |
| C(lu, ju); | |
| var mu = ue(); | |
| C(mu, fo); | |
| Be(mu); | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| mu.prototype.hb = function(item) { | |
| return mu.v.hb.call(this, item && item.firstChild); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| mu.prototype.R = function(a, b) { | |
| var key = Sh("*", Ib, b)[0]; | |
| if (key) { | |
| S(key, false); | |
| Ph(key).body.appendChild(key); | |
| var parent = new gu; | |
| parent.R(key); | |
| a.Tc(parent); | |
| } | |
| return mu.v.R.call(this, a, b); | |
| }; | |
| /** | |
| * @param {undefined} id | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| mu.prototype.Id = function(id, n) { | |
| return mu.v.Id.call(this, [n.b(k, Hb + (this.S() + ba), id), n.b(k, Hb + (this.S() + ea), "\u00a0")], n); | |
| }; | |
| mu.prototype.S = x(Jb); | |
| /** | |
| * @param {?} o | |
| * @param {undefined} op | |
| * @param {?} value | |
| * @param {?} queryObj | |
| * @param {string} propertiesObj | |
| * @return {undefined} | |
| */ | |
| var nu = function(o, op, value, queryObj, propertiesObj) { | |
| eo.call(this, o, value || mu.M(), queryObj); | |
| this.Ba(64, true); | |
| this.I = new lu(null, 9); | |
| if (op) { | |
| this.Tc(op); | |
| } | |
| this.U = new Zk(500); | |
| if (!(!wl && !xl || I("533.17.9"))) { | |
| /** @type {boolean} */ | |
| this.pe = true; | |
| } | |
| this.Cc = propertiesObj || eu.M(); | |
| }; | |
| C(nu, eo); | |
| y = nu.prototype; | |
| /** @type {boolean} */ | |
| y.pe = false; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| nu.v.V.call(this); | |
| ou(this, true); | |
| if (this.b) { | |
| pu(this, this.b, true); | |
| } | |
| dn(this.D, mc, !!this.b); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ya = function() { | |
| nu.v.Ya.call(this); | |
| ou(this, false); | |
| if (this.b) { | |
| this.Ja(false); | |
| this.b.Ya(); | |
| pu(this, this.b, false); | |
| var file = this.b.l(); | |
| if (file) { | |
| mi(file); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| nu.v.J.call(this); | |
| if (this.b) { | |
| this.b.za(); | |
| delete this.b; | |
| } | |
| delete this.Dc; | |
| this.U.za(); | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @return {undefined} | |
| */ | |
| y.Za = function(that) { | |
| nu.v.Za.call(this, that); | |
| if (tn(this, 4)) { | |
| this.Ja(!tn(this, 64), that); | |
| if (this.b) { | |
| this.b.Ub = tn(this, 64); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {undefined} | |
| */ | |
| y.ib = function(node) { | |
| nu.v.ib.call(this, node); | |
| if (this.b && !tn(this, 4)) { | |
| /** @type {boolean} */ | |
| this.b.Ub = false; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Wb = function() { | |
| Wn(this, false); | |
| return true; | |
| }; | |
| /** | |
| * @param {!Event} mutationEvent | |
| * @return {undefined} | |
| */ | |
| y.ei = function(mutationEvent) { | |
| if (this.b && this.b.isVisible() && !this.mf(mutationEvent.target)) { | |
| this.Ja(false); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {?} | |
| */ | |
| y.mf = function(a) { | |
| return a && ti(this.l(), a) || this.b && hu(this.b, a) || false; | |
| }; | |
| /** | |
| * @param {!Event} key | |
| * @return {?} | |
| */ | |
| y.tc = function(key) { | |
| if (32 == key.keyCode) { | |
| if (key.preventDefault(), key.type != Kc) { | |
| return true; | |
| } | |
| } else { | |
| if (key.type != Hc) { | |
| return false; | |
| } | |
| } | |
| if (this.b && this.b.isVisible()) { | |
| /** @type {boolean} */ | |
| var buttonAfter = 13 == key.keyCode || 32 == key.keyCode; | |
| var children = this.b.Ka(key); | |
| return 27 == key.keyCode || buttonAfter ? (this.Ja(false), true) : children; | |
| } | |
| return 40 == key.keyCode || 38 == key.keyCode || 32 == key.keyCode || 13 == key.keyCode ? (this.Ja(true, key), true) : false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.rf = function() { | |
| this.Ja(false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.wi = function() { | |
| if (!tn(this, 4)) { | |
| this.Ja(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| y.Zd = function(a) { | |
| if (!this.pe) { | |
| this.Ja(false); | |
| } | |
| nu.v.Zd.call(this, a); | |
| }; | |
| /** | |
| * @param {!Object} root | |
| * @return {?} | |
| */ | |
| var qu = function(root) { | |
| if (!root.b) { | |
| root.Tc(new gu(root.a, root.Cc)); | |
| } | |
| return root.b || null; | |
| }; | |
| /** | |
| * @param {string} p | |
| * @return {?} | |
| */ | |
| nu.prototype.Tc = function(p) { | |
| var name = this.b; | |
| if (p != name && (name && (this.Ja(false), this.sa && pu(this, name, false), delete this.b), this.sa && dn(this.D, mc, !!p), p)) { | |
| /** @type {string} */ | |
| this.b = p; | |
| Jl(p, this); | |
| p.setVisible(false); | |
| var left = this.pe; | |
| if (p.L = left) { | |
| Tt(p, true); | |
| } | |
| if (this.sa) { | |
| pu(this, p, true); | |
| } | |
| } | |
| return name; | |
| }; | |
| /** | |
| * @param {number} y | |
| * @return {undefined} | |
| */ | |
| nu.prototype.ae = function(y) { | |
| qu(this).Ia(y, true); | |
| }; | |
| /** | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| nu.prototype.vc = function(i) { | |
| var element = qu(this); | |
| if (i = element.removeChild(Nl(element, i), true)) { | |
| i.za(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var ru = function(n, a) { | |
| return n.b ? Nl(n.b, a) : null; | |
| }; | |
| /** | |
| * @param {!Object} cell | |
| * @return {?} | |
| */ | |
| var su = function(cell) { | |
| return cell.b ? Ml(cell.b) : 0; | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @param {boolean} visible | |
| * @return {?} | |
| */ | |
| nu.prototype.setVisible = function(id, visible) { | |
| var ret = nu.v.setVisible.call(this, id, visible); | |
| if (ret && !this.isVisible()) { | |
| this.Ja(false); | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * @param {boolean} fn | |
| * @return {undefined} | |
| */ | |
| nu.prototype.ba = function(fn) { | |
| nu.v.ba.call(this, fn); | |
| if (!this.isEnabled()) { | |
| this.Ja(false); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @param {!Event} item | |
| * @return {undefined} | |
| */ | |
| nu.prototype.Ja = function(a, item) { | |
| nu.v.Ja.call(this, a); | |
| if (this.b && tn(this, 64) == a) { | |
| if (a) { | |
| if (!this.b.sa) { | |
| this.b.aa(); | |
| } | |
| this.Fb = aj(this.l()); | |
| this.bb = ij(this.l()); | |
| tu(this); | |
| if (!item || 40 != item.keyCode && 38 != item.keyCode) { | |
| this.b.Hb(-1); | |
| } else { | |
| Pt(this.b); | |
| } | |
| } else { | |
| Wn(this, false); | |
| /** @type {boolean} */ | |
| this.b.Ub = false; | |
| var message = this.l(); | |
| if (message) { | |
| dn(message, Ia, ""); | |
| dn(message, "owns", ""); | |
| } | |
| if (null != this.W) { | |
| this.W = void 0; | |
| if (message = this.b.l()) { | |
| fj(message, "", ""); | |
| } | |
| } | |
| } | |
| this.b.setVisible(a, false, item); | |
| if (!this.Ca) { | |
| message = X(this); | |
| var result = a ? message.a : message.b; | |
| result.call(message, this.a.a, Vc, this.ei, true); | |
| if (this.pe) { | |
| result.call(message, this.b, Va, this.wi); | |
| } | |
| result.call(message, this.U, "tick", this.Wc); | |
| if (a) { | |
| al(this.U); | |
| } else { | |
| $k(this.U); | |
| } | |
| } | |
| } | |
| if (this.b && this.b.l()) { | |
| this.b.D.removeAttribute("aria-hidden"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var tu = function(item) { | |
| if (item.b.sa) { | |
| var scope = item.I; | |
| item.I.b = item.Dc || item.l(); | |
| var a = item.b.l(); | |
| if (!item.b.isVisible()) { | |
| a.style.visibility = oc; | |
| S(a, true); | |
| } | |
| if (!item.W && item.I.o && item.I.j & 32) { | |
| item.W = hj(a); | |
| } | |
| scope.a(a, scope.g ^ 1, null, item.W); | |
| if (!item.b.isVisible()) { | |
| S(a, false); | |
| a.style.visibility = me; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nu.prototype.Wc = function() { | |
| var b = ij(this.l()); | |
| var bounds = aj(this.l()); | |
| var a; | |
| a = this.bb; | |
| if (!(a = !(a == b || a && b && a.left == b.left && a.width == b.width && a.top == b.top && a.height == b.height))) { | |
| a = this.Fb; | |
| /** @type {boolean} */ | |
| a = !(a == bounds || a && bounds && a.top == bounds.top && a.right == bounds.right && a.bottom == bounds.bottom && a.left == bounds.left); | |
| } | |
| if (a) { | |
| this.bb = b; | |
| this.Fb = bounds; | |
| tu(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} name | |
| * @param {!Function} res | |
| * @return {undefined} | |
| */ | |
| var pu = function(f, name, res) { | |
| var self = X(f); | |
| res = res ? self.a : self.b; | |
| res.call(self, name, p, f.rf); | |
| res.call(self, name, "close", f.gc); | |
| res.call(self, name, qc, f.kc); | |
| res.call(self, name, je, f.lc); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var ou = function(a, b) { | |
| var t = X(a); | |
| (b ? t.a : t.b).call(t, a.l(), Ic, a.Xc); | |
| }; | |
| /** | |
| * @param {!Function} action | |
| * @return {undefined} | |
| */ | |
| nu.prototype.kc = function(action) { | |
| if (action = action.target.l()) { | |
| uu(this, action); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| nu.prototype.Xc = function(event) { | |
| if (sn(this, 32) && this.l() && this.b && this.b.isVisible()) { | |
| event.stopPropagation(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nu.prototype.lc = function() { | |
| if (!Ot(this.b)) { | |
| var dataElementsCount = this.l(); | |
| dn(dataElementsCount, Ia, ""); | |
| dn(dataElementsCount, "owns", ""); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| nu.prototype.gc = function(e) { | |
| if (tn(this, 64) && e.target instanceof bu) { | |
| e = e.target; | |
| var recordWithMsg = e.l(); | |
| if (e.isVisible() && tn(e, 2) && null != recordWithMsg) { | |
| uu(this, recordWithMsg); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @param {string} record | |
| * @return {undefined} | |
| */ | |
| var uu = function(res, record) { | |
| var loadinfo = res.l(); | |
| var rec = fn(record) || record; | |
| if (!rec.id) { | |
| var clonedI = Dl.M(); | |
| /** @type {string} */ | |
| rec.id = ":" + (clonedI.a++).toString(36); | |
| } | |
| gn(loadinfo, rec); | |
| dn(loadinfo, "owns", rec.id); | |
| }; | |
| On(Jb, function() { | |
| return new nu(null); | |
| }); | |
| var vu = ue(); | |
| C(vu, Bt); | |
| Be(vu); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| vu.prototype.Pa = function(a) { | |
| var b = nn(this, a); | |
| b = a.a.b(k, { | |
| "class" : Hb + b.join(" ") | |
| }, [wu(this, a.Aa(), a.a), xu(this, a.a)]); | |
| xn(b, a.w); | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| vu.prototype.hb = function(b) { | |
| return b && b.firstChild; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| vu.prototype.R = function(a, b) { | |
| var result = Sh("*", Ib, b)[0]; | |
| if (result) { | |
| S(result, false); | |
| a.a.a.body.appendChild(result); | |
| var parent = new gu; | |
| parent.R(result); | |
| a.Tc(parent); | |
| } | |
| if (!Sh("*", this.S() + ba, b)[0]) { | |
| b.appendChild(wu(this, b.childNodes, a.a)); | |
| } | |
| if (!Sh("*", this.S() + ea, b)[0]) { | |
| b.appendChild(xu(this, a.a)); | |
| } | |
| return vu.v.R.call(this, a, b); | |
| }; | |
| /** | |
| * @param {?} layer | |
| * @param {undefined} x | |
| * @param {!Object} arr | |
| * @return {?} | |
| */ | |
| var wu = function(layer, x, arr) { | |
| return arr.b(k, Hb + (layer.S() + ba), x); | |
| }; | |
| /** | |
| * @param {?} i | |
| * @param {!Object} t | |
| * @return {?} | |
| */ | |
| var xu = function(i, t) { | |
| return t.b(k, { | |
| "class" : Hb + (i.S() + ea), | |
| "aria-hidden" : true | |
| }, "\u00a0"); | |
| }; | |
| vu.prototype.S = x(Eb); | |
| On(Eb, function() { | |
| return new nu(null, null, vu.M()); | |
| }); | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {?} rev | |
| * @return {undefined} | |
| */ | |
| var yu = function(a, b, rev) { | |
| bu.call(this, a, b, rev); | |
| this.Ba(8, true); | |
| }; | |
| C(yu, bu); | |
| /** | |
| * @return {?} | |
| */ | |
| yu.prototype.Wb = function() { | |
| return this.dispatchEvent(p); | |
| }; | |
| On(Ob, function() { | |
| return new yu(null); | |
| }); | |
| var zu = ue(); | |
| Be(zu); | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| var Au = function(event) { | |
| var touch; | |
| a: { | |
| touch = event.changedTouches[0]; | |
| var type; | |
| switch(event.type) { | |
| case ae: | |
| type = Vc; | |
| break; | |
| case $d: | |
| type = Wc; | |
| break; | |
| case Zd: | |
| type = Zc; | |
| break; | |
| default: | |
| /** @type {null} */ | |
| touch = null; | |
| break a; | |
| } | |
| /** @type {(Event|null)} */ | |
| var simulatedEvent = document.createEvent("MouseEvent"); | |
| simulatedEvent.initMouseEvent(type, true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null); | |
| /** @type {!Event} */ | |
| touch = simulatedEvent; | |
| } | |
| if (null != touch) { | |
| event.changedTouches[0].target.dispatchEvent(touch); | |
| event.preventDefault(); | |
| } | |
| }; | |
| var Bu = wl || xl || yl; | |
| /** | |
| * @param {?} checkDist | |
| * @param {!HTMLElement} list | |
| * @return {undefined} | |
| */ | |
| var Cu = function(checkDist, list) { | |
| if (Bu) { | |
| list.addEventListener(ae, Au, true); | |
| list.addEventListener($d, Au, true); | |
| list.addEventListener(Zd, Au, true); | |
| list.addEventListener("touchcancel", Au, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} v0_sample | |
| * @return {undefined} | |
| */ | |
| var Eu = function(v0_sample) { | |
| V.call(this); | |
| /** @type {!Array} */ | |
| this.a = []; | |
| Du(this, v0_sample); | |
| }; | |
| C(Eu, V); | |
| /** @type {null} */ | |
| Eu.prototype.b = null; | |
| /** | |
| * @param {!Object} s | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| var Du = function(s, v) { | |
| if (v) { | |
| xf(v, function(cX1) { | |
| Fu(cX1, false); | |
| }, s); | |
| Kf(s.a, v); | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} a | |
| * @param {!Function} b | |
| * @param {undefined} aStack | |
| * @return {undefined} | |
| */ | |
| var Gu = function(a, b, aStack) { | |
| if (b) { | |
| Fu(b, false); | |
| Mf(a.a, aStack, 0, b); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} all | |
| * @return {?} | |
| */ | |
| var Hu = function(all) { | |
| var b = all.b; | |
| return b ? wf(all.a, b) : -1; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Eu.prototype.clear = function() { | |
| var a = this.a; | |
| if (!De(a)) { | |
| /** @type {number} */ | |
| var $orderCol = a.length - 1; | |
| for (; 0 <= $orderCol; $orderCol--) { | |
| delete a[$orderCol]; | |
| } | |
| } | |
| /** @type {number} */ | |
| a.length = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Eu.prototype.J = function() { | |
| Eu.v.J.call(this); | |
| delete this.a; | |
| /** @type {null} */ | |
| this.b = null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {boolean} v | |
| * @return {undefined} | |
| */ | |
| var Fu = function(a, v) { | |
| if (a && typeof a.Kf == Bb) { | |
| a.Kf(v); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {?} c | |
| * @param {?} quality | |
| * @param {?} type | |
| * @return {undefined} | |
| */ | |
| var Iu = function(a, b, c, quality, type) { | |
| nu.call(this, a, b, c, quality, type || new eu("listbox")); | |
| this.qa = this.Aa(); | |
| /** @type {null} */ | |
| this.va = null; | |
| /** @type {string} */ | |
| this.lf = "listbox"; | |
| }; | |
| C(Iu, nu); | |
| y = Iu.prototype; | |
| /** @type {null} */ | |
| y.ya = null; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| Iu.v.V.call(this); | |
| Ju(this); | |
| Ku(this); | |
| }; | |
| /** | |
| * @param {!Object} selector | |
| * @return {undefined} | |
| */ | |
| y.Y = function(selector) { | |
| Iu.v.Y.call(this, selector); | |
| if (selector = this.Na()) { | |
| /** @type {!Object} */ | |
| this.qa = selector; | |
| Ju(this); | |
| } else { | |
| if (!Lu(this)) { | |
| Mu(this, 0); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| Iu.v.J.call(this); | |
| if (this.ya) { | |
| this.ya.za(); | |
| /** @type {null} */ | |
| this.ya = null; | |
| } | |
| /** @type {null} */ | |
| this.qa = null; | |
| }; | |
| /** | |
| * @param {!Event} a | |
| * @return {undefined} | |
| */ | |
| y.rf = function(a) { | |
| Nu(this, a.target); | |
| Iu.v.rf.call(this, a); | |
| a.stopPropagation(); | |
| this.dispatchEvent(p); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Di = function() { | |
| var item = Lu(this); | |
| Iu.v.Vd.call(this, item && item.T()); | |
| Ju(this); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| y.Tc = function(o) { | |
| var n = Iu.v.Tc.call(this, o); | |
| if (o != n) { | |
| if (this.ya) { | |
| this.ya.clear(); | |
| } | |
| if (o) { | |
| if (this.ya) { | |
| Ll(o, function(a) { | |
| Ou(a); | |
| var b = this.ya; | |
| Gu(b, a, b.a.length); | |
| }, this); | |
| } else { | |
| Pu(this, o); | |
| } | |
| } | |
| } | |
| return n; | |
| }; | |
| /** | |
| * @param {!Object} y | |
| * @return {undefined} | |
| */ | |
| y.ae = function(y) { | |
| Ou(y); | |
| Iu.v.ae.call(this, y); | |
| if (this.ya) { | |
| var b = this.ya; | |
| Gu(b, y, b.a.length); | |
| } else { | |
| Pu(this, qu(this)); | |
| } | |
| Qu(this); | |
| }; | |
| /** | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| y.vc = function(i) { | |
| Iu.v.vc.call(this, i); | |
| if (this.ya) { | |
| var exports = this.ya; | |
| if ((i = exports.a[i] || null) && Hf(exports.a, i) && i == exports.b) { | |
| /** @type {null} */ | |
| exports.b = null; | |
| exports.dispatchEvent(ud); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Nu = function(d, b) { | |
| if (d.ya) { | |
| var _ = Lu(d); | |
| var model = d.ya; | |
| if (b != model.b) { | |
| Fu(model.b, false); | |
| /** @type {string} */ | |
| model.b = b; | |
| Fu(b, true); | |
| } | |
| model.dispatchEvent(ud); | |
| if (b != _) { | |
| d.dispatchEvent(Ya); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var Mu = function(d, i) { | |
| if (d.ya) { | |
| Nu(d, d.ya.a[i] || null); | |
| } | |
| }; | |
| /** | |
| * @param {string} size | |
| * @return {undefined} | |
| */ | |
| Iu.prototype.Vd = function(size) { | |
| if (null != size && this.ya) { | |
| /** @type {number} */ | |
| var attri = 0; | |
| var prop; | |
| for (; prop = this.ya.a[attri] || null; attri++) { | |
| if (prop && typeof prop.T == Bb && prop.T() == size) { | |
| Nu(this, prop); | |
| return; | |
| } | |
| } | |
| } | |
| Nu(this, null); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Iu.prototype.T = function() { | |
| var tet = Lu(this); | |
| return tet ? tet.T() : null; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var Lu = function(d) { | |
| return d.ya ? d.ya.b : null; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var Ru = function(d) { | |
| return d.ya ? Hu(d.ya) : -1; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} m | |
| * @return {undefined} | |
| */ | |
| var Pu = function(b, m) { | |
| b.ya = new Eu; | |
| if (m) { | |
| Ll(m, function(a) { | |
| Ou(a); | |
| var b = this.ya; | |
| Gu(b, a, b.a.length); | |
| }, b); | |
| } | |
| Ku(b); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var Ku = function(data) { | |
| if (data.ya) { | |
| X(data).a(data.ya, ud, data.Di); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| var Ju = function(v) { | |
| var n = Lu(v); | |
| v.g(n ? n.Na() : v.qa); | |
| var params = v.c.hb(v.l()); | |
| if (params && v.a.Ji(params)) { | |
| if (null == v.va) { | |
| v.va = en(params, Lc); | |
| } | |
| n = (n = n ? n.l() : null) ? en(n, Lc) : v.va; | |
| dn(params, Lc, n); | |
| Qu(v); | |
| } | |
| }; | |
| /** | |
| * @param {number} self | |
| * @return {undefined} | |
| */ | |
| var Qu = function(self) { | |
| var result = self.c; | |
| if (result && (result = result.hb(self.l()))) { | |
| var items = self.D; | |
| if (!result.id) { | |
| /** @type {string} */ | |
| result.id = ":" + (Dl.M().a++).toString(36); | |
| } | |
| cn(result, "option"); | |
| dn(items, Ia, result.id); | |
| if (self.ya) { | |
| items = Jf(self.ya.a); | |
| dn(result, "setsize", Su(items)); | |
| self = Hu(self.ya); | |
| dn(result, "posinset", 0 <= self ? Su(Lf(items, 0, self + 1)) : 0); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Su = function(a) { | |
| return Cf(a, function(a) { | |
| return a instanceof bu; | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Ou = function(b) { | |
| b.lf = b instanceof bu ? "option" : xd; | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @param {!Object} fn | |
| * @return {undefined} | |
| */ | |
| Iu.prototype.Ja = function(a, fn) { | |
| Iu.v.Ja.call(this, a, fn); | |
| if (tn(this, 64)) { | |
| qu(this).Hb(Ru(this)); | |
| } else { | |
| Qu(this); | |
| } | |
| }; | |
| On("goog-select", function() { | |
| return new Iu(null); | |
| }); | |
| /** | |
| * @param {string} i | |
| * @param {string} s | |
| * @param {!Object} tag | |
| * @param {!Object} str | |
| * @param {string} name | |
| * @param {string} cssClassName | |
| * @param {?} subjectIdentifier | |
| * @param {?} bodyIdentifier | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var Wu = function(i, s, tag, str, name, cssClassName, subjectIdentifier, bodyIdentifier, cb) { | |
| tag = new Tu(tag); | |
| Iu.call(this, "", tag, subjectIdentifier, bodyIdentifier); | |
| if (this.I.c) { | |
| this.I.c(33); | |
| } | |
| /** @type {string} */ | |
| this.Qa = i; | |
| this.Xb = i.id; | |
| Gl(tag, this.Xb + "-menu"); | |
| /** @type {!Array} */ | |
| this.$ = []; | |
| /** @type {null} */ | |
| this.Z = null; | |
| this.Da = null != cssClassName ? cssClassName : ""; | |
| /** @type {boolean} */ | |
| this.zc = !!cb; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < s.length; i++) { | |
| var style; | |
| cssClassName = null != str && i < str.length && null != str[i] ? str[i] : s[i]; | |
| if (cssClassName != xd) { | |
| style = new yu(s[i], cssClassName); | |
| } else { | |
| style = new fu; | |
| } | |
| this.ae(style); | |
| } | |
| this.R(this.Qa); | |
| Uu(this, null != name ? name : Vu(this, 0)); | |
| }; | |
| C(Wu, Iu); | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Wu.prototype.g = function(name) { | |
| if (this.zc) { | |
| name = this.Da; | |
| } else { | |
| if (this.Da) { | |
| /** @type {string} */ | |
| name = this.Da + " " + name; | |
| } | |
| } | |
| Wu.v.g.call(this, name); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var Xu = function(value) { | |
| if (value.Z) { | |
| dl(value.Z); | |
| /** @type {null} */ | |
| value.Z = null; | |
| } | |
| value.Z = cl(function() { | |
| /** @type {!Array} */ | |
| value.$ = []; | |
| }, 1E3); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Wu.prototype.J = function() { | |
| mi(this.Qa); | |
| /** @type {null} */ | |
| this.Qa = null; | |
| Wu.v.J.call(this); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| Wu.prototype.Ka = function(key) { | |
| if (!tn(this, 64) && 48 <= key.keyCode && 90 >= key.keyCode) { | |
| Xu(this); | |
| this.$.push(String.fromCharCode(key.keyCode)); | |
| key = this.$.join(""); | |
| /** @type {!RegExp} */ | |
| var stringPrefixes = new RegExp("^" + nf(key), "i"); | |
| var undefined = Ru(this); | |
| var m = undefined; | |
| if (-1 < m && 1 < key.length) { | |
| m--; | |
| } | |
| var curMonth = su(this); | |
| var targetSibling = 0 > m ? 0 : m; | |
| /** @type {boolean} */ | |
| var siblingBox = false; | |
| /** @type {boolean} */ | |
| var isChangeInProfile = false; | |
| do { | |
| ++m; | |
| if (m == curMonth) { | |
| /** @type {number} */ | |
| m = 0; | |
| /** @type {boolean} */ | |
| siblingBox = true; | |
| } | |
| var p = ru(this, m); | |
| if (p instanceof bu && (p = p.Na()) && p.match(stringPrefixes)) { | |
| /** @type {boolean} */ | |
| isChangeInProfile = true; | |
| break; | |
| } | |
| if (siblingBox && m == targetSibling && 3 == key.length) { | |
| p = key.split(""); | |
| if (p[1] == p[2]) { | |
| /** @type {!RegExp} */ | |
| stringPrefixes = new RegExp("^" + p[1], "i"); | |
| /** @type {!Array} */ | |
| this.$ = [p[1]]; | |
| /** @type {boolean} */ | |
| siblingBox = false; | |
| } | |
| } | |
| } while (!siblingBox || m != targetSibling); | |
| if (isChangeInProfile && m != undefined) { | |
| Mu(this, m); | |
| } | |
| return true; | |
| } | |
| return Wu.v.Ka.call(this, key); | |
| }; | |
| /** | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| Wu.prototype.vc = function(i) { | |
| var value = Ru(this); | |
| Wu.v.vc.call(this, i); | |
| if ((i == value || -1 === value) && ru(this, 0) instanceof bu) { | |
| Mu(this, 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} cell | |
| * @param {!Object} string | |
| * @return {?} | |
| */ | |
| var Yu = function(cell, string) { | |
| if (string) { | |
| var obj; | |
| /** @type {number} */ | |
| var val = 0; | |
| for (; obj = ru(cell, val); val++) { | |
| if (obj instanceof bu && obj.T() == string) { | |
| return ru(cell, val).Na(); | |
| } | |
| } | |
| return ""; | |
| } | |
| obj = Ru(cell); | |
| return ru(cell, obj).Na(); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| var Zu = function(c, s) { | |
| /** @type {boolean} */ | |
| var t = c.T() == Qa; | |
| if ("" != s) { | |
| var d; | |
| /** @type {number} */ | |
| var fff = 0; | |
| for (; d = ru(c, fff); fff++) { | |
| if (d instanceof bu && d.T() == Qa) { | |
| if (d.Na() != s) { | |
| d.g(s); | |
| if (t) { | |
| c.g(s); | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Object} child | |
| * @return {undefined} | |
| */ | |
| var Uu = function(node, child) { | |
| var s; | |
| a: { | |
| /** @type {number} */ | |
| var settings = 0; | |
| for (; s = ru(node, settings); settings++) { | |
| if (s instanceof bu && s.T() == child) { | |
| /** @type {number} */ | |
| s = settings; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| s = -1; | |
| } | |
| if (0 <= s) { | |
| Mu(node, s); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Vu = function(a, b) { | |
| /** @type {string} */ | |
| var c = ""; | |
| var d = ru(a, b); | |
| if (d instanceof bu) { | |
| c = d.T(); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Wu.prototype.T = function() { | |
| var sp = Ru(this); | |
| return -1 != sp ? Vu(this, sp) : ""; | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {?} f | |
| * @param {?} o | |
| * @return {undefined} | |
| */ | |
| var Tu = function(b, f, o) { | |
| /** @type {number} */ | |
| this.b = b; | |
| /** @type {!Array} */ | |
| this.m = []; | |
| /** @type {!Array} */ | |
| this.A = []; | |
| gu.call(this, f, o); | |
| }; | |
| C(Tu, gu); | |
| y = Tu.prototype; | |
| y.Dg = P(qb, { | |
| id : "goog-menuitem-group-", | |
| "class" : Mb | |
| }); | |
| /** @type {boolean} */ | |
| y.tf = false; | |
| /** @type {number} */ | |
| y.yc = 0; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| Tu.v.ra.call(this); | |
| this.l().id = this.F(); | |
| }; | |
| /** | |
| * @param {number} obj | |
| * @param {number} key | |
| * @param {boolean} marker | |
| * @return {undefined} | |
| */ | |
| y.Zc = function(obj, key, marker) { | |
| if (this.tf) { | |
| this.c = key == Ml(this) ? this.g[key - 1] : this.g[key]; | |
| } | |
| Tu.v.Zc.call(this, obj, key, marker); | |
| if (this.c) { | |
| /** @type {null} */ | |
| this.c = null; | |
| $u(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @param {boolean} options | |
| * @return {?} | |
| */ | |
| y.removeChild = function(element, options) { | |
| if (Fe(element)) { | |
| element = Il(this, element); | |
| } | |
| var widget = Pl(this, element); | |
| if (this.tf) { | |
| this.c = 0 == widget ? this.g[widget + 1] : this.g[widget]; | |
| } | |
| widget = Tu.v.removeChild.call(this, element, options); | |
| if (this.c) { | |
| /** @type {null} */ | |
| this.c = null; | |
| $u(this); | |
| } | |
| return widget; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.yb = function() { | |
| var primaryAxis; | |
| if (this.c) { | |
| primaryAxis = this.c; | |
| } else { | |
| primaryAxis = Tu.v.yb.call(this); | |
| } | |
| return primaryAxis; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| y.aa = function(key) { | |
| Tu.v.aa.call(this, key); | |
| $u(this); | |
| Cu(zu.M(), this.l()); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| y.R = function(a) { | |
| Tu.v.R.call(this, a); | |
| $u(this); | |
| Cu(zu.M(), this.l()); | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @return {undefined} | |
| */ | |
| var $u = function(args) { | |
| /** @type {boolean} */ | |
| args.tf = true; | |
| av(args); | |
| var div = args.l(); | |
| /** @type {string} */ | |
| div.innerHTML = ""; | |
| var tbl; | |
| var containerTR; | |
| /** @type {!Array} */ | |
| var cells = []; | |
| /** @type {number} */ | |
| var colSpan = 0; | |
| /** @type {!Element} */ | |
| tbl = document.createElement("table"); | |
| containerTR = tbl.insertRow(-1); | |
| /** @type {number} */ | |
| var i = 0; | |
| var l; | |
| for (; l = args.j[i]; i++) { | |
| var cell = containerTR.insertCell(containerTR.cells.length); | |
| cell.appendChild(l); | |
| /** @type {string} */ | |
| l.style.width = "100%"; | |
| if (Bh(l, Fb)) { | |
| cells.push(cell); | |
| containerTR = tbl.insertRow(tbl.rows.length); | |
| } else { | |
| colSpan++; | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; cell = cells[i]; i++) { | |
| cell.setAttribute("colspan", colSpan); | |
| /** @type {number} */ | |
| cell.colSpan = colSpan; | |
| } | |
| div.appendChild(tbl); | |
| }; | |
| /** | |
| * @param {!Object} component | |
| * @param {?} data | |
| * @param {number} fn | |
| * @return {?} | |
| */ | |
| var bv = function(component, data, fn) { | |
| if (!Ef(component.j, data.nb)) { | |
| component.j.push(data.nb); | |
| } | |
| if (Nl(component, fn + 1)) { | |
| data.nb = component.Dg.cloneNode(true); | |
| data.nb.id += data.Wg; | |
| data.Wg++; | |
| /** @type {number} */ | |
| data.he = 1; | |
| } | |
| return data; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var av = function(a) { | |
| /** @type {!Array} */ | |
| a.j = []; | |
| a.g = {}; | |
| var nb = a.Dg.cloneNode(true); | |
| nb.id += 1; | |
| var data = { | |
| nb : nb, | |
| Wg : 2, | |
| he : 1 | |
| }; | |
| Ll(a, function(prevResidue, key) { | |
| data.nb.appendChild(prevResidue.l()); | |
| this.g[key] = data.nb; | |
| if (data.he == this.b) { | |
| data = bv(this, data, key); | |
| } else { | |
| if (prevResidue instanceof bu) { | |
| data.he++; | |
| } | |
| } | |
| if (Ef(this.A, key)) { | |
| K(data.nb, Mb); | |
| J(data.nb, Fb); | |
| this.g[key] = data.nb; | |
| data = bv(this, data, key); | |
| } | |
| }, a); | |
| if (!(1 == data.he || Ef(a.j, data.nb))) { | |
| a.j.push(data.nb); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @param {boolean} visible | |
| * @return {?} | |
| */ | |
| Tu.prototype.setVisible = function(id, visible) { | |
| var ret = Tu.v.setVisible.call(this, id, visible); | |
| if (ret && this.yc) { | |
| dl(this.yc); | |
| /** @type {number} */ | |
| this.yc = 0; | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * @param {!Event} data | |
| * @return {?} | |
| */ | |
| Tu.prototype.hd = function(data) { | |
| var r = Tu.v.hd.call(this, data); | |
| if (r) { | |
| return r; | |
| } | |
| switch(data.keyCode) { | |
| case 37: | |
| return Ut(this, A(this.o, this), this.xa), true; | |
| case 39: | |
| return Ut(this, A(this.w, this), this.xa), true; | |
| default: | |
| return 48 <= data.keyCode && 90 >= data.keyCode ? (cv(this), this.m.push(String.fromCharCode(data.keyCode)), this.Mg(this.m.join("")), true) : false; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @return {undefined} | |
| */ | |
| var cv = function(context) { | |
| if (context.yc) { | |
| dl(context.yc); | |
| /** @type {number} */ | |
| context.yc = 0; | |
| } | |
| context.yc = cl(function() { | |
| /** @type {!Array} */ | |
| this.m = []; | |
| }, 1E3, context); | |
| }; | |
| /** | |
| * @param {!Object} stars | |
| * @return {?} | |
| */ | |
| Tu.prototype.Mg = function(stars) { | |
| /** @type {!RegExp} */ | |
| var r = new RegExp("^" + nf(stars), "i"); | |
| var QueryLanguageComponent = this.xa; | |
| if (-1 < QueryLanguageComponent && 1 < stars.length) { | |
| QueryLanguageComponent--; | |
| } | |
| return Ut(this, function(i, colClassIndex) { | |
| var type = 0 > i ? 0 : i; | |
| /** @type {boolean} */ | |
| var prevAction = false; | |
| do { | |
| ++i; | |
| if (i == colClassIndex) { | |
| /** @type {number} */ | |
| i = 0; | |
| /** @type {boolean} */ | |
| prevAction = true; | |
| } | |
| var l = Nl(this, i).Na(); | |
| if (l && l.match(r)) { | |
| return i; | |
| } | |
| } while (!prevAction || i != type); | |
| return this.xa; | |
| }, QueryLanguageComponent); | |
| }; | |
| /** | |
| * @param {number} name | |
| * @param {number} type | |
| * @return {?} | |
| */ | |
| Tu.prototype.o = function(name, type) { | |
| /** @type {number} */ | |
| var y = name - this.b; | |
| var x; | |
| if (0 > y) { | |
| x = y + type + (Math.ceil(type / this.b) * this.b - type) + this.b; | |
| } | |
| return x || y; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {number} type | |
| * @return {?} | |
| */ | |
| Tu.prototype.w = function(name, type) { | |
| var yInt = name + this.b; | |
| var F; | |
| if (yInt > type) { | |
| /** @type {number} */ | |
| F = yInt - type - (Math.ceil(type / this.b) * this.b - type) - this.b; | |
| } | |
| return F || yInt; | |
| }; | |
| /** | |
| * @param {string} path | |
| * @return {undefined} | |
| */ | |
| var dv = function(path) { | |
| this.A = M(path); | |
| /** @type {string} */ | |
| var name = this.A.id + "-gms"; | |
| var h; | |
| var i = Sh("option", null, this.A); | |
| /** @type {!Array} */ | |
| path = []; | |
| /** @type {!Array} */ | |
| var e = []; | |
| var item; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; item = i[j]; j++) { | |
| var file = Fi(item); | |
| path.push(file); | |
| e.push(item.value); | |
| if (item.selected) { | |
| h = item.value; | |
| } | |
| } | |
| this.P = P(wc, { | |
| type : oc, | |
| id : this.A.id, | |
| name : this.A.name, | |
| value : h | |
| }); | |
| ki(this.P, this.A); | |
| /** @type {(Element|null)} */ | |
| i = document.getElementById(name); | |
| if (null == i) { | |
| i = P(qb, { | |
| id : name | |
| }); | |
| ki(i, this.A); | |
| } | |
| /** @type {string} */ | |
| name = ""; | |
| item = Sh(Lc); | |
| /** @type {number} */ | |
| j = 0; | |
| for (; file = item[j]; j++) { | |
| if (file.htmlFor && file.htmlFor == this.A.id) { | |
| name = Fi(file); | |
| mi(file); | |
| } | |
| } | |
| j = vu.M(); | |
| Wu.call(this, i, path, 16, e, h, name, j, void 0, "" == name); | |
| if ("" == name) { | |
| zn(this.c, this, 1); | |
| J(this.l(), "gt-gms-icon"); | |
| } | |
| U(this, Ya, this.Vb, false, this); | |
| mi(this.A); | |
| /** @type {number} */ | |
| this.Ha = 3; | |
| /** @type {number} */ | |
| this.Fa = 0; | |
| U(this, [Ad, p], this.Ac, false, this); | |
| }; | |
| C(dv, Wu); | |
| /** | |
| * @return {undefined} | |
| */ | |
| dv.prototype.J = function() { | |
| mi(this.P); | |
| /** @type {null} */ | |
| this.P = null; | |
| dv.v.J.call(this); | |
| }; | |
| /** | |
| * @param {!Object} locale | |
| * @return {undefined} | |
| */ | |
| dv.prototype.Ac = function(locale) { | |
| var b; | |
| if (locale.type == Ad) { | |
| this.Bc = Pe(); | |
| } else { | |
| b = locale.target.T(); | |
| } | |
| if (b) { | |
| /** @type {number} */ | |
| this.Fa = Pe() - this.Bc; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| dv.prototype.Vb = function() { | |
| var ny = this.T(); | |
| if (this.P.value != ny) { | |
| this.P.value = ny; | |
| } | |
| }; | |
| /** | |
| * @param {undefined} target | |
| * @return {undefined} | |
| */ | |
| var ev = function(target) { | |
| /** @type {!Array} */ | |
| var b = []; | |
| var x; | |
| x = su(target); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < target.Ha + 1 && i < x; i++) { | |
| if (ru(target, i) instanceof fu) { | |
| /** @type {number} */ | |
| x = 0; | |
| for (; x < i; x++) { | |
| b.push(Vu(target, x)); | |
| } | |
| break; | |
| } | |
| if (Vu(target, i) == Qa) { | |
| break; | |
| } | |
| } | |
| if (b.length) { | |
| i = target.T(); | |
| /** @type {number} */ | |
| x = 0; | |
| /** @type {number} */ | |
| b = b.length + 1; | |
| for (; x < b; x++) { | |
| target.vc(0); | |
| } | |
| Uu(target, i); | |
| } else { | |
| if (ru(target, 0) instanceof fu) { | |
| target.vc(0); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| dv.prototype.ob = function(name) { | |
| var m = name.data; | |
| /** @type {!Array} */ | |
| name = []; | |
| /** @type {number} */ | |
| var t = 0; | |
| for (; t < m.length; ++t) { | |
| if (m[t] != this.T()) { | |
| name.push(m[t]); | |
| } | |
| } | |
| /** @type {number} */ | |
| m = 0; | |
| for (; t = ru(this, m); m++) { | |
| if (t.T && t.T()) { | |
| if (-1 != wf(name, t.T())) { | |
| J(t.l(), Lb); | |
| } else { | |
| K(t.l(), Lb); | |
| } | |
| } | |
| } | |
| }; | |
| var fv = ve("a"); | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} id | |
| * @param {!Object} result | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var gv = function(a, id, result, x) { | |
| U(id, Kd, result.ob, false, result); | |
| U(id, Vd, x.ob, false, x); | |
| result = a.a; | |
| U(id, Ld, result.va, false, result); | |
| a = a.a; | |
| U(id, Wd, a.va, false, a); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| fv.prototype.b = function(name) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < arguments.length; i++) { | |
| var c = arguments[i]; | |
| if (null != c && null != c.l()) { | |
| var va = this.a; | |
| U(c.l(), r, va.va, false, va); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} match | |
| * @return {?} | |
| */ | |
| var hv = function(match) { | |
| return (match = match.exec(bg)) ? match[1] : ""; | |
| }; | |
| var iv = function() { | |
| if (vl) { | |
| return hv(/Firefox\/([0-9.]+)/); | |
| } | |
| if (E || gh || fh) { | |
| return vh; | |
| } | |
| if (zl) { | |
| return hv(/Chrome\/([0-9.]+)/); | |
| } | |
| if (Al && !(eh() || D(tc) || D(uc))) { | |
| return hv(/Version\/([0-9.]+)/); | |
| } | |
| if (wl || xl) { | |
| /** @type {(Array<string>|null)} */ | |
| var button_off_bg = /Version\/(\S+).*Mobile\/(\S+)/.exec(bg); | |
| if (button_off_bg) { | |
| return button_off_bg[1] + "." + button_off_bg[2]; | |
| } | |
| } else { | |
| if (yl) { | |
| return (button_off_bg = hv(/Android\s+([0-9.]+)/)) ? button_off_bg : hv(/Version\/([0-9.]+)/); | |
| } | |
| } | |
| return ""; | |
| }(); | |
| /** | |
| * @param {?} span | |
| * @return {?} | |
| */ | |
| var jv = function(span) { | |
| return 0 <= sf(iv, span); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var kv = function() { | |
| this.a = E ? jv(9) : zl && jv(25) || E && jv(8) || gh || vl && jv(19) || fh && jv(12.1) || Al && jv(5.1) || xl && jv(3.2) || yl && jv(2.1); | |
| }; | |
| Be(kv); | |
| /** | |
| * @param {(number|string)} a | |
| * @param {!Object} i | |
| * @return {?} | |
| */ | |
| var nv = function(a, i) { | |
| var layout = lv[i]; | |
| var me = mv[i]; | |
| layout = null != layout ? Jf(layout) : []; | |
| if (a.a && null != me) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < me.length; i++) { | |
| layout.push(me[i]); | |
| } | |
| } | |
| return layout; | |
| }; | |
| /** | |
| * @param {string} x | |
| * @return {?} | |
| */ | |
| var pv = function(x) { | |
| return 0 <= x.indexOf("-i0-") && !ov(x); | |
| }; | |
| /** | |
| * @param {string} url | |
| * @return {?} | |
| */ | |
| var ov = function(url) { | |
| return 0 <= url.indexOf("-i0-handwrit"); | |
| }; | |
| var lv = { | |
| af : [Oc], | |
| am : ["am-t-i0-und", "und-ethi-t-k0-und"], | |
| ar : ["ar-t-i0-und", "ar-t-k0-und"], | |
| be : ["be-t-i0-und", "be-t-k0-und"], | |
| bg : ["bg-t-i0-und", "bg-t-k0-und", "bg-t-k0-qwerty"], | |
| bn : ["bn-t-i0-und", "bn-t-k0-und", "bn-t-und-latn-k0-und"], | |
| bs : ["bs-t-k0-und"], | |
| ca : ["ca-t-k0-und"], | |
| chr : ["chr-t-k0-und", "chr-t-und-latn-k0-und"], | |
| cs : ["cs-t-k0-und", "cs-t-k0-qwertz"], | |
| cy : [Oc], | |
| da : ["da-t-k0-und"], | |
| de : ["de-t-k0-und", "de-ch-t-k0-und", tb], | |
| el : ["el-t-i0-und", "el-t-k0-und"], | |
| en : ["en-t-k0-und", "en-t-k0-dvorak"], | |
| es : ["es-t-k0-und", tb], | |
| et : ["et-t-k0-und"], | |
| eu : ["eu-t-k0-und"], | |
| fa : ["fa-t-i0-und", "fa-t-k0-und"], | |
| fi : ["fi-t-k0-und"], | |
| fr : [Ab, tb], | |
| ga : [Oc], | |
| gl : ["gl-t-k0-und"], | |
| gu : ["gu-t-i0-und", "gu-t-k0-und", "gu-t-und-latn-k0-qwerty"], | |
| ha : [Oc], | |
| hi : ["hi-t-i0-und", "hi-t-k0-und", nc], | |
| hr : ["hr-t-k0-und"], | |
| ht : [Ab], | |
| hu : ["hu-t-k0-101key"], | |
| hy : ["hy-hyr-t-k0-und", "hy-hyt-t-k0-und"], | |
| id : [Oc], | |
| ig : [Oc], | |
| is : ["is-t-k0-und"], | |
| it : ["it-t-k0-und", tb], | |
| iw : ["he-t-i0-und", "he-t-k0-und"], | |
| jw : [Oc], | |
| ja : ["ja-t-ja-hira-i0-und"], | |
| ka : ["ka-t-k0-und", "ka-t-k0-legacy"], | |
| kk : ["kk-t-k0-und"], | |
| km : ["km-t-k0-und"], | |
| kn : ["kn-t-i0-und", "kn-t-k0-und", "kn-t-und-latn-k0-und"], | |
| ko : ["ko-t-k0-und"], | |
| ku : ["ku-t-k0-und"], | |
| ky : ["ky-cyrl-t-k0-und"], | |
| lb : [Ab, tb], | |
| lo : ["lo-t-k0-und"], | |
| lt : ["lt-t-k0-und"], | |
| lv : ["lv-t-k0-und"], | |
| mg : [Oc], | |
| mi : ["mi-t-k0-und"], | |
| mk : ["mk-t-k0-und"], | |
| ml : ["ml-t-i0-und", "ml-t-und-latn-k0-und", "ml-t-k0-und"], | |
| mn : ["mn-cyrl-t-k0-und"], | |
| mr : ["mr-t-i0-und", nc], | |
| ms : [Oc], | |
| mt : ["mt-t-k0-und"], | |
| my : ["my-t-k0-und", "my-t-k0-myansan"], | |
| ne : ["ne-t-i0-und", "ne-t-k0-und", "ne-t-und-latn-k0-und"], | |
| nl : ["nl-t-k0-und", tb], | |
| no : ["no-t-k0-und"], | |
| ny : [Oc], | |
| or : ["or-t-i0-und"], | |
| pa : ["pa-t-i0-und", "pa-guru-t-und-latn-k0-und", "pa-guru-t-k0-und"], | |
| pl : ["pl-t-k0-und"], | |
| ps : ["ps-t-k0-und"], | |
| pt : ["pt-br-t-k0-und", "pt-pt-t-k0-und", tb], | |
| ro : ["ro-t-k0-und", "ro-t-k0-legacy", "ro-t-k0-extended"], | |
| ru : ["ru-t-i0-und", "ru-t-k0-und"], | |
| rw : [Oc], | |
| sd : ["sd-t-k0-und"], | |
| si : ["si-t-i0-und", "si-t-k0-und"], | |
| sk : ["sk-t-k0-und", "sk-t-k0-qwerty"], | |
| sl : ["sl-t-k0-und"], | |
| sn : [Oc], | |
| so : [Oc], | |
| sq : ["sq-t-k0-und"], | |
| sr : ["sr-t-i0-und", "sr-cyrl-t-k0-und", "sr-latn-t-k0-und"], | |
| st : [Oc], | |
| su : [Oc], | |
| sv : ["sv-t-k0-und"], | |
| sw : [Oc], | |
| ta : "ta-t-i0-und ta-t-k0-ta99 ta-t-und-latn-k0-und ta-t-k0-und ta-t-k0-typewriter ta-t-k0-itrans".split(" "), | |
| te : ["te-t-i0-und", "te-t-k0-und", "te-t-und-latn-k0-und"], | |
| tg : ["tg-t-k0-und"], | |
| th : ["th-t-i0-und", "th-t-k0-und", "th-t-k0-pattajoti", "th-t-k0-tis"], | |
| tk : [Oc], | |
| tl : [Oc], | |
| tr : ["tr-t-k0-und", "tr-t-k0-legacy"], | |
| tt : ["tt-t-k0-und"], | |
| ug : ["ug-t-k0-und"], | |
| uk : ["uk-t-i0-und", "uk-t-k0-101key"], | |
| ur : ["ur-t-i0-und", "ur-t-k0-und"], | |
| uz : ["uz-latn-t-k0-und", "uz-cyrl-t-k0-und", "uz-cyrl-t-k0-legacy"], | |
| vi : ["vi-t-i0-und", "vi-t-k0-legacy", "vi-t-k0-viqr", "vi-t-k0-und", "vi-t-k0-vni"], | |
| wo : [Oc], | |
| xh : [Oc], | |
| yi : ["yi-t-k0-und"], | |
| yo : [Oc], | |
| yue : [oe, re], | |
| zu : [Oc], | |
| "zh-CN" : ["zh-t-i0-pinyin", "zh-t-i0-wubi-1986", te, re, se, oe], | |
| "zh-TW" : [te, re, se, oe] | |
| }; | |
| var mv = { | |
| af : ["af-t-i0-handwrit"], | |
| ar : ["ar-t-i0-handwrit"], | |
| az : ["az-t-i0-handwrit"], | |
| be : ["be-t-i0-handwrit"], | |
| bg : ["bg-t-i0-handwrit"], | |
| bn : ["bn-t-i0-handwrit"], | |
| bs : ["bs-t-i0-handwrit"], | |
| ca : ["ca-t-i0-handwrit"], | |
| ceb : ["ceb-t-i0-handwrit"], | |
| co : ["co-t-i0-handwrit"], | |
| cs : ["cs-t-i0-handwrit"], | |
| cy : ["cy-t-i0-handwrit"], | |
| da : ["da-t-i0-handwrit"], | |
| de : ["de-t-i0-handwrit"], | |
| el : ["el-t-i0-handwrit"], | |
| en : ["en-t-i0-handwrit"], | |
| eo : ["eo-t-i0-handwrit"], | |
| es : ["es-t-i0-handwrit"], | |
| et : ["et-t-i0-handwrit"], | |
| eu : ["eu-t-i0-handwrit"], | |
| fa : ["fa-t-i0-handwrit"], | |
| fi : ["fi-t-i0-handwrit"], | |
| fr : ["fr-t-i0-handwrit"], | |
| fy : ["fy-t-i0-handwrit"], | |
| ga : ["ga-t-i0-handwrit"], | |
| gd : ["gd-t-i0-handwrit"], | |
| gl : ["gl-t-i0-handwrit"], | |
| gu : ["gu-t-i0-handwrit"], | |
| haw : ["haw-t-i0-handwrit"], | |
| hi : ["hi-t-i0-handwrit"], | |
| hmn : ["hmn-t-i0-handwrit"], | |
| hr : ["hr-t-i0-handwrit"], | |
| ht : ["ht-t-i0-handwrit"], | |
| hu : ["hu-t-i0-handwrit"], | |
| id : ["id-t-i0-handwrit"], | |
| is : ["is-t-i0-handwrit"], | |
| it : ["it-t-i0-handwrit"], | |
| iw : ["he-t-i0-handwrit"], | |
| ja : ["ja-t-i0-handwrit"], | |
| jv : ["jv-t-i0-handwrit"], | |
| kk : ["kk-t-i0-handwrit"], | |
| km : ["km-t-i0-handwrit"], | |
| kn : ["kn-t-i0-handwrit"], | |
| ko : ["ko-t-i0-handwrit"], | |
| ku : ["ku-t-i0-handwrit"], | |
| ky : ["ky-t-i0-handwrit"], | |
| la : ["la-t-i0-handwrit"], | |
| lb : ["lb-t-i0-handwrit"], | |
| lo : ["lo-t-i0-handwrit"], | |
| lt : ["lt-t-i0-handwrit"], | |
| lv : ["lv-t-i0-handwrit"], | |
| mg : ["mg-t-i0-handwrit"], | |
| mi : ["mi-t-i0-handwrit"], | |
| mk : ["mk-t-i0-handwrit"], | |
| ml : ["ml-t-i0-handwrit"], | |
| mn : ["mn-t-i0-handwrit"], | |
| mr : ["mr-t-i0-handwrit"], | |
| ms : ["ms-t-i0-handwrit"], | |
| mt : ["mt-t-i0-handwrit"], | |
| auto : ["mul-t-i0-handwrit"], | |
| my : ["my-t-i0-handwrit"], | |
| ne : ["ne-t-i0-handwrit"], | |
| nl : ["nl-t-i0-handwrit"], | |
| no : ["no-t-i0-handwrit"], | |
| ny : ["ny-t-i0-handwrit"], | |
| or : ["or-t-i0-handwrit"], | |
| pa : ["pa-t-i0-handwrit"], | |
| pl : ["pl-t-i0-handwrit"], | |
| pt : ["pt-t-i0-handwrit"], | |
| ro : ["ro-t-i0-handwrit"], | |
| ru : ["ru-t-i0-handwrit"], | |
| si : ["si-t-i0-handwrit"], | |
| sk : ["sk-t-i0-handwrit"], | |
| sl : ["sl-t-i0-handwrit"], | |
| sm : ["sm-t-i0-handwrit"], | |
| sn : ["sn-t-i0-handwrit"], | |
| so : ["so-t-i0-handwrit"], | |
| sq : ["sq-t-i0-handwrit"], | |
| sr : ["sr-t-i0-handwrit"], | |
| su : ["su-t-i0-handwrit"], | |
| sv : ["sv-t-i0-handwrit"], | |
| sw : ["sw-t-i0-handwrit"], | |
| ta : ["ta-t-i0-handwrit"], | |
| te : ["te-t-i0-handwrit"], | |
| tg : ["tg-t-i0-handwrit"], | |
| th : ["th-t-i0-handwrit"], | |
| tl : ["fil-t-i0-handwrit"], | |
| tr : ["tr-t-i0-handwrit"], | |
| uk : ["uk-t-i0-handwrit"], | |
| ur : ["ur-t-i0-handwrit"], | |
| uz : ["uz-t-i0-handwrit"], | |
| vi : ["vi-t-i0-handwrit"], | |
| xh : ["xh-t-i0-handwrit"], | |
| "zh-CN" : ["zh-t-i0-handwrit"], | |
| zu : ["zu-t-i0-handwrit"] | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var qv = function() { | |
| /** @type {boolean} */ | |
| this.c = this.b = false; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| }; | |
| Be(qv); | |
| /** | |
| * @return {undefined} | |
| */ | |
| qv.prototype.j = function() { | |
| /** @type {boolean} */ | |
| this.c = true; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; ++i) { | |
| this.a[i](); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| qv.prototype.load = function(name) { | |
| if (this.b) { | |
| if (this.b && !this.c) { | |
| this.a.push(name); | |
| } else { | |
| name(); | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| this.a.push(name); | |
| name = A(this.g, this, A(this.j, this)); | |
| /** @type {!Object} */ | |
| window._loadinputtoolcb = name; | |
| name = Sh("head")[0]; | |
| var p = P("script", { | |
| src : (window.INPUT_TOOL_PATH || "") + "/jsapi?key=internal-translate&callback=_loadinputtoolcb" + (0 > window.location.href.indexOf("?deb=static") ? "" : "&debug"), | |
| type : Sd | |
| }); | |
| name.appendChild(p); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| qv.prototype.g = function(name) { | |
| /** @type {string} */ | |
| window._inputtoolloadedcb = name; | |
| google.load("elements", "1", { | |
| packages : "inputtools", | |
| callback : "_inputtoolloadedcb" | |
| }); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var rv = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var sv = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var tv = function(a) { | |
| this.a = a || []; | |
| }; | |
| rv.prototype.b = w("a"); | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var uv = function(v) { | |
| v = v.a[0]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var vv = function(key) { | |
| key = key.a[1]; | |
| return null != key ? key : false; | |
| }; | |
| sv.prototype.b = w("a"); | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var wv = function(v) { | |
| v = v.a[0]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} d | |
| * @return {?} | |
| */ | |
| var xv = function(d) { | |
| d = d.a[1]; | |
| return null != d ? d : false; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var yv = function(v) { | |
| v = v.a[2]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var zv = function(v) { | |
| v = v.a[3]; | |
| return null != v ? v : ""; | |
| }; | |
| tv.prototype.b = w("a"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Bv = function() { | |
| this.g = kv.M(); | |
| this.c = {}; | |
| this.b = {}; | |
| this.a = {}; | |
| this.a[$b] = new Av; | |
| }; | |
| Be(Bv); | |
| var Cv = { | |
| ar : "Arab", | |
| fa : "Arab", | |
| ur : "Arab", | |
| be : qa, | |
| bg : qa, | |
| mk : qa, | |
| ru : qa, | |
| sr : qa, | |
| uk : qa, | |
| hi : "Deva", | |
| mr : "Deva", | |
| iw : "Hebr", | |
| yi : "Hebr" | |
| }; | |
| /** | |
| * @param {string} match | |
| * @return {?} | |
| */ | |
| var Dv = function(match) { | |
| var s; | |
| s = match.split(/[-_]/g); | |
| s = 1 < s.length && s[1].match(/^[a-zA-Z]{4}$/) ? s[1] : ""; | |
| if ("" != s) { | |
| return s; | |
| } | |
| match = (match = match.match(/^\w{2,3}([-_]|$)/)) ? match[0].replace(/[_-]/g, "") : ""; | |
| return xe(Cv[match]) ? Cv[match] : match; | |
| }; | |
| /** | |
| * @param {string} r | |
| * @param {string} m | |
| * @return {?} | |
| */ | |
| var Ev = function(r, m) { | |
| return r == m || Dv(r) == Dv(m) ? false : true; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {boolean} c | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Gv = function(b, c, a) { | |
| c = Fv(b, c, a); | |
| if (xe(c)) { | |
| b = c.Rg; | |
| } else { | |
| a: { | |
| b = nv(b.g, a); | |
| if (null != b) { | |
| /** @type {number} */ | |
| a = 0; | |
| for (; a < b.length; a++) { | |
| if (pv(b[a])) { | |
| b = b[a]; | |
| break a; | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| b = ""; | |
| } | |
| b = b || ""; | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} c | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| var Fv = function(b, c, x) { | |
| if (b = Hv(b, c)) { | |
| return b.a[x]; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} k | |
| * @param {boolean} min_diff | |
| * @return {?} | |
| */ | |
| var Hv = function(f, k, min_diff) { | |
| var cov = f.a[k]; | |
| if (min_diff && !xe(cov)) { | |
| cov = new Av; | |
| f.a[k] = cov; | |
| } | |
| return cov; | |
| }; | |
| /** | |
| * @param {string} array | |
| * @param {?} value | |
| * @param {string} c | |
| * @param {string} _ | |
| * @param {?} v | |
| * @return {undefined} | |
| */ | |
| var Iv = function(array, value, c, _, v) { | |
| var data = {}; | |
| /** @type {string} */ | |
| data.ua = array; | |
| data.uav = Fe(value) ? value : value ? 1 : 0; | |
| /** @type {string} */ | |
| data.sl = c; | |
| /** @type {string} */ | |
| data.tl = _; | |
| data.hl = v; | |
| /** @type {!Image} */ | |
| var textureimg = new Image; | |
| /** @type {string} */ | |
| textureimg.src = "/translate/uc?" + sq(data); | |
| /** | |
| * @return {undefined} | |
| */ | |
| textureimg.onload = function() { | |
| /** @type {null} */ | |
| textureimg.onload = null; | |
| }; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Av = function() { | |
| this.a = {}; | |
| var i; | |
| for (i in Jv) { | |
| this.a[i] = new Kv(Jv[i], ""); | |
| } | |
| }; | |
| var Jv = { | |
| iw : false, | |
| ja : false, | |
| vi : false, | |
| "zh-CN" : false | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {boolean} id | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Av.prototype.update = function(name, id, value) { | |
| var c = this.a[name]; | |
| if (xe(c)) { | |
| /** @type {boolean} */ | |
| c.isEnabled = id; | |
| /** @type {string} */ | |
| c.Rg = value; | |
| } else { | |
| this.a[name] = new Kv(id, value); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} state | |
| * @param {?} noBack | |
| * @return {undefined} | |
| */ | |
| var Kv = function(state, noBack) { | |
| /** @type {boolean} */ | |
| this.isEnabled = state; | |
| this.Rg = noBack; | |
| }; | |
| /** | |
| * @param {!Array} val | |
| * @param {?} i | |
| * @param {?} t | |
| * @param {number} b | |
| * @param {!Object} edge | |
| * @return {undefined} | |
| */ | |
| var Lv = function(val, i, t, b, edge) { | |
| V.call(this); | |
| this.G = kv.M(); | |
| /** @type {!Array} */ | |
| this.m = val; | |
| this.H = t; | |
| this.N = i; | |
| /** @type {null} */ | |
| this.o = this.a = null; | |
| /** @type {string} */ | |
| this.B = this.A = ""; | |
| this.F = this.m.id; | |
| /** @type {string} */ | |
| this.c = ""; | |
| /** @type {boolean} */ | |
| this.C = this.g = false; | |
| this.j = Wp.M(); | |
| /** @type {number} */ | |
| this.b = b; | |
| /** @type {!Array} */ | |
| this.L = ag(b) ? [5, 4] : [1, 0]; | |
| /** @type {!Array} */ | |
| this.I = [30, 0, 0, 0]; | |
| this.w = Bv.M(); | |
| /** @type {boolean} */ | |
| this.K = true; | |
| if (null != edge) { | |
| U(this, Ya, edge.va, false, edge); | |
| } | |
| }; | |
| C(Lv, V); | |
| /** | |
| * @param {!Object} options | |
| * @param {(Array|number|string)} value | |
| * @return {undefined} | |
| */ | |
| var Ov = function(options, value) { | |
| if (null == options.a) { | |
| /** @type {(Array|number|string)} */ | |
| options.B = value; | |
| if ((null != lv[value] || options.G.a && null != mv[value]) && options.K) { | |
| /** @type {boolean} */ | |
| options.K = false; | |
| qv.M().load(A(options.P, options)); | |
| } | |
| } else { | |
| if (options.A != value) { | |
| if (options.A = value, null != lv[value] || options.G.a && null != mv[value]) { | |
| var validTypes = nv(options.G, value); | |
| var type = Gv(options.w, options.F, value); | |
| var x; | |
| x = options.w; | |
| var max = options.F; | |
| var data = Fv(x, max, value); | |
| x = xe(data) ? data.isEnabled : pv(Gv(x, max, value)); | |
| /** @type {boolean} */ | |
| options.C = true; | |
| options.c = Ef(validTypes, type) ? type : validTypes[0]; | |
| options.a.disableCurrentInputTool(); | |
| options.g = x; | |
| options.a.setInputTools(validTypes); | |
| options.a.activateInputTool(options.c); | |
| if (options.g) { | |
| options.a.enableCurrentInputTool(); | |
| } else { | |
| options.a.disableCurrentInputTool(); | |
| } | |
| if (null == options.o) { | |
| options.o = options.a.showControl({ | |
| ui : "kd", | |
| container : options.m | |
| }); | |
| } | |
| if (null != options.a.localize) { | |
| options.a.localize(options.b); | |
| } | |
| options.o.show(); | |
| Mv(options); | |
| Nv(options); | |
| /** @type {boolean} */ | |
| options.C = false; | |
| } else { | |
| options.a.disableCurrentInputTool(); | |
| if (null != options.o) { | |
| options.o.hide(); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} proto | |
| * @return {undefined} | |
| */ | |
| var Mv = function(proto) { | |
| if (null != proto.a) { | |
| proto.a.repositionKeyboard(proto.H, proto.L, proto.I); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Lv.prototype.isEnabled = function() { | |
| return null != this.a && this.g; | |
| }; | |
| /** | |
| * @param {!Object} dat | |
| * @return {?} | |
| */ | |
| var Pv = function(dat) { | |
| return dat.isEnabled() && pv(dat.c); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Lv.prototype.O = function(name) { | |
| Mv(this); | |
| if (!this.C && (this.c != name.currInputToolName || this.g != name.currInputToolActive)) { | |
| this.c = name.currInputToolName; | |
| this.g = name.currInputToolActive; | |
| Nv(this); | |
| name = this.g; | |
| var b = this.A; | |
| var pb = this.b; | |
| var preview = this.F; | |
| var d = this.c; | |
| Hv(this.w, preview, true).update(b, name, d); | |
| Iv("itui", (name ? "1" : "0") + "." + preview + "." + d, b, "und", pb); | |
| } | |
| this.dispatchEvent(Ya); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Lv.prototype.P = function() { | |
| var request = new google.elements.inputtools.InputToolsController; | |
| request.setAutoDirection(false); | |
| request.setApplicationName(ge); | |
| request.addPageElements([this.N]); | |
| request.addEventListener(google.elements.inputtools.EventType.INPUT_TOOL_ENABLED, this.O, this); | |
| this.a = request; | |
| if ("" != this.B) { | |
| Ov(this, this.B); | |
| /** @type {string} */ | |
| this.B = ""; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} test | |
| * @return {undefined} | |
| */ | |
| var Nv = function(test) { | |
| var a = O("ita-kd-inputtool-icon", test.m); | |
| if (null != a) { | |
| var TMP_FILENAME; | |
| TMP_FILENAME = pv(test.c) ? test.isEnabled() ? window.MSG_IME_OFF || "" : window.MSG_IME_ON || "" : 0 <= test.c.indexOf("-k0-") ? test.isEnabled() ? window.MSG_VK_OFF || "" : window.MSG_VK_ON || "" : ov(test.c) ? test.isEnabled() ? window.MSG_VK_OFF || "" : window.MSG_HW_ON || "" : ""; | |
| Go(a, TMP_FILENAME); | |
| Ko(a); | |
| } | |
| test = O("ita-kd-dropdown", test.m); | |
| if (null != test) { | |
| Go(test, window.MSG_CHANGE_ITA || ""); | |
| Ko(test); | |
| } | |
| }; | |
| Qh(window.document); | |
| new V; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Qv = function() { | |
| Aj.call(this); | |
| }; | |
| C(Qv, Aj); | |
| /** | |
| * @param {!Node} a | |
| * @param {?} fn | |
| * @param {?} n | |
| * @param {undefined} d | |
| * @param {number} e | |
| * @return {undefined} | |
| */ | |
| var Sv = function(a, fn, n, d, e) { | |
| /** @type {boolean} */ | |
| this.a = !!fn; | |
| /** @type {null} */ | |
| this.node = null; | |
| /** @type {number} */ | |
| this.j = 0; | |
| /** @type {boolean} */ | |
| this.A = false; | |
| /** @type {boolean} */ | |
| this.F = !n; | |
| if (a) { | |
| Rv(this, a, d); | |
| } | |
| this.g = void 0 != e ? e : this.j || 0; | |
| if (this.a) { | |
| this.g *= -1; | |
| } | |
| }; | |
| C(Sv, Tg); | |
| /** | |
| * @param {!Object} a | |
| * @param {!Node} obj | |
| * @param {number} t | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var Rv = function(a, obj, t, c) { | |
| if (a.node = obj) { | |
| a.j = Ge(t) ? t : 1 != a.node.nodeType ? 0 : a.a ? -1 : 1; | |
| } | |
| if (Ge(c)) { | |
| /** @type {number} */ | |
| a.g = c; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @return {undefined} | |
| */ | |
| Sv.prototype.Mb = function(args) { | |
| this.node = args.node; | |
| this.j = args.j; | |
| this.g = args.g; | |
| this.a = args.a; | |
| this.F = args.F; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Sv.prototype.clone = function() { | |
| return new Sv(this.node, this.a, !this.F, this.j, this.g); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Sv.prototype.next = function() { | |
| var node; | |
| if (this.A) { | |
| if (!this.node || this.F && 0 == this.g) { | |
| throw Sg; | |
| } | |
| node = this.node; | |
| /** @type {number} */ | |
| var space = this.a ? -1 : 1; | |
| if (this.j == space) { | |
| var pornResult = this.a ? node.lastChild : node.firstChild; | |
| if (pornResult) { | |
| Rv(this, pornResult); | |
| } else { | |
| Rv(this, node, -1 * space); | |
| } | |
| } else { | |
| if (pornResult = this.a ? node.previousSibling : node.nextSibling) { | |
| Rv(this, pornResult); | |
| } else { | |
| Rv(this, node.parentNode, -1 * space); | |
| } | |
| } | |
| this.g += this.j * (this.a ? -1 : 1); | |
| } else { | |
| /** @type {boolean} */ | |
| this.A = true; | |
| } | |
| node = this.node; | |
| if (!this.node) { | |
| throw Sg; | |
| } | |
| return node; | |
| }; | |
| /** | |
| * @param {number} pos | |
| * @return {undefined} | |
| */ | |
| Sv.prototype.splice = function(pos) { | |
| var node = this.node; | |
| /** @type {number} */ | |
| var value = this.a ? 1 : -1; | |
| if (this.j == value) { | |
| /** @type {number} */ | |
| this.j = -1 * value; | |
| this.g += this.j * (this.a ? -1 : 1); | |
| } | |
| /** @type {boolean} */ | |
| this.a = !this.a; | |
| Sv.prototype.next.call(this); | |
| /** @type {boolean} */ | |
| this.a = !this.a; | |
| value = Ee(arguments[0]) ? arguments[0] : arguments; | |
| /** @type {number} */ | |
| var j = value.length - 1; | |
| for (; 0 <= j; j--) { | |
| li(value[j], node); | |
| } | |
| mi(node); | |
| }; | |
| var Tv = ue(); | |
| /** | |
| * @param {!Object} doc | |
| * @return {?} | |
| */ | |
| var Uv = function(doc) { | |
| if (doc.getSelection) { | |
| return doc.getSelection(); | |
| } | |
| doc = doc.document; | |
| var nativeSel = doc.selection; | |
| if (nativeSel) { | |
| try { | |
| var rowsnodeList = nativeSel.createRange(); | |
| if (rowsnodeList.parentElement) { | |
| if (rowsnodeList.parentElement().document != doc) { | |
| return null; | |
| } | |
| } else { | |
| if (!rowsnodeList.length || rowsnodeList.item(0).document != doc) { | |
| return null; | |
| } | |
| } | |
| } catch (d) { | |
| return null; | |
| } | |
| return nativeSel; | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @return {?} | |
| */ | |
| var Vv = function(t) { | |
| /** @type {!Array} */ | |
| var xmlCells = []; | |
| /** @type {number} */ | |
| var c = 0; | |
| var complexSize = t.ed(); | |
| for (; c < complexSize; c++) { | |
| xmlCells.push(t.Jc(c)); | |
| } | |
| return xmlCells; | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {?} | |
| */ | |
| var Wv = function(p) { | |
| return p.pd() ? p.fb() : p.ub(); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {?} | |
| */ | |
| var Xv = function(m) { | |
| return m.pd() ? m.gb() : m.vb(); | |
| }; | |
| Tv.prototype.pd = x(false); | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var Yv = function(a, b) { | |
| Sv.call(this, a, b, true); | |
| }; | |
| C(Yv, Sv); | |
| var Zv = ue(); | |
| C(Zv, Tv); | |
| /** | |
| * @param {!Object} value | |
| * @param {number} p | |
| * @param {!Node} c | |
| * @param {?} i | |
| * @param {number} force | |
| * @return {undefined} | |
| */ | |
| var $v = function(value, p, c, i, force) { | |
| /** @type {null} */ | |
| this.c = this.b = null; | |
| /** @type {number} */ | |
| this.C = this.w = 0; | |
| var f; | |
| if (value) { | |
| /** @type {!Object} */ | |
| this.b = value; | |
| /** @type {number} */ | |
| this.w = p; | |
| /** @type {!Node} */ | |
| this.c = c; | |
| this.C = i; | |
| if (1 == value.nodeType && "BR" != value.tagName) { | |
| value = value.childNodes; | |
| if (p = value[p]) { | |
| /** @type {number} */ | |
| this.b = p; | |
| /** @type {number} */ | |
| this.w = 0; | |
| } else { | |
| if (value.length) { | |
| this.b = vf(value); | |
| } | |
| /** @type {boolean} */ | |
| f = true; | |
| } | |
| } | |
| if (1 == c.nodeType) { | |
| if (this.c = c.childNodes[i]) { | |
| /** @type {number} */ | |
| this.C = 0; | |
| } else { | |
| /** @type {!Node} */ | |
| this.c = c; | |
| } | |
| } | |
| } | |
| Sv.call(this, force ? this.c : this.b, force, true); | |
| if (f) { | |
| try { | |
| this.next(); | |
| } catch (g) { | |
| if (g != Sg) { | |
| throw g; | |
| } | |
| } | |
| } | |
| }; | |
| C($v, Yv); | |
| y = $v.prototype; | |
| y.Td = w("b"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.nd = function() { | |
| return this.A && this.node == this.c && (!this.C || 1 != this.j); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.next = function() { | |
| if (this.nd()) { | |
| throw Sg; | |
| } | |
| return $v.v.next.call(this); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| y.Mb = function(data) { | |
| this.b = data.b; | |
| this.c = data.c; | |
| this.w = data.w; | |
| this.C = data.C; | |
| this.m = data.m; | |
| $v.v.Mb.call(this, data); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| var mtx = new $v(this.b, this.w, this.c, this.C, this.m); | |
| mtx.Mb(this); | |
| return mtx; | |
| }; | |
| var aw = ue(); | |
| /** | |
| * @param {!Object} x | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var bw = function(x, obj) { | |
| var undefined = obj.dd(); | |
| try { | |
| return 0 <= x.Db(undefined, 0, 0) && 0 >= x.Db(undefined, 1, 1); | |
| } catch (d) { | |
| if (!E) { | |
| throw d; | |
| } | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| aw.prototype.mb = function() { | |
| return new $v(this.wb(), this.Ob(), this.Nb(), this.$b()); | |
| }; | |
| var cw = ve("a"); | |
| C(cw, aw); | |
| /** | |
| * @param {!Object} start | |
| * @return {?} | |
| */ | |
| var ew = function(start) { | |
| var range = Ph(start).createRange(); | |
| if (3 == start.nodeType) { | |
| range.setStart(start, 0); | |
| range.setEnd(start, start.length); | |
| } else { | |
| if (dw(start)) { | |
| var node; | |
| /** @type {!Object} */ | |
| var prev = start; | |
| for (; (node = prev.firstChild) && dw(node);) { | |
| prev = node; | |
| } | |
| range.setStart(prev, 0); | |
| /** @type {!Object} */ | |
| prev = start; | |
| for (; (node = prev.lastChild) && dw(node);) { | |
| prev = node; | |
| } | |
| range.setEnd(prev, 1 == prev.nodeType ? prev.childNodes.length : prev.length); | |
| } else { | |
| node = start.parentNode; | |
| start = wf(node.childNodes, start); | |
| range.setStart(node, start); | |
| range.setEnd(node, start + 1); | |
| } | |
| } | |
| return range; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {?} start | |
| * @param {?} text | |
| * @param {?} offset | |
| * @return {?} | |
| */ | |
| var fw = function(node, start, text, offset) { | |
| var range = Ph(node).createRange(); | |
| range.setStart(node, start); | |
| range.setEnd(text, offset); | |
| return range; | |
| }; | |
| y = cw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| return new this.constructor(this.a.cloneRange()); | |
| }; | |
| y.dd = w("a"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.ef = function() { | |
| return this.a.commonAncestorContainer; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.wb = function() { | |
| return this.a.startContainer; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Ob = function() { | |
| return this.a.startOffset; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Nb = function() { | |
| return this.a.endContainer; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.$b = function() { | |
| return this.a.endOffset; | |
| }; | |
| /** | |
| * @param {?} options | |
| * @param {number} path | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| y.Db = function(options, path, name) { | |
| return this.a.compareBoundaryPoints(1 == name ? 1 == path ? z.Range.START_TO_START : z.Range.START_TO_END : 1 == path ? z.Range.END_TO_START : z.Range.END_TO_END, options); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.xb = function() { | |
| return this.a.collapsed; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.xg = function() { | |
| return this.a.toString(); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| y.select = function(a) { | |
| var iframe_window = $h(Ph(this.wb())); | |
| this.rd(iframe_window.getSelection(), a); | |
| }; | |
| /** | |
| * @param {!Selection} selection | |
| * @return {undefined} | |
| */ | |
| y.rd = function(selection) { | |
| selection.removeAllRanges(); | |
| selection.addRange(this.a); | |
| }; | |
| var gw = ve("a"); | |
| C(gw, cw); | |
| /** | |
| * @param {!Object} node | |
| * @param {?} context | |
| * @return {undefined} | |
| */ | |
| gw.prototype.rd = function(node, context) { | |
| if (!context || this.xb()) { | |
| gw.v.rd.call(this, node, context); | |
| } else { | |
| node.collapse(this.Nb(), this.$b()); | |
| node.extend(this.wb(), this.Ob()); | |
| } | |
| }; | |
| /** | |
| * @param {number} val | |
| * @param {(Object|string)} o | |
| * @return {undefined} | |
| */ | |
| var hw = function(val, o) { | |
| /** @type {null} */ | |
| this.c = this.b = this.m = null; | |
| /** @type {number} */ | |
| this.j = this.g = -1; | |
| /** @type {number} */ | |
| this.a = val; | |
| /** @type {(Object|string)} */ | |
| this.o = o; | |
| }; | |
| C(hw, aw); | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var iw = function(node) { | |
| var nodeRange = Ph(node).body.createTextRange(); | |
| if (1 == node.nodeType) { | |
| nodeRange.moveToElementText(node); | |
| if (dw(node) && !node.childNodes.length) { | |
| nodeRange.collapse(false); | |
| } | |
| } else { | |
| /** @type {number} */ | |
| var offset = 0; | |
| /** @type {!Object} */ | |
| var sibling = node; | |
| for (; sibling = sibling.previousSibling;) { | |
| var nType = sibling.nodeType; | |
| if (3 == nType) { | |
| offset = offset + sibling.length; | |
| } else { | |
| if (1 == nType) { | |
| nodeRange.moveToElementText(sibling); | |
| break; | |
| } | |
| } | |
| } | |
| if (!sibling) { | |
| nodeRange.moveToElementText(node.parentNode); | |
| } | |
| nodeRange.collapse(!sibling); | |
| if (offset) { | |
| nodeRange.move(Za, offset); | |
| } | |
| nodeRange.moveEnd(Za, node.length); | |
| } | |
| return nodeRange; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hw.prototype.clone = function() { | |
| var matrix = new hw(this.a.duplicate(), this.o); | |
| matrix.m = this.m; | |
| matrix.b = this.b; | |
| matrix.c = this.c; | |
| return matrix; | |
| }; | |
| hw.prototype.dd = w("a"); | |
| /** | |
| * @return {?} | |
| */ | |
| hw.prototype.ef = function() { | |
| if (!this.m) { | |
| var c = this.a.text; | |
| var e = this.a.duplicate(); | |
| var b = c.replace(/ +$/, ""); | |
| if (b = c.length - b.length) { | |
| e.moveEnd(Za, -b); | |
| } | |
| b = e.parentElement(); | |
| e = e.htmlText.replace(/(\r\n|\r|\n)+/g, " ").length; | |
| if (this.xb() && 0 < e) { | |
| return this.m = b; | |
| } | |
| for (; e > b.outerHTML.replace(/(\r\n|\r|\n)+/g, " ").length;) { | |
| b = b.parentNode; | |
| } | |
| for (; 1 == b.childNodes.length && b.innerText == jw(b.firstChild) && dw(b.firstChild);) { | |
| b = b.firstChild; | |
| } | |
| if (0 == c.length) { | |
| b = kw(this, b); | |
| } | |
| this.m = b; | |
| } | |
| return this.m; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {!Node} options | |
| * @return {?} | |
| */ | |
| var kw = function(type, options) { | |
| var commands = options.childNodes; | |
| /** @type {number} */ | |
| var i = 0; | |
| var length = commands.length; | |
| for (; i < length; i++) { | |
| var item = commands[i]; | |
| if (dw(item)) { | |
| var value = iw(item); | |
| /** @type {boolean} */ | |
| var isCrossDomainUrl = value.htmlText != item.outerHTML; | |
| if (type.xb() && isCrossDomainUrl ? 0 <= type.Db(value, 1, 1) && 0 >= type.Db(value, 1, 0) : type.a.inRange(value)) { | |
| return kw(type, item); | |
| } | |
| } | |
| } | |
| return options; | |
| }; | |
| y = hw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.wb = function() { | |
| if (!this.b) { | |
| this.b = lw(this, 1); | |
| if (this.xb()) { | |
| this.c = this.b; | |
| } | |
| } | |
| return this.b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Ob = function() { | |
| if (0 > this.g) { | |
| this.g = mw(this, 1); | |
| if (this.xb()) { | |
| this.j = this.g; | |
| } | |
| } | |
| return this.g; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Nb = function() { | |
| if (this.xb()) { | |
| return this.wb(); | |
| } | |
| if (!this.c) { | |
| this.c = lw(this, 0); | |
| } | |
| return this.c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.$b = function() { | |
| if (this.xb()) { | |
| return this.Ob(); | |
| } | |
| if (0 > this.j) { | |
| this.j = mw(this, 0); | |
| if (this.xb()) { | |
| this.g = this.j; | |
| } | |
| } | |
| return this.j; | |
| }; | |
| /** | |
| * @param {?} end | |
| * @param {number} path | |
| * @param {number} options | |
| * @return {?} | |
| */ | |
| y.Db = function(end, path, options) { | |
| return this.a.compareEndPoints((1 == path ? "Start" : "End") + "To" + (1 == options ? "Start" : "End"), end); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {number} actual | |
| * @param {!Object} r | |
| * @return {?} | |
| */ | |
| var lw = function(t, actual, r) { | |
| r = r || t.ef(); | |
| if (!r || !r.firstChild) { | |
| return r; | |
| } | |
| /** @type {boolean} */ | |
| var result = 1 == actual; | |
| /** @type {number} */ | |
| var currentNumber = 0; | |
| var connectNumber = r.childNodes.length; | |
| for (; currentNumber < connectNumber; currentNumber++) { | |
| /** @type {number} */ | |
| var start = result ? currentNumber : connectNumber - currentNumber - 1; | |
| var n = r.childNodes[start]; | |
| var val; | |
| try { | |
| val = nw(n); | |
| } catch (q) { | |
| continue; | |
| } | |
| var undefined = val.dd(); | |
| if (t.xb()) { | |
| if (!dw(n)) { | |
| if (0 == t.Db(undefined, 1, 1)) { | |
| /** @type {number} */ | |
| t.g = t.j = start; | |
| break; | |
| } | |
| } else { | |
| if (bw(val, t)) { | |
| return lw(t, actual, n); | |
| } | |
| } | |
| } else { | |
| if (bw(t, val)) { | |
| if (!dw(n)) { | |
| if (result) { | |
| /** @type {number} */ | |
| t.g = start; | |
| } else { | |
| /** @type {number} */ | |
| t.j = start + 1; | |
| } | |
| break; | |
| } | |
| return lw(t, actual, n); | |
| } | |
| if (0 > t.Db(undefined, 1, 0) && 0 < t.Db(undefined, 0, 1)) { | |
| return lw(t, actual, n); | |
| } | |
| } | |
| } | |
| return r; | |
| }; | |
| /** | |
| * @param {(number|string)} r | |
| * @param {number} start | |
| * @return {?} | |
| */ | |
| var mw = function(r, start) { | |
| /** @type {boolean} */ | |
| var isStartEndpoint = 1 == start; | |
| var el = isStartEndpoint ? r.wb() : r.Nb(); | |
| if (1 == el.nodeType) { | |
| el = el.childNodes; | |
| var range = el.length; | |
| /** @type {number} */ | |
| var end = isStartEndpoint ? 1 : -1; | |
| /** @type {number} */ | |
| var i = isStartEndpoint ? 0 : range - 1; | |
| for (; 0 <= i && i < range; i = i + end) { | |
| var y = el[i]; | |
| if (!dw(y) && 0 == r.a.compareEndPoints((1 == start ? "Start" : "End") + "To" + (1 == start ? "Start" : "End"), nw(y).dd())) { | |
| return isStartEndpoint ? i : i + 1; | |
| } | |
| } | |
| return -1 == i ? 0 : i; | |
| } | |
| range = r.a.duplicate(); | |
| end = iw(el); | |
| range.setEndPoint(isStartEndpoint ? "EndToEnd" : "StartToStart", end); | |
| range = range.text.length; | |
| return isStartEndpoint ? el.length - range : range; | |
| }; | |
| /** | |
| * @param {!Node} oDom | |
| * @return {?} | |
| */ | |
| var jw = function(oDom) { | |
| return 3 == oDom.nodeType ? oDom.nodeValue : oDom.innerText; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hw.prototype.xb = function() { | |
| return 0 == this.a.compareEndPoints(Ca, this.a); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hw.prototype.xg = function() { | |
| return this.a.text; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hw.prototype.select = function() { | |
| this.a.select(); | |
| }; | |
| var ow = ve("a"); | |
| C(ow, cw); | |
| /** | |
| * @param {!Selection} selection | |
| * @return {undefined} | |
| */ | |
| ow.prototype.rd = function(selection) { | |
| selection.collapse(this.wb(), this.Ob()); | |
| if (!(this.Nb() == this.wb() && this.$b() == this.Ob())) { | |
| selection.extend(this.Nb(), this.$b()); | |
| } | |
| if (0 == selection.rangeCount) { | |
| selection.addRange(this.a); | |
| } | |
| }; | |
| var pw = ve("a"); | |
| C(pw, cw); | |
| /** | |
| * @param {?} options | |
| * @param {number} path | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| pw.prototype.Db = function(options, path, name) { | |
| return I("528") ? pw.v.Db.call(this, options, path, name) : this.a.compareBoundaryPoints(1 == name ? 1 == path ? z.Range.START_TO_START : z.Range.END_TO_START : 1 == path ? z.Range.START_TO_END : z.Range.END_TO_END, options); | |
| }; | |
| /** | |
| * @param {!Selection} context | |
| * @param {?} node | |
| * @return {undefined} | |
| */ | |
| pw.prototype.rd = function(context, node) { | |
| if (node) { | |
| context.setBaseAndExtent(this.Nb(), this.$b(), this.wb(), this.Ob()); | |
| } else { | |
| context.setBaseAndExtent(this.wb(), this.Ob(), this.Nb(), this.$b()); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} pane | |
| * @return {?} | |
| */ | |
| var qw = function(pane) { | |
| return Mh ? new hw(pane, Ph(pane.parentElement())) : G ? new pw(pane) : ih ? new gw(pane) : fh ? new ow(pane) : new cw(pane); | |
| }; | |
| /** | |
| * @param {number} m | |
| * @return {?} | |
| */ | |
| var nw = function(m) { | |
| if (E && !yh(9)) { | |
| var o = new hw(iw(m), Ph(m)); | |
| if (dw(m)) { | |
| var b; | |
| /** @type {number} */ | |
| var d = m; | |
| for (; (b = d.firstChild) && dw(b);) { | |
| d = b; | |
| } | |
| o.b = d; | |
| /** @type {number} */ | |
| o.g = 0; | |
| /** @type {number} */ | |
| d = m; | |
| for (; (b = d.lastChild) && dw(b);) { | |
| d = b; | |
| } | |
| o.c = d; | |
| o.j = 1 == d.nodeType ? d.childNodes.length : d.length; | |
| /** @type {number} */ | |
| o.m = m; | |
| } else { | |
| o.b = o.c = o.m = m.parentNode; | |
| o.g = wf(o.m.childNodes, m); | |
| o.j = o.g + 1; | |
| } | |
| m = o; | |
| } else { | |
| m = G ? new pw(ew(m)) : ih ? new gw(ew(m)) : fh ? new ow(ew(m)) : new cw(ew(m)); | |
| } | |
| return m; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var dw = function(options) { | |
| return hi(options) || 3 == options.nodeType; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var rw = function() { | |
| /** @type {null} */ | |
| this.a = this.c = this.g = this.b = this.j = null; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| }; | |
| C(rw, Tv); | |
| /** | |
| * @param {number} event | |
| * @param {string} buffer | |
| * @return {?} | |
| */ | |
| var sw = function(event, buffer) { | |
| var me = new rw; | |
| /** @type {number} */ | |
| me.j = event; | |
| /** @type {boolean} */ | |
| me.m = !!buffer; | |
| return me; | |
| }; | |
| y = rw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| var c = new rw; | |
| c.j = this.j && this.j.clone(); | |
| c.b = this.b; | |
| c.g = this.g; | |
| c.c = this.c; | |
| c.a = this.a; | |
| c.m = this.m; | |
| return c; | |
| }; | |
| y.Ua = x("text"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.df = function() { | |
| return tw(this).dd(); | |
| }; | |
| y.ed = x(1); | |
| /** | |
| * @return {?} | |
| */ | |
| y.Jc = function() { | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var tw = function(s) { | |
| var q; | |
| if (!(q = s.j)) { | |
| q = s.fb(); | |
| var p = s.gb(); | |
| var k = s.ub(); | |
| var instance = s.vb(); | |
| if (E && !yh(9)) { | |
| var r = q; | |
| var c = p; | |
| var a = k; | |
| var b = instance; | |
| /** @type {boolean} */ | |
| var pos = false; | |
| if (1 == r.nodeType) { | |
| c = r.childNodes[c]; | |
| /** @type {boolean} */ | |
| pos = !c; | |
| r = c || r.lastChild || r; | |
| /** @type {number} */ | |
| c = 0; | |
| } | |
| var range = iw(r); | |
| if (c) { | |
| range.move(Za, c); | |
| } | |
| if (r == a && c == b) { | |
| range.collapse(true); | |
| } else { | |
| if (pos) { | |
| range.collapse(false); | |
| } | |
| /** @type {boolean} */ | |
| pos = false; | |
| if (1 == a.nodeType) { | |
| a = (c = a.childNodes[b]) || a.lastChild || a; | |
| /** @type {number} */ | |
| b = 0; | |
| /** @type {boolean} */ | |
| pos = !c; | |
| } | |
| r = iw(a); | |
| r.collapse(!pos); | |
| if (b) { | |
| r.moveEnd(Za, b); | |
| } | |
| range.setEndPoint("EndToEnd", r); | |
| } | |
| b = new hw(range, Ph(q)); | |
| b.b = q; | |
| b.g = p; | |
| b.c = k; | |
| b.j = instance; | |
| q = b; | |
| } else { | |
| q = G ? new pw(fw(q, p, k, instance)) : ih ? new gw(fw(q, p, k, instance)) : fh ? new ow(fw(q, p, k, instance)) : new cw(fw(q, p, k, instance)); | |
| } | |
| q = s.j = q; | |
| } | |
| return q; | |
| }; | |
| y = rw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Od = function() { | |
| return tw(this).ef(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.fb = function() { | |
| return this.b || (this.b = tw(this).wb()); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.gb = function() { | |
| return null != this.g ? this.g : this.g = tw(this).Ob(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.ub = function() { | |
| return this.c || (this.c = tw(this).Nb()); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.vb = function() { | |
| return null != this.a ? this.a : this.a = tw(this).$b(); | |
| }; | |
| y.pd = w("m"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.Qd = function() { | |
| return tw(this).xb(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Pd = function() { | |
| return tw(this).xg(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.mb = function() { | |
| return new $v(this.fb(), this.gb(), this.ub(), this.vb()); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.select = function() { | |
| tw(this).select(this.m); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Gf = function() { | |
| return new uw(this); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {undefined} | |
| */ | |
| var uw = function(m) { | |
| Aj.call(this); | |
| if (m.pd()) { | |
| m.ub(); | |
| } else { | |
| m.fb(); | |
| } | |
| if (m.pd()) { | |
| m.vb(); | |
| } else { | |
| m.gb(); | |
| } | |
| Wv(m); | |
| Xv(m); | |
| }; | |
| C(uw, Qv); | |
| /** | |
| * @return {undefined} | |
| */ | |
| uw.prototype.J = function() { | |
| uw.v.J.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var vw = function() { | |
| /** @type {null} */ | |
| this.c = this.b = this.a = null; | |
| }; | |
| C(vw, Zv); | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| var ww = function(key) { | |
| var p = new vw; | |
| /** @type {!Object} */ | |
| p.a = key; | |
| return p; | |
| }; | |
| /** | |
| * @param {?} item | |
| * @return {?} | |
| */ | |
| var xw = function(item) { | |
| var parent = Ph(arguments[0]).body.createControlRange(); | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var argl = arguments.length; | |
| for (; i < argl; i++) { | |
| parent.addElement(arguments[i]); | |
| } | |
| return ww(parent); | |
| }; | |
| y = vw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| return xw.apply(this, yw(this)); | |
| }; | |
| y.Ua = x("control"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.df = function() { | |
| return this.a || document.body.createControlRange(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.ed = function() { | |
| return this.a ? this.a.length : 0; | |
| }; | |
| /** | |
| * @param {number} index | |
| * @return {?} | |
| */ | |
| y.Jc = function(index) { | |
| index = this.a.item(index); | |
| return sw(nw(index), void 0); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Od = function() { | |
| return xi.apply(null, yw(this)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.fb = function() { | |
| return zw(this)[0]; | |
| }; | |
| y.gb = x(0); | |
| /** | |
| * @return {?} | |
| */ | |
| y.ub = function() { | |
| var p = zw(this); | |
| var message = vf(p); | |
| return Df(p, function(a) { | |
| return ti(a, message); | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.vb = function() { | |
| return this.ub().childNodes.length; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var yw = function(a) { | |
| if (!a.b && (a.b = [], a.a)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.a.length; i++) { | |
| a.b.push(a.a.item(i)); | |
| } | |
| } | |
| return a.b; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var zw = function(a) { | |
| if (!a.c) { | |
| a.c = yw(a).concat(); | |
| a.c.sort(function(a, b) { | |
| return a.sourceIndex - b.sourceIndex; | |
| }); | |
| } | |
| return a.c; | |
| }; | |
| y = vw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Qd = function() { | |
| return !this.a || !this.a.length; | |
| }; | |
| y.Pd = x(""); | |
| /** | |
| * @return {?} | |
| */ | |
| y.mb = function() { | |
| return new Aw(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.select = function() { | |
| if (this.a) { | |
| this.a.select(); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Gf = function() { | |
| return new Bw(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Bw = function(a) { | |
| this.a = yw(a); | |
| }; | |
| C(Bw, Qv); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Bw.prototype.J = function() { | |
| Bw.v.J.call(this); | |
| delete this.a; | |
| }; | |
| /** | |
| * @param {!Object} base | |
| * @return {undefined} | |
| */ | |
| var Aw = function(base) { | |
| /** @type {null} */ | |
| this.o = this.c = this.b = null; | |
| if (base) { | |
| this.o = zw(base); | |
| this.b = this.o.shift(); | |
| this.c = vf(this.o) || this.b; | |
| } | |
| Sv.call(this, this.b, false, true); | |
| }; | |
| C(Aw, Yv); | |
| y = Aw.prototype; | |
| y.Td = w("b"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.nd = function() { | |
| return !this.g && !this.o.length; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.next = function() { | |
| if (this.nd()) { | |
| throw Sg; | |
| } | |
| if (!this.g) { | |
| var value = this.o.shift(); | |
| Rv(this, value, 1, 1); | |
| return value; | |
| } | |
| return Aw.v.next.call(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| y.Mb = function(a) { | |
| this.o = a.o; | |
| this.b = a.b; | |
| this.c = a.c; | |
| Aw.v.Mb.call(this, a); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| var clonedRouter = new Aw(null); | |
| clonedRouter.Mb(this); | |
| return clonedRouter; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Cw = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {null} */ | |
| this.c = this.b = null; | |
| }; | |
| C(Cw, Zv); | |
| y = Cw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| var a = this.a; | |
| var r = new Cw; | |
| r.a = Jf(a); | |
| return r; | |
| }; | |
| y.Ua = x("mutli"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.df = function() { | |
| return this.a[0]; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.ed = function() { | |
| return this.a.length; | |
| }; | |
| /** | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| y.Jc = function(key) { | |
| if (!this.g[key]) { | |
| this.g[key] = sw(qw(this.a[key]), void 0); | |
| } | |
| return this.g[key]; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Od = function() { | |
| if (!this.c) { | |
| /** @type {!Array} */ | |
| var searchPipeline = []; | |
| /** @type {number} */ | |
| var j = 0; | |
| var rown = this.ed(); | |
| for (; j < rown; j++) { | |
| searchPipeline.push(this.Jc(j).Od()); | |
| } | |
| this.c = xi.apply(null, searchPipeline); | |
| } | |
| return this.c; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Ew = function(value) { | |
| if (!value.b) { | |
| value.b = Vv(value); | |
| value.b.sort(function(m, res) { | |
| var x = m.fb(); | |
| var nextC = m.gb(); | |
| var r = res.fb(); | |
| var g = res.gb(); | |
| return x == r && nextC == g ? 0 : Dw(x, nextC, r, g) ? 1 : -1; | |
| }); | |
| } | |
| return value.b; | |
| }; | |
| y = Cw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.fb = function() { | |
| return Ew(this)[0].fb(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.gb = function() { | |
| return Ew(this)[0].gb(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.ub = function() { | |
| return vf(Ew(this)).ub(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.vb = function() { | |
| return vf(Ew(this)).vb(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Qd = function() { | |
| return 0 == this.a.length || 1 == this.a.length && this.Jc(0).Qd(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Pd = function() { | |
| return zf(Vv(this), function(global) { | |
| return global.Pd(); | |
| }).join(""); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.mb = function() { | |
| return new Fw(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.select = function() { | |
| var selection = Uv($h(Ph(E ? this.Od() : this.fb()))); | |
| selection.removeAllRanges(); | |
| /** @type {number} */ | |
| var j = 0; | |
| var rown = this.ed(); | |
| for (; j < rown; j++) { | |
| selection.addRange(this.Jc(j).df()); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Gf = function() { | |
| return new Gw(this); | |
| }; | |
| /** | |
| * @param {!Object} tResult | |
| * @return {undefined} | |
| */ | |
| var Gw = function(tResult) { | |
| this.a = zf(Vv(tResult), function(a) { | |
| return a.Gf(); | |
| }); | |
| }; | |
| C(Gw, Qv); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gw.prototype.J = function() { | |
| Gw.v.J.call(this); | |
| xf(this.a, function(a) { | |
| a.za(); | |
| }); | |
| delete this.a; | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| var Fw = function(event) { | |
| /** @type {null} */ | |
| this.B = null; | |
| /** @type {number} */ | |
| this.G = 0; | |
| if (event) { | |
| this.B = zf(Ew(event), function(newModelData) { | |
| return Ug(newModelData); | |
| }); | |
| } | |
| Sv.call(this, event ? this.Td() : null, false, true); | |
| }; | |
| C(Fw, Yv); | |
| y = Fw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Td = function() { | |
| return this.B[0].Td(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.nd = function() { | |
| return this.B[this.G].nd(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.next = function() { | |
| try { | |
| var me = this.B[this.G]; | |
| var nextNote = me.next(); | |
| Rv(this, me.node, me.j, me.g); | |
| return nextNote; | |
| } catch (c) { | |
| if (c !== Sg || this.B.length - 1 == this.G) { | |
| throw c; | |
| } | |
| this.G++; | |
| return this.next(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} col2 | |
| * @return {undefined} | |
| */ | |
| y.Mb = function(col2) { | |
| this.B = Jf(col2.B); | |
| Fw.v.Mb.call(this, col2); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.clone = function() { | |
| var clonedRouter = new Fw(null); | |
| clonedRouter.Mb(this); | |
| return clonedRouter; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Iw = function() { | |
| var el = Uv(window); | |
| return el && Hw(el); | |
| }; | |
| /** | |
| * @param {!Object} sel | |
| * @return {?} | |
| */ | |
| var Hw = function(sel) { | |
| var i; | |
| /** @type {boolean} */ | |
| var c = false; | |
| if (sel.createRange) { | |
| try { | |
| i = sel.createRange(); | |
| } catch (e) { | |
| return null; | |
| } | |
| } else { | |
| if (sel.rangeCount) { | |
| if (1 < sel.rangeCount) { | |
| c = new Cw; | |
| /** @type {number} */ | |
| i = 0; | |
| var len = sel.rangeCount; | |
| for (; i < len; i++) { | |
| c.a.push(sel.getRangeAt(i)); | |
| } | |
| return c; | |
| } | |
| i = sel.getRangeAt(0); | |
| c = Dw(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset); | |
| } else { | |
| return null; | |
| } | |
| } | |
| return (sel = i) && sel.addElement ? ww(sel) : sw(qw(sel), c); | |
| }; | |
| /** | |
| * @param {?} module | |
| * @return {?} | |
| */ | |
| var Jw = function(module) { | |
| return sw(nw(module), void 0); | |
| }; | |
| /** | |
| * @param {!HTMLElement} a | |
| * @param {number} c | |
| * @param {!HTMLElement} v | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Dw = function(a, c, v, i) { | |
| if (a == v) { | |
| return i < c; | |
| } | |
| var t; | |
| if (1 == a.nodeType && c) { | |
| if (t = a.childNodes[c]) { | |
| a = t; | |
| /** @type {number} */ | |
| c = 0; | |
| } else { | |
| if (ti(a, v)) { | |
| return true; | |
| } | |
| } | |
| } | |
| if (1 == v.nodeType && i) { | |
| if (t = v.childNodes[i]) { | |
| v = t; | |
| /** @type {number} */ | |
| i = 0; | |
| } else { | |
| if (ti(v, a)) { | |
| return false; | |
| } | |
| } | |
| } | |
| return 0 < (wi(a, v) || c - i); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Kw = function(a) { | |
| var ret = a.getBoundingClientRect(); | |
| if (E) { | |
| var v = bj(a); | |
| a = hj(a); | |
| ret.left = v.x; | |
| ret.right = v.x + a.width; | |
| ret.top = v.y; | |
| ret.bottom = v.y + a.height; | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {?} value | |
| * @return {?} | |
| */ | |
| var Lw = function(node, value) { | |
| var element = Qh(node); | |
| /** @type {number} */ | |
| var position = 0; | |
| if (Ge(value)) { | |
| position = value; | |
| } else { | |
| if (E && !I(9)) { | |
| var d = element.a.selection.createRange(); | |
| if (d) { | |
| try { | |
| var range = node.createTextRange(); | |
| var precedingRange = range.duplicate(); | |
| range.moveToBookmark(d.getBookmark()); | |
| precedingRange.setEndPoint("EndToStart", range); | |
| position = precedingRange.text.length; | |
| } catch (q) { | |
| } | |
| } | |
| } else { | |
| position = node.selectionStart; | |
| } | |
| } | |
| /** @type {string} */ | |
| d = "_h#" + Le(node); | |
| var c = element.l(d); | |
| if (c) { | |
| element.Rd(c); | |
| } else { | |
| c = element.b("PRE", { | |
| id : d | |
| }); | |
| } | |
| if (!c.parentNode) { | |
| element.a.body.appendChild(c); | |
| } | |
| /** @type {!Array} */ | |
| var m = []; | |
| xf(node.value, function(to, i, l) { | |
| m.push(" " == to && i + 1 != l.length && " " == l[i + 1] ? "\u00a0" : to); | |
| }); | |
| /** @type {string} */ | |
| m = m.join(""); | |
| element.appendChild(c, element.a.createTextNode(String(m.substring(0, position)))); | |
| d = Ji(element, za); | |
| d.appendChild(element.a.createTextNode("\u200b")); | |
| element.appendChild(c, d); | |
| element.appendChild(c, element.a.createTextNode(String(m.substring(position) + " "))); | |
| element = Ah(node); | |
| xf(element, function(b) { | |
| J(c, b); | |
| }); | |
| /** @type {string} */ | |
| var divStyle = "white-space:pre-wrap;word-wrap:pre-wrap;position:absolute;z-index:-9;visibility:hidden;display:block;"; | |
| xf(["font-family", "font-size", "font-weight", "font-style", "text-transform", "text-decoration", "letter-spacing", "word-spacing", "line-height", "text-align", "vertical-align", nb, "width", "height", Tc, Sc, "margin-bottom", "margin-left", "padding-top", "padding-right", "padding-bottom", "padding-left", "border-top-width", "border-right-width", "border-bottom-width", "border-left-width", "border-top-style", "border-right-style", "border-bottom-style", "border-left-style", "overflow-x", "overflow-y"], | |
| function(prop) { | |
| try { | |
| var subprop; | |
| if (subprop = Ti(node, prop) || (node.currentStyle ? node.currentStyle[prop] : null) || node.style[prop]) { | |
| divStyle = divStyle + (prop + ":" + subprop + ";"); | |
| } | |
| } catch (d) { | |
| } | |
| }); | |
| c.style.cssText = divStyle; | |
| element = Ui(node, "overflowX"); | |
| c.style.overflowX = element && element != me ? element : Qa; | |
| element = Ui(node, "overflowY"); | |
| c.style.overflowY = element && element != me ? element : Qa; | |
| c.scrollTop = node.scrollTop; | |
| c.scrollLeft = node.scrollLeft; | |
| Wi(c, $i(node)); | |
| element = Kw(d); | |
| return node.tagName.toUpperCase() == ta ? new L(element.left, Math.ceil(bj(node).y + hj(node).height)) : new L(element.left, Math.ceil(element.bottom)); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {?} dist | |
| * @return {undefined} | |
| */ | |
| var Mw = function(b, dist) { | |
| W.call(this, dist); | |
| /** @type {number} */ | |
| this.j = b; | |
| }; | |
| C(Mw, W); | |
| /** @type {string} */ | |
| Mw.prototype.c = "info"; | |
| /** @type {boolean} */ | |
| Mw.prototype.o = false; | |
| var Nw = { | |
| info : "jfk-butterBar-info", | |
| error : "jfk-butterBar-error", | |
| warning : "jfk-butterBar-warning", | |
| promo : "jfk-butterBar-promo" | |
| }; | |
| Mw.prototype.Ua = w("c"); | |
| /** | |
| * @param {!Object} me | |
| * @param {number} config | |
| * @return {undefined} | |
| */ | |
| var Ow = function(me, config) { | |
| /** @type {number} */ | |
| me.j = config; | |
| var c = me.l(); | |
| if (c) { | |
| var map = me.a; | |
| map.Rd(c); | |
| map.rg(c, me.j); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Mw.prototype.isVisible = function() { | |
| var b = this.l(); | |
| return null != b && Bh(b, zc); | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| Mw.prototype.setVisible = function(id) { | |
| Eh(this.l(), zc, id); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mw.prototype.ra = function() { | |
| this.D = this.a.b(qb, "jfk-butterBar"); | |
| var c = this.l(); | |
| if (c) { | |
| dn(c, "live", "assertive"); | |
| dn(c, "atomic", ie); | |
| } | |
| Ow(this, this.j); | |
| this.o = this.o; | |
| if (c = this.l()) { | |
| Eh(c, "jfk-butterBar-mini", this.o); | |
| } | |
| c = this.c; | |
| if (this.yb()) { | |
| var document = this.l(); | |
| var b = Nw[c]; | |
| K(document, Nw[this.c]); | |
| J(document, b); | |
| } | |
| this.c = c; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Pw = function(a, b) { | |
| /** @type {number} */ | |
| this.a = a; | |
| this.b = b || null; | |
| }; | |
| Pw.prototype.j = w("a"); | |
| Pw.prototype.X = w("b"); | |
| var Qw = ue(); | |
| C(Qw, hn); | |
| Be(Qw); | |
| y = Qw.prototype; | |
| y.Rb = x("menuitem"); | |
| /** | |
| * @param {!Object} p | |
| * @return {?} | |
| */ | |
| y.Pa = function(p) { | |
| var i = P(za, null, p.j()); | |
| J(i, "gt-is-sg"); | |
| var s = P(k, null, ""); | |
| J(s, p.fc ? "gt-is-ld-top" : "gt-is-ld"); | |
| /** @type {!Array} */ | |
| s = [k, nn(this, p), s]; | |
| var b = P(za); | |
| if (p.N) { | |
| var m = new eo(null, new Vo); | |
| m.aa(b); | |
| J(m.l(), "gt-is-flag"); | |
| Go(m.l(), p.Fc); | |
| m.setVisible(false); | |
| p.m = m; | |
| b.id = m.F(); | |
| } | |
| /** @type {!Array<?>} */ | |
| s = s.concat([i, b]); | |
| if (p.Ec) { | |
| i = P(k, null, p.X()); | |
| s.push(i); | |
| J(i, "gt-is-tr"); | |
| } | |
| i = P.apply(null, s); | |
| i.id = p.F(); | |
| return p.D = i; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| y.Kc = function(data) { | |
| return data.tagName == k; | |
| }; | |
| y.S = x("gt-is-itm"); | |
| /** | |
| * @param {!Object} args | |
| * @param {number} typeName | |
| * @param {boolean} name | |
| * @return {undefined} | |
| */ | |
| y.rc = function(args, typeName, name) { | |
| Qw.v.rc.call(this, args, typeName, name); | |
| if (2 == typeName && args.N && args.m && !args.b) { | |
| args.m.setVisible(name); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} i | |
| * @param {!Object} name | |
| * @param {string} fc | |
| * @param {string} lastFilter | |
| * @param {?} activityIds | |
| * @param {?} entry__3995__auto__ | |
| * @return {undefined} | |
| */ | |
| var Rw = function(a, i, name, fc, lastFilter, activityIds, entry__3995__auto__) { | |
| Qn.call(this, a.j(), activityIds || Qw.M(), entry__3995__auto__); | |
| /** @type {!Object} */ | |
| this.A = a; | |
| this.N = i; | |
| /** @type {!Object} */ | |
| this.Fc = name; | |
| /** @type {string} */ | |
| this.fc = fc; | |
| /** @type {string} */ | |
| this.Ec = lastFilter; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| this.Ba(1, false); | |
| }; | |
| C(Rw, Qn); | |
| /** | |
| * @return {?} | |
| */ | |
| Rw.prototype.j = function() { | |
| return this.A.j(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Rw.prototype.X = function() { | |
| return this.A.X(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| Rw.prototype.Za = function(a) { | |
| if (this.N && ti(this.m.l(), a.target)) { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| this.m.Za(a); | |
| } else { | |
| Rw.v.Za.call(this, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {undefined} | |
| */ | |
| Rw.prototype.ib = function(node) { | |
| if (this.N && ti(this.m.l(), node.target) && this.b) { | |
| this.m.ib(node); | |
| /** @type {boolean} */ | |
| this.b = false; | |
| if (!tn(this, 2)) { | |
| this.m.setVisible(false); | |
| } | |
| } else { | |
| if (this.N) { | |
| xf(Sw(this.K()), function(_) { | |
| if (_.b) { | |
| /** @type {boolean} */ | |
| _.b = false; | |
| Wn(_.m, false); | |
| } | |
| if (_ != this) { | |
| _.m.setVisible(false); | |
| } | |
| }); | |
| } | |
| Rw.v.ib.call(this, node); | |
| } | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Tw = function(b) { | |
| this.b = b || "menu"; | |
| }; | |
| C(Tw, Ct); | |
| Be(Tw); | |
| Tw.prototype.S = x("gt-is"); | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Tw.prototype.g = function(name) { | |
| return pi(name); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| Tw.prototype.a = function(key) { | |
| return key.tagName == k && key.firstChild && key.firstChild.tagName == k ? true : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Tw.prototype.m = function() { | |
| var p = P(k, "gt-is"); | |
| var memory = P(k, "gt-is-ctr"); | |
| p.appendChild(memory); | |
| return p; | |
| }; | |
| /** | |
| * @param {number} header | |
| * @param {?} timeout | |
| * @param {string} p | |
| * @param {!Array} b | |
| * @param {(Array|number|string)} B | |
| * @param {?} k | |
| * @param {?} n | |
| * @param {number} s | |
| * @param {?} other | |
| * @param {!Function} event | |
| * @param {?} t | |
| * @param {?} xgh2 | |
| * @param {?} xgh3 | |
| * @param {!Array} xgh4 | |
| * @param {!Object} xh2 | |
| * @param {?} xh3 | |
| * @param {!Array} X_initial | |
| * @return {undefined} | |
| */ | |
| var Ww = function(header, timeout, p, b, B, k, n, s, other, event, t, xgh2, xgh3, xgh4, xh2, xh3, X_initial) { | |
| /** @type {number} */ | |
| this.w = header; | |
| this.G = timeout; | |
| /** @type {string} */ | |
| this.g = p; | |
| /** @type {!Array} */ | |
| this.m = b; | |
| /** @type {boolean} */ | |
| this.Ca = false; | |
| /** @type {(Array|number|string)} */ | |
| this.B = B; | |
| this.K = k; | |
| this.C = n; | |
| /** @type {number} */ | |
| this.b = s; | |
| this.Z = other; | |
| /** @type {!Function} */ | |
| this.qa = event; | |
| this.H = t; | |
| this.I = xgh2; | |
| this.N = xgh3; | |
| /** @type {number} */ | |
| this.A = 0; | |
| this.o = {}; | |
| /** @type {!Array} */ | |
| this.P = xgh4; | |
| /** @type {!Object} */ | |
| this.$ = xh2; | |
| this.L = xh3; | |
| /** @type {!Array} */ | |
| this.X = X_initial; | |
| header = new Mw(""); | |
| header.aa(M("gt-bbar")); | |
| header.setVisible(false); | |
| /** @type {number} */ | |
| this.O = header; | |
| /** @type {string} */ | |
| this.na = this.c = this.j = ""; | |
| this.F = Wp.M(); | |
| if ("async_translate_onebox" == this.w) { | |
| /** @type {string} */ | |
| this.F.j = "/translate"; | |
| } | |
| this.a = new nk(this); | |
| this.W = new Gn(this.m.l()); | |
| if (this.L) { | |
| Uw(this); | |
| } | |
| header = ag(this.C.a) ? sd : Qc; | |
| Vw(this.g.l(), header); | |
| if ("webapp" == this.w) { | |
| if (this.I) { | |
| J(this.g.l(), "gt-is-tr-on"); | |
| } else { | |
| J(this.g.l(), "gt-is-tr-off"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var Uw = function(data) { | |
| data.a.a(data.W, Hc, data.pi).a(data.m, Ya, data.ri).a(data.m.l(), Va, data.Ra).a(data.g, p, data.Ei).a(data.C, Ld, data.Jg).a(data.C, Wd, data.Jg); | |
| if (null != data.K) { | |
| data.a.a(data.K, Ya, data.ti); | |
| } | |
| }; | |
| y = Ww.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.update = function() { | |
| if (0 == this.j.length) { | |
| this.clear(); | |
| } else { | |
| this.A++; | |
| this.o[this.A] = {}; | |
| this.o[this.A][0] = Pe(); | |
| Xw(this.Z, this.j, this.c, this.na, A(this.ej, this, this.j, this.c, this.na, this.A)); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ti = function() { | |
| if (Pv(this.K)) { | |
| this.clear(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| y.pi = function(a) { | |
| if (!this.g.isVisible()) { | |
| return false; | |
| } | |
| if (27 == a.keyCode) { | |
| var c = Yw(this.G.a); | |
| aq(this.F, this.w, "is", "0", { | |
| q : this.j, | |
| sl : this.c, | |
| tl : this.na, | |
| sn : c.length, | |
| s : c | |
| }); | |
| this.clear(); | |
| } | |
| if (13 == a.keyCode && -1 == this.g.xa) { | |
| this.clear(); | |
| } | |
| if (36 == a.keyCode || 35 == a.keyCode) { | |
| return false; | |
| } | |
| c = this.g.Ka(a); | |
| if (!(38 != a.keyCode && 40 != a.keyCode || -1 == this.g.xa)) { | |
| a = Ot(this.g); | |
| if (this.m.T() != a.j()) { | |
| /** @type {boolean} */ | |
| this.Ca = true; | |
| this.m.b(a.j()); | |
| if (null != this.B) { | |
| this.B.b(""); | |
| } | |
| } | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {string} context | |
| * @return {undefined} | |
| */ | |
| y.ri = function(context) { | |
| if (this.Ca) { | |
| /** @type {boolean} */ | |
| this.Ca = false; | |
| } else { | |
| if (this.K && Pv(this.K)) { | |
| this.clear(); | |
| } else { | |
| cl(A(this.Dj, this, context), 0); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Dj = function() { | |
| var b = -1 != this.m.T().indexOf("\n") ? "" : Zw(this.m.T()); | |
| var value = this.C.a; | |
| var tb = this.C.b; | |
| if (b != this.j || value != this.c || tb != this.na) { | |
| /** @type {boolean} */ | |
| var move = value != this.c; | |
| this.j = b; | |
| this.c = value; | |
| this.na = tb; | |
| this.update(); | |
| if (move) { | |
| b = ag(value) ? sd : Qc; | |
| Vw(this.g.l(), b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Zw = function(b) { | |
| return b.replace(/[ \n\t\r\f,\.\?!]+/g, " ").replace(/^ /, ""); | |
| }; | |
| y = Ww.prototype; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| y.Ei = function(a) { | |
| a = a.target.j(); | |
| var stack = Yw(this.G.a); | |
| /** @type {number} */ | |
| var si = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < stack.length; i++) { | |
| if (stack[i] == a) { | |
| /** @type {number} */ | |
| si = i + 1; | |
| break; | |
| } | |
| } | |
| aq(this.F, this.w, "is", "2", { | |
| q : this.j, | |
| sl : this.c, | |
| tl : this.na, | |
| sn : stack.length, | |
| s : stack, | |
| si : si | |
| }); | |
| this.j = Zw(a); | |
| this.m.b(a); | |
| this.clear(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Jg = function() { | |
| this.clear(); | |
| }; | |
| /** | |
| * @param {undefined} previous | |
| * @param {?} madMid | |
| * @param {?} madEnd | |
| * @param {undefined} from | |
| * @param {string} arrow | |
| * @return {undefined} | |
| */ | |
| y.ej = function(previous, madMid, madEnd, from, arrow) { | |
| this.o[from][1] = Pe(); | |
| if (0 == arrow.length || 0 == this.j.length) { | |
| this.clear(); | |
| } else { | |
| if (this.c != madMid || this.na != madEnd) { | |
| this.clear(); | |
| } else { | |
| if (this.H) { | |
| this.o[from][2] = Pe(); | |
| Er(this.qa, this.c, this.na, this.b, arrow, A(this.fj, this, previous, from, arrow), "is"); | |
| } else { | |
| $w(this, previous, zf(arrow, function(a) { | |
| return new Pw(a); | |
| }), from); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {undefined} $r | |
| * @param {undefined} i | |
| * @param {string} result | |
| * @param {string} results | |
| * @return {undefined} | |
| */ | |
| y.fj = function($r, i, result, results) { | |
| this.o[i][3] = Pe(); | |
| if (result.length == results.length) { | |
| $w(this, $r, zf(result, function(a, resultIndex) { | |
| return new Pw(result[resultIndex], results[resultIndex]); | |
| }), i); | |
| } else { | |
| ax(this); | |
| $w(this, $r, zf(result, function(a) { | |
| return new Pw(a); | |
| }), i); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.clear = function() { | |
| this.g.setVisible(false); | |
| Ql(this.g); | |
| this.G.clear(); | |
| if (null != this.B) { | |
| this.B.b(""); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {number} target | |
| * @param {!Object} data | |
| * @param {number} n | |
| * @return {undefined} | |
| */ | |
| var $w = function(c, target, data, n) { | |
| /** @type {number} */ | |
| var b = c.o[n][1] - c.o[n][0]; | |
| if (c.H) { | |
| /** @type {number} */ | |
| var cell = c.o[n][3] - c.o[n][2]; | |
| } | |
| delete c.o[n]; | |
| if (0 != data.length) { | |
| /** @type {!Object} */ | |
| var v = data; | |
| if (data.length > c.N) { | |
| v = Lf(data, 0, c.N); | |
| } | |
| c.G.clear(); | |
| Kf(c.G.a, v); | |
| data = {}; | |
| if (c.H) { | |
| /** @type {(number|undefined)} */ | |
| data.td = cell; | |
| } | |
| if (c.A > n) { | |
| bx(c, b, target, v, data, false); | |
| } else { | |
| bx(c, b, target, v, data, true); | |
| Ql(c.g); | |
| xf(v, function(a, b) { | |
| var x = new Rw(a, this.P, this.$, 0 == b, this.I); | |
| this.g.Ia(x, true); | |
| /** @type {string} */ | |
| var menuId = "gt-is-si-" + b; | |
| /** @type {string} */ | |
| Hl(x, "gt-is-sg").id = menuId; | |
| }, c); | |
| cx(c, v[0]); | |
| if (!c.X) { | |
| target = Zh(Qh(document).a); | |
| n = Lw(c.m.l(), c.m.T().length); | |
| b = $i(si(c.g.l())); | |
| /** @type {number} */ | |
| n.x = 0; | |
| n.y += target.y; | |
| n.y -= b.y; | |
| Wi(c.g.l(), n); | |
| } | |
| if (c.P) { | |
| dx(c); | |
| } | |
| c.g.setVisible(true); | |
| if (c.I) { | |
| target = ag(c.C.a); | |
| n = ag(c.C.b); | |
| if (target != n) { | |
| ex(c.g, n ? sd : Qc); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} i | |
| * @return {undefined} | |
| */ | |
| var cx = function(a, i) { | |
| if (a.B) { | |
| var file = a.m.T(); | |
| if (0 == i.j().lastIndexOf(file, 0)) { | |
| a.B.b(i.j()); | |
| } else { | |
| a.B.b(file); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var dx = function(d) { | |
| var code = Sw(d.g); | |
| xf(code, function(res) { | |
| if (res.m) { | |
| U(res.m, p, this.U, false, this); | |
| } | |
| }, d); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Ww.prototype.U = function(key) { | |
| var code = Sw(this.g); | |
| xf(code, function(event, canCreateDiscussions) { | |
| if (event.m == key.target) { | |
| var name = P(za, null, (window.MSG_SUGGESTION_FLAGGED || "").replace(aa, event.j())); | |
| var val = P(za, null, " "); | |
| var C = P("A", { | |
| href : "javascript:;" | |
| }, window.MSG_DISMISS || ""); | |
| name = P(k, null, name, val, C); | |
| Ow(this.O, name); | |
| this.O.setVisible(true); | |
| U(C, r, this.wa, false, this); | |
| fx(this, canCreateDiscussions + 1, code); | |
| } | |
| }, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ww.prototype.wa = function() { | |
| this.O.setVisible(false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ww.prototype.Ra = function() { | |
| if (this.g) { | |
| this.g.setVisible(false); | |
| } | |
| if (this.B) { | |
| this.B.b(""); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} src | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| var fx = function(options, src, x) { | |
| x = zf(x, function(val) { | |
| return val.j(); | |
| }); | |
| aq(options.F, options.w, "is", "3", { | |
| q : options.j, | |
| sl : options.c, | |
| tl : options.na, | |
| sn : x.length, | |
| s : x, | |
| si : src | |
| }); | |
| }; | |
| /** | |
| * @param {string} x | |
| * @return {?} | |
| */ | |
| var Yw = function(x) { | |
| return x ? zf(x, function(val) { | |
| return val ? val.j() : ""; | |
| }) : []; | |
| }; | |
| /** | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var gx = function(val) { | |
| if (!val) { | |
| return []; | |
| } | |
| val = zf(val, function(range) { | |
| return range ? range.X() : ""; | |
| }); | |
| return yf(val, function(a) { | |
| return null != a; | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} opts | |
| * @param {string} obj | |
| * @param {number} type | |
| * @param {string} segment | |
| * @param {!Object} data | |
| * @param {string} isKanban | |
| * @return {undefined} | |
| */ | |
| var bx = function(opts, obj, type, segment, data, isKanban) { | |
| segment = Yw(segment); | |
| obj = { | |
| q : type, | |
| sl : opts.c, | |
| tl : opts.na, | |
| sd : obj, | |
| sn : segment.length, | |
| s : segment | |
| }; | |
| var prop; | |
| for (prop in data) { | |
| obj[prop] = data[prop]; | |
| } | |
| aq(opts.F, opts.w, "is", isKanban ? "1" : "7", obj); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var ax = function(c) { | |
| var str = c.G.a; | |
| var s = Yw(str); | |
| str = gx(str); | |
| aq(c.F, c.w, "is", "6", { | |
| q : c.j, | |
| sl : c.c, | |
| tl : c.na, | |
| sn : s.length, | |
| s : s, | |
| tn : str.length, | |
| st : str | |
| }); | |
| }; | |
| /** | |
| * @param {!Array} val | |
| * @param {number} prop | |
| * @param {string} t | |
| * @param {?} xgh2 | |
| * @param {?} xgh3 | |
| * @param {?} xgh4 | |
| * @return {undefined} | |
| */ | |
| var hx = function(val, prop, t, xgh2, xgh3, xgh4) { | |
| /** @type {!Array} */ | |
| this.m = val; | |
| /** @type {number} */ | |
| this.a = prop; | |
| /** @type {string} */ | |
| this.g = t; | |
| this.F = xgh2; | |
| this.O = xgh3; | |
| this.C = xgh4; | |
| /** @type {string} */ | |
| this.b = ""; | |
| this.c = new io(this.K, 300, this); | |
| /** @type {number} */ | |
| this.o = 0; | |
| /** @type {null} */ | |
| this.w = null; | |
| /** @type {boolean} */ | |
| this.B = false; | |
| this.j = Wp.M(); | |
| if (this.g) { | |
| this.w = new lt(this.g); | |
| U(this.w, p, this.A, false, this); | |
| } | |
| U(this.m, Ya, this.G, false, this); | |
| ko(this.c, void 0); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| hx.prototype.G = function(key) { | |
| /** @type {string} */ | |
| var j = ""; | |
| if (key.j) { | |
| j = key.j; | |
| } | |
| if (j == hd) { | |
| this.o++; | |
| cq(this.j, "pc", 1, Ha); | |
| } | |
| ko(this.c, void 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hx.prototype.K = function() { | |
| if (this.a) { | |
| jo(this.c); | |
| var b = We(this.m.T()); | |
| if (b != this.b) { | |
| if (this.C && this.C()) { | |
| ko(this.c, 300); | |
| } else { | |
| if (!(2E3 < Xe(b).length && 0 == this.o)) { | |
| /** @type {number} */ | |
| this.o = 0; | |
| /** @type {boolean} */ | |
| var a = b.substring(0, this.b.length) == this.b; | |
| if ((b = this.b.substring(0, b.length) == b) || 0 != this.b.length && a && !this.B) { | |
| cq(this.j, "otf", "2"); | |
| } else { | |
| cq(this.j, "otf", "1"); | |
| } | |
| /** @type {boolean} */ | |
| this.B = b; | |
| this.O(); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| hx.prototype.reset = function(data) { | |
| jo(this.c); | |
| this.b = We(this.m.T()); | |
| if (!data) { | |
| /** @type {boolean} */ | |
| this.B = false; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| hx.prototype.A = function(type) { | |
| type.preventDefault(); | |
| /** @type {boolean} */ | |
| this.a = !this.a; | |
| if (this.g) { | |
| this.g.innerHTML = this.a ? msg_disable_otf : msg_enable_otf; | |
| } | |
| if (this.F) { | |
| type = this.F; | |
| /** @type {boolean} */ | |
| var next = this.a; | |
| if (next != type.L) { | |
| if (type.L = next) { | |
| Uw(type); | |
| } else { | |
| pk(type.a); | |
| } | |
| } | |
| } | |
| $p(this.j, "/translate/uc?ua=eotf&uav=" + (this.a ? 1 : 0)); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var jx = function(a) { | |
| this.D = a || null; | |
| this.a = P(k, "gt-hl-layer", ei("")); | |
| /** @type {null} */ | |
| this.b = null; | |
| if (this.D) { | |
| ki(this.a, this.D); | |
| ix(this); | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} t | |
| * @param {number} b | |
| * @param {number} a | |
| * @param {string} f | |
| * @param {number} values | |
| * @return {undefined} | |
| */ | |
| var lx = function(t, b, a, f, values) { | |
| var e = f || "gt-hl-text"; | |
| f = t.D && (t.D.value || Fi(t.D)); | |
| ix(t); | |
| ji(t.a); | |
| if (b != a || values) { | |
| if (0 < b) { | |
| var result = f.substring(0, b); | |
| kx(t.a, result, 0, values); | |
| } | |
| if (b < a) { | |
| result = f.substring(b, a); | |
| e = P(za, e); | |
| kx(e, result, b, values); | |
| t.a.appendChild(e); | |
| } | |
| if (a < f.length) { | |
| result = f.substring(a); | |
| kx(t.a, result, a, values); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} options | |
| * @return {undefined} | |
| */ | |
| var ix = function(options) { | |
| var node; | |
| var p = options.D; | |
| var data = Ph(p); | |
| if ((node = E && p.currentStyle) && Wh(Qh(data).a) && node.width != Qa && node.height != Qa && !node.boxSizing) { | |
| data = rj(p, node.width, "width", "pixelWidth"); | |
| p = rj(p, node.height, "height", "pixelHeight"); | |
| node = new Gh(data, p); | |
| } else { | |
| node = new Gh(p.offsetWidth, p.offsetHeight); | |
| data = uj(p); | |
| p = xj(p); | |
| node = new Gh(node.width - p.left - data.left - data.right - p.right, node.height - p.top - data.top - data.bottom - p.bottom); | |
| } | |
| p = options.a; | |
| data = Ph(p); | |
| var e = Wh(Qh(data).a); | |
| if (!E || I("10") || e && I("8")) { | |
| qj(p, node, "content-box"); | |
| } else { | |
| data = p.style; | |
| if (e) { | |
| data.pixelWidth = node.width; | |
| data.pixelHeight = node.height; | |
| } else { | |
| e = uj(p); | |
| p = xj(p); | |
| data.pixelWidth = node.width + p.left + e.left + e.right + p.right; | |
| data.pixelHeight = node.height + p.top + e.top + e.bottom + p.bottom; | |
| } | |
| } | |
| p = $i(options.D); | |
| ej(options.a, p.x, p.y); | |
| p = uj(options.D); | |
| R(options.a, fd, p.left + md); | |
| R(options.a, gd, p.right + md); | |
| options.a.dir = options.D.dir; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {string} text | |
| * @param {number} i | |
| * @param {number} options | |
| * @return {undefined} | |
| */ | |
| var kx = function(d, text, i, options) { | |
| options = options || []; | |
| /** @type {number} */ | |
| var name = 0; | |
| var opt; | |
| for (; opt = options[name]; name++) { | |
| if (!(0 > opt.cd - i)) { | |
| if (opt.cd - i >= text.length) { | |
| break; | |
| } | |
| if (0 < opt.cd - i) { | |
| var max = text.substring(0, opt.cd - i); | |
| mx(d, max); | |
| } | |
| var val = opt.className || "gt-hl-text"; | |
| max = text.substring(opt.cd - i, opt.Pf - i); | |
| val = P(za, val); | |
| mx(val, max); | |
| d.appendChild(val); | |
| text = text.substring(opt.Pf - i); | |
| i = opt.Pf; | |
| } | |
| } | |
| if (text) { | |
| mx(d, text); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var mx = function(data, value) { | |
| var readOnlyElements = Ue(value).split("\n"); | |
| /** @type {number} */ | |
| var j = 0; | |
| var m = readOnlyElements.length; | |
| for (; j < m; j++) { | |
| if (0 < j) { | |
| var text = P("BR"); | |
| data.appendChild(text); | |
| } | |
| data.appendChild(ei(readOnlyElements[j])); | |
| } | |
| }; | |
| /** | |
| * @param {string} data | |
| * @param {(!Function|RegExp|string)} options | |
| * @return {undefined} | |
| */ | |
| var nx = function(data, options) { | |
| this.b = data instanceof L ? data : new L(data, options); | |
| }; | |
| C(nx, so); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} data | |
| * @param {string} code | |
| * @return {undefined} | |
| */ | |
| nx.prototype.a = function(name, type, data, code) { | |
| var b; | |
| b = Ph(name); | |
| var r = b.body; | |
| b = b.documentElement; | |
| b = new L(r.scrollLeft || b.scrollLeft, r.scrollTop || b.scrollTop); | |
| r = this.b.x + b.x; | |
| b = this.b.y + b.y; | |
| var item = oo(name); | |
| /** @type {number} */ | |
| r = r - item.x; | |
| /** @type {number} */ | |
| b = b - item.y; | |
| qo(new L(r, b), name, type, data, null, null, code); | |
| }; | |
| /** | |
| * @param {?} expr | |
| * @param {?} context | |
| * @return {undefined} | |
| */ | |
| var ox = function(expr, context) { | |
| nx.call(this, expr, context); | |
| }; | |
| C(ox, nx); | |
| /** @type {number} */ | |
| ox.prototype.g = 0; | |
| ox.prototype.c = ve("g"); | |
| /** | |
| * @param {string} name | |
| * @param {number} type | |
| * @param {!Function} c | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| ox.prototype.a = function(name, type, c, val) { | |
| var i = Xi(name); | |
| i = aj(i); | |
| var d = Yh(Qh(name).a); | |
| d = new L(this.b.x + d.scrollLeft, this.b.y + d.scrollTop); | |
| /** @type {number} */ | |
| var idx = type; | |
| var ret = qo(d, name, idx, c, i, 10, val); | |
| if (0 != (ret & 496)) { | |
| if (ret & 16 || ret & 32) { | |
| /** @type {number} */ | |
| idx = idx ^ 4; | |
| } | |
| if (ret & 64 || ret & 128) { | |
| /** @type {number} */ | |
| idx = idx ^ 1; | |
| } | |
| ret = qo(d, name, idx, c, i, 10, val); | |
| if (0 != (ret & 496)) { | |
| qo(d, name, type, c, i, this.g, val); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {!Array} n | |
| * @return {undefined} | |
| */ | |
| var px = function(value, n) { | |
| V.call(this); | |
| this.g = new nk(this); | |
| this.ld(value || null); | |
| if (n) { | |
| /** @type {!Array} */ | |
| this.Mc = n; | |
| } | |
| }; | |
| C(px, V); | |
| y = px.prototype; | |
| /** @type {null} */ | |
| y.D = null; | |
| /** @type {boolean} */ | |
| y.Yf = true; | |
| /** @type {null} */ | |
| y.Xf = null; | |
| /** @type {boolean} */ | |
| y.wc = false; | |
| /** @type {number} */ | |
| y.xf = -1; | |
| /** @type {number} */ | |
| y.wf = -1; | |
| /** @type {string} */ | |
| y.Mc = Yd; | |
| y.Ua = w("Mc"); | |
| y.l = w("D"); | |
| /** | |
| * @param {?} object | |
| * @return {undefined} | |
| */ | |
| y.ld = function(object) { | |
| qx(this); | |
| this.D = object; | |
| }; | |
| /** | |
| * @param {boolean} autoHide | |
| * @return {undefined} | |
| */ | |
| y.setAutoHide = function(autoHide) { | |
| qx(this); | |
| /** @type {boolean} */ | |
| this.Yf = autoHide; | |
| }; | |
| /** | |
| * @param {?} context | |
| * @return {undefined} | |
| */ | |
| var qx = function(context) { | |
| if (context.wc) { | |
| throw Error("Can not change this state of the popup while showing."); | |
| } | |
| }; | |
| px.prototype.isVisible = w("wc"); | |
| /** | |
| * @param {?} text | |
| * @return {?} | |
| */ | |
| var rx = function(text) { | |
| return text.wc || 150 > Pe() - text.wf; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| px.prototype.setVisible = function(a) { | |
| if (this.B) { | |
| this.B.Eb(); | |
| } | |
| if (this.o) { | |
| this.o.Eb(); | |
| } | |
| if (a) { | |
| if (!this.wc && this.Cf()) { | |
| if (!this.D) { | |
| throw Error("Caller must call setElement before trying to show the popup"); | |
| } | |
| this.w(); | |
| a = Ph(this.D); | |
| if (this.Yf) { | |
| if (this.g.a(a, Vc, this.Yg, true), E) { | |
| var d; | |
| try { | |
| d = a.activeElement; | |
| } catch (d) { | |
| } | |
| for (; d && "IFRAME" == d.nodeName;) { | |
| try { | |
| var b = yi(d); | |
| } catch (d) { | |
| break; | |
| } | |
| a = b; | |
| d = a.activeElement; | |
| } | |
| this.g.a(a, Vc, this.Yg, true); | |
| this.g.a(a, "deactivate", this.Xg); | |
| } else { | |
| this.g.a(a, Va, this.Xg); | |
| } | |
| } | |
| if (this.Mc == Yd) { | |
| this.D.style.visibility = me; | |
| S(this.D, true); | |
| } else { | |
| if (this.Mc == $c) { | |
| this.w(); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| this.wc = true; | |
| this.xf = Pe(); | |
| /** @type {number} */ | |
| this.wf = -1; | |
| if (this.B) { | |
| gk(this.B, ub, this.Cg, false, this); | |
| this.B.play(); | |
| } else { | |
| this.Cg(); | |
| } | |
| } | |
| } else { | |
| sx(this); | |
| } | |
| }; | |
| px.prototype.w = Ae; | |
| /** | |
| * @param {!Object} c | |
| * @param {(Object|string)} t | |
| * @return {undefined} | |
| */ | |
| var sx = function(c, t) { | |
| if (c.wc && c.dispatchEvent({ | |
| type : Sa, | |
| target : t | |
| })) { | |
| if (c.g) { | |
| pk(c.g); | |
| } | |
| /** @type {boolean} */ | |
| c.wc = false; | |
| c.wf = Pe(); | |
| if (c.o) { | |
| gk(c.o, ub, Oe(c.fg, t), false, c); | |
| c.o.play(); | |
| } else { | |
| c.fg(t); | |
| } | |
| } | |
| }; | |
| y = px.prototype; | |
| /** | |
| * @param {string} seconds | |
| * @return {undefined} | |
| */ | |
| y.fg = function(seconds) { | |
| if (this.Mc == Yd) { | |
| this.Ii(); | |
| } else { | |
| if (this.Mc == $c) { | |
| /** @type {string} */ | |
| this.D.style.top = "-10000px"; | |
| } | |
| } | |
| this.nf(seconds); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ii = function() { | |
| this.D.style.visibility = oc; | |
| S(this.D, false); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Cf = function() { | |
| return this.dispatchEvent(Ta); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Cg = function() { | |
| this.dispatchEvent(Ad); | |
| }; | |
| /** | |
| * @param {string} n | |
| * @return {undefined} | |
| */ | |
| y.nf = function(n) { | |
| this.dispatchEvent({ | |
| type : pc, | |
| target : n | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| y.Yg = function(data) { | |
| data = data.target; | |
| if (!(ti(this.D, data) || tx(this, data) || 150 > Pe() - this.xf)) { | |
| sx(this, data); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| y.Xg = function(item) { | |
| var element = Ph(this.D); | |
| if ("undefined" != typeof document.activeElement) { | |
| if (item = element.activeElement, !item || ti(this.D, item) || "BODY" == item.tagName) { | |
| return; | |
| } | |
| } else { | |
| if (item.target != element) { | |
| return; | |
| } | |
| } | |
| if (!(150 > Pe() - this.xf)) { | |
| sx(this); | |
| } | |
| }; | |
| /** | |
| * @param {?} res | |
| * @param {!Function} body | |
| * @return {?} | |
| */ | |
| var tx = function(res, body) { | |
| return Af(res.Xf || [], function(target) { | |
| return body === target || ti(target, body); | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| px.prototype.J = function() { | |
| px.v.J.call(this); | |
| this.g.za(); | |
| Bj(this.B); | |
| Bj(this.o); | |
| delete this.D; | |
| delete this.g; | |
| delete this.Xf; | |
| }; | |
| /** | |
| * @param {?} f | |
| * @param {?} o | |
| * @return {undefined} | |
| */ | |
| var ux = function(f, o) { | |
| gu.call(this, f, o); | |
| /** @type {boolean} */ | |
| this.L = true; | |
| Tt(this, true); | |
| this.setVisible(false, true); | |
| this.b = new Wg; | |
| }; | |
| C(ux, gu); | |
| y = ux.prototype; | |
| /** @type {boolean} */ | |
| y.oh = false; | |
| /** @type {number} */ | |
| y.Qg = 0; | |
| /** @type {null} */ | |
| y.Xa = null; | |
| /** | |
| * @param {!Element} d | |
| * @return {undefined} | |
| */ | |
| y.Y = function(d) { | |
| ux.v.Y.call(this, d); | |
| if (d = d.getAttribute("for") || d.htmlFor) { | |
| vx(this, this.a.l(d), 1); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| ux.v.V.call(this); | |
| this.b.forEach(this.Cd, this); | |
| var math = X(this); | |
| math.a(this, p, this.Bf); | |
| math.a(this.a.a, Vc, this.va, true); | |
| if (G) { | |
| math.a(this.a.a, eb, this.va, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {!Object} opts | |
| * @param {number} p | |
| * @param {number} id | |
| * @param {number} o | |
| * @param {undefined} r | |
| * @return {undefined} | |
| */ | |
| var vx = function(data, opts, p, id, o, r) { | |
| if (!(opts && Zg(data.b, Le(opts)))) { | |
| p = data.Ye(opts, p, id, o, r); | |
| if (data.sa) { | |
| data.Cd(p); | |
| } | |
| opts = Oe(data.Yi, opts); | |
| if (data.l()) { | |
| X(data).a(data.l(), Ic, opts); | |
| } | |
| } | |
| }; | |
| y = ux.prototype; | |
| /** | |
| * @param {!EventTarget} cid | |
| * @param {!Object} ev | |
| * @return {undefined} | |
| */ | |
| y.Yi = function(cid, ev) { | |
| if (27 == ev.keyCode) { | |
| cid.focus(); | |
| } else { | |
| var m = Nl(this, this.xa); | |
| if (m) { | |
| m = m.l(); | |
| var b = new Ij(ev.b, m); | |
| b.target = m; | |
| if (32 == ev.keyCode || 13 == ev.keyCode) { | |
| if (Mj(m)) { | |
| qk(m, Ic, false, b); | |
| } else { | |
| lk(m, Ic, false, b); | |
| } | |
| } | |
| if (32 == ev.keyCode) { | |
| this.Sb(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @param {number} type | |
| * @param {number} row | |
| * @param {number} vec | |
| * @return {?} | |
| */ | |
| y.Ye = function(a, b, type, row, vec) { | |
| if (!a) { | |
| return null; | |
| } | |
| b = { | |
| D : a, | |
| jh : b, | |
| Oi : type, | |
| mc : row ? eb : Vc, | |
| ue : vec | |
| }; | |
| this.b.set(Le(a), b); | |
| return b; | |
| }; | |
| /** | |
| * @param {number} data | |
| * @return {undefined} | |
| */ | |
| y.Cd = function(data) { | |
| X(this).a(data.D, data.mc, this.we); | |
| if (data.mc != eb) { | |
| X(this).a(data.D, Ic, this.$i); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Jd = function() { | |
| if (this.sa) { | |
| var points = this.b.tb(); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < points.length; i++) { | |
| this.bf(this.b.get(points[i])); | |
| } | |
| } | |
| this.b.clear(); | |
| }; | |
| /** | |
| * @param {?} data | |
| * @return {undefined} | |
| */ | |
| y.bf = function(data) { | |
| X(this).b(data.D, data.mc, this.we); | |
| }; | |
| /** | |
| * @param {?} val | |
| * @param {number} col | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| y.ge = function(val, col, value) { | |
| col = xe(val.jh) ? new ju(val.D, val.jh, true) : new ox(col, value); | |
| if (col.c) { | |
| col.c(5); | |
| } | |
| var data = val.Oi; | |
| value = val.ue; | |
| var _f = val.D; | |
| val = this.isVisible(); | |
| var f; | |
| if (!(f = this.isVisible())) { | |
| /** @type {boolean} */ | |
| f = 150 > Pe() - this.Qg; | |
| } | |
| if (f && this.oh) { | |
| this.Sb(); | |
| } else { | |
| this.Xa = _f || null; | |
| if (this.dispatchEvent(Ta)) { | |
| data = "undefined" != typeof data ? data : 8; | |
| if (!val) { | |
| this.l().style.visibility = oc; | |
| } | |
| S(this.l(), true); | |
| col.a(this.l(), data, value); | |
| if (!val) { | |
| this.l().style.visibility = me; | |
| } | |
| this.Hb(-1); | |
| this.setVisible(true); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Sb = function() { | |
| if (this.isVisible()) { | |
| this.setVisible(false); | |
| if (!this.isVisible()) { | |
| this.Qg = Pe(); | |
| /** @type {null} */ | |
| this.Xa = null; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Bf = function() { | |
| this.Sb(); | |
| }; | |
| /** | |
| * @param {!Object} paths | |
| * @return {undefined} | |
| */ | |
| y.we = function(paths) { | |
| wx(this, paths); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| y.$i = function(key) { | |
| if (!(32 != key.keyCode && 13 != key.keyCode && 40 != key.keyCode)) { | |
| wx(this, key); | |
| } | |
| if (40 == key.keyCode) { | |
| Pt(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var wx = function(self, data) { | |
| var statKeys = self.b.tb(); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < statKeys.length; i++) { | |
| var n = self.b.get(statKeys[i]); | |
| if (n.D == data.a) { | |
| self.ge(n, data.clientX, data.clientY); | |
| data.preventDefault(); | |
| data.stopPropagation(); | |
| break; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| ux.prototype.va = function(key) { | |
| if (this.isVisible() && !hu(this, key.target)) { | |
| this.Sb(); | |
| } | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| ux.prototype.Xd = function(p1__3354_SHARP_) { | |
| ux.v.Xd.call(this, p1__3354_SHARP_); | |
| this.Sb(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ux.prototype.J = function() { | |
| ux.v.J.call(this); | |
| if (this.b) { | |
| this.b.clear(); | |
| delete this.b; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var xx = function() { | |
| V.call(this); | |
| /** @type {number} */ | |
| this.a = 0; | |
| /** @type {null} */ | |
| this.G = this.o = null; | |
| }; | |
| C(xx, V); | |
| /** | |
| * @return {undefined} | |
| */ | |
| xx.prototype.g = function() { | |
| this.b("begin"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xx.prototype.j = function() { | |
| this.b(ub); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| xx.prototype.b = function(name) { | |
| this.dispatchEvent(name); | |
| }; | |
| /** | |
| * @param {!Object} size | |
| * @param {string} keys | |
| * @return {undefined} | |
| */ | |
| var yx = function(size, keys) { | |
| if (!De(keys)) { | |
| /** @type {!Array} */ | |
| keys = [keys]; | |
| } | |
| var extraNonEnglishKeys = zf(keys, function(args) { | |
| return Fe(args) ? args : args.gj + " " + args.duration + "s " + args.timing + " " + args.Gc + "s"; | |
| }); | |
| R(size, fe, extraNonEnglishKeys.join(",")); | |
| }; | |
| var zx = function(require) { | |
| /** @type {boolean} */ | |
| var b = false; | |
| var HeadlessApi; | |
| return function() { | |
| if (!b) { | |
| HeadlessApi = require(); | |
| /** @type {boolean} */ | |
| b = true; | |
| } | |
| return HeadlessApi; | |
| }; | |
| }(function() { | |
| if (E) { | |
| return I("10.0"); | |
| } | |
| /** @type {!Element} */ | |
| var element = document.createElement(k); | |
| /** @type {(null|string)} */ | |
| var name = G ? "-webkit" : ih ? "-moz" : E ? "-ms" : fh ? "-o" : null; | |
| var style = { | |
| transition : dd | |
| }; | |
| if (name) { | |
| style[name + "-transition"] = dd; | |
| } | |
| Nh(element, Og(qb, { | |
| style : style | |
| })); | |
| /** @type {(Node|null)} */ | |
| element = element.firstChild; | |
| name = element.style[tf(fe)]; | |
| return "" != ("undefined" !== typeof name ? name : element.style[Ri(element, fe)] || ""); | |
| }); | |
| /** | |
| * @param {?} object | |
| * @param {(Array|number|string)} normalunits | |
| * @param {?} oktousevalues | |
| * @param {number} value | |
| * @param {string} e | |
| * @return {undefined} | |
| */ | |
| var Ax = function(object, normalunits, oktousevalues, value, e) { | |
| xx.call(this); | |
| this.D = object; | |
| /** @type {(Array|number|string)} */ | |
| this.B = normalunits; | |
| this.C = oktousevalues; | |
| /** @type {number} */ | |
| this.c = value; | |
| this.w = De(e) ? e : [e]; | |
| }; | |
| C(Ax, xx); | |
| y = Ax.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.play = function() { | |
| if (1 == this.a) { | |
| return false; | |
| } | |
| this.g(); | |
| this.b(kd); | |
| this.o = Pe(); | |
| /** @type {number} */ | |
| this.a = 1; | |
| if (zx()) { | |
| return R(this.D, this.C), this.m = cl(this.cj, void 0, this), true; | |
| } | |
| this.ff(false); | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.cj = function() { | |
| hj(this.D); | |
| yx(this.D, this.w); | |
| R(this.D, this.c); | |
| this.m = cl(A(this.ff, this, false), 1E3 * this.B); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Eb = function() { | |
| if (1 == this.a) { | |
| this.ff(true); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| y.ff = function(a) { | |
| R(this.D, fe, ""); | |
| dl(this.m); | |
| R(this.D, this.c); | |
| this.G = Pe(); | |
| /** @type {number} */ | |
| this.a = 0; | |
| if (a) { | |
| this.b("stop"); | |
| } else { | |
| this.b(vb); | |
| } | |
| this.j(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| this.Eb(); | |
| Ax.v.J.call(this); | |
| }; | |
| /** | |
| * @param {!Element} sometotal | |
| * @param {number} value | |
| * @param {string} timing | |
| * @param {number} startOpacity | |
| * @param {number} endOpacity | |
| * @return {?} | |
| */ | |
| var Bx = function(sometotal, value, timing, startOpacity, endOpacity) { | |
| return new Ax(sometotal, value, { | |
| opacity : startOpacity | |
| }, { | |
| opacity : endOpacity | |
| }, { | |
| gj : "opacity", | |
| duration : value, | |
| timing : timing, | |
| Gc : 0 | |
| }); | |
| }; | |
| /** | |
| * @param {string} strings | |
| * @return {undefined} | |
| */ | |
| var Cx = function(strings) { | |
| V.call(this); | |
| /** @type {string} */ | |
| this.D = strings; | |
| strings = E ? yb : Va; | |
| this.a = U(this.D, E ? xb : wb, this, !E); | |
| this.b = U(this.D, strings, this, !E); | |
| }; | |
| C(Cx, V); | |
| /** | |
| * @param {!Object} source | |
| * @return {undefined} | |
| */ | |
| Cx.prototype.handleEvent = function(source) { | |
| var event = new Ij(source.b); | |
| event.type = source.type == xb || source.type == wb ? xb : yb; | |
| this.dispatchEvent(event); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Cx.prototype.J = function() { | |
| Cx.v.J.call(this); | |
| ik(this.a); | |
| ik(this.b); | |
| delete this.D; | |
| }; | |
| /** | |
| * @param {string} data | |
| * @param {(!Function|RegExp|string)} options | |
| * @return {undefined} | |
| */ | |
| var Dx = function(data, options) { | |
| this.b = data instanceof L ? data : new L(data, options); | |
| }; | |
| C(Dx, so); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} data | |
| * @param {string} code | |
| * @return {undefined} | |
| */ | |
| Dx.prototype.a = function(name, type, data, code) { | |
| ro(Xi(name), 0, name, type, this.b, data, null, code); | |
| }; | |
| /** | |
| * @param {?} args | |
| * @param {string} message | |
| * @return {undefined} | |
| */ | |
| var Ex = function(args, message) { | |
| this.H = message || void 0; | |
| px.call(this, args); | |
| }; | |
| C(Ex, px); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ex.prototype.w = function() { | |
| if (this.H) { | |
| /** @type {boolean} */ | |
| var n = !this.isVisible() && this.Ua() != $c; | |
| var a = this.l(); | |
| if (n) { | |
| a.style.visibility = oc; | |
| S(a, true); | |
| } | |
| this.H.a(a, 8, this.ue); | |
| if (n) { | |
| S(a, false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} x | |
| * @param {string} key | |
| * @param {string} cb_wrap | |
| * @return {undefined} | |
| */ | |
| var Gx = function(x, key, cb_wrap) { | |
| this.A = cb_wrap || (x ? Qh(M(x)) : Qh()); | |
| Ex.call(this, this.A.b(k, { | |
| style : "position:absolute;display:none;" | |
| })); | |
| this.P = new L(1, 1); | |
| this.m = new dh; | |
| /** @type {null} */ | |
| this.C = null; | |
| if (x) { | |
| Fx(this, x); | |
| } | |
| if (null != key) { | |
| this.Z(key); | |
| } | |
| }; | |
| C(Gx, Ex); | |
| /** @type {!Array} */ | |
| var Hx = []; | |
| /** @type {null} */ | |
| Gx.prototype.b = null; | |
| /** @type {string} */ | |
| Gx.prototype.className = "goog-tooltip"; | |
| /** @type {number} */ | |
| Gx.prototype.L = 500; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| var Fx = function(f, x) { | |
| var val = x = M(x); | |
| f.m.a.set(ch(val), val); | |
| U(x, Yc, f.X, false, f); | |
| U(x, Xc, f.O, false, f); | |
| U(x, Wc, f.$, false, f); | |
| U(x, wb, f.W, false, f); | |
| U(x, Va, f.O, false, f); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} x | |
| * @return {undefined} | |
| */ | |
| var Jx = function(a, x) { | |
| if (x) { | |
| var c = M(x); | |
| Ix(a, c); | |
| $g(a.m.a, ch(c)); | |
| } else { | |
| var cols = a.m.Va(); | |
| /** @type {number} */ | |
| var iLetter = 0; | |
| for (; c = cols[iLetter]; iLetter++) { | |
| Ix(a, c); | |
| } | |
| a.m.clear(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Ix = function(f, a) { | |
| hk(a, Yc, f.X, false, f); | |
| hk(a, Xc, f.O, false, f); | |
| hk(a, Wc, f.$, false, f); | |
| hk(a, wb, f.W, false, f); | |
| hk(a, Va, f.O, false, f); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.Z = function(name) { | |
| Q(this.l(), name); | |
| }; | |
| /** | |
| * @param {?} flag | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.ld = function(flag) { | |
| var head = this.l(); | |
| if (head) { | |
| mi(head); | |
| } | |
| Gx.v.ld.call(this, flag); | |
| if (flag) { | |
| head = this.A.a.body; | |
| head.insertBefore(flag, head.lastChild); | |
| Bj(this.C); | |
| this.C = new Cx(this.l()); | |
| Cj(this, this.C); | |
| U(this.C, xb, this.G, void 0, this); | |
| U(this.C, yb, this.N, void 0, this); | |
| } else { | |
| Bj(this.C); | |
| /** @type {null} */ | |
| this.C = null; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @return {?} | |
| */ | |
| var Kx = function(t) { | |
| return t.j ? t.isVisible() ? 4 : 1 : t.K ? 3 : t.isVisible() ? 2 : 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gx.prototype.Cf = function() { | |
| if (!px.prototype.Cf.call(this)) { | |
| return false; | |
| } | |
| if (this.a) { | |
| var item; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; item = Hx[i]; i++) { | |
| if (!ti(item.l(), this.a)) { | |
| item.setVisible(false); | |
| } | |
| } | |
| } | |
| Gf(Hx, this); | |
| item = this.l(); | |
| item.className = this.className; | |
| this.G(); | |
| U(item, Yc, this.Ma, false, this); | |
| U(item, Xc, this.qa, false, this); | |
| Lx(this); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.nf = function() { | |
| Hf(Hx, this); | |
| var v = this.l(); | |
| var c; | |
| /** @type {number} */ | |
| var iLetter = 0; | |
| for (; c = Hx[iLetter]; iLetter++) { | |
| if (c.a && ti(v, c.a)) { | |
| c.setVisible(false); | |
| } | |
| } | |
| if (this.Da) { | |
| this.Da.N(); | |
| } | |
| hk(v, Yc, this.Ma, false, this); | |
| hk(v, Xc, this.qa, false, this); | |
| this.a = void 0; | |
| if (0 == Kx(this)) { | |
| /** @type {boolean} */ | |
| this.I = false; | |
| } | |
| px.prototype.nf.call(this); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.va = function(name, type) { | |
| if (this.a == name && this.m.contains(this.a)) { | |
| if (this.I || !this.Ha) { | |
| this.setVisible(false); | |
| if (!this.isVisible()) { | |
| Mx(this, name, type); | |
| } | |
| } else { | |
| this.a = void 0; | |
| } | |
| } | |
| this.j = void 0; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Mx = function(o, a, b) { | |
| /** @type {string} */ | |
| o.a = a; | |
| a = b || o.wa(0); | |
| o.H = a || void 0; | |
| if (o.isVisible()) { | |
| o.w(); | |
| } | |
| o.setVisible(true); | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.Fa = function(type) { | |
| this.K = void 0; | |
| if (type == this.a) { | |
| type = this.A; | |
| var left; | |
| a: { | |
| var t = type.a; | |
| try { | |
| left = t && t.activeElement; | |
| break a; | |
| } catch (d) { | |
| } | |
| /** @type {null} */ | |
| left = null; | |
| } | |
| left = left && this.l() && type.contains(this.l(), left); | |
| if (!(null != this.b && (this.b == this.l() || this.m.contains(this.b)) || left || this.U && this.U.b)) { | |
| this.setVisible(false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} root | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| var Nx = function(root, event) { | |
| var scroll = Zh(root.A.a); | |
| root.P.x = event.clientX + scroll.x; | |
| root.P.y = event.clientY + scroll.y; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.X = function(key) { | |
| var prop = Ox(this, key.target); | |
| this.b = prop; | |
| this.G(); | |
| if (prop != this.a) { | |
| this.a = prop; | |
| if (!this.j) { | |
| this.j = cl(A(this.va, this, prop, void 0), this.L); | |
| } | |
| Px(this); | |
| Nx(this, key); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Ox = function(p, a) { | |
| try { | |
| for (; a && !p.m.contains(a);) { | |
| a = a.parentNode; | |
| } | |
| return a; | |
| } catch (c) { | |
| return null; | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.$ = function(name) { | |
| Nx(this, name); | |
| /** @type {boolean} */ | |
| this.I = true; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.W = function(name) { | |
| this.b = name = Ox(this, name.target); | |
| /** @type {boolean} */ | |
| this.I = true; | |
| if (this.a != name) { | |
| /** @type {string} */ | |
| this.a = name; | |
| var artistTrack = this.wa(1); | |
| this.G(); | |
| if (!this.j) { | |
| this.j = cl(A(this.va, this, name, artistTrack), this.L); | |
| } | |
| Px(this); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Gx.prototype.wa = function(name) { | |
| return 0 == name ? (name = this.P.clone(), new Qx(name)) : new Rx(this.b); | |
| }; | |
| /** | |
| * @param {(number|string)} parent | |
| * @return {undefined} | |
| */ | |
| var Px = function(parent) { | |
| if (parent.a) { | |
| var node; | |
| /** @type {number} */ | |
| var PARENT_NODE = 0; | |
| for (; node = Hx[PARENT_NODE]; PARENT_NODE++) { | |
| if (ti(node.l(), parent.a)) { | |
| /** @type {(number|string)} */ | |
| node.U = parent; | |
| parent.Da = node; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.O = function(key) { | |
| var b = Ox(this, key.target); | |
| var button = Ox(this, key.c); | |
| if (b != button) { | |
| if (b == this.b) { | |
| /** @type {null} */ | |
| this.b = null; | |
| } | |
| Lx(this); | |
| /** @type {boolean} */ | |
| this.I = false; | |
| if (!this.isVisible() || key.c && ti(this.l(), key.c)) { | |
| this.a = void 0; | |
| } else { | |
| this.N(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.Ma = function() { | |
| var l = this.l(); | |
| if (this.b != l) { | |
| this.G(); | |
| this.b = l; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.qa = function(b) { | |
| var a = this.l(); | |
| if (!(this.b != a || b.c && ti(a, b.c))) { | |
| /** @type {null} */ | |
| this.b = null; | |
| this.N(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} drop | |
| * @return {undefined} | |
| */ | |
| var Lx = function(drop) { | |
| if (drop.j) { | |
| dl(drop.j); | |
| drop.j = void 0; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.N = function() { | |
| if (2 == Kx(this)) { | |
| this.K = cl(A(this.Fa, this, this.a), 0); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.G = function() { | |
| if (this.K) { | |
| dl(this.K); | |
| this.K = void 0; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Gx.prototype.J = function() { | |
| this.setVisible(false); | |
| Lx(this); | |
| Jx(this); | |
| if (this.l()) { | |
| mi(this.l()); | |
| } | |
| /** @type {null} */ | |
| this.b = null; | |
| delete this.A; | |
| Gx.v.J.call(this); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var Qx = function(a, b) { | |
| Dx.call(this, a, b); | |
| }; | |
| C(Qx, Dx); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| Qx.prototype.a = function(name, type, a) { | |
| type = Xi(name); | |
| type = aj(type); | |
| a = a ? new Ni(a.top + 10, a.right, a.bottom, a.left + 10) : new Ni(10, 0, 0, 10); | |
| if (qo(this.b, name, 8, a, type, 9) & 496) { | |
| qo(this.b, name, 8, a, type, 5); | |
| } | |
| }; | |
| /** | |
| * @param {?} obj | |
| * @return {undefined} | |
| */ | |
| var Rx = function(obj) { | |
| iu.call(this, obj, 5); | |
| }; | |
| C(Rx, iu); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} a | |
| * @return {undefined} | |
| */ | |
| Rx.prototype.a = function(name, type, a) { | |
| var whichOutputFile = new L(10, 0); | |
| if (ro(this.b, this.g, name, type, whichOutputFile, a, 9) & 496) { | |
| ro(this.b, 4, name, 1, whichOutputFile, a, 5); | |
| } | |
| }; | |
| /** | |
| * @param {number} c | |
| * @param {(Object|string)} a | |
| * @param {?} f | |
| * @param {number} data | |
| * @param {!Object} meta | |
| * @return {undefined} | |
| */ | |
| var Sx = function(c, a, f, data, meta) { | |
| data = data || (a ? Qh(M(a)) : Qh()); | |
| /** @type {number} */ | |
| this.c = c; | |
| data.a.body.appendChild(this.c.l()); | |
| S(this.c.l(), false); | |
| this.className = Co(); | |
| Gx.call(this, a, f, data); | |
| Cj(this, this.c); | |
| this.ld(this.c.l()); | |
| c = Bx(this.c.l(), .13, "ease-out", 0, 1); | |
| a = Bx(this.c.l(), .13, "ease-in", 1, 0); | |
| /** @type {number} */ | |
| this.B = c; | |
| /** @type {(Object|string)} */ | |
| this.o = a; | |
| this.F = new to(Co(), true); | |
| uo(this.F, null != meta ? meta : 1, void 0, -1); | |
| meta = this.F; | |
| c = this.c.c; | |
| meta.c = this.c.l(); | |
| /** @type {number} */ | |
| meta.j = c; | |
| /** @type {boolean} */ | |
| this.F.oe = true; | |
| /** @type {number} */ | |
| this.L = 300; | |
| }; | |
| C(Sx, Gx); | |
| /** | |
| * @return {?} | |
| */ | |
| Sx.prototype.wa = function() { | |
| this.F.b = this.b; | |
| return this.F; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Sx.prototype.Z = function(name) { | |
| Q(this.c.a, name); | |
| }; | |
| /** | |
| * @param {string} S | |
| * @param {?} options | |
| * @param {string} config | |
| * @param {?} d | |
| * @return {undefined} | |
| */ | |
| var Tx = function(S, options, config, d) { | |
| config = config || (S ? Qh(M(S)) : Qh()); | |
| var cn = new Do(config); | |
| Sx.call(this, cn, S, options, config, d); | |
| }; | |
| C(Tx, Sx); | |
| /** | |
| * @param {?} action | |
| * @param {number} canvas | |
| * @return {undefined} | |
| */ | |
| var Ux = function(action, canvas) { | |
| Ex.call(this, action); | |
| /** @type {number} */ | |
| this.c = canvas; | |
| /** @type {number} */ | |
| this.a = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {number} */ | |
| this.j = 0; | |
| this.setVisible(true); | |
| this.setVisible(false); | |
| J(this.l(), "round-trip-popup"); | |
| J(this.c, "round-trip-content"); | |
| }; | |
| C(Ux, Ex); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ux.prototype.F = function() { | |
| dl(this.j); | |
| if (1 == this.a) { | |
| gk(this.b, vb, A(this.F, this)); | |
| } else { | |
| if (0 == this.a) { | |
| this.j = cl(A(this.C, this, -1), 200); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} name | |
| * @return {undefined} | |
| */ | |
| Ux.prototype.C = function(name) { | |
| if (this.a != name && (0 != this.a || !(this.isVisible() && 1 == name || !this.isVisible() && -1 == name))) { | |
| var m = this.isVisible(); | |
| this.setVisible(true); | |
| /** @type {number} */ | |
| var value = -Math.ceil(hj(this.c).width); | |
| if (nj(this.l())) { | |
| /** @type {number} */ | |
| value = -value; | |
| } | |
| /** @type {number} */ | |
| var y = 1 == name ? value : 0; | |
| /** @type {number} */ | |
| value = 1 == name ? 0 : value; | |
| this.setVisible(m); | |
| if (zx()) { | |
| /** @type {number} */ | |
| m = .2; | |
| if (0 != this.a) { | |
| /** @type {number} */ | |
| var x = parseInt(Ti(this.c, Pc), 10); | |
| this.m(); | |
| /** @type {number} */ | |
| m = m * ((value - x) / (value - y)); | |
| /** @type {number} */ | |
| y = x; | |
| } | |
| /** @type {number} */ | |
| this.a = name; | |
| this.b = new Ax(this.c, m, { | |
| left : y + md | |
| }, { | |
| left : value + md | |
| }, "left " + m + "s"); | |
| this.b.play(); | |
| gk(this.b, vb, A(this.m, this)); | |
| if (-1 == name) { | |
| gk(this.b, vb, A(this.setVisible, this, false)); | |
| } else { | |
| this.setVisible(true); | |
| } | |
| } else { | |
| R(this.c, Pc, value + md); | |
| this.setVisible(1 == name ? true : false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ux.prototype.m = function() { | |
| if (0 != this.a) { | |
| this.b.Eb(); | |
| cl(A(jk, this, this.b)); | |
| /** @type {number} */ | |
| this.a = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} direction | |
| * @return {?} | |
| */ | |
| var Xx = function(a, direction) { | |
| /** @type {number} */ | |
| var e = 0; | |
| /** @type {number} */ | |
| var title = 0; | |
| if (Vx(a)) { | |
| e = a.selectionStart; | |
| title = direction ? -1 : a.selectionEnd; | |
| } else { | |
| if (E) { | |
| var value = Wx(a); | |
| var range = value[0]; | |
| value = value[1]; | |
| if (range.inRange(value)) { | |
| range.setEndPoint("EndToStart", value); | |
| if (a.type == Td) { | |
| e = value.duplicate(); | |
| var origText = range.text; | |
| title = origText; | |
| var next = value = e.text; | |
| /** @type {boolean} */ | |
| var m = false; | |
| for (; !m;) { | |
| if (0 == range.compareEndPoints(Ca, range)) { | |
| /** @type {boolean} */ | |
| m = true; | |
| } else { | |
| range.moveEnd(Za, -1); | |
| if (range.text == origText) { | |
| /** @type {string} */ | |
| title = title + "\r\n"; | |
| } else { | |
| /** @type {boolean} */ | |
| m = true; | |
| } | |
| } | |
| } | |
| if (direction) { | |
| /** @type {!Array} */ | |
| range = [title.length, -1]; | |
| } else { | |
| /** @type {boolean} */ | |
| range = false; | |
| for (; !range;) { | |
| if (0 == e.compareEndPoints(Ca, e)) { | |
| /** @type {boolean} */ | |
| range = true; | |
| } else { | |
| e.moveEnd(Za, -1); | |
| if (e.text == value) { | |
| /** @type {string} */ | |
| next = next + "\r\n"; | |
| } else { | |
| /** @type {boolean} */ | |
| range = true; | |
| } | |
| } | |
| } | |
| /** @type {!Array} */ | |
| range = [title.length, title.length + next.length]; | |
| } | |
| return range; | |
| } | |
| e = range.text.length; | |
| if (direction) { | |
| /** @type {number} */ | |
| title = -1; | |
| } else { | |
| title = range.text.length + value.text.length; | |
| } | |
| } | |
| } | |
| } | |
| return [e, title]; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Yx = function(a) { | |
| if (Vx(a)) { | |
| return a.value.substring(a.selectionStart, a.selectionEnd); | |
| } | |
| if (E) { | |
| var c = Wx(a); | |
| var b = c[1]; | |
| if (c[0].inRange(b)) { | |
| if (a.type == Td) { | |
| a = b.duplicate(); | |
| b = c = a.text; | |
| /** @type {boolean} */ | |
| var d = false; | |
| for (; !d;) { | |
| if (0 == a.compareEndPoints(Ca, a)) { | |
| /** @type {boolean} */ | |
| d = true; | |
| } else { | |
| a.moveEnd(Za, -1); | |
| if (a.text == c) { | |
| /** @type {string} */ | |
| b = b + "\r\n"; | |
| } else { | |
| /** @type {boolean} */ | |
| d = true; | |
| } | |
| } | |
| } | |
| a = b; | |
| } else { | |
| a = b.text; | |
| } | |
| } else { | |
| /** @type {string} */ | |
| a = ""; | |
| } | |
| return a; | |
| } | |
| throw Error("Cannot get the selection text"); | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var Wx = function(el) { | |
| var doc = el.ownerDocument || el.document; | |
| var c = doc.selection.createRange(); | |
| if (el.type == Td) { | |
| doc = doc.body.createTextRange(); | |
| doc.moveToElementText(el); | |
| } else { | |
| doc = el.createTextRange(); | |
| } | |
| return [doc, c]; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} n | |
| * @return {?} | |
| */ | |
| var Zx = function(a, n) { | |
| if (a.type == Td) { | |
| n = Ue(a.value.substring(0, n)).length; | |
| } | |
| return n; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Vx = function(b) { | |
| try { | |
| return typeof b.selectionStart == bd; | |
| } catch (b) { | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var $x = function() { | |
| var global = Iw(); | |
| return null != global && !global.Qd() && 0 < global.Pd().length; | |
| }; | |
| /** | |
| * @param {?} widget | |
| * @return {?} | |
| */ | |
| var ay = function(widget) { | |
| Iw(); | |
| Jw(widget).select(); | |
| widget.setAttribute("tabIndex", "-1"); | |
| return true; | |
| }; | |
| /** | |
| * @param {number} pos | |
| * @return {?} | |
| */ | |
| var by = function(pos) { | |
| var c = P(Da, { | |
| id : "hdt" | |
| }); | |
| var range = Zh(document).y; | |
| R(c, { | |
| position : Ga, | |
| top : range + md, | |
| left : "-1000px" | |
| }); | |
| document.body.appendChild(c); | |
| c.focus(); | |
| Q(c, pos); | |
| /** @type {number} */ | |
| pos = 0; | |
| if (Vx(c)) { | |
| /** @type {number} */ | |
| c.selectionStart = pos; | |
| } else { | |
| if (E) { | |
| range = Wx(c); | |
| var start = range[0]; | |
| if (start.inRange(range[1])) { | |
| pos = Zx(c, pos); | |
| start.collapse(true); | |
| start.move(Za, pos); | |
| start.select(); | |
| } | |
| } | |
| } | |
| pos = c.value.length; | |
| if (Vx(c)) { | |
| /** @type {number} */ | |
| c.selectionEnd = pos; | |
| } else { | |
| if (E) { | |
| start = Wx(c); | |
| range = start[1]; | |
| if (start[0].inRange(range)) { | |
| pos = Zx(c, pos); | |
| start = Zx(c, Xx(c, true)[0]); | |
| range.collapse(true); | |
| range.moveEnd(Za, pos - start); | |
| range.select(); | |
| } | |
| } | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {string} y | |
| * @param {?} w | |
| * @param {?} i | |
| * @return {undefined} | |
| */ | |
| var cy = function(y, w, i) { | |
| ux.call(this, w, i); | |
| this.w = new Wg; | |
| this.g = y || 5; | |
| /** @type {null} */ | |
| this.A = null; | |
| /** @type {boolean} */ | |
| this.H = false; | |
| /** @type {!Array} */ | |
| this.m = Array(this.g); | |
| /** @type {!Array} */ | |
| this.P = Array(this.g); | |
| this.I = Wp.M(); | |
| /** @type {null} */ | |
| this.U = this.o = this.j = null; | |
| /** @type {boolean} */ | |
| this.oh = true; | |
| }; | |
| C(cy, ux); | |
| /** @type {string} */ | |
| var dy = ""; | |
| /** @type {string} */ | |
| var ey = ""; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cy.prototype.ra = function() { | |
| cy.v.ra.call(this); | |
| /** @type {number} */ | |
| var a = 0; | |
| for (; a < this.g; ++a) { | |
| this.Ia(new bu(""), true); | |
| } | |
| if ("" != ey) { | |
| this.o = new bu(ey); | |
| Tn(this.o, "gt-edit-menuitem"); | |
| this.Ia(this.o, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| cy.prototype.aa = function(key) { | |
| cy.v.aa.call(this, key); | |
| J(this.l(), "alt-menu"); | |
| }; | |
| /** | |
| * @param {!Object} dt | |
| * @return {undefined} | |
| */ | |
| cy.prototype.Jf = function(dt) { | |
| dt = this.w.get(Le(dt)); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < tm(dt) && i < this.g; ++i) { | |
| var o = Nl(this, i); | |
| o.g(wm(um(dt, i))); | |
| /** @type {number} */ | |
| o.wa = i; | |
| o.setVisible(true, true); | |
| } | |
| for (; i < this.g; ++i) { | |
| Nl(this, i).setVisible(false); | |
| } | |
| if (this.o) { | |
| this.o.setVisible(true, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Window} y | |
| * @param {!Object} c | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| var fy = function(y, c, text) { | |
| y.w.set(Le(c), text); | |
| vx(y, c, 9, 8, false, new Ni(-2, 1, -2, 1)); | |
| }; | |
| y = cy.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Jd = function() { | |
| cy.v.Jd.call(this); | |
| if (null != this.j) { | |
| Jx(this.j); | |
| } | |
| this.w.clear(); | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @param {boolean} x | |
| * @return {?} | |
| */ | |
| y.setVisible = function(v, x) { | |
| var ret = this.Xa; | |
| this.U = ret; | |
| if (v && null != ret) { | |
| gy(this, ret); | |
| this.I.c("altshow", 2E3, 1, Ha); | |
| } else { | |
| if (null != this.A) { | |
| lx(this.A, 0, 0); | |
| } | |
| } | |
| if (null != ret) { | |
| if (v) { | |
| this.Ze(ret); | |
| } else { | |
| this.We(ret); | |
| } | |
| } | |
| ret = cy.v.setVisible.call(this, v, x); | |
| if (v && null != this.l()) { | |
| pj(this.l(), false); | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Na = function() { | |
| if (null != this.U) { | |
| var a = Fi(this.U); | |
| if (null != a) { | |
| return a; | |
| } | |
| } | |
| return ""; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Sb = function() { | |
| cy.v.Sb.call(this); | |
| if (this.H) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.m.length; i++) { | |
| var c = this.m[i]; | |
| dl(c.j); | |
| c.m(); | |
| c.C(-1); | |
| c.m(); | |
| c.setVisible(false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| y.Ze = function(s) { | |
| J(s, "trans-target"); | |
| if (null === this.j) { | |
| /** @type {string} */ | |
| s.title = ""; | |
| } else { | |
| Jx(this.j, s); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| y.We = function(a) { | |
| K(a, "trans-target"); | |
| if (null === this.j) { | |
| a.title = dy; | |
| } else { | |
| Fx(this.j, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| y.Ka = function(event) { | |
| if (event.shiftKey || event.ctrlKey || event.altKey || 36 == event.keyCode || 35 == event.keyCode) { | |
| return false; | |
| } | |
| var continueOn = cy.v.Ka.call(this, event); | |
| if (!continueOn && (37 == event.keyCode || 39 == event.keyCode)) { | |
| var id = nj(this.Xa.parentNode.parentNode); | |
| /** @type {null} */ | |
| var element = null; | |
| if (!id && 37 == event.keyCode || id && 39 == event.keyCode) { | |
| /** @type {boolean} */ | |
| element = false; | |
| } | |
| if (!id && 39 == event.keyCode || id && 37 == event.keyCode) { | |
| /** @type {boolean} */ | |
| element = true; | |
| } | |
| if (this.Oe(element) && (id = this.Xa, (id = element ? qi(id) : xe(id.previousElementSibling) ? id.previousElementSibling : oi(id.previousSibling, false)) && id != this.Xa)) { | |
| return this.Sb(), this.bh(element), this.ge(id ? this.b.get(Le(id)) : null, 0, 0), hy(this), event.preventDefault(), event.stopPropagation(), true; | |
| } | |
| } | |
| return continueOn; | |
| }; | |
| /** | |
| * @param {?} val | |
| * @param {number} x | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| y.ge = function(val, x, a) { | |
| if (nj((val.D || this.Xa).parentNode.parentNode)) { | |
| R(this.l(), nb, sd); | |
| } else { | |
| R(this.l(), nb, ""); | |
| } | |
| if (this.H) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.m.length; i++) { | |
| iy(this, i); | |
| Q(this.m[i].c, "..."); | |
| } | |
| } | |
| this.Jf(val.D); | |
| cy.v.ge.call(this, val, x, a); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {?} j | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| var jy = function(t, j, val) { | |
| if (!(!t.H || j >= t.g || "" == val)) { | |
| Q(t.m[j].c, val); | |
| iy(t, j); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {?} i | |
| * @return {undefined} | |
| */ | |
| var iy = function(b, i) { | |
| ro(Nl(b, i).l(), 12, b.m[i].l(), 8, new L(1, 0)); | |
| }; | |
| y = cy.prototype; | |
| /** | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| y.fd = function(i) { | |
| cy.v.fd.call(this, i); | |
| var m = this.Xa; | |
| if (null != m) { | |
| this.I.c("altmenuhl", 2E3, 1, Ha); | |
| gy(this, m); | |
| i = this.Nd(i.target); | |
| if (-1 != i && i != this.g) { | |
| dl(this.P[i]); | |
| this.P[i] = cl(A(this.I.c, this.I, "altmenuhold", 2E3, 1, Ha), 300); | |
| if (this.H) { | |
| m = this.m[i]; | |
| if (nj(this.Xa.parentNode.parentNode)) { | |
| J(m.l(), sd); | |
| R(m.l(), nb, sd); | |
| } else { | |
| K(m.l(), sd); | |
| R(m.l(), nb, ""); | |
| } | |
| iy(this, i); | |
| dl(m.j); | |
| if (0 == m.a) { | |
| m.j = cl(A(m.C, m, 1), 300); | |
| } else { | |
| m.C(1); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| y.gf = function(i) { | |
| cy.v.gf.call(this, i); | |
| i = this.Nd(i.target); | |
| if (-1 != i && i != this.g) { | |
| dl(this.P[i]); | |
| if (this.H) { | |
| this.m[i].F(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} p_dom_object_id | |
| * @return {?} | |
| */ | |
| y.Nd = function(p_dom_object_id) { | |
| return Pl(this, p_dom_object_id); | |
| }; | |
| y.Oe = x(true); | |
| y.bh = ue(); | |
| /** | |
| * @param {!Object} d | |
| * @param {number} t | |
| * @param {number} c | |
| * @param {number} n | |
| * @param {!Object} arr | |
| * @return {?} | |
| */ | |
| y.Ye = function(d, t, c, n, arr) { | |
| if ((d = cy.v.Ye.call(this, d, t, c, n, arr)) && d.mc == Vc) { | |
| d.mc = r; | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {number} data | |
| * @return {undefined} | |
| */ | |
| y.Cd = function(data) { | |
| cy.v.Cd.call(this, data); | |
| X(this).a(data.D, Yc, this.qa); | |
| X(this).a(data.D, Xc, this.N); | |
| X(this).a(data.D, eb, this.Z); | |
| X(this).a(data.D, Wc, this.$); | |
| }; | |
| /** | |
| * @param {?} data | |
| * @return {undefined} | |
| */ | |
| y.bf = function(data) { | |
| cy.v.bf.call(this, data); | |
| X(this).b(data.D, Yc, this.qa); | |
| X(this).b(data.D, Xc, this.N); | |
| X(this).b(data.D, eb, this.Z); | |
| X(this).b(data.D, Wc, this.$); | |
| }; | |
| /** | |
| * @param {!Window} s | |
| * @param {!Function} str | |
| * @return {undefined} | |
| */ | |
| var gy = function(s, str) { | |
| if (null != s.A) { | |
| var m = s.w.get(Le(str)); | |
| if (m) { | |
| var n = s.A; | |
| if (n.b) { | |
| var values = n.D && (n.D.value || Fi(n.D)); | |
| /** @type {number} */ | |
| var reset = -1; | |
| /** @type {number} */ | |
| var update = -1; | |
| /** @type {boolean} */ | |
| var resetOne = false; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < Qm(n.b); i++) { | |
| var p = Rm(n.b, i); | |
| if (0 != tm(p) && (0 == sm(p) && (resetOne = values.indexOf(rm(p), update + 1), 0 <= resetOne ? (reset = resetOne, update = reset + rm(p).length, resetOne = true) : resetOne = false), Rm(n.b, i).a == m.a)) { | |
| if (resetOne) { | |
| /** @type {!Array} */ | |
| values = []; | |
| /** @type {number} */ | |
| update = 0; | |
| for (; update < Y(m.a, 3); ++update) { | |
| values.push({ | |
| cd : reset + zm(vm(m, update)), | |
| Pf : reset + Am(vm(m, update)) | |
| }); | |
| } | |
| lx(n, 0, 0, void 0, values); | |
| } else { | |
| reset = values.indexOf(qm(m)); | |
| if (0 <= reset) { | |
| lx(n, reset, reset + qm(m).length); | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} map | |
| * @param {boolean} isMapClicked | |
| * @return {undefined} | |
| */ | |
| var ky = function(map, isMapClicked) { | |
| if (isMapClicked) { | |
| Vg(map.b.mb(false), function(obj) { | |
| if ("" == this.a.vg(obj.D)) { | |
| J(obj.D, de); | |
| this.a.Sd(obj.D, "_"); | |
| } | |
| return true; | |
| }, map); | |
| } else { | |
| Vg(map.b.mb(false), function(n) { | |
| if (Bh(n.D, de)) { | |
| K(n.D, de); | |
| this.a.Sd(n.D, ""); | |
| } | |
| return true; | |
| }, map); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} b | |
| * @return {undefined} | |
| */ | |
| cy.prototype.qa = function(b) { | |
| if (!$x()) { | |
| J(b.target, ee); | |
| gy(this, b.target); | |
| ky(this, true); | |
| this.I.c("althighlight", 2E3, 1, Ha); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| cy.prototype.N = function(name) { | |
| K(name.target, ee); | |
| if (!(null == this.A || this.isVisible())) { | |
| lx(this.A, 0, 0); | |
| } | |
| ky(this, false); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| cy.prototype.$ = function(name) { | |
| if ($x()) { | |
| this.N(name); | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| cy.prototype.Z = function(key) { | |
| if (!$x()) { | |
| this.N(key); | |
| Jw(key.target).select(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} map | |
| * @return {undefined} | |
| */ | |
| var hy = function(map) { | |
| Vg(map.b.mb(false), function(n) { | |
| K(n.D, ee); | |
| return true; | |
| }, map); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| cy.prototype.Bf = function(c) { | |
| if (c && c.a && c.a.Xa) { | |
| c.o = c.a.Xa; | |
| } | |
| cy.v.Bf.call(this, c); | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| cy.prototype.we = function(p1__3354_SHARP_) { | |
| if ($x()) { | |
| hy(this); | |
| } else { | |
| cy.v.we.call(this, p1__3354_SHARP_); | |
| } | |
| }; | |
| /** | |
| * @param {?} event | |
| * @param {?} i | |
| * @param {?} until | |
| * @return {undefined} | |
| */ | |
| var ly = function(event, i, until) { | |
| cy.call(this, event, i, until); | |
| /** @type {null} */ | |
| this.c = null; | |
| }; | |
| C(ly, cy); | |
| y = ly.prototype; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| y.aa = function(key) { | |
| ly.v.aa.call(this, key); | |
| this.c = new my(""); | |
| this.Ia(this.c, true); | |
| }; | |
| /** | |
| * @param {!Object} title | |
| * @return {undefined} | |
| */ | |
| y.Jf = function(title) { | |
| ly.v.Jf.call(this, title); | |
| this.c.l().firstChild.value = this.a.vg(title); | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @param {boolean} visible | |
| * @return {?} | |
| */ | |
| y.setVisible = function(id, visible) { | |
| var ret = ly.v.setVisible.call(this, id, visible); | |
| if (id && null != this.l()) { | |
| if (!(Jt(this) != this.c.l().firstChild && Jt(this) != this.c.l().firstChild.nextSibling)) { | |
| Xn(this.c, true); | |
| } | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * @param {!Event} cb | |
| * @return {undefined} | |
| */ | |
| y.fd = function(cb) { | |
| ly.v.fd.call(this, cb); | |
| if (cb.target == this.c) { | |
| Mt(this, this.c.l().firstChild); | |
| } else { | |
| Mt(this, this.l()); | |
| } | |
| Jt(this).focus(); | |
| /** @type {number} */ | |
| Jt(this).tabIndex = 0; | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| y.Nd = function(b) { | |
| return b == this.c ? -1 : ly.v.Nd.call(this, b); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| y.Ka = function(key) { | |
| return 9 == key.keyCode ? (tn(this.c, 2) ? (Jt(this) == this.c.l().firstChild ? Mt(this, this.c.l().firstChild.nextSibling) : Mt(this, this.c.l().firstChild), Jt(this).focus(), Jt(this).tabIndex = 0) : Xn(this.c, true), key.preventDefault(), key.stopPropagation(), true) : ly.v.Ka.call(this, key); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Oe = function() { | |
| return null === Ot(this) || !(Ot(this) instanceof my); | |
| }; | |
| /** | |
| * @param {?} group | |
| * @param {?} resource | |
| * @param {?} name | |
| * @return {undefined} | |
| */ | |
| var my = function(group, resource, name) { | |
| Qn.call(this, group, name || ny.M(), resource); | |
| this.Ba(4, false); | |
| }; | |
| C(my, Qn); | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| my.prototype.Za = function(a) { | |
| if (a.target == this.l().firstChild.nextSibling) { | |
| this.dispatchEvent(p); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| my.prototype.V = function() { | |
| my.v.V.call(this); | |
| X(this).a(this.l().firstChild, Ic, function(event) { | |
| if (32 == event.keyCode) { | |
| event.stopPropagation(); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| my.prototype.Na = function() { | |
| return this.l().firstChild.value; | |
| }; | |
| var ny = ue(); | |
| C(ny, hn); | |
| Be(ny); | |
| /** @type {string} */ | |
| var oy = ""; | |
| /** @type {string} */ | |
| var py = ""; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| ny.prototype.Pa = function(a) { | |
| var p = a.a.b(wc, { | |
| value : a.Aa(), | |
| id : "alt-input-text", | |
| type : "text" | |
| }); | |
| var c = a.a.b(wc, { | |
| value : oy, | |
| id : "alt-input-submit", | |
| "class" : py, | |
| type : Xa | |
| }); | |
| return a.a.b(qb, { | |
| id : "alt-input" | |
| }, p, c); | |
| }; | |
| var Rf = {}; | |
| /** @type {null} */ | |
| var qy = null; | |
| /** | |
| * @param {!Object} val | |
| * @return {undefined} | |
| */ | |
| var ry = function(val) { | |
| val = Le(val); | |
| delete Rf[val]; | |
| if (Sf() && qy) { | |
| jo(qy); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var ty = function() { | |
| if (!qy) { | |
| qy = new io(function() { | |
| sy(); | |
| }, 20); | |
| } | |
| var e = qy; | |
| if (!(0 != e.Ga)) { | |
| ko(e); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var sy = function() { | |
| var spyCall = Pe(); | |
| Nf(Rf, function(searchDefinition) { | |
| uy(searchDefinition, spyCall); | |
| }); | |
| if (!Sf()) { | |
| ty(); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @param {number} duration | |
| * @param {?} removeSwitch | |
| * @return {undefined} | |
| */ | |
| var vy = function(a, b, duration, removeSwitch) { | |
| xx.call(this); | |
| if (!De(a) || !De(b)) { | |
| throw Error("Start and end parameters must be arrays"); | |
| } | |
| if (a.length != b.length) { | |
| throw Error("Start and end points must be the same length"); | |
| } | |
| /** @type {string} */ | |
| this.C = a; | |
| /** @type {string} */ | |
| this.H = b; | |
| /** @type {number} */ | |
| this.duration = duration; | |
| this.K = removeSwitch; | |
| /** @type {!Array} */ | |
| this.m = []; | |
| /** @type {number} */ | |
| this.c = 0; | |
| /** @type {null} */ | |
| this.O = null; | |
| }; | |
| C(vy, xx); | |
| /** | |
| * @param {number} o | |
| * @return {?} | |
| */ | |
| vy.prototype.play = function(o) { | |
| if (o || 0 == this.a) { | |
| /** @type {number} */ | |
| this.c = 0; | |
| this.m = this.C; | |
| } else { | |
| if (1 == this.a) { | |
| return false; | |
| } | |
| } | |
| ry(this); | |
| this.o = o = Pe(); | |
| if (-1 == this.a) { | |
| this.o -= this.duration * this.c; | |
| } | |
| this.G = this.o + this.duration; | |
| this.O = this.o; | |
| if (!this.c) { | |
| this.g(); | |
| } | |
| this.b(kd); | |
| if (-1 == this.a) { | |
| this.b("resume"); | |
| } | |
| /** @type {number} */ | |
| this.a = 1; | |
| var indexLookupKey = Le(this); | |
| if (!(indexLookupKey in Rf)) { | |
| Rf[indexLookupKey] = this; | |
| } | |
| ty(); | |
| uy(this, o); | |
| return true; | |
| }; | |
| /** | |
| * @param {boolean} generator | |
| * @return {undefined} | |
| */ | |
| vy.prototype.Eb = function(generator) { | |
| ry(this); | |
| /** @type {number} */ | |
| this.a = 0; | |
| if (generator) { | |
| /** @type {number} */ | |
| this.c = 1; | |
| } | |
| wy(this, this.c); | |
| this.b("stop"); | |
| this.j(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vy.prototype.J = function() { | |
| if (!(0 == this.a)) { | |
| this.Eb(false); | |
| } | |
| this.b("destroy"); | |
| vy.v.J.call(this); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {number} now | |
| * @return {undefined} | |
| */ | |
| var uy = function(d, now) { | |
| /** @type {number} */ | |
| d.c = (now - d.o) / (d.G - d.o); | |
| if (1 <= d.c) { | |
| /** @type {number} */ | |
| d.c = 1; | |
| } | |
| /** @type {number} */ | |
| d.O = now; | |
| wy(d, d.c); | |
| if (1 == d.c) { | |
| /** @type {number} */ | |
| d.a = 0; | |
| ry(d); | |
| d.b(vb); | |
| d.j(); | |
| } else { | |
| if (1 == d.a) { | |
| d.A(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {number} v | |
| * @return {undefined} | |
| */ | |
| var wy = function(o, v) { | |
| if (He(o.K)) { | |
| v = o.K(v); | |
| } | |
| /** @type {!Array} */ | |
| o.m = Array(o.C.length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < o.C.length; i++) { | |
| o.m[i] = (o.H[i] - o.C[i]) * v + o.C[i]; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vy.prototype.A = function() { | |
| this.b("animate"); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| vy.prototype.b = function(name) { | |
| this.dispatchEvent(new xy(name, this)); | |
| }; | |
| /** | |
| * @param {?} x | |
| * @param {!Object} y | |
| * @return {undefined} | |
| */ | |
| var xy = function(x, y) { | |
| T.call(this, x); | |
| this.x = y.m[0]; | |
| this.y = y.m[1]; | |
| this.duration = y.duration; | |
| }; | |
| C(xy, T); | |
| /** | |
| * @param {(Array|number|string)} value | |
| * @param {?} context | |
| * @param {?} d | |
| * @param {?} i | |
| * @param {?} v | |
| * @return {undefined} | |
| */ | |
| var yy = function(value, context, d, i, v) { | |
| vy.call(this, context, d, i, v); | |
| /** @type {(Array|number|string)} */ | |
| this.B = value; | |
| }; | |
| C(yy, vy); | |
| yy.prototype.w = Ae; | |
| /** | |
| * @return {undefined} | |
| */ | |
| yy.prototype.A = function() { | |
| this.w(); | |
| yy.v.A.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| yy.prototype.j = function() { | |
| this.w(); | |
| yy.v.j.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| yy.prototype.g = function() { | |
| this.w(); | |
| yy.v.g.call(this); | |
| }; | |
| /** | |
| * @param {?} params | |
| * @param {!Array} out | |
| * @param {!Array} op | |
| * @param {?} status | |
| * @param {?} etag | |
| * @return {undefined} | |
| */ | |
| var zy = function(params, out, op, status, etag) { | |
| if (Ge(out)) { | |
| /** @type {!Array} */ | |
| out = [out]; | |
| } | |
| if (Ge(op)) { | |
| /** @type {!Array} */ | |
| op = [op]; | |
| } | |
| yy.call(this, params, out, op, status, etag); | |
| if (1 != out.length || 1 != op.length) { | |
| throw Error("Start and end points must be 1D"); | |
| } | |
| /** @type {number} */ | |
| this.F = -1; | |
| }; | |
| C(zy, yy); | |
| /** @type {number} */ | |
| var Ay = 1 / 1024; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zy.prototype.w = function() { | |
| var F = this.m[0]; | |
| if (Math.abs(F - this.F) >= Ay) { | |
| jj(this.B, F); | |
| this.F = F; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zy.prototype.g = function() { | |
| /** @type {number} */ | |
| this.F = -1; | |
| zy.v.g.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zy.prototype.j = function() { | |
| /** @type {number} */ | |
| this.F = -1; | |
| zy.v.j.call(this); | |
| }; | |
| /** | |
| * @param {?} ron | |
| * @param {?} schema | |
| * @param {?} instance | |
| * @return {undefined} | |
| */ | |
| var By = function(ron, schema, instance) { | |
| zy.call(this, ron, 1, 0, schema, instance); | |
| }; | |
| C(By, zy); | |
| /** | |
| * @return {undefined} | |
| */ | |
| By.prototype.g = function() { | |
| /** @type {string} */ | |
| this.B.style.display = ""; | |
| By.v.g.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| By.prototype.j = function() { | |
| this.B.style.display = ad; | |
| By.v.j.call(this); | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @param {?} bodyIdentifier | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var Cy = function(p1__3354_SHARP_, bodyIdentifier, cb) { | |
| zy.call(this, p1__3354_SHARP_, 0, 1, bodyIdentifier, cb); | |
| }; | |
| C(Cy, zy); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Cy.prototype.g = function() { | |
| /** @type {string} */ | |
| this.B.style.display = ""; | |
| Cy.v.g.call(this); | |
| }; | |
| /** | |
| * @param {?} firename | |
| * @param {!NodeList} fn | |
| * @param {!NodeList} data | |
| * @param {?} linkedEntities | |
| * @param {?} force | |
| * @return {undefined} | |
| */ | |
| var Dy = function(firename, fn, data, linkedEntities, force) { | |
| if (3 != fn.length || 3 != data.length) { | |
| throw Error("Start and end points must be 3D"); | |
| } | |
| yy.apply(this, arguments); | |
| }; | |
| C(Dy, yy); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Dy.prototype.w = function() { | |
| /** @type {!Array} */ | |
| var calIds = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.m.length; i++) { | |
| /** @type {number} */ | |
| calIds[i] = Math.round(this.m[i]); | |
| } | |
| /** @type {string} */ | |
| this.B.style.backgroundColor = "rgb(" + calIds.join(",") + ")"; | |
| }; | |
| /** | |
| * @param {?} p | |
| * @param {?} l | |
| * @param {?} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Ey = function(p, l, a, b) { | |
| W.call(this); | |
| /** @type {number} */ | |
| this.b = b; | |
| Wp.M(); | |
| this.c = new Rp(p); | |
| Tp(this.c, 2); | |
| /** @type {null} */ | |
| this.m = null; | |
| this.o = new Rp(l); | |
| /** @type {null} */ | |
| this.j = null; | |
| this.A = a; | |
| /** @type {null} */ | |
| this.w = this.g = null; | |
| }; | |
| C(Ey, W); | |
| y = Ey.prototype; | |
| /** | |
| * @param {boolean} val | |
| * @return {undefined} | |
| */ | |
| y.ba = function(val) { | |
| this.c.ba(val); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| Ey.v.ra.call(this); | |
| this.Y(di(k)); | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| y.Y = function(x) { | |
| Ey.v.Y.call(this, x); | |
| if (null != this.b) { | |
| this.b.R(x); | |
| } | |
| J(x, "st-wrap"); | |
| x.appendChild(ip(Cp, { | |
| Si : this.A | |
| })); | |
| this.g = O("st-stp1", x); | |
| x = M("st-buttons"); | |
| this.c.aa(x); | |
| this.c.Uc(this); | |
| X(this).a(this.c, p, this.ci); | |
| this.o.aa(x); | |
| this.o.Uc(this); | |
| X(this).a(this.o, p, this.Yh); | |
| }; | |
| /** | |
| * @param {undefined} a | |
| * @return {undefined} | |
| */ | |
| y.ci = function(a) { | |
| S(this.g, false); | |
| if (null != this.b) { | |
| this.b.setVisible(true); | |
| } | |
| if (null != this.m) { | |
| this.m(a); | |
| } | |
| }; | |
| /** | |
| * @param {undefined} a | |
| * @return {undefined} | |
| */ | |
| y.Yh = function(a) { | |
| S(this.g, false); | |
| if (null != this.j) { | |
| this.j(a); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.reset = function() { | |
| if (this.w) { | |
| dl(this.w); | |
| } | |
| /** @type {null} */ | |
| this.w = null; | |
| Tp(this.c, 2); | |
| jj(this.l(), 1); | |
| S(this.l(), true); | |
| S(this.g, true); | |
| if (null != this.b) { | |
| this.b.setVisible(false); | |
| } | |
| }; | |
| var Fy = { | |
| ascii_tlds : "AC AD AE AERO AF AG AI AL AM AN AO AQ AR ARPA AS ASIA AT AU AW AX AZ BA BB BD BE BF BG BH BI BIZ BJ BM BN BO BR BS BT BV BW BY BZ CA CAT CC CD CF CG CH CI CK CL CM CN CO COM COOP CR CU CV CX CY CZ DE DJ DK DM DO DZ EC EDU EE EG ER ES ET EU FI FJ FK FM FO FR GA GB GD GE GF GG GH GI GL GM GN GOV GP GQ GR GS GT GU GW GY HK HM HN HR HT HU ID IE IL IM IN INFO INT IO IQ IR IS IT JE JM JO JOBS JP KE KG KH KI KM KN KP KR KW KY KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD ME MG MH MIL MK ML MM MN MO MOBI MP MQ MR MS MT MU MUSEUM MV MW MX MY MZ NA NAME NC NE NET NF NG NI NL NO NP NR NU NZ OM ORG PA PE PF PG PH PK PL PM PN PR PRO PS PT PW PY QA RE RO RS RU RW SA SB SC SD SE SG SH SI SJ SK SL SM SN SO SR ST SU SV SY SZ TC TD TEL TF TG TH TJ TK TL TM TN TO TP TR TRAVEL TT TV TW TZ UA UG UK US UY UZ VA VC VE VG VI VN VU WF WS XN--0ZWM56D XN--11B5BS3A9AJ6G XN--80AKHBYKNJ4F XN--9T4B11YI5A XN--DEBA0AD XN--FIQS8S XN--FIQZ9S XN--FZC2C9E2C XN--G6W251D XN--HGBK6AJ7F53BBA XN--HLCJ6AYA9ESC7A XN--J6W193G XN--JXALPDLP XN--KGBECHTV XN--KPRW13D XN--KPRY57D XN--MGBAAM7A8H XN--MGBAYH7GPA XN--MGBERP4A5D4AR XN--O3CW4H XN--P1AI XN--PGBS0DH XN--WGBH1C XN--XKC2AL3HYE2A XN--YGBI2AMMX XN--ZCKZAH YE YT ZA ZM ZW".split(" "), | |
| unicode_tlds : "\u6d4b\u8bd5 \u092a\u0930\u0940\u0915\u094d\u0937\u093e \u0438\u0441\u043f\u044b\u0442\u0430\u043d\u0438\u0435 \ud14c\uc2a4\ud2b8 \u05d8\u05e2\u05e1\u05d8 \u4e2d\u56fd \u4e2d\u570b \u0dbd\u0d82\u0d9a\u0dcf \u6e2c\u8a66 \u0622\u0632\u0645\u0627\u06cc\u0634\u06cc \u0baa\u0bb0\u0bbf\u0b9f\u0bcd\u0b9a\u0bc8 \u9999\u6e2f \u03b4\u03bf\u03ba\u03b9\u03bc\u03ae \u0625\u062e\u062a\u0628\u0627\u0631 \u53f0\u6e7e \u53f0\u7063 \u0627\u0645\u0627\u0631\u0627\u062a \u0627\u0644\u0627\u0631\u062f\u0646 \u0627\u0644\u0633\u0639\u0648\u062f\u064a\u0629 \u0e44\u0e17\u0e22 \u0440\u0444 \u062a\u0648\u0646\u0633 \u0645\u0635\u0631 \u0b87\u0bb2\u0b99\u0bcd\u0b95\u0bc8 \u0641\u0644\u0633\u0637\u064a\u0646 \u30c6\u30b9\u30c8".split(" ") | |
| }; | |
| var Gy; | |
| var Hy = { | |
| http : 1, | |
| https : 1, | |
| ftp : 1 | |
| }; | |
| /** @type {!RegExp} */ | |
| var Iy = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/; | |
| /** | |
| * @param {string} a | |
| * @param {boolean} be | |
| * @return {?} | |
| */ | |
| var Jy = function(a, be) { | |
| var d; | |
| try { | |
| d = a instanceof Sq ? a.clone() : new Sq(a, void 0); | |
| } catch (n) { | |
| return false; | |
| } | |
| var result; | |
| if (!(result = d.b && !Hy[d.b.toLowerCase()] || !d.c)) { | |
| d = d.c; | |
| var s; | |
| a: { | |
| result = d.split("."); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < result.length; i++) { | |
| if (!result[i]) { | |
| /** @type {boolean} */ | |
| s = false; | |
| break a; | |
| } | |
| } | |
| if (1 < result.length) { | |
| result = result[result.length - 1].toLowerCase(); | |
| if (!Gy) { | |
| try { | |
| s = Fy; | |
| } catch (n) { | |
| throw Error("Variable CFG_twsfe_likelyurl_module_file has not been loaded. This is probaly due the configuration data not being properly included."); | |
| } | |
| i = {}; | |
| var all = s.ascii_tlds; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < all.length; j++) { | |
| var a = all[j]; | |
| /** @type {number} */ | |
| i[a.toLowerCase()] = 1; | |
| } | |
| s = s.unicode_tlds; | |
| /** @type {number} */ | |
| j = 0; | |
| for (; j < s.length; j++) { | |
| a = s[j]; | |
| /** @type {number} */ | |
| i[a.toLowerCase()] = 1; | |
| } | |
| Gy = i; | |
| } | |
| /** @type {boolean} */ | |
| s = !!Gy[result]; | |
| } else { | |
| /** @type {boolean} */ | |
| s = !be; | |
| } | |
| } | |
| if (!s) { | |
| a: { | |
| if (d = d.match(Iy)) { | |
| /** @type {number} */ | |
| s = 1; | |
| for (; 4 >= s; s++) { | |
| if (255 < parseInt(d[s], 10)) { | |
| /** @type {boolean} */ | |
| s = false; | |
| break a; | |
| } | |
| } | |
| /** @type {boolean} */ | |
| s = true; | |
| } else { | |
| /** @type {boolean} */ | |
| s = false; | |
| } | |
| } | |
| } | |
| /** @type {boolean} */ | |
| result = !s; | |
| } | |
| return result ? false : true; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Ky = function(a) { | |
| a = We(a); | |
| return 0 <= a.search(/[\s\xa0@]/) ? false : Jy(a, false) ? true : Jy("http://" + a, true); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Ly = function() { | |
| var a = (new Sq(window.location.href)).a; | |
| var text = a.get("e"); | |
| a = a.get("expid"); | |
| /** @type {string} */ | |
| var errMsg = ""; | |
| if (text) { | |
| /** @type {string} */ | |
| errMsg = errMsg + ("e=" + text); | |
| } | |
| if ("ForceExperiment" == text && a) { | |
| /** @type {string} */ | |
| errMsg = errMsg + ("&expid=" + a); | |
| } | |
| return errMsg; | |
| }; | |
| var My = E || G || fh || gh || false; | |
| if (G) { | |
| I("534.16"); | |
| } | |
| if (E) { | |
| I("7.0"); | |
| } | |
| if (ih) { | |
| I("1.8"); | |
| } | |
| if (!G) { | |
| if (E) { | |
| I("9"); | |
| } | |
| } | |
| if (!(E || gh || fh)) { | |
| if (ih) { | |
| I("1.9"); | |
| } | |
| } | |
| if (!ih) { | |
| if (G) { | |
| I("527"); | |
| } | |
| } | |
| if (!(E || gh)) { | |
| if (G) { | |
| I("525"); | |
| } | |
| } | |
| if (G) { | |
| I("531"); | |
| } | |
| if (G) { | |
| I("528"); | |
| } | |
| if (!(ih && I("1.9") || E || gh || fh)) { | |
| if (G) { | |
| I("531"); | |
| } | |
| } | |
| if (!ih) { | |
| if (G) { | |
| I("526"); | |
| } | |
| } | |
| if (!(zl && jv("4") || Al && I("533") || ih && I("2.0") || E && I("10"))) { | |
| if (fh) { | |
| sf(ig(), "15"); | |
| } | |
| } | |
| if (fh) { | |
| I("11.10"); | |
| } | |
| if (zl) { | |
| jv("12"); | |
| } | |
| /** | |
| * @param {?} event | |
| * @param {?} i | |
| * @param {?} until | |
| * @return {undefined} | |
| */ | |
| var Ny = function(event, i, until) { | |
| /** @type {null} */ | |
| this.X = this.c = null; | |
| cy.call(this, event, i, until); | |
| }; | |
| C(Ny, cy); | |
| y = Ny.prototype; | |
| y.bh = ve("c"); | |
| /** | |
| * @param {boolean} id | |
| * @param {boolean} visible | |
| * @return {?} | |
| */ | |
| y.setVisible = function(id, visible) { | |
| var ret = Ny.v.setVisible.call(this, id, visible); | |
| /** @type {null} */ | |
| this.c = null; | |
| if (id) { | |
| this.X = this.Na(); | |
| } else { | |
| if (null != this.X && this.X != this.Na()) { | |
| this.dispatchEvent(new T(p, this)); | |
| } | |
| } | |
| return ret; | |
| }; | |
| /** | |
| * @param {string} m | |
| * @return {undefined} | |
| */ | |
| y.Ze = function(m) { | |
| Ny.v.Ze.call(this, m); | |
| J(m, "trans-edit"); | |
| /** @type {boolean} */ | |
| m.contentEditable = true; | |
| Mt(this, m); | |
| Jt(this).focus(); | |
| Bi(Jt(this), true); | |
| X(this).a(m, Ic, this.Hg); | |
| X(this).a(m, Xc, this.je); | |
| X(this).a(m, Yc, this.je); | |
| if (null != this.c) { | |
| m = Jw(m); | |
| var v = this.c ? m.gb() : m.vb(); | |
| var c = Wv(m); | |
| m = c; | |
| var value = v; | |
| var f = new rw; | |
| f.m = Dw(m, value, c, v); | |
| if (ri(m) && !hi(m)) { | |
| var n = m.parentNode; | |
| value = wf(n.childNodes, m); | |
| m = n; | |
| } | |
| if (ri(c) && !hi(c)) { | |
| n = c.parentNode; | |
| v = wf(n.childNodes, c); | |
| c = n; | |
| } | |
| if (f.m) { | |
| f.b = c; | |
| f.g = v; | |
| /** @type {string} */ | |
| f.c = m; | |
| f.a = value; | |
| } else { | |
| /** @type {string} */ | |
| f.b = m; | |
| f.g = value; | |
| f.c = c; | |
| f.a = v; | |
| } | |
| f.select(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} parent | |
| * @return {undefined} | |
| */ | |
| y.We = function(parent) { | |
| Ny.v.We.call(this, parent); | |
| K(parent, "trans-edit"); | |
| /** @type {boolean} */ | |
| parent.contentEditable = false; | |
| if (Jt(this)) { | |
| Bi(Jt(this), false); | |
| } | |
| X(this).b(parent, Ic, this.Hg); | |
| X(this).b(parent, Xc, this.je); | |
| X(this).b(parent, Yc, this.je); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.je = function() { | |
| var payload = Iw(); | |
| if (!(null == payload || payload.fb() == payload.ub() && payload.gb() == payload.vb())) { | |
| this.setVisible(payload.fb() == payload.ub()); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {?} | |
| */ | |
| y.Hg = function(event) { | |
| /** @type {number} */ | |
| var NINETY_EIGHT_HOURS = 0; | |
| for (; NINETY_EIGHT_HOURS < this.g; ++NINETY_EIGHT_HOURS) { | |
| Nl(this, NINETY_EIGHT_HOURS).setVisible(false); | |
| } | |
| if (this.o) { | |
| this.o.setVisible(false); | |
| } | |
| if (13 == event.keyCode || 3 == event.keyCode) { | |
| return null === Ot(this) ? (this.Sb(), event.stopPropagation(), event.preventDefault(), true) : false; | |
| } | |
| if (!(null === Ot(this) || !An(event) && 37 != event.keyCode && 39 != event.keyCode)) { | |
| this.Xa.focus(); | |
| this.Hb(Pl(this, null)); | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {string} item | |
| * @return {?} | |
| */ | |
| y.Oe = function(item) { | |
| var m = Iw(); | |
| if (m.fb() == m.ub() && m.gb() == m.vb()) { | |
| var type = Xv(m); | |
| m = Jw(Wv(m)); | |
| if (!item && type == m.gb() || item && type == m.vb()) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {number} s | |
| * @param {(Array|number|string)} b | |
| * @param {number} c | |
| * @param {!Object} version | |
| * @param {!Array} input | |
| * @param {string} scalar | |
| * @return {undefined} | |
| */ | |
| var Oy = function(s, b, c, version, input, scalar) { | |
| /** @type {number} */ | |
| this.b = s; | |
| /** @type {(Array|number|string)} */ | |
| this.B = b; | |
| /** @type {number} */ | |
| this.w = c; | |
| /** @type {!Object} */ | |
| this.C = version; | |
| U(this.b.l(), wb, function() { | |
| J(version, wb); | |
| }); | |
| U(this.b.l(), Va, function() { | |
| K(version, wb); | |
| }); | |
| /** @type {string} */ | |
| this.g = scalar; | |
| if (null != this.g) { | |
| U(this.g, p, this.G, false, this); | |
| } | |
| /** @type {boolean} */ | |
| this.j = false; | |
| /** @type {null} */ | |
| this.a = null; | |
| /** @type {boolean} */ | |
| this.c = false; | |
| /** @type {null} */ | |
| this.o = null; | |
| /** @type {!Array} */ | |
| this.m = input; | |
| /** @type {boolean} */ | |
| this.F = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Oy.prototype.G = function() { | |
| /** @type {boolean} */ | |
| this.c = false; | |
| this.b.b(""); | |
| this.b.l().focus(); | |
| this.g.setVisible(false); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var Py = function(self) { | |
| /** @type {boolean} */ | |
| self.j = false; | |
| K(self.C, "full-edit"); | |
| S(self.w, true); | |
| S(self.B, false); | |
| S(self.m, self.F); | |
| self.b.setVisible(false); | |
| self.b.hc(false); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Oy.prototype.A = function(name) { | |
| /** @type {boolean} */ | |
| this.c = false; | |
| if ("" != this.b.T()) { | |
| this.g.setVisible(true); | |
| if (this.b.T() != this.o) { | |
| /** @type {boolean} */ | |
| this.c = true; | |
| } | |
| } | |
| name(); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Ry = function(b) { | |
| var e = M(fc); | |
| this.g = M("gt-res-tools"); | |
| this.a = e; | |
| if (null != this.a) { | |
| (new eo(Qy, new Vo("trans-undo-button"))).R(this.a); | |
| ii(this.a, Qy); | |
| } | |
| /** @type {number} */ | |
| this.b = b; | |
| /** @type {boolean} */ | |
| this.c = false; | |
| }; | |
| /** @type {string} */ | |
| var Qy = ""; | |
| /** | |
| * @param {!Object} me | |
| * @param {boolean} newTab | |
| * @return {undefined} | |
| */ | |
| var Sy = function(me, newTab) { | |
| if (newTab) { | |
| J(me.g, "edit"); | |
| me.c = me.b.isVisible(); | |
| me.b.setVisible(false); | |
| } else { | |
| K(me.g, "edit"); | |
| me.b.setVisible(me.c); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} val | |
| * @param {number} x | |
| * @param {number} rawData | |
| * @param {number} i | |
| * @param {string} w | |
| * @param {string} data | |
| * @param {string} linkedEntities | |
| * @param {string} force | |
| * @return {undefined} | |
| */ | |
| var Ty = function(options, val, x, rawData, i, w, data, linkedEntities, force) { | |
| W.call(this, options); | |
| this.m = data || null; | |
| if (null != this.m) { | |
| options = this.m; | |
| data = A(this.li, this); | |
| options.a = A(options.A, options, data); | |
| data = options.b.l(); | |
| var fn = new Gn(data); | |
| U(fn, Hc, options.a, false, options); | |
| fn = new Vs(data); | |
| U(fn, hd, options.a, false, options); | |
| U(data, Kc, options.a, false, options); | |
| } | |
| /** @type {null} */ | |
| this.o = null; | |
| this.c = Qa; | |
| /** @type {string} */ | |
| this.b = this.na = ""; | |
| this.Z = new Ar("mt"); | |
| this.$ = !!val && My && !E; | |
| this.N = null != i ? i : 0; | |
| /** @type {null} */ | |
| this.g = null; | |
| if (this.$) { | |
| this.g = new Ny; | |
| } else { | |
| this.g = new ly; | |
| } | |
| if (0 < this.N) { | |
| /** @type {null} */ | |
| val = this.g; | |
| /** @type {boolean} */ | |
| val.H = true; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < val.g; i++) { | |
| data = P(qb, Ib, ""); | |
| options = P(qb, null, data); | |
| data = new Ux(options, data); | |
| /** @type {string} */ | |
| val.m[i] = data; | |
| document.body.appendChild(options); | |
| } | |
| } | |
| this.g.aa(x); | |
| this.j = linkedEntities || null; | |
| this.W = null != rawData ? rawData : -1; | |
| this.H = Wp.M(); | |
| this.A = new Wg; | |
| /** @type {null} */ | |
| this.I = this.L = null; | |
| this.w = w || null; | |
| /** @type {boolean} */ | |
| this.P = false; | |
| if (null != this.w) { | |
| x = A(this.va, this); | |
| /** @type {number} */ | |
| this.w.m = x; | |
| x = A(this.ai, this); | |
| /** @type {number} */ | |
| this.w.j = x; | |
| } | |
| this.X = force || null; | |
| /** @type {null} */ | |
| this.U = null; | |
| }; | |
| C(Ty, W); | |
| /** | |
| * @param {!Object} exports | |
| * @param {?} module | |
| * @return {undefined} | |
| */ | |
| var Uy = function(exports, module) { | |
| exports.U = module; | |
| exports.g.A = module; | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {number} config | |
| * @param {string} data | |
| * @param {string} result | |
| * @param {number} err | |
| * @return {?} | |
| */ | |
| var bz = function(self, config, data, result, err) { | |
| if (null != self.w) { | |
| var x = self.w; | |
| S(x.l(), false); | |
| S(x.g, false); | |
| if (null != x.b) { | |
| x.b.setVisible(false); | |
| } | |
| } | |
| if (config) { | |
| self.o = new pm(config); | |
| /** @type {null} */ | |
| self.I = null; | |
| } | |
| if (data) { | |
| /** @type {string} */ | |
| self.c = data; | |
| } | |
| if (result) { | |
| /** @type {string} */ | |
| self.na = result; | |
| } | |
| if (err) { | |
| /** @type {number} */ | |
| self.b = err; | |
| } | |
| if (Vy(self)) { | |
| Py(self.m); | |
| if (null != self.j) { | |
| Sy(self.j, false); | |
| } | |
| } | |
| if (self.o) { | |
| /** @type {boolean} */ | |
| config = 0 != Th(La).length; | |
| self.a.Rd(self.l()); | |
| self.g.Jd(); | |
| if (self.U) { | |
| self.U.b = self.o; | |
| } | |
| /** @type {number} */ | |
| var x0 = x = 0; | |
| /** @type {!Array} */ | |
| data = Array(21); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < data.length; i++) { | |
| /** @type {number} */ | |
| data[i] = 0; | |
| } | |
| /** @type {string} */ | |
| result = ""; | |
| /** @type {number} */ | |
| i = err = 0; | |
| for (; i < Qm(self.o); i++) { | |
| if (Wy(self.o, i)) { | |
| /** @type {string} */ | |
| result = result + " "; | |
| } | |
| /** @type {string} */ | |
| result = result + Xy(self.o, i); | |
| err = err + tm(Rm(self.o, i)); | |
| } | |
| if (0 == err) { | |
| return false; | |
| } | |
| /** @type {!Array} */ | |
| result = []; | |
| /** @type {boolean} */ | |
| err = false; | |
| i = self.o; | |
| /** @type {string} */ | |
| var tmp = ""; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < Qm(i); j++) { | |
| var e = Rm(i, j); | |
| if (null != e.a[4] && 0 < rm(e).length) { | |
| tmp = rm(e); | |
| } else { | |
| /** @type {string} */ | |
| (new bm(e.a)).a[4] = tmp; | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < Qm(self.o); i++) { | |
| tmp = Rm(self.o, i); | |
| j = um(tmp, 0); | |
| if (Wy(self.o, i)) { | |
| self.a.appendChild(self.l(), self.a.a.createTextNode(" ")); | |
| } else { | |
| if (!("km" != self.na && "lo" != self.na)) { | |
| self.a.appendChild(self.l(), G ? gi() : fh ? ei("­") : E && I(8) ? ei("​") : gi()); | |
| } | |
| } | |
| if (null != tmp.a[4] && 0 < rm(tmp).length && 0 == sm(tmp)) { | |
| result.push(rm(tmp)); | |
| } | |
| var c; | |
| e = Xy(self.o, i); | |
| if (Te(e)) { | |
| if (!(0 == e.length)) { | |
| c = Yy(e); | |
| } | |
| } else { | |
| c = self.a.b(Hd, null, e); | |
| j = xm(j); | |
| if (0 <= self.W && j < self.W) { | |
| x0++; | |
| J(c, "alt-low-conf"); | |
| } | |
| x = x + j; | |
| if (1E3 == j) { | |
| data[data.length - 1]++; | |
| } else { | |
| data[Math.floor((j - 0) / 50)]++; | |
| } | |
| if (Zg(self.A, self.c + "." + self.na + "." + qm(tmp))) { | |
| j = self.A.get(self.c + "." + self.na + "." + qm(tmp)); | |
| if (j != wm(um(tmp, 0))) { | |
| self.a.Sd(c, j); | |
| J(c, La); | |
| /** @type {boolean} */ | |
| err = true; | |
| Zy(self, true); | |
| } | |
| } | |
| if (null != self.g.j) { | |
| Fx(self.g.j, c); | |
| } else { | |
| c.title = dy; | |
| } | |
| fy(self.g, c, tmp); | |
| } | |
| if (c) { | |
| self.a.appendChild(self.l(), c); | |
| } | |
| } | |
| c = { | |
| confSum : x, | |
| numLowConf : x0, | |
| numPhrases : Qm(self.o) | |
| }; | |
| /** @type {number} */ | |
| x = 0; | |
| for (; x < data.length; x++) { | |
| if (0 != data[x]) { | |
| c["cB" + x] = data[x]; | |
| } | |
| } | |
| dq(self.H, "trans", c); | |
| if (null != self.m) { | |
| /** @type {string} */ | |
| c = self.c + "." + self.na; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < result.length; ++i) { | |
| /** @type {string} */ | |
| c = c + ("." + result[i]); | |
| } | |
| if (Zg(self.A, c)) { | |
| $y(self, false); | |
| /** @type {boolean} */ | |
| err = true; | |
| az(self, self.A.get(c)); | |
| if (null != self.j) { | |
| Sy(self.j, false); | |
| } | |
| Zy(self, true); | |
| } | |
| } | |
| if (!err) { | |
| Zy(self, false); | |
| $y(self, false); | |
| } | |
| if (err || config) { | |
| self.dispatchEvent(p); | |
| } | |
| return 0 < Qm(self.o); | |
| } | |
| Zy(self, false); | |
| $y(self, false); | |
| return false; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var Yy = function(v) { | |
| v = Ze(hf(v)).split("<br>"); | |
| /** @type {!DocumentFragment} */ | |
| var d = document.createDocumentFragment(); | |
| /** @type {number} */ | |
| var c = 0; | |
| xf(v, function(access_token) { | |
| if (0 != c) { | |
| d.appendChild(P("BR")); | |
| } | |
| c++; | |
| if ("" != access_token) { | |
| d.appendChild(ei(lf(access_token))); | |
| } | |
| }); | |
| return d; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} d | |
| * @return {?} | |
| */ | |
| var cz = function(b, d) { | |
| if (Vy(b)) { | |
| return b.m.b.T(); | |
| } | |
| /** @type {!Array} */ | |
| var attrs = []; | |
| if (b.l() && b.l().childNodes) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.l().childNodes.length; ++i) { | |
| var first = b.l().childNodes[i]; | |
| attrs[i] = d && "BR" == first.tagName ? "\n" : Fi(first); | |
| } | |
| } | |
| return attrs.join(""); | |
| }; | |
| /** | |
| * @param {!Object} g | |
| * @param {number} b | |
| * @param {number} t | |
| * @return {?} | |
| */ | |
| var ez = function(g, b, t) { | |
| /** @type {number} */ | |
| var r = 0; | |
| for (; r < Qm(g); r++) { | |
| var x = Rm(g, r); | |
| if (Vl(b.a, x ? x.a : null)) { | |
| /** @type {number} */ | |
| x = t; | |
| /** @type {number} */ | |
| b = -1; | |
| t = Qm(g); | |
| /** @type {number} */ | |
| var y = r; | |
| for (; 0 <= y; y--) { | |
| if (0 == sm(Rm(g, y))) { | |
| /** @type {number} */ | |
| b = y; | |
| break; | |
| } | |
| } | |
| /** @type {number} */ | |
| y = r + 1; | |
| for (; y <= Qm(g); y++) { | |
| if (0 == sm(Rm(g, y))) { | |
| /** @type {number} */ | |
| t = y; | |
| break; | |
| } | |
| } | |
| if (null != x && x) { | |
| r = dz(g, b, t); | |
| } else { | |
| if (g) { | |
| /** @type {number} */ | |
| x = r + 1; | |
| /** @type {number} */ | |
| y = r; | |
| r = Xy(g, r).length; | |
| for (; 64 > r && (x != t || y != b);) { | |
| if (x < t) { | |
| r = r + (Xy(g, x++).length + 1); | |
| } | |
| if (64 > r && y > b) { | |
| r = r + (Xy(g, --y).length + 1); | |
| } | |
| } | |
| r = dz(g, y, x); | |
| } else { | |
| /** @type {string} */ | |
| r = ""; | |
| } | |
| } | |
| return r; | |
| } | |
| } | |
| return ""; | |
| }; | |
| /** | |
| * @param {!Object} begin | |
| * @param {number} end | |
| * @param {number} d | |
| * @return {?} | |
| */ | |
| var dz = function(begin, end, d) { | |
| /** @type {!Array} */ | |
| var chunks = []; | |
| chunks.push(Xy(begin, end)); | |
| end = end + 1; | |
| for (; end < d; end++) { | |
| if (Wy(begin, end)) { | |
| chunks.push(" "); | |
| } | |
| chunks.push(Xy(begin, end)); | |
| } | |
| return chunks.join(""); | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @param {number} s | |
| * @return {?} | |
| */ | |
| var Wy = function(i, s) { | |
| if (0 == s) { | |
| return false; | |
| } | |
| var r = Rm(i, s); | |
| var value = Rm(i, s - 1); | |
| if (r = ym(um(r, 0))) { | |
| value = um(value, 0).a[3]; | |
| /** @type {boolean} */ | |
| r = !(null != value && value); | |
| } | |
| return r && !Se(Xy(i, s - 1), "\n"); | |
| }; | |
| y = Ty.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| this.Y(Ji(this.a, Hd)); | |
| }; | |
| /** | |
| * @param {string} selector | |
| * @return {undefined} | |
| */ | |
| y.Y = function(selector) { | |
| Ty.v.Y.call(this, selector); | |
| bz(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| Ty.v.V.call(this); | |
| X(this).a(this.g, p, this.qa); | |
| if (null != this.j && null != this.j.a) { | |
| X(this).a(this.j.a, r, this.Hi); | |
| } | |
| X(this).a(this.g, Ad, this.Ai); | |
| if (this.l()) { | |
| X(this).a(this.l(), Ic, function(event) { | |
| if (32 == event.keyCode) { | |
| event.stopPropagation(); | |
| } | |
| }, true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| Ty.v.J.call(this); | |
| this.g.za(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.li = function() { | |
| this.w.ba(this.m.c); | |
| Zy(this, this.m.c); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var fz = function(options) { | |
| if (null != options.j) { | |
| Sy(options.j, true); | |
| } | |
| var self = options.m; | |
| var width = cz(options); | |
| J(self.C, "full-edit"); | |
| self.g.setVisible(true); | |
| self.o = width; | |
| self.b.g(width); | |
| self.b.setVisible(true); | |
| self.b.hc(true); | |
| S(self.B, true); | |
| S(self.w, false); | |
| self.F = kj(self.m); | |
| S(self.m, false); | |
| bt(self.b); | |
| at(self.b); | |
| self.b.l().focus(); | |
| /** @type {boolean} */ | |
| self.j = true; | |
| options.P = kj(options.w.l()); | |
| options.w.reset(); | |
| options.w.ba(kj(options.j.a)); | |
| Zy(options, false); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| Ty.prototype.qa = function(e) { | |
| if (e.type != pc || e.target == this.g) { | |
| if (e.target == this.g.o && null != this.m) { | |
| this.H.log("editpopupclk"); | |
| fz(this); | |
| } else { | |
| var target = e.o; | |
| if (null == target && null != e.a) { | |
| target = e.a.Xa; | |
| } | |
| var left = e.target.Na(); | |
| if (null != target && null != e.target) { | |
| var a = target; | |
| var result = this.g.w.get(Le(a)); | |
| this.a.Sd(a, left); | |
| if (left == wm(um(result, 0))) { | |
| K(a, La); | |
| if (0 == Th(La).length) { | |
| Zy(this, false); | |
| $y(this, false); | |
| } | |
| } else { | |
| J(a, La); | |
| Zy(this, true); | |
| $y(this, true); | |
| } | |
| if (null != this.A) { | |
| this.A.set(this.c + "." + this.na + "." + qm(result), left); | |
| } | |
| target = this.g.w.get(Le(target)); | |
| if (null != this.A) { | |
| this.A.set(this.c + "." + this.na + "." + qm(target), left); | |
| } | |
| result = wm(um(target, 0)); | |
| a = Pl(this.g, e.target); | |
| result = { | |
| sl : this.c, | |
| tl : this.na, | |
| utrans : left, | |
| gtrans : result, | |
| index : a, | |
| ophrase : qm(target), | |
| osentence : rm(target), | |
| tsentence : ez(this.o, target) | |
| }; | |
| if (0 < tm(target)) { | |
| result.confidence = xm(um(target, 0)); | |
| } | |
| if (e.target instanceof my || -1 == a) { | |
| /** @type {number} */ | |
| result.manual = 1; | |
| } | |
| var i; | |
| for (i in result) { | |
| if (Fe(result[i]) && 64 < result[i].length) { | |
| /** @type {number} */ | |
| result.tr = 1; | |
| result[i] = result[i].substr(0, 64); | |
| } | |
| } | |
| this.H.log("usealt", result, null); | |
| e = new T("usealt"); | |
| e.text = left; | |
| this.dispatchEvent(e); | |
| this.dispatchEvent(p); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} next | |
| * @return {undefined} | |
| */ | |
| var az = function(node, next) { | |
| if (node.l()) { | |
| if (null == node.L) { | |
| node.I = Jf(node.a.sg(node.l())); | |
| } | |
| /** @type {string} */ | |
| node.L = next; | |
| var i; | |
| if (i = node.l().childNodes && 0 < node.l().childNodes.length) { | |
| i = (i = node.l().childNodes[0]) ? Zg(node.g.b, Le(i)) : false; | |
| } | |
| if (i) { | |
| node.a.Rd(node.l()); | |
| node.g.Jd(); | |
| i = node.a.b(Hd, La, node.L); | |
| node.a.appendChild(node.l(), i); | |
| fy(node.g, i, new bm); | |
| } else { | |
| node.l().innerHTML = Ze(hf(next)); | |
| } | |
| } | |
| }; | |
| y = Ty.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Cj = function() { | |
| /** @type {null} */ | |
| this.L = null; | |
| /** @type {boolean} */ | |
| this.m.c = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Hi = function() { | |
| if (null != this.m && Vy(this)) { | |
| var options = this.m; | |
| options.g.setVisible(true); | |
| options.b.g(options.o); | |
| options.b.l().focus(); | |
| options.a(null); | |
| } else { | |
| if (Vy(this)) { | |
| if (null != this.j) { | |
| Sy(this.j, false); | |
| } | |
| Py(this.m); | |
| } | |
| this.A.clear(); | |
| /** @type {null} */ | |
| this.L = null; | |
| bz(this); | |
| this.dispatchEvent(p); | |
| } | |
| this.H.log("clkundo", void 0, null); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ai = function() { | |
| if (Vy(this)) { | |
| if (this.m.c) { | |
| az(this, this.m.b.T()); | |
| /** @type {boolean} */ | |
| this.P = true; | |
| } | |
| Py(this.m); | |
| if (null != this.j) { | |
| Sy(this.j, false); | |
| } | |
| if (this.m.c) { | |
| Zy(this, true); | |
| } | |
| this.w.ba(true); | |
| S(this.w.l(), this.P); | |
| this.dispatchEvent(p); | |
| } | |
| this.H.log("clkcancel", void 0, null); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ai = function() { | |
| var files = this.g.w.get(Le(this.g.Xa)); | |
| if (files) { | |
| if (0 < this.N) { | |
| var data = new Xq("source=baf"); | |
| if (1 == this.N) { | |
| /** @type {!Array} */ | |
| var c = []; | |
| /** @type {number} */ | |
| var previous = 0; | |
| var timeMod = tm(files); | |
| for (; previous < timeMod; previous++) { | |
| c.push(wm(um(files, previous))); | |
| } | |
| Er(this.Z, this.na, this.c, M("hl").value, c, A(this.pj, this), void 0, data); | |
| } else { | |
| /** @type {number} */ | |
| previous = 0; | |
| timeMod = tm(files); | |
| for (; previous < timeMod; previous++) { | |
| c = wm(um(files, previous)); | |
| Fr(this.Z, this.na, this.c, M("hl").value, c, ["at", "t"], A(this.qj, this, previous), void 0, data); | |
| } | |
| } | |
| } | |
| data = new T(r); | |
| data.text = this.g.Na(); | |
| data.Ti = Qm(this.o); | |
| this.dispatchEvent(data); | |
| data = {}; | |
| data.confidence = xm(um(files, 0)); | |
| if (this.c && this.na && this.b) { | |
| data.segments = Qm(this.o); | |
| data.sl = this.c; | |
| data.tl = this.na; | |
| data.hl = this.b; | |
| } | |
| this.H.log("phrsclk", data, null); | |
| } | |
| }; | |
| /** | |
| * @param {?} max_x | |
| * @param {!Object} v0_sample | |
| * @return {undefined} | |
| */ | |
| y.qj = function(max_x, v0_sample) { | |
| var current; | |
| if (1 == this.N || 1 < Qm(v0_sample)) { | |
| var path = Om(v0_sample, 0).Ta(); | |
| /** @type {number} */ | |
| current = 1; | |
| var h1_mean = Nm(v0_sample); | |
| for (; current < h1_mean; current++) { | |
| path = path + (" " + Om(v0_sample, current).Ta()); | |
| } | |
| current = path; | |
| } else { | |
| if (1 == Qm(v0_sample)) { | |
| /** @type {!Array} */ | |
| path = []; | |
| var dataMax = Rm(v0_sample, 0); | |
| /** @type {number} */ | |
| current = 0; | |
| /** @type {number} */ | |
| h1_mean = Math.min(this.N, tm(dataMax)); | |
| for (; current < h1_mean; current++) { | |
| path.push(wm(um(dataMax, current))); | |
| } | |
| /** @type {string} */ | |
| current = path.join(", "); | |
| } else { | |
| /** @type {string} */ | |
| current = "..."; | |
| } | |
| } | |
| jy(this.g, max_x, current); | |
| }; | |
| /** | |
| * @param {!NodeList} serverElements | |
| * @return {undefined} | |
| */ | |
| y.pj = function(serverElements) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < serverElements.length; i++) { | |
| jy(this.g, i, serverElements[i]); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {boolean} d | |
| * @return {undefined} | |
| */ | |
| var Zy = function(options, d) { | |
| if (null != options.j && null != options.j.a) { | |
| S(options.j.a, d); | |
| } | |
| var x = M(dc); | |
| if (d && null != x && kj(x)) { | |
| R(options.j.a, Uc, "18px"); | |
| R(options.j.a, ed, oc); | |
| x = O(Bc, options.j.a); | |
| R(x, Sc, "5px"); | |
| x = M(cc); | |
| R(x, Uc, "18px"); | |
| R(x, ed, oc); | |
| x = O(Bc, x); | |
| R(x, Sc, "5px"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| var $y = function(p, a) { | |
| if (null != p.w) { | |
| if (a) { | |
| p.w.reset(); | |
| } | |
| S(p.w.l(), a); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ty.prototype.va = function() { | |
| /** @type {!Array} */ | |
| var path = []; | |
| var tree; | |
| if (null != this.I) { | |
| tree = this.I; | |
| } else { | |
| tree = ni(this.l()); | |
| } | |
| var target = { | |
| segment : [] | |
| }; | |
| /** @type {null} */ | |
| var result = null; | |
| /** @type {number} */ | |
| var offset = 0; | |
| /** @type {number} */ | |
| var index = 0; | |
| for (; index < tree.length; index++) { | |
| var t = Rm(this.o, index); | |
| if (null != t) { | |
| var s = Fi(tree[index]); | |
| var m; | |
| a: { | |
| m = s; | |
| var n = t; | |
| if (0 == tm(n)) { | |
| /** @type {number} */ | |
| m = 0; | |
| } else { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < tm(n); ++i) { | |
| if (m == wm(um(n, i))) { | |
| /** @type {number} */ | |
| m = i; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| m = -1; | |
| } | |
| } | |
| n = We(rm(t)); | |
| i = ez(this.o, t, true); | |
| if (0 != n.length) { | |
| if (0 == path.length || n != path[path.length - 1]) { | |
| path.push(n); | |
| result = gz(this, path.length - 1); | |
| /** @type {number} */ | |
| offset = 0; | |
| result = { | |
| source : n, | |
| original_target : i, | |
| segment_source : result, | |
| phrase_correction : [] | |
| }; | |
| target.segment.push(result); | |
| } | |
| if (0 != m) { | |
| n = wm(um(t, 0)).length; | |
| m = { | |
| alternative_index : m, | |
| edited_phrase : s, | |
| source_span : [], | |
| target_span : [{ | |
| start : offset, | |
| end : offset + n | |
| }] | |
| }; | |
| result.phrase_correction.push(m); | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < Y(t.a, 3); ++n) { | |
| i = vm(t, n); | |
| m.source_span.push({ | |
| start : zm(i), | |
| end : Am(i) | |
| }); | |
| } | |
| } | |
| offset = offset + s.length; | |
| if (ym(um(t, 0))) { | |
| offset++; | |
| } | |
| } | |
| } | |
| } | |
| if (Vy(this)) { | |
| this.dispatchEvent(p); | |
| Py(this.m); | |
| if (null != this.j) { | |
| Sy(this.j, false); | |
| } | |
| Zy(this, true); | |
| if (this.m.b.T() != cz(this)) { | |
| az(this, this.m.b.T()); | |
| } | |
| /** @type {string} */ | |
| tree = this.c + "." + this.na; | |
| /** @type {number} */ | |
| index = 0; | |
| for (; index < path.length; ++index) { | |
| /** @type {string} */ | |
| tree = tree + ("." + path[index]); | |
| } | |
| path = this.m.b.T(); | |
| this.A.set(tree, path); | |
| /** @type {boolean} */ | |
| target.contains_full_edit = true; | |
| } | |
| target.edited_target = cz(this, true); | |
| if (this.X) { | |
| target.formality = this.X.g; | |
| } | |
| path = new Xq; | |
| path.set("ue", JSON.stringify(target)); | |
| path.set("sl", this.c); | |
| path.set("tl", this.na); | |
| Fq("/translate_suggestion?client=t", void 0, wa, path.toString(), void 0, 1E4); | |
| }; | |
| /** | |
| * @param {!Object} $this | |
| * @param {number} content | |
| * @return {?} | |
| */ | |
| var gz = function($this, content) { | |
| if (content < Nm($this.o)) { | |
| switch(Dm(Om($this.o, content))) { | |
| case 0: | |
| return 1; | |
| case 1: | |
| return 2; | |
| case 2: | |
| return 3; | |
| case 10: | |
| return 4; | |
| } | |
| } | |
| return 0; | |
| }; | |
| /** | |
| * @param {!Object} to | |
| * @return {?} | |
| */ | |
| var Vy = function(to) { | |
| return null != to.m && to.m.j; | |
| }; | |
| /** | |
| * @param {!Object} array | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| var Xy = function(array, value) { | |
| var pos = Rm(array, value); | |
| return 0 == tm(pos) ? qm(pos) : wm(um(pos, 0)); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var hz = function(a) { | |
| this.a = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var iz = function(a) { | |
| this.a = a || []; | |
| }; | |
| hz.prototype.b = w("a"); | |
| /** | |
| * @return {?} | |
| */ | |
| hz.prototype.Zb = function() { | |
| var city = this.a[0]; | |
| return null != city ? city : ""; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var jz = function(v) { | |
| v = v.a[1]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var kz = function(v) { | |
| v = v.a[2]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var lz = function(v) { | |
| v = v.a[3]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hz.prototype.Ta = function() { | |
| var city = this.a[4]; | |
| return null != city ? city : ""; | |
| }; | |
| iz.prototype.b = w("a"); | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var mz = function(v) { | |
| v = v.a[3]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| iz.prototype.F = function() { | |
| var city = this.a[5]; | |
| return null != city ? city : ""; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var nz = function(v) { | |
| v = v.a[6]; | |
| return null != v ? v : ""; | |
| }; | |
| /** | |
| * @param {string} t | |
| * @param {number} scale | |
| * @return {?} | |
| */ | |
| var oz = function(t, scale) { | |
| return new hz(Tl(t.a, 2)[scale]); | |
| }; | |
| /** | |
| * @param {number} z | |
| * @return {undefined} | |
| */ | |
| var pz = function(z) { | |
| /** @type {number} */ | |
| this.b = z; | |
| /** @type {string} */ | |
| this.a = ""; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| pz.prototype.c = function(name, type) { | |
| var a; | |
| a = type.target; | |
| if (Pq(a) && "" != Qq(a) && null != Rq(a)) { | |
| a = Rq(a); | |
| a = new iz(a); | |
| var time; | |
| time = a.a[1]; | |
| time = null != time ? time : ""; | |
| if (null != time && "" != time) { | |
| this.a = time; | |
| } | |
| } else { | |
| a = new iz; | |
| a.a[3] = MSG_PB_ERROR; | |
| } | |
| name(a); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {string} d | |
| * @param {string} context | |
| * @param {string} key | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| var qz = function(t, d, context, key, e) { | |
| /** @type {string} */ | |
| var f = window.location.href; | |
| d = new Sq(d); | |
| if (f = (new Sq(f, true)).a.get(Pa)) { | |
| d.a.set(Pa, f); | |
| } | |
| d = d.toString(); | |
| /** @type {string} */ | |
| d = d + ("&hl=" + t.b); | |
| if ("" != USAGE) { | |
| /** @type {string} */ | |
| d = d + ("&xt=" + USAGE); | |
| } | |
| if (null != e) { | |
| Fq(d, A(t.c, t, context), key, e); | |
| } else { | |
| Fq(d, A(t.c, t, context), key); | |
| } | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var rz = function(p1__3354_SHARP_) { | |
| Lr.call(this, p1__3354_SHARP_, "rw", MSG_SEE_ALSO, MSG_SEE_ALSO); | |
| /** @type {boolean} */ | |
| this.Qe = true; | |
| }; | |
| C(rz, Lr); | |
| /** | |
| * @param {!Object} o | |
| * @param {string} e | |
| * @param {!Object} n | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| rz.prototype.update = function(o, e, n, a) { | |
| rz.v.update.call(this, o, e, n, a); | |
| if (!a || 0 == Y(Mm(a).a, 0)) { | |
| return false; | |
| } | |
| ji(this.b); | |
| n = o = P(za, { | |
| "class" : "gt-rw-span" | |
| }); | |
| /** @type {boolean} */ | |
| e = 15 < Y(Mm(a).a, 0); | |
| /** @type {number} */ | |
| var item = 0; | |
| for (; item < Y(Mm(a).a, 0); ++item) { | |
| var selector; | |
| /** @type {number} */ | |
| var content = item; | |
| selector = Tl(Mm(a).a, 0)[content]; | |
| content = P(za, { | |
| "class" : Yb | |
| }); | |
| Q(content, selector); | |
| if (10 == item && e) { | |
| var d = P(za, { | |
| "class" : "gt-rw-span" | |
| }); | |
| n = d; | |
| d = e ? P(za, { | |
| "class" : Wb | |
| }, d) : d; | |
| R(d, { | |
| display : ad | |
| }); | |
| } | |
| if (0 != item && item != Y(Mm(a).a, 0)) { | |
| n.appendChild(ei(", ")); | |
| } | |
| n.appendChild(content); | |
| } | |
| n = ag(this.g) ? sd : Qc; | |
| R(this.b, { | |
| direction : n | |
| }); | |
| this.b.appendChild(o); | |
| if (d) { | |
| this.b.appendChild(d); | |
| } | |
| if (e) { | |
| a = MSG_N_MORE_RELATED_LABEL.replace(aa, Y(Mm(a).a, 0) - 7); | |
| Nr(this, a, MSG_FEWER_RELATED_LABEL); | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rz.prototype.V = function() { | |
| rz.v.V.call(this); | |
| X(this).a(this.l(), r, this.c); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| rz.prototype.c = function(key) { | |
| if (Bh(key.target, Yb)) { | |
| this.dispatchEvent(new T("a", key.target)); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| rz.prototype.H = function(name) { | |
| /** @type {!Array} */ | |
| var soundsForWeek = []; | |
| var c; | |
| var mrg = Th(Wb, this.l()); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < mrg.length; i++) { | |
| c = mrg[i]; | |
| if (name) { | |
| soundsForWeek.push(new Cy(c, 218)); | |
| } else { | |
| soundsForWeek.push(new By(c, 218)); | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < soundsForWeek.length; i++) { | |
| soundsForWeek[i].play(); | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} selector | |
| * @param {!NodeList} init | |
| * @return {undefined} | |
| */ | |
| var sz = function(selector, init) { | |
| V.call(this); | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < selector.length; ++j) { | |
| var value = selector[j]; | |
| U(value, Zc, this.a, false, this); | |
| U(value, Kc, function(key) { | |
| if (16 == key.keyCode) { | |
| this.a(key); | |
| } | |
| }, false, this); | |
| } | |
| /** @type {number} */ | |
| j = 0; | |
| for (; j < init.length; ++j) { | |
| value = init[j]; | |
| U(value, Zc, this.b, false, this); | |
| U(value, Kc, function(key) { | |
| if (16 == key.keyCode) { | |
| this.b(key); | |
| } | |
| }, false, this); | |
| } | |
| }; | |
| C(sz, V); | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sz.prototype.a = function(name) { | |
| name = tz(name.target); | |
| if ("" != name) { | |
| var obj = new T(ud); | |
| /** @type {string} */ | |
| obj.text = name; | |
| this.dispatchEvent(obj); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sz.prototype.b = function(name) { | |
| name = tz(name.target); | |
| if ("" != name) { | |
| var obj = new T(ud); | |
| /** @type {string} */ | |
| obj.text = name; | |
| /** @type {boolean} */ | |
| obj.w = true; | |
| this.dispatchEvent(obj); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @return {?} | |
| */ | |
| var tz = function(result) { | |
| /** @type {string} */ | |
| var s = ""; | |
| try { | |
| if (s = Yx(result).trim(), "" != s) { | |
| return s; | |
| } | |
| } catch (c) { | |
| } | |
| result = Uv(window); | |
| return result.toString ? result.toString().trim() : result.createRange ? result.createRange().text : ""; | |
| }; | |
| /** | |
| * @param {?} raw | |
| * @param {string} bbox_is_required | |
| * @return {undefined} | |
| */ | |
| var uz = function(raw, bbox_is_required) { | |
| /** @type {!Array} */ | |
| this.j = []; | |
| this.G = raw; | |
| this.F = bbox_is_required || null; | |
| /** @type {boolean} */ | |
| this.g = this.a = false; | |
| this.c = void 0; | |
| /** @type {boolean} */ | |
| this.C = this.A = this.o = false; | |
| /** @type {number} */ | |
| this.m = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {number} */ | |
| this.B = 0; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| uz.prototype.cancel = function(a) { | |
| if (this.a) { | |
| if (this.c instanceof uz) { | |
| this.c.cancel(); | |
| } | |
| } else { | |
| if (this.b) { | |
| var b = this.b; | |
| delete this.b; | |
| if (a) { | |
| b.cancel(a); | |
| } else { | |
| b.B--; | |
| if (0 >= b.B) { | |
| b.cancel(); | |
| } | |
| } | |
| } | |
| if (this.G) { | |
| this.G.call(this.F, this); | |
| } else { | |
| /** @type {boolean} */ | |
| this.C = true; | |
| } | |
| if (!this.a) { | |
| a = new vz; | |
| wz(this); | |
| xz(this, false, a); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| uz.prototype.w = function(name, type) { | |
| /** @type {boolean} */ | |
| this.o = false; | |
| xz(this, name, type); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} state | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var xz = function(item, state, value) { | |
| /** @type {boolean} */ | |
| item.a = true; | |
| /** @type {string} */ | |
| item.c = value; | |
| /** @type {boolean} */ | |
| item.g = !state; | |
| yz(item); | |
| }; | |
| /** | |
| * @param {(number|string)} item | |
| * @return {undefined} | |
| */ | |
| var wz = function(item) { | |
| if (item.a) { | |
| if (!item.C) { | |
| throw new zz; | |
| } | |
| /** @type {boolean} */ | |
| item.C = false; | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| uz.prototype.K = function(key) { | |
| wz(this); | |
| xz(this, true, key); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @param {!Function} result | |
| * @param {!Object} r | |
| * @return {undefined} | |
| */ | |
| var Az = function(a, b, result, r) { | |
| a.j.push([b, result, r]); | |
| if (a.a) { | |
| yz(a); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {boolean} f | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| uz.prototype.then = function(a, f, obj) { | |
| var MyIfComp; | |
| var cb; | |
| var connect = new Kk(function(boardManager, casesArg) { | |
| MyIfComp = boardManager; | |
| cb = casesArg; | |
| }); | |
| Az(this, MyIfComp, function(errReadDir) { | |
| if (errReadDir instanceof vz) { | |
| connect.cancel(); | |
| } else { | |
| cb(errReadDir); | |
| } | |
| }); | |
| return connect.then(a, f, obj); | |
| }; | |
| Hk(uz); | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var Bz = function(val) { | |
| return Af(val.j, function(a) { | |
| return He(a[1]); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var yz = function(a) { | |
| if (a.m && a.a && Bz(a)) { | |
| var b = a.m; | |
| var o = Cz[b]; | |
| if (o) { | |
| z.clearTimeout(o.Ga); | |
| delete Cz[b]; | |
| } | |
| /** @type {number} */ | |
| a.m = 0; | |
| } | |
| if (a.b) { | |
| a.b.B--; | |
| delete a.b; | |
| } | |
| b = a.c; | |
| /** @type {boolean} */ | |
| var d = o = false; | |
| for (; a.j.length && !a.o;) { | |
| var e = a.j.shift(); | |
| var x = e[0]; | |
| var y = e[1]; | |
| e = e[2]; | |
| if (x = a.g ? y : x) { | |
| try { | |
| var value = x.call(e || a.F, b); | |
| if (xe(value)) { | |
| a.g = a.g && (value == b || value instanceof Error); | |
| a.c = b = value; | |
| } | |
| if (Ik(b) || typeof z.Promise === Bb && b instanceof z.Promise) { | |
| /** @type {boolean} */ | |
| d = true; | |
| /** @type {boolean} */ | |
| a.o = true; | |
| } | |
| } catch (vfrac) { | |
| b = vfrac; | |
| /** @type {boolean} */ | |
| a.g = true; | |
| if (!Bz(a)) { | |
| /** @type {boolean} */ | |
| o = true; | |
| } | |
| } | |
| } | |
| } | |
| a.c = b; | |
| if (d) { | |
| value = A(a.w, a, true); | |
| d = A(a.w, a, false); | |
| if (b instanceof uz) { | |
| Az(b, value, d); | |
| /** @type {boolean} */ | |
| b.A = true; | |
| } else { | |
| b.then(value, d); | |
| } | |
| } | |
| if (o) { | |
| b = new Dz(b); | |
| Cz[b.Ga] = b; | |
| a.m = b.Ga; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var zz = function() { | |
| Qe.call(this); | |
| }; | |
| C(zz, Qe); | |
| /** @type {string} */ | |
| zz.prototype.message = "Deferred has already fired"; | |
| /** @type {string} */ | |
| zz.prototype.name = "AlreadyCalledError"; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var vz = function() { | |
| Qe.call(this); | |
| }; | |
| C(vz, Qe); | |
| /** @type {string} */ | |
| vz.prototype.message = "Deferred was canceled"; | |
| /** @type {string} */ | |
| vz.prototype.name = "CanceledError"; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var Dz = function(a) { | |
| this.Ga = z.setTimeout(A(this.b, this), 0); | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Dz.prototype.b = function() { | |
| delete Cz[this.Ga]; | |
| throw this.a; | |
| }; | |
| var Cz = {}; | |
| /** | |
| * @param {string} value | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var Iz = function(value, options) { | |
| var params = options || {}; | |
| var container = params.document || document; | |
| var x = di(xa); | |
| var item = { | |
| Yb : x, | |
| ic : void 0 | |
| }; | |
| var cmd = new uz(Ez, item); | |
| /** @type {null} */ | |
| var wallColor = null; | |
| var renewTokenIn = null != params.timeout ? params.timeout : 5E3; | |
| if (0 < renewTokenIn) { | |
| wallColor = window.setTimeout(function() { | |
| Fz(x, true); | |
| var realVal = new Gz(1, "Timeout reached for loading script " + value); | |
| wz(cmd); | |
| xz(cmd, false, realVal); | |
| }, renewTokenIn); | |
| item.ic = wallColor; | |
| } | |
| /** @type {function(): undefined} */ | |
| x.onload = x.onreadystatechange = function() { | |
| if (!(x.readyState && "loaded" != x.readyState && x.readyState != db)) { | |
| Fz(x, params.Jh || false, wallColor); | |
| cmd.K(null); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| x.onerror = function() { | |
| Fz(x, true, wallColor); | |
| var realVal = new Gz(0, "Error while loading script " + value); | |
| wz(cmd); | |
| xz(cmd, false, realVal); | |
| }; | |
| item = params.attributes || {}; | |
| Wf(item, { | |
| type : Sd, | |
| charset : "UTF-8", | |
| src : value | |
| }); | |
| Vh(x, item); | |
| Hz(container).appendChild(x); | |
| return cmd; | |
| }; | |
| /** | |
| * @param {!Document} document | |
| * @return {?} | |
| */ | |
| var Hz = function(document) { | |
| var bodies = document.getElementsByTagName("HEAD"); | |
| return bodies && 0 != bodies.length ? bodies[0] : document.documentElement; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ez = function() { | |
| if (this && this.Yb) { | |
| var a = this.Yb; | |
| if (a && a.tagName == xa) { | |
| Fz(a, true, this.ic); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} file | |
| * @param {boolean} indent | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| var Fz = function(file, indent, name) { | |
| if (null != name) { | |
| z.clearTimeout(name); | |
| } | |
| file.onload = Ae; | |
| file.onerror = Ae; | |
| file.onreadystatechange = Ae; | |
| if (indent) { | |
| window.setTimeout(function() { | |
| mi(file); | |
| }, 0); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Gz = function(a, b) { | |
| /** @type {string} */ | |
| var buffer = "Jsloader error (code #" + a + ")"; | |
| if (b) { | |
| /** @type {string} */ | |
| buffer = buffer + (": " + b); | |
| } | |
| Qe.call(this, buffer); | |
| }; | |
| C(Gz, Qe); | |
| /** | |
| * @param {?} options | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| var Jz = function(options, data) { | |
| this.b = new Sq(options); | |
| this.a = data ? data : "callback"; | |
| /** @type {number} */ | |
| this.ic = 5E3; | |
| }; | |
| /** @type {number} */ | |
| var Kz = 0; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| Jz.prototype.cancel = function(a) { | |
| if (a) { | |
| if (a.gg) { | |
| a.gg.cancel(); | |
| } | |
| if (a.Ga) { | |
| Lz(a.Ga, false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} pos | |
| * @param {?} x | |
| * @param {?} h | |
| * @return {?} | |
| */ | |
| var Mz = function(pos, x, h) { | |
| return function() { | |
| Lz(pos, false); | |
| if (h) { | |
| h(x); | |
| } | |
| }; | |
| }; | |
| /** | |
| * @param {string} k | |
| * @param {!Function} d | |
| * @return {?} | |
| */ | |
| var Nz = function(k, d) { | |
| return function(canCreateDiscussions) { | |
| Lz(k, true); | |
| d.apply(void 0, arguments); | |
| }; | |
| }; | |
| /** | |
| * @param {string} i | |
| * @param {boolean} enableCache | |
| * @return {undefined} | |
| */ | |
| var Lz = function(i, enableCache) { | |
| /** @type {string} */ | |
| var j = "_callbacks___" + i; | |
| if (z[j]) { | |
| if (enableCache) { | |
| try { | |
| delete z[j]; | |
| } catch (d) { | |
| z[j] = void 0; | |
| } | |
| } else { | |
| z[j] = Ae; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} C | |
| * @param {?} instance | |
| * @param {string} genericType | |
| * @return {undefined} | |
| */ | |
| var Oz = function(C, instance, genericType) { | |
| this.g = new Jz(instance); | |
| /** @type {number} */ | |
| this.g.ic = 500; | |
| /** @type {null} */ | |
| this.a = null; | |
| /** @type {number} */ | |
| this.j = 0; | |
| /** @type {boolean} */ | |
| this.c = false; | |
| this.w = Wp.M(); | |
| this.C = C; | |
| this.o = genericType || ge; | |
| }; | |
| /** | |
| * @param {!Object} state | |
| * @param {string} value | |
| * @param {string} p | |
| * @param {string} f | |
| * @param {?} x | |
| * @return {undefined} | |
| */ | |
| var Xw = function(state, value, p, f, x) { | |
| Pz(state); | |
| if (0 == value.length || 64 < value.length || p == Qa) { | |
| x([]); | |
| } else { | |
| p = p == pe || p == qe ? "zh" : p; | |
| /** @type {number} */ | |
| var height = 167 - (Pe() - state.j); | |
| if (0 > height) { | |
| /** @type {number} */ | |
| height = 0; | |
| } | |
| state.b = cl(function() { | |
| if (this.b) { | |
| this.b = void 0; | |
| var y = p; | |
| this.j = Pe(); | |
| var options = {}; | |
| /** @type {string} */ | |
| options.q = value; | |
| /** @type {string} */ | |
| options.client = "translate_separate_corpus"; | |
| options.ds = this.o; | |
| options.hl = y; | |
| /** @type {string} */ | |
| options.requiredfields = "tl:" + f; | |
| var c = this.g; | |
| var a = A(this.B, this, value, y, f, x); | |
| y = A(this.m, this, "4", value, y, f); | |
| options = options || null; | |
| var id = "_" + (Kz++).toString(36) + Pe().toString(36); | |
| /** @type {string} */ | |
| var j = "_callbacks___" + id; | |
| var transform = c.b.clone(); | |
| if (options) { | |
| var property; | |
| for (property in options) { | |
| if (!options.hasOwnProperty || options.hasOwnProperty(property)) { | |
| var value = transform; | |
| /** @type {string} */ | |
| var attr = property; | |
| var children = options[property]; | |
| if (!De(children)) { | |
| /** @type {!Array} */ | |
| children = [String(children)]; | |
| } | |
| kr(value.a, attr, children); | |
| } | |
| } | |
| } | |
| if (a) { | |
| z[j] = Nz(id, a); | |
| a = c.a; | |
| /** @type {string} */ | |
| property = j; | |
| if (!De(property)) { | |
| /** @type {!Array} */ | |
| property = [String(property)]; | |
| } | |
| kr(transform.a, a, property); | |
| } | |
| c = Iz(transform.toString(), { | |
| timeout : c.ic, | |
| Jh : true | |
| }); | |
| Az(c, null, Mz(id, options, y), void 0); | |
| this.a = { | |
| Ga : id, | |
| gg : c | |
| }; | |
| } | |
| }, height, state); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var Pz = function(obj) { | |
| if (obj.a) { | |
| /** @type {boolean} */ | |
| obj.c = true; | |
| obj.g.cancel(obj.a); | |
| /** @type {null} */ | |
| obj.a = null; | |
| } | |
| if (obj.b) { | |
| dl(obj.b); | |
| obj.b = void 0; | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @param {string} e | |
| * @param {string} input | |
| * @param {?} f | |
| * @param {string} date | |
| * @return {undefined} | |
| */ | |
| Oz.prototype.m = function(key, name, e, input, f, date) { | |
| if (!this.c) { | |
| name = { | |
| q : name, | |
| sl : e, | |
| tl : input | |
| }; | |
| if (f) { | |
| name.se = f.substring(0, 64); | |
| } | |
| if (date) { | |
| name.msg = date.substring(0, 64); | |
| } | |
| aq(this.w, this.C, "is", key, name); | |
| } | |
| /** @type {boolean} */ | |
| this.c = false; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} type | |
| * @param {!Function} a | |
| * @param {string} e | |
| * @param {?} t | |
| * @return {undefined} | |
| */ | |
| Oz.prototype.B = function(name, type, a, e, t) { | |
| try { | |
| var HeaderBar = zf(t[1], function(a) { | |
| return lf(a[0]); | |
| }, this); | |
| e(HeaderBar); | |
| } catch (controlFlowAction) { | |
| this.m("5", name, type, a, lq(t), controlFlowAction.message); | |
| } | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Qz = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Qz.prototype.clear = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| }; | |
| /** | |
| * @param {?} context | |
| * @param {?} config | |
| * @param {?} filenameOrOptions | |
| * @return {undefined} | |
| */ | |
| var Rz = function(context, config, filenameOrOptions) { | |
| It.call(this, context || Ht(Tw.M()), config || Tw.M(), filenameOrOptions); | |
| Tt(this, false); | |
| }; | |
| C(Rz, It); | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| Rz.prototype.Ka = function(key) { | |
| return 27 == key.keyCode ? (this.setVisible(false), key.stopPropagation(), key.preventDefault(), true) : Rz.v.Ka.call(this, key); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {number} fn | |
| * @return {undefined} | |
| */ | |
| var Vw = function(m, fn) { | |
| if (fn == Qc) { | |
| var suggestion = Pc; | |
| } else { | |
| if (fn == sd) { | |
| suggestion = qd; | |
| } else { | |
| return; | |
| } | |
| } | |
| R(m, nb, fn); | |
| R(m, "text-align", suggestion); | |
| }; | |
| /** | |
| * @param {(number|string)} state | |
| * @param {undefined} f | |
| * @return {undefined} | |
| */ | |
| var ex = function(state, f) { | |
| zf(state.D ? Th("gt-is-tr", state.D || state.a.a) : [], function(column_reordering_1_1) { | |
| Vw(column_reordering_1_1, f); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} cX1 | |
| * @return {?} | |
| */ | |
| var Sw = function(cX1) { | |
| /** @type {!Array} */ | |
| var eventPrototypes = []; | |
| Ll(cX1, function(a) { | |
| eventPrototypes.push(a); | |
| }); | |
| return eventPrototypes; | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var Sz = function(p1__3354_SHARP_) { | |
| Lr.call(this, p1__3354_SHARP_, "ss", MSG_SYNONYMS_OF, MSG_SYNONYMS); | |
| }; | |
| C(Sz, Lr); | |
| /** | |
| * @param {?} arr | |
| * @param {string} name | |
| * @param {number} count | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| Sz.prototype.update = function(arr, name, count, v) { | |
| Sz.v.update.call(this, arr, name, count, v); | |
| if (!v || 0 == Y(v.a, 11)) { | |
| return false; | |
| } | |
| ji(this.b); | |
| /** @type {number} */ | |
| var e = count = 0; | |
| /** @type {number} */ | |
| arr = 0; | |
| for (; arr < Y(v.a, 11); ++arr) { | |
| var i = Sm(v, arr); | |
| var a; | |
| name = i.g[2]; | |
| a = null != name ? name : ""; | |
| count = count + i.a(); | |
| /** @type {number} */ | |
| name = 0; | |
| for (; name < i.a(); ++name) { | |
| e = e + Y(i.c(name).a, 0); | |
| } | |
| } | |
| if (name = 2 < count / Y(v.a, 11) && 1 < e - count) { | |
| arr = MSG_N_MORE_SYNONYMS_LABEL.replace(aa, e - count); | |
| Nr(this, arr, MSG_FEWER_SYNONYMS_LABEL); | |
| } | |
| /** @type {boolean} */ | |
| count = 1 == count / Y(v.a, 11); | |
| if (a) { | |
| this.Ed = a; | |
| Mr(this, a); | |
| } | |
| /** @type {number} */ | |
| arr = 0; | |
| for (; arr < Y(v.a, 11); ++arr) { | |
| i = Sm(v, arr); | |
| a = P(k, { | |
| "class" : Zb | |
| }); | |
| this.b.appendChild(a); | |
| e = i.g[0]; | |
| Q(a, null != e ? e : ""); | |
| a = i; | |
| /** @type {number} */ | |
| i = count; | |
| /** @type {string} */ | |
| e = name; | |
| var d = P("UL", { | |
| "class" : "gt-syn-list" | |
| }); | |
| var value = ag(this.g) ? sd : Qc; | |
| R(d, { | |
| direction : value | |
| }); | |
| if (e) { | |
| value = P(za, { | |
| "class" : "gt-syn-span" | |
| }); | |
| var v = P(k, { | |
| "class" : kc | |
| }, value); | |
| /** @type {!Array} */ | |
| var X = []; | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < a.a(); ++key) { | |
| var p = Fm(a.c(key), 0); | |
| if (!Ef(X, p)) { | |
| X.push(p); | |
| if (0 < key) { | |
| value.appendChild(ei(", ")); | |
| } | |
| var a = P(za, { | |
| "class" : Yb | |
| }); | |
| value.appendChild(a); | |
| Q(a, p); | |
| } | |
| } | |
| value = P(k, { | |
| "class" : lc | |
| }, v); | |
| d.appendChild(value); | |
| } | |
| /** @type {number} */ | |
| value = 0; | |
| for (; value < a.a(); ++value) { | |
| v = a.c(value); | |
| /** @type {boolean} */ | |
| key = e; | |
| p = i ? k : "LI"; | |
| X = P(za, { | |
| "class" : "gt-syn-span" | |
| }); | |
| p = P(p, { | |
| "class" : kc | |
| }, X); | |
| key = Or(p, !key); | |
| /** @type {number} */ | |
| p = 0; | |
| for (; p < Y(v.a, 0); ++p) { | |
| a = P(za, { | |
| "class" : Yb | |
| }); | |
| X.appendChild(a); | |
| Q(a, Fm(v, p)); | |
| if (p < Y(v.a, 0) - 1) { | |
| X.appendChild(ei(", ")); | |
| } | |
| } | |
| d.appendChild(key); | |
| } | |
| this.b.appendChild(d); | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Sz.prototype.V = function() { | |
| Sz.v.V.call(this); | |
| X(this).a(this.l(), r, this.c); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Sz.prototype.c = function(key) { | |
| if (Bh(key.target, Yb)) { | |
| this.dispatchEvent(new T("a", key.target)); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Sz.prototype.H = function(name) { | |
| Sz.v.H.call(this, name); | |
| var notActiveCursors = Th(lc, this.l()); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < notActiveCursors.length; i++) { | |
| var key = notActiveCursors[i]; | |
| var k = O(kc, key); | |
| var rec = tj(k, Rc); | |
| k = hj(k).height + rec.top + rec.bottom; | |
| R(key, "max-height", name ? 0 : k + md); | |
| } | |
| }; | |
| /** | |
| * @param {string} b | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var Tz = function(b, a) { | |
| this.C = Wp.M(); | |
| /** @type {string} */ | |
| this.b = b; | |
| if (!(E || gh || ih)) { | |
| U(b, "copy", this.o, false, this); | |
| } | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < a.length; k++) { | |
| U(a[k], Vc, this.B, false, this); | |
| } | |
| /** @type {null} */ | |
| this.g = this.c = null; | |
| /** @type {boolean} */ | |
| this.m = this.j = false; | |
| }; | |
| C(Tz, Aj); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Tz.prototype.J = function() { | |
| Tz.v.J.call(this); | |
| hk(this.b, "copy", this.o, false, this); | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| hk(this.a[i], Vc, this.B, false, this); | |
| } | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Tz.prototype.o = function() { | |
| var tmp = Iw(); | |
| if (tmp && this.b) { | |
| this.g = tmp; | |
| cl(this.w, 0, this); | |
| if (M(cc)) { | |
| this.j = kj(M(cc)); | |
| this.m = kj(M(fc)); | |
| S(M(cc), false); | |
| S(M(fc), false); | |
| } | |
| tmp = Uv(window).toString(); | |
| this.c = by(tmp); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| Tz.prototype.B = function(key) { | |
| var d = key.b.detail; | |
| if (1 < d && Kj(key) && Ef(this.a, key.target)) { | |
| key.preventDefault(); | |
| ay(this.b); | |
| key = {}; | |
| key.clickCount = d; | |
| this.C.log("dblClickSelectall", key); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Tz.prototype.w = function() { | |
| if (this.g) { | |
| this.g.select(); | |
| /** @type {null} */ | |
| this.g = null; | |
| } | |
| if (this.c) { | |
| mi(this.c); | |
| /** @type {null} */ | |
| this.c = null; | |
| } | |
| if (this.j) { | |
| S(M(cc), true); | |
| } | |
| if (this.m) { | |
| S(M(fc), true); | |
| } | |
| }; | |
| /** @type {!Array} */ | |
| var Uz = [r, ih ? Jc : Ic, Kc]; | |
| /** | |
| * @param {undefined} type | |
| * @param {!Object} n | |
| * @param {number} p | |
| * @param {(number|string)} l | |
| * @return {undefined} | |
| */ | |
| var Vz = function(type, n, p, l) { | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| var f = function(e) { | |
| var f = Zj(n); | |
| var orig = ri(e.target) ? e.target.getAttribute(rd) || null : null; | |
| if (e.type == r && Kj(e)) { | |
| f.call(p, e); | |
| } else { | |
| if (13 != e.keyCode && 3 != e.keyCode || e.type == Kc) { | |
| if (!(32 != e.keyCode || e.type != Kc || orig != Xa && "tab" != orig)) { | |
| f.call(p, e); | |
| e.preventDefault(); | |
| } | |
| } else { | |
| e.type = Jc; | |
| f.call(p, e); | |
| } | |
| } | |
| }; | |
| /** @type {!Object} */ | |
| f.a = n; | |
| /** @type {number} */ | |
| f.b = p; | |
| if (l) { | |
| l.a(type, Uz, f, void 0); | |
| } else { | |
| U(type, Uz, f, void 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Function} value | |
| * @return {?} | |
| */ | |
| var Wz = function(value) { | |
| /** @type {string} */ | |
| var tmp = '<div class="jfk-bubble" role="alertdialog"' + (value.uid ? ' aria-describedby="' + tp(value.uid) + '"' : "") + '><div class="jfk-bubble-content-id"' + (value.uid ? ' id="' + tp(value.uid) + '"' : "") + "></div>"; | |
| if (value.tj) { | |
| /** @type {string} */ | |
| value = tmp; | |
| /** @type {string} */ | |
| tmp = "Close".replace(rp, sp); | |
| /** @type {string} */ | |
| tmp = value + ('<div class="jfk-bubble-closebtn-id jfk-bubble-closebtn" aria-label="' + tmp + '" role="button" tabindex=0></div>'); | |
| } | |
| return mp(tmp + '<div class="jfk-bubble-arrow-id jfk-bubble-arrow"><div class="jfk-bubble-arrowimplbefore"></div><div class="jfk-bubble-arrowimplafter"></div></div></div>'); | |
| }; | |
| /** | |
| * @param {?} conn | |
| * @return {undefined} | |
| */ | |
| var Xz = function(conn) { | |
| W.call(this, conn); | |
| this.c = new to("jfk-bubble", true); | |
| this.b = new Ex; | |
| /** @type {!Array} */ | |
| this.w = []; | |
| }; | |
| C(Xz, W); | |
| /** @type {boolean} */ | |
| Xz.prototype.g = true; | |
| /** | |
| * @param {?} i | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| var Zz = function(i, text) { | |
| /** @type {string} */ | |
| i.I = text; | |
| Yz(i, text); | |
| }; | |
| /** | |
| * @param {?} p | |
| * @param {string} point | |
| * @return {undefined} | |
| */ | |
| var Yz = function(p, point) { | |
| var object = p.yb(); | |
| if (point && object) { | |
| if (Fe(point)) { | |
| Q(object, point); | |
| } else { | |
| if (point instanceof lp) { | |
| Nh(object, ep(point)); | |
| } else { | |
| if (point instanceof Fg) { | |
| Nh(object, point); | |
| } else { | |
| Nh(object, Qg); | |
| object.appendChild(point); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| y = Xz.prototype; | |
| /** | |
| * @param {boolean} autoHide | |
| * @return {undefined} | |
| */ | |
| y.setAutoHide = function(autoHide) { | |
| this.b.setAutoHide(autoHide); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.yb = function() { | |
| return Hl(this, "jfk-bubble-content-id"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| this.D = jp(Wz, { | |
| tj : this.g, | |
| uid : "bubble-" + Le(this) | |
| }, void 0, this.a); | |
| Yz(this, this.I); | |
| S(this.l(), false); | |
| this.b.ld(this.l()); | |
| if (!jh) { | |
| var b = this.b; | |
| var BemFormatter = Bx(this.l(), .218, "ease-out", 0, 1); | |
| var o = Bx(this.l(), .218, "ease-in", 1, 0); | |
| b.B = BemFormatter; | |
| b.o = o; | |
| } | |
| Ch(this.l(), this.w); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| Xz.v.V.call(this); | |
| X(this).a(this.b, [Ta, Ad, Sa, pc], this.H); | |
| if (this.g) { | |
| var f = X(this); | |
| var arg = Hl(this, "jfk-bubble-closebtn-id"); | |
| Vz(arg, Oe(this.setVisible, false), f.F || f, f); | |
| } | |
| f = this.l(); | |
| arg = Hl(this, "jfk-bubble-arrow-id"); | |
| var c = this.c; | |
| c.c = f; | |
| c.j = arg; | |
| f = this.b; | |
| f.H = this.c || void 0; | |
| if (f.isVisible()) { | |
| f.w(); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(id) { | |
| this.b.setVisible(id); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.isVisible = function() { | |
| return this.b.isVisible(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var $z = function(a) { | |
| if (a.isVisible()) { | |
| a.b.w(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xz.prototype.J = function() { | |
| this.b.za(); | |
| delete this.b; | |
| Xz.v.J.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Xz.prototype.j = function() { | |
| bj(this.l()); | |
| return false; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| Xz.prototype.H = function(name) { | |
| if (name.type == Ad || name.type == pc) { | |
| var _ = X(this); | |
| var a = this.a; | |
| a = E ? Ki(a) : a.a; | |
| if (name.type == Ad) { | |
| _.a(a, td, this.j); | |
| } else { | |
| _.b(a, td, this.j); | |
| } | |
| } | |
| return this.dispatchEvent(name.type); | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @param {(Object|string)} options | |
| * @param {?} item | |
| * @param {number} w | |
| * @param {?} t | |
| * @param {!Array} val | |
| * @return {undefined} | |
| */ | |
| var aA = function(compiler, options, item, w, t, val) { | |
| W.call(this); | |
| this.g = Wp.M(); | |
| /** @type {(Object|string)} */ | |
| this.o = options; | |
| this.A = item; | |
| /** @type {number} */ | |
| this.w = w; | |
| this.H = t; | |
| /** @type {number} */ | |
| this.c = compiler; | |
| /** @type {null} */ | |
| this.b = this.j = null; | |
| /** @type {!Array} */ | |
| this.m = val; | |
| }; | |
| C(aA, W); | |
| y = aA.prototype; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(id) { | |
| if (id) { | |
| this.g.log(cb, "show-" + this.c); | |
| this.j.setVisible(true); | |
| if (!this.m) { | |
| this.g.log(cb, "open-" + this.c); | |
| this.b.setVisible(true); | |
| /** @type {boolean} */ | |
| this.m = true; | |
| $p(this.g, ha + this.c); | |
| } | |
| } else { | |
| this.j.setVisible(false); | |
| this.b.setVisible(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| y.Y = function(d) { | |
| aA.v.Y.call(this, d); | |
| var value = P(k, { | |
| id : this.c + "-button", | |
| style : pb | |
| }); | |
| d.insertBefore(value, d.firstChild); | |
| this.j = new eo("", new Vo("trans-verified-button", true)); | |
| this.j.R(value); | |
| d = this.b = new Xz; | |
| d.c.b = value; | |
| $z(d); | |
| uo(this.b.c, 1, 1, void 0); | |
| /** @type {boolean} */ | |
| this.b.g = false; | |
| this.b.aa(); | |
| value = op(Fs, { | |
| id : this.c, | |
| $e : this.o, | |
| qd : this.A, | |
| Qh : this.w, | |
| url : this.H | |
| }); | |
| Zz(this.b, value); | |
| this.b.setVisible(false); | |
| U(this.j, p, this.Fj, false, this); | |
| value = O("vt-link", this.b.l()); | |
| X(this).a(value, r, this.Ej); | |
| value = O("vt-dismiss", this.b.l()); | |
| X(this).a(value, r, this.di); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Fj = function() { | |
| if (rx(this.b.b)) { | |
| this.b.setVisible(false); | |
| } else { | |
| this.g.log(cb, "open-" + this.c); | |
| this.b.setVisible(true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ej = function() { | |
| this.g.log(cb, "click-" + this.c); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.di = function() { | |
| this.g.log(cb, "dismiss-" + this.c); | |
| this.b.setVisible(false); | |
| }; | |
| var bA = function() { | |
| var match; | |
| return lh ? (match = /Windows NT ([0-9.]+)/, (match = match.exec(bg)) ? match[1] : "0") : kh ? (match = /10[_.][0-9_.]+/, (match = match.exec(bg)) ? match[0].replace(/_/g, ".") : "10") : mh ? (match = /Android\s+([^\);]+)(\)|;)/, (match = match.exec(bg)) ? match[1] : "") : nh || oh || ph ? (match = /(?:iPhone|CPU)\s+OS\s+(\S+)/, (match = match.exec(bg)) ? match[1].replace(/_/g, ".") : "") : ""; | |
| }(); | |
| var cA = ue(); | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var dA = function(a) { | |
| var p = P(Hd); | |
| /** @type {string} */ | |
| p.style.color = "transparent"; | |
| /** @type {string} */ | |
| p.style.background = "transparent"; | |
| /** @type {string} */ | |
| p.style.top = "-1000px"; | |
| /** @type {string} */ | |
| p.style.left = "-1000px"; | |
| p.style.position = Ga; | |
| document.body.appendChild(p); | |
| Q(p, a); | |
| a = p.offsetWidth; | |
| mi(p); | |
| return a; | |
| }; | |
| Be(cA); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var eA = function() { | |
| cA.M(); | |
| }; | |
| Be(eA); | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var fA = function(a) { | |
| var fa = dA(a); | |
| a = dA(a.substr(0, 1)); | |
| return fa != a; | |
| }; | |
| /** | |
| * @param {string} prop | |
| * @return {undefined} | |
| */ | |
| var gA = function(prop) { | |
| this.b = mj(""); | |
| this.a = (De(prop) ? prop.join(",") : prop) + "{font-family:%FONT%arial,sans-serif!important}"; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| gA.prototype.set = function(name) { | |
| name = "" == name ? "" : this.a.replace("%FONT%", '"' + name + '",'); | |
| lj(this.b, Mi(name)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hA = function() { | |
| eA.M(); | |
| this.a = { | |
| am : dA("\u1288") == dA("\u1290"), | |
| bn : fA("\u09a5\u09cd"), | |
| km : fA("\u1780\u17d1"), | |
| lo : fA("\u0e81\u0ec8"), | |
| ml : fA("\u0d15\u0d4d"), | |
| my : fA("\u1001\u1039\u1010"), | |
| ps : true, | |
| sd : true, | |
| si : fA("\u0da5\u0dca"), | |
| ta : fA("\u0ba4\u0bcd") || dA("\u0bb1\u0bc6\u0bbe") + dA("\u0bb1") != dA("\u0bb1\u0bc6") + dA("\u0bb1\u0bbe") | |
| }; | |
| }; | |
| Be(hA); | |
| var iA = { | |
| "Noto Sans Ethiopic" : "notosansethiopic", | |
| "Noto Naskh Arabic" : "notonaskharabic", | |
| "Noto Sans Malayalam" : "notosansmalayalam", | |
| "Noto Sans Myanmar" : "notosansmyanmar", | |
| "Noto Sans Sinhala" : "notosanssinhala" | |
| }; | |
| var jA = { | |
| Dhyana : Al || fh || yl || xl || wl | |
| }; | |
| var kA; | |
| if (kA = lh) { | |
| /** @type {boolean} */ | |
| kA = 0 <= sf(bA, "6.0"); | |
| } | |
| var lA = { | |
| lo : kA | |
| }; | |
| var mA = { | |
| am : "Noto Sans Ethiopic", | |
| bn : "Lohit Bengali", | |
| lo : "Dhyana", | |
| km : "Nokora", | |
| ml : "Noto Sans Malayalam", | |
| my : "Noto Sans Myanmar", | |
| ps : ua, | |
| sd : ua, | |
| si : "Noto Sans Sinhala", | |
| ta : "Lohit Tamil" | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var nA = function() { | |
| this.a = {}; | |
| hA.M(); | |
| }; | |
| Be(nA); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var rA = function() { | |
| this.j = hA.M(); | |
| this.b = nA.M(); | |
| this.a = new gA(oA); | |
| this.c = new gA(pA); | |
| this.g = new gA(qA); | |
| }; | |
| /** @type {!Array} */ | |
| var oA = ["body", "#gb"]; | |
| /** @type {!Array<string>} */ | |
| var pA = "#source .gt-hl-layer .gt-baf-translations .round-trip-content .vk-cap .vk-t .orig".split(" "); | |
| /** @type {!Array<string>} */ | |
| var qA = "#result_box .gt-baf-word .gt-baf-word-clickable .alt-menu .gt-ex-translate #alt-input-text .text-wrap".split(" "); | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} prop | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var sA = function(b, prop, value) { | |
| a: { | |
| var type = lA[value]; | |
| var obj = b.j.a[value]; | |
| if ((null == type || !type) && null != obj && obj && (value = mA[value], null != value && (type = jA[value], null == type || !type))) { | |
| break a; | |
| } | |
| /** @type {string} */ | |
| value = ""; | |
| } | |
| b = b.b; | |
| if ("" != value && null == b.a[value]) { | |
| b = b.a; | |
| obj = type = value; | |
| var exports = new Sq; | |
| if (null != iA[obj]) { | |
| /** @type {string} */ | |
| exports.j = "/earlyaccess/" + iA[obj] + ".css"; | |
| } else { | |
| /** @type {string} */ | |
| exports.j = "/css"; | |
| exports.a.set("family", obj); | |
| } | |
| b[type] = mj("@import url(//fonts.googleapis.com" + exports.toString() + ");"); | |
| } | |
| prop.set(value); | |
| }; | |
| /** | |
| * @param {!Object} prop | |
| * @param {string} startValue | |
| * @return {undefined} | |
| */ | |
| var tA = function(prop, startValue) { | |
| sA(prop, prop.a, startValue); | |
| }; | |
| /** | |
| * @param {!Object} prop | |
| * @param {string} re | |
| * @return {undefined} | |
| */ | |
| var uA = function(prop, re) { | |
| sA(prop, prop.c, re); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} childCompute | |
| * @return {undefined} | |
| */ | |
| var vA = function(options, childCompute) { | |
| sA(options, options.g, childCompute); | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @return {undefined} | |
| */ | |
| var wA = function(a) { | |
| this.rb = a || []; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var xA = function(a) { | |
| this.a = a || []; | |
| }; | |
| wA.prototype.b = w("rb"); | |
| /** | |
| * @param {?} m | |
| * @param {!Object} att | |
| * @return {?} | |
| */ | |
| var yA = function(m, att) { | |
| return Tl(m.rb, 0)[att]; | |
| }; | |
| /** | |
| * @param {?} m | |
| * @param {!Object} att | |
| * @return {?} | |
| */ | |
| var zA = function(m, att) { | |
| return Tl(m.rb, 1)[att]; | |
| }; | |
| xA.prototype.b = w("a"); | |
| var AA = new wA; | |
| /** | |
| * @param {string} diff | |
| * @return {?} | |
| */ | |
| var BA = function(diff) { | |
| return (diff = diff.a[0]) ? new wA(diff) : AA; | |
| }; | |
| var CA = new tv; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var HA = function(data) { | |
| var doc = M("gt-res-tools-l"); | |
| var node = M(jc); | |
| /** @type {string} */ | |
| M(ec).style.display = ""; | |
| if (zl && jv(43) || E && I(11) || fh && I(29)) { | |
| var test = new eo(MSG_COPY, new Vo("copy-button")); | |
| test.R(DA(bc, doc)); | |
| test.setVisible(false); | |
| data.b = test; | |
| } else { | |
| if (MSG_SELECT_ALL && "" != MSG_SELECT_ALL) { | |
| test = new eo(MSG_SELECT_ALL, new Vo("select-button")); | |
| test.R(DA("gt-res-select", doc)); | |
| test.setVisible(false); | |
| data.b = test; | |
| } | |
| } | |
| data.L = EA("gt-res-roman", doc, nd); | |
| data.I = FA("gt-res-listen", doc); | |
| data.wa = EA("gt-src-roman", node, Jd); | |
| data.P = FA("gt-src-listen", node); | |
| if (nr) { | |
| data.a = P(k, { | |
| id : $b, | |
| style : "display:inline-block" | |
| }); | |
| node.appendChild(data.a); | |
| if (MSG_SHARE) { | |
| node = new eo(MSG_SHARE, new Vo("share-button")); | |
| node.R(DA("gt-res-share", doc)); | |
| node.setVisible(false); | |
| data.N = node; | |
| } | |
| } | |
| data.O = GA(); | |
| data.X = GA(); | |
| data.B = vr; | |
| return data; | |
| }; | |
| /** | |
| * @param {string} c | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var DA = function(c, d) { | |
| var p = P(k, { | |
| id : c, | |
| style : pb | |
| }); | |
| d.appendChild(p); | |
| return p; | |
| }; | |
| /** | |
| * @param {string} date | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var FA = function(date, value) { | |
| var input = new So(MSG_LISTEN, void 0, new Vo(be)); | |
| input.R(DA(date, value)); | |
| input.setVisible(false); | |
| return input; | |
| }; | |
| /** | |
| * @param {string} i | |
| * @param {!Object} value | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var EA = function(i, value, node) { | |
| node = new To(MSG_READ_PHONETICALLY, M(node), void 0, new Vo("trans-roman-button")); | |
| node.R(DA(i, value)); | |
| node.setVisible(false); | |
| return node; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var GA = function() { | |
| var L = new eo(MSG_CLEAR_TEXT, new Vo("clear-button")); | |
| L.R(P(k, { | |
| id : "gt-clear", | |
| style : pb, | |
| tabindex : "0" | |
| })); | |
| L.setVisible(false); | |
| return L; | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {?} status | |
| * @return {undefined} | |
| */ | |
| var IA = function(b, status) { | |
| /** @type {string} */ | |
| this.m = ""; | |
| /** @type {number} */ | |
| this.b = b; | |
| this.A = P("a", { | |
| href : "javascript:;", | |
| id : "gt-bbar-dm" | |
| }, MSG_DISMISS); | |
| this.g = P("a", { | |
| id : "gt-bbar-lm" | |
| }); | |
| this.w = P(Hd); | |
| var div = P(Hd); | |
| div.appendChild(this.w); | |
| div.appendChild(this.g); | |
| div.appendChild(this.A); | |
| U(this.A, r, this.H, false, this); | |
| U(this.g, r, this.I, false, this); | |
| Mw.call(this, div, status); | |
| }; | |
| C(IA, Mw); | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| IA.prototype.log = function(name) { | |
| var b = { | |
| hl : this.b, | |
| type : this.m | |
| }; | |
| Wp.M().log(name, b); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var JA = function(item) { | |
| if (!(Te(MSG_BUTTER_BAR_DESC) && Te(MSG_BUTTER_BAR_BUTTON))) { | |
| item.m = BUTTER_BAR_LOGTYPE; | |
| Q(item.w, MSG_BUTTER_BAR_DESC); | |
| Q(item.g, MSG_BUTTER_BAR_BUTTON); | |
| item.g.href = BUTTER_BAR_URL; | |
| item.setVisible(true); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| IA.prototype.setVisible = function(id) { | |
| if (id) { | |
| this.log("bbarshow"); | |
| } | |
| IA.v.setVisible.call(this, id); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| IA.prototype.I = function() { | |
| this.setVisible(false); | |
| this.log("bbarlm"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| IA.prototype.H = function() { | |
| this.setVisible(false); | |
| $p(Wp.M(), "/translate/uc?ua=dismiss&uav=" + this.m); | |
| }; | |
| var KA = ve("a"); | |
| /** | |
| * @param {string} i | |
| * @param {boolean} x | |
| * @param {boolean} index | |
| * @return {undefined} | |
| */ | |
| var LA = function(i, x, index) { | |
| var m = M(i); | |
| if (m) { | |
| S(m, x); | |
| } else { | |
| if (index) { | |
| null.Qj("Element was not found on the page. ID=" + i); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} repeats | |
| * @return {undefined} | |
| */ | |
| var MA = function(a, repeats) { | |
| LA("file", repeats, false); | |
| LA("file_div", repeats, false); | |
| if (repeats) { | |
| var attr = a.a; | |
| if (null != attr.Ae) { | |
| attr.Ae.Th(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} repeats | |
| * @return {undefined} | |
| */ | |
| var PA = function(a, repeats) { | |
| LA("gt-src-wrap", repeats, true); | |
| NA(repeats); | |
| OA(a.a); | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var NA = function(x) { | |
| if (x) { | |
| x = M(ic); | |
| /** @type {number} */ | |
| var target = 0; | |
| var minOffset = x.childNodes.length; | |
| for (; target < minOffset; target++) { | |
| if (x.childNodes[target].style.display != ad) { | |
| LA(ic, true, true); | |
| return; | |
| } | |
| } | |
| } | |
| LA(ic, false, true); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var QA = function() { | |
| T.call(this, he); | |
| }; | |
| C(QA, T); | |
| /** | |
| * @param {?} fh | |
| * @return {undefined} | |
| */ | |
| var RA = function(fh) { | |
| T.call(this, Gd); | |
| this.fh = fh; | |
| }; | |
| C(RA, T); | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var SA = function(a, b) { | |
| /** @type {string} */ | |
| var id = "ex"; | |
| if (null != b && b) { | |
| /** @type {string} */ | |
| id = "m" + id; | |
| } | |
| Lr.call(this, a, id, MSG_EXAMPLES_OF, MSG_EXAMPLES); | |
| this.c = new am; | |
| this.L = this.A = Qc; | |
| }; | |
| C(SA, Lr); | |
| /** | |
| * @param {number} result | |
| * @param {string} a | |
| * @param {!Object} e | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| SA.prototype.update = function(result, a, e, v) { | |
| SA.v.update.call(this, result, a, e, v); | |
| ji(this.b); | |
| this.c = (result = v.a[13]) ? new am(result) : Km; | |
| if (0 == Y(this.c.a, 0)) { | |
| return false; | |
| } | |
| this.setVisible(true); | |
| if (3 <= Y(this.c.a, 0)) { | |
| result = MSG_N_MORE_EXAMPLES_LABEL.replace(aa, Y(this.c.a, 0) - 1); | |
| Nr(this, result, MSG_FEWER_EXAMPLES_LABEL); | |
| } | |
| this.A = ag(this.g) ? sd : Qc; | |
| this.L = ag(this.j) ? sd : Qc; | |
| /** @type {number} */ | |
| result = 0; | |
| for (; result < Y(this.c.a, 0); ++result) { | |
| /** @type {boolean} */ | |
| a = 0 == result || 1 == result && 2 == Y(this.c.a, 0); | |
| var city; | |
| /** @type {number} */ | |
| e = result; | |
| city = new $l(Tl(this.c.a, 0)[e]); | |
| e = city.a[0]; | |
| v = city.a[1]; | |
| city = city.a[2]; | |
| e = jp(Jp, { | |
| uj : this.A, | |
| fh : null != e ? e : "", | |
| yf : null != city ? city : "", | |
| Li : null != v ? v : "", | |
| Tf : this.L, | |
| Mj : MSG_MT_FROM_GOOGLE | |
| }); | |
| a = Or(e, a); | |
| this.b.appendChild(a); | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| SA.prototype.qg = function() { | |
| var labelFormatObject = {}; | |
| labelFormatObject.total = Y(this.c.a, 0); | |
| return labelFormatObject; | |
| }; | |
| /** @type {!RegExp} */ | |
| var TA = /^[\w+/]+[=]{0,2}$/; | |
| /** | |
| * @param {number} t | |
| * @param {string} n | |
| * @param {number} s | |
| * @return {undefined} | |
| */ | |
| var UA = function(t, n, s) { | |
| /** @type {number} */ | |
| this.a = t; | |
| /** @type {string} */ | |
| this.g = n; | |
| /** @type {number} */ | |
| this.b = s; | |
| }; | |
| /** @type {!Array} */ | |
| var VA = ["file", "gt-otf-switch", "gt-tl", "gt-res-listen", pd, "gt-res-roman", Id, Fd, "gt-sl", "gt-src-listen", "gt-src-roman", nd, Jd]; | |
| /** | |
| * @param {!Object} res | |
| * @return {undefined} | |
| */ | |
| var WA = function(res) { | |
| if (null != res.a) { | |
| U(res.a, r, res.c, false, res); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| UA.prototype.c = function() { | |
| var options = { | |
| productId : "275", | |
| locale : this.b | |
| }; | |
| var item = this.g; | |
| var obj = { | |
| NO_CACHE_RESULT : item.Be ? lq(item.Be) : "not found" | |
| }; | |
| obj.DISPLAY_LANGUAGE = item.b; | |
| obj.SOURCE_LANGUAGE = XA(item); | |
| obj.TARGET_LANGUAGE = YA(item); | |
| obj.ACTUAL_SOURCE = ZA(item); | |
| obj.SOURCE_TEXT = $A(item); | |
| obj.TARGET_TEXT = cz(item.c, void 0); | |
| obj.SOURCE_STATIC = zt(item.a.w.a); | |
| obj.TARGET_STATIC = zt(item.a.F.a); | |
| obj.BOTTOM_SUGG = zt(item.a.C.a); | |
| if (!(ZA(item) == YA(item) || Te($A(item)) || Te(cz(item.c, void 0)) || $A(item) != cz(item.c, void 0))) { | |
| /** @type {string} */ | |
| obj.IDENTICAL_TRANSLATION = "1"; | |
| } | |
| if (window.JS_ERR_COUNT) { | |
| obj.JS_ERR_COUNT = JS_ERR_COUNT; | |
| obj.JS_ERR_ARR = JS_ERR_ARR; | |
| } | |
| if (null != item.L) { | |
| /** @type {number} */ | |
| obj.TTL = item.lg - item.L; | |
| } | |
| if (null != item.Le) { | |
| obj.TTNC = item.Le; | |
| } | |
| if (0 < EXPERIMENT_IDS.length) { | |
| obj.EXP = EXPERIMENT_IDS.join(","); | |
| } | |
| if (item.wd) { | |
| item = item.wd; | |
| item = 10 * (item.c - 1) + item.m; | |
| if (0 <= item) { | |
| obj.HATS = item; | |
| } | |
| } | |
| var i; | |
| for (i in VA) { | |
| var type = VA[i]; | |
| /** @type {(Element|null)} */ | |
| item = document.getElementById(type); | |
| /** @type {string} */ | |
| type = "ELEMENT[id:" + type + "]"; | |
| /** @type {string} */ | |
| obj[type] = item ? "exists" : "missing"; | |
| if (item) { | |
| if ("value" in item) { | |
| /** @type {string} */ | |
| obj[type + ".value"] = "" + item.value; | |
| } | |
| if ("" != Fi(item)) { | |
| /** @type {string} */ | |
| obj[type + ".innerText"] = "" + Fi(item); | |
| } | |
| } | |
| } | |
| try { | |
| /** @type {number} */ | |
| options.timeOfStartCall = (new Date).getTime(); | |
| var frameDocument = z.document; | |
| var data; | |
| var script = (z || z).document.querySelector("script[nonce]"); | |
| var params = script && script.getAttribute("nonce"); | |
| if (data = params && TA.test(params) ? params : void 0) { | |
| options.nonce = data; | |
| } | |
| if ("help" == options.flow) { | |
| var xyz = ze("document.location.href", z); | |
| if (!options.helpCenterContext && xyz) { | |
| options.helpCenterContext = xyz.substring(0, 1200); | |
| } | |
| /** @type {boolean} */ | |
| script = true; | |
| if (obj && JSON && JSON.stringify) { | |
| /** @type {string} */ | |
| var args = JSON.stringify(obj); | |
| if (script = 1200 >= args.length) { | |
| /** @type {string} */ | |
| options.psdJson = args; | |
| } | |
| } | |
| if (!script) { | |
| obj = { | |
| invalidPsd : true | |
| }; | |
| } | |
| } | |
| /** @type {!Array} */ | |
| args = [options, obj, void 0]; | |
| /** @type {!Array} */ | |
| z.GOOGLE_FEEDBACK_START_ARGUMENTS = args; | |
| var path = options.serverUri || "//www.google.com/tools/feedback"; | |
| var m = z.GOOGLE_FEEDBACK_START; | |
| if (m) { | |
| m.apply(z, args); | |
| } else { | |
| /** @type {string} */ | |
| path = path + "/load.js?"; | |
| var name; | |
| for (name in options) { | |
| var otpUrl = options[name]; | |
| if (null != otpUrl && !Ie(otpUrl)) { | |
| /** @type {string} */ | |
| path = path + (encodeURIComponent(name) + "=" + encodeURIComponent(otpUrl) + "&"); | |
| } | |
| } | |
| var el = frameDocument.createElement("script"); | |
| if (data) { | |
| el.setAttribute("nonce", data); | |
| } | |
| /** @type {string} */ | |
| el.src = path; | |
| frameDocument.body.appendChild(el); | |
| } | |
| } catch (Ba) { | |
| } | |
| }; | |
| /** | |
| * @param {?} conn | |
| * @return {undefined} | |
| */ | |
| var aB = function(conn) { | |
| W.call(this, conn); | |
| }; | |
| C(aB, W); | |
| /** | |
| * @return {undefined} | |
| */ | |
| aB.prototype.ra = function() { | |
| this.D = this.a.b("FORM", { | |
| method : wa, | |
| style : pb | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {!Array} input | |
| * @param {string} url | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| var cB = function(m, input, url, text) { | |
| var el = m.l(); | |
| if (!el) { | |
| m.aa(); | |
| el = m.l(); | |
| } | |
| el.action = url || ""; | |
| el.target = text || ""; | |
| bB(m, el, input); | |
| el.submit(); | |
| }; | |
| /** | |
| * @param {!Function} f | |
| * @param {undefined} e | |
| * @param {!Array} w | |
| * @return {undefined} | |
| */ | |
| var bB = function(f, e, w) { | |
| var j; | |
| var v; | |
| /** @type {!Array} */ | |
| var newY = []; | |
| for (j in w) { | |
| v = w[j]; | |
| if (Ee(v)) { | |
| xf(v, A(function(slackName) { | |
| newY.push(dB(j, String(slackName))); | |
| }, f)); | |
| } else { | |
| newY.push(dB(j, String(v))); | |
| } | |
| } | |
| Nh(e, Pg(newY)); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} handler | |
| * @return {?} | |
| */ | |
| var dB = function(name, handler) { | |
| return Og(wc, { | |
| type : oc, | |
| name : name, | |
| value : handler | |
| }); | |
| }; | |
| /** | |
| * @param {number} c | |
| * @param {!Array} val | |
| * @param {number} opt_validate | |
| * @return {undefined} | |
| */ | |
| var eB = function(c, val, opt_validate) { | |
| W.call(this); | |
| /** @type {number} */ | |
| this.c = c; | |
| /** @type {!Array} */ | |
| this.m = val; | |
| /** @type {number} */ | |
| this.j = opt_validate; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| }; | |
| C(eB, W); | |
| y = eB.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| eB.v.ra.call(this); | |
| this.Y(di(k)); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| y.Y = function(s) { | |
| eB.v.Y.call(this, s); | |
| J(s, "pt-wrap"); | |
| s.appendChild(ip(Dp, { | |
| Dh : MSG_HUMAN_TRANSLATION_ACTION, | |
| $e : MSG_HUMAN_TRANSLATION_DESCRIPTION | |
| })); | |
| X(this).a(this.l(), r, this.Gj); | |
| s = new eo(MSG_DISMISS, new Vo("clear-button")); | |
| s.aa(this.l()); | |
| this.g = s.l(); | |
| X(this).a(s, p, this.Hj); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| y.Gj = function(a) { | |
| if (!a.target || !ti(this.g, a.target)) { | |
| a = new aB; | |
| var data = {}; | |
| data.hl = this.j; | |
| var c = ZA(this.c); | |
| if (c != Qa) { | |
| data.sl = c; | |
| } | |
| data.tl = YA(this.c); | |
| data.r = ge; | |
| c = $A(this.m, true); | |
| if (1500 > Xe(c).length) { | |
| data.src = c; | |
| window.open(fa + sq(data) + "#text", "_top"); | |
| } else { | |
| var d = {}; | |
| d.src = c; | |
| cB(a, d, fa + sq(data) + "#text"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Hj = function() { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| (new By(this.l(), 300)).play(); | |
| Wp.M().log("dismissht"); | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(id) { | |
| if (!this.b) { | |
| S(this.l(), id); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} M | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| var fB = function(M, s) { | |
| this.j = Wp.M(); | |
| /** @type {string} */ | |
| this.g = s; | |
| /** @type {number} */ | |
| this.b = this.c = this.a = 0; | |
| this.Gc = new io(this.Tg, 3E3, this); | |
| U(M, "copy", this.Jj, false, this); | |
| U(M, Zc, this.Kj, false, this); | |
| U(M, eb, this.bi, false, this); | |
| U(M, r, this.Ij, false, this); | |
| }; | |
| y = fB.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Jj = function() { | |
| jo(this.Gc); | |
| this.Tg(1); | |
| }; | |
| /** | |
| * @param {number} data | |
| * @return {undefined} | |
| */ | |
| y.Tg = function(data) { | |
| /** @type {number} */ | |
| var autoReview = 0; | |
| if (data) { | |
| /** @type {number} */ | |
| autoReview = data; | |
| } | |
| this.j.log(this.g, { | |
| cpy : autoReview, | |
| clk : this.a, | |
| sel : this.c, | |
| ctx : this.b | |
| }); | |
| /** @type {number} */ | |
| this.b = this.c = this.a = 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Kj = function() { | |
| if ($x()) { | |
| this.c++; | |
| ko(this.Gc); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} selectedHostFolder | |
| * @return {undefined} | |
| */ | |
| y.Ij = function(selectedHostFolder) { | |
| if (Kj(selectedHostFolder)) { | |
| this.a++; | |
| ko(this.Gc); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.bi = function() { | |
| this.b++; | |
| ko(this.Gc); | |
| }; | |
| var gB = { | |
| 8 : "backspace", | |
| 9 : "tab", | |
| 13 : "enter", | |
| 16 : "shift", | |
| 17 : "ctrl", | |
| 18 : "alt", | |
| 19 : "pause", | |
| 20 : "caps-lock", | |
| 27 : "esc", | |
| 32 : "space", | |
| 33 : "pg-up", | |
| 34 : "pg-down", | |
| 35 : ub, | |
| 36 : "home", | |
| 37 : Pc, | |
| 38 : "up", | |
| 39 : qd, | |
| 40 : "down", | |
| 45 : "insert", | |
| 46 : "delete", | |
| 48 : "0", | |
| 49 : "1", | |
| 50 : "2", | |
| 51 : "3", | |
| 52 : "4", | |
| 53 : "5", | |
| 54 : "6", | |
| 55 : "7", | |
| 56 : "8", | |
| 57 : "9", | |
| 59 : "semicolon", | |
| 61 : "equals", | |
| 65 : "a", | |
| 66 : "b", | |
| 67 : "c", | |
| 68 : "d", | |
| 69 : "e", | |
| 70 : "f", | |
| 71 : "g", | |
| 72 : "h", | |
| 73 : "i", | |
| 74 : "j", | |
| 75 : "k", | |
| 76 : "l", | |
| 77 : "m", | |
| 78 : "n", | |
| 79 : "o", | |
| 80 : "p", | |
| 81 : "q", | |
| 82 : "r", | |
| 83 : "s", | |
| 84 : "t", | |
| 85 : "u", | |
| 86 : "v", | |
| 87 : "w", | |
| 88 : "x", | |
| 89 : "y", | |
| 90 : "z", | |
| 93 : "context", | |
| 96 : "num-0", | |
| 97 : "num-1", | |
| 98 : "num-2", | |
| 99 : "num-3", | |
| 100 : "num-4", | |
| 101 : "num-5", | |
| 102 : "num-6", | |
| 103 : "num-7", | |
| 104 : "num-8", | |
| 105 : "num-9", | |
| 106 : "num-multiply", | |
| 107 : "num-plus", | |
| 109 : "num-minus", | |
| 110 : "num-period", | |
| 111 : "num-division", | |
| 112 : "f1", | |
| 113 : "f2", | |
| 114 : "f3", | |
| 115 : "f4", | |
| 116 : "f5", | |
| 117 : "f6", | |
| 118 : "f7", | |
| 119 : "f8", | |
| 120 : "f9", | |
| 121 : "f10", | |
| 122 : "f11", | |
| 123 : "f12", | |
| 186 : "semicolon", | |
| 187 : "equals", | |
| 189 : "dash", | |
| 188 : ",", | |
| 190 : ".", | |
| 191 : "/", | |
| 192 : "`", | |
| 219 : "open-square-bracket", | |
| 220 : "\\", | |
| 221 : "close-square-bracket", | |
| 222 : "single-quote", | |
| 224 : "win" | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var jB = function(a) { | |
| V.call(this); | |
| this.b = this.c = {}; | |
| /** @type {number} */ | |
| this.j = 0; | |
| this.A = Yf(hB); | |
| this.O = Yf(iB); | |
| /** @type {boolean} */ | |
| this.o = true; | |
| /** @type {null} */ | |
| this.m = null; | |
| /** @type {number} */ | |
| this.a = a; | |
| U(this.a, Ic, this.g, false, this); | |
| if (ih) { | |
| U(this.a, Kc, this.B, false, this); | |
| } | |
| if (lh && !ih) { | |
| U(this.a, Jc, this.C, false, this); | |
| U(this.a, Kc, this.w, false, this); | |
| } | |
| }; | |
| var kB; | |
| C(jB, V); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var lB = function(a) { | |
| this.a = a || null; | |
| /** @type {(null|{})} */ | |
| this.next = a ? null : {}; | |
| }; | |
| /** @type {!Array} */ | |
| var hB = [27, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 19]; | |
| /** @type {!Array} */ | |
| var iB = ["color", "date", "datetime", "datetime-local", "email", "month", bd, "password", "search", "tel", "text", "time", "url", "week"]; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| jB.prototype.K = function(key, name) { | |
| mB(this.c, nB(arguments), key); | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @return {?} | |
| */ | |
| var nB = function(a) { | |
| if (Fe(a[1])) { | |
| a = zf(oB(a[1]), function(event) { | |
| return event.keyCode & 255 | event.Pi << 8; | |
| }); | |
| } else { | |
| /** @type {!Array} */ | |
| var actual = a; | |
| /** @type {number} */ | |
| var i = 1; | |
| if (De(a[1])) { | |
| actual = a[1]; | |
| /** @type {number} */ | |
| i = 0; | |
| } | |
| /** @type {!Array} */ | |
| a = []; | |
| for (; i < actual.length; i = i + 2) { | |
| a.push(actual[i] & 255 | actual[i + 1] << 8); | |
| } | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| jB.prototype.J = function() { | |
| jB.v.J.call(this); | |
| this.c = {}; | |
| hk(this.a, Ic, this.g, false, this); | |
| if (ih) { | |
| hk(this.a, Kc, this.B, false, this); | |
| } | |
| if (lh && !ih) { | |
| hk(this.a, Jc, this.C, false, this); | |
| hk(this.a, Kc, this.w, false, this); | |
| } | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @param {string} src | |
| * @return {?} | |
| */ | |
| var oB = function(src) { | |
| src = src.replace(/[ +]*\+[ +]*/g, "+").replace(/[ ]+/g, " ").toLowerCase(); | |
| src = src.split(" "); | |
| /** @type {!Array} */ | |
| var strokes = []; | |
| var s; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; s = src[j]; j++) { | |
| var param = s.split("+"); | |
| /** @type {null} */ | |
| var value = null; | |
| /** @type {number} */ | |
| s = 0; | |
| var key; | |
| /** @type {number} */ | |
| var _j = 0; | |
| for (; key = param[_j]; _j++) { | |
| switch(key) { | |
| case "shift": | |
| /** @type {number} */ | |
| s = s | 1; | |
| continue; | |
| case "ctrl": | |
| /** @type {number} */ | |
| s = s | 2; | |
| continue; | |
| case "alt": | |
| /** @type {number} */ | |
| s = s | 4; | |
| continue; | |
| case "meta": | |
| /** @type {number} */ | |
| s = s | 8; | |
| continue; | |
| } | |
| param = key; | |
| if (!kB) { | |
| value = {}; | |
| key = void 0; | |
| for (key in gB) { | |
| value[gB[key]] = Cn(parseInt(key, 10)); | |
| } | |
| kB = value; | |
| } | |
| value = kB[param]; | |
| break; | |
| } | |
| strokes.push({ | |
| keyCode : value, | |
| Pi : s | |
| }); | |
| } | |
| return strokes; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| jB.prototype.B = function(key) { | |
| if (kh) { | |
| if (224 == key.keyCode) { | |
| /** @type {boolean} */ | |
| this.G = true; | |
| cl(function() { | |
| /** @type {boolean} */ | |
| this.G = false; | |
| }, 400, this); | |
| return; | |
| } | |
| var metaKey = key.metaKey || this.G; | |
| if (!(67 != key.keyCode && 88 != key.keyCode && 86 != key.keyCode || !metaKey)) { | |
| key.metaKey = metaKey; | |
| this.g(key); | |
| } | |
| } | |
| if (32 == this.m && 32 == key.keyCode) { | |
| key.preventDefault(); | |
| } | |
| /** @type {null} */ | |
| this.m = null; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| jB.prototype.C = function(key) { | |
| if (32 < key.keyCode && lh && !ih && key.ctrlKey && key.altKey) { | |
| /** @type {boolean} */ | |
| this.F = true; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| jB.prototype.w = function(key) { | |
| if (!this.F && lh && !ih && key.ctrlKey && key.altKey) { | |
| this.g(key); | |
| } | |
| }; | |
| /** | |
| * @param {?} obj | |
| * @param {!Array} vec | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| var mB = function(obj, vec, val) { | |
| var key = vec.shift(); | |
| var value = obj[key]; | |
| if (value && (0 == vec.length || value.a)) { | |
| throw Error("Keyboard shortcut conflicts with existing shortcut"); | |
| } | |
| if (vec.length) { | |
| key = key.toString(); | |
| value = new lB; | |
| value = key in obj ? obj[key] : obj[key] = value; | |
| mB(value.next, vec, val); | |
| } else { | |
| obj[key] = new lB(val); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| jB.prototype.g = function(key) { | |
| var keyCode; | |
| keyCode = key.keyCode; | |
| if (16 == keyCode || 17 == keyCode || 18 == keyCode) { | |
| /** @type {boolean} */ | |
| keyCode = false; | |
| } else { | |
| var node = key.target; | |
| /** @type {boolean} */ | |
| var id = node.tagName == Da || node.tagName == ta || node.tagName == oa || node.tagName == ya; | |
| var qty = !id && (node.isContentEditable || node.ownerDocument && "on" == node.ownerDocument.designMode); | |
| /** @type {boolean} */ | |
| keyCode = !id && !qty || this.A[keyCode] ? true : qty ? false : key.altKey || key.ctrlKey || key.metaKey ? true : node.tagName == ta && this.O[node.type] ? 13 == keyCode : node.tagName == ta || node.tagName == oa ? 32 != keyCode : false; | |
| } | |
| if (keyCode) { | |
| if (key.type == Ic && lh && !ih && key.ctrlKey && key.altKey) { | |
| /** @type {boolean} */ | |
| this.F = false; | |
| } else { | |
| keyCode = Cn(key.keyCode); | |
| /** @type {number} */ | |
| node = keyCode & 255 | ((key.shiftKey ? 1 : 0) | (key.ctrlKey ? 2 : 0) | (key.altKey ? 4 : 0) | (key.metaKey ? 8 : 0)) << 8; | |
| if (!this.b[node] || 1500 <= Pe() - this.j) { | |
| this.b = this.c; | |
| this.j = Pe(); | |
| } | |
| if (node = this.b[node]) { | |
| if (node.next) { | |
| this.b = node.next; | |
| this.j = Pe(); | |
| key.preventDefault(); | |
| } else { | |
| this.b = this.c; | |
| this.j = Pe(); | |
| if (this.o) { | |
| key.preventDefault(); | |
| } | |
| node = node.a; | |
| id = key.target; | |
| qty = this.dispatchEvent(new pB(zd, node, id)); | |
| if (!(qty = qty & this.dispatchEvent(new pB("shortcut_" + node, node, id)))) { | |
| key.preventDefault(); | |
| } | |
| if (ih) { | |
| this.m = keyCode; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {(Array|number|string)} b | |
| * @param {?} stat | |
| * @return {undefined} | |
| */ | |
| var pB = function(a, b, stat) { | |
| T.call(this, a, stat); | |
| /** @type {(Array|number|string)} */ | |
| this.B = b; | |
| }; | |
| C(pB, T); | |
| /** | |
| * @param {number} val | |
| * @param {(Object|string)} o | |
| * @return {undefined} | |
| */ | |
| var qB = function(val, o) { | |
| /** @type {number} */ | |
| this.a = val; | |
| /** @type {(Object|string)} */ | |
| this.o = o; | |
| /** @type {null} */ | |
| this.c = null; | |
| this.m = Wp.M(); | |
| this.b = new jB(document); | |
| /** @type {boolean} */ | |
| this.b.o = false; | |
| this.b.K("CTRL_C", 67, kh ? 8 : 2); | |
| U(this.b, zd, this.j, false, this); | |
| }; | |
| C(qB, Aj); | |
| /** | |
| * @return {undefined} | |
| */ | |
| qB.prototype.J = function() { | |
| qB.v.J.call(this); | |
| hk(this.b, zd, this.j, false, this); | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| qB.prototype.j = function(key) { | |
| if (!("CTRL_C" != key.B || $x() || "" != Yx(this.a) || "" == this.a.value)) { | |
| key = cz(this.o.c, true); | |
| this.g = Xx(this.a, false)[1]; | |
| this.c = by(key); | |
| cl(this.B, 0, this); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| qB.prototype.B = function() { | |
| if (this.c) { | |
| this.a.focus(); | |
| if (E && null != this.g) { | |
| var t = this.a; | |
| var c = this.g; | |
| if (Vx(t)) { | |
| t.selectionStart = c; | |
| t.selectionEnd = c; | |
| } else { | |
| if (E) { | |
| c = Zx(t, c); | |
| t = t.createTextRange(); | |
| t.collapse(true); | |
| t.move(Za, c); | |
| t.select(); | |
| } | |
| } | |
| } | |
| mi(this.c); | |
| /** @type {null} */ | |
| this.c = null; | |
| this.m.log("cptrans"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} group | |
| * @param {string} data | |
| * @param {boolean} c | |
| * @return {undefined} | |
| */ | |
| var rB = function(item, group, data, c) { | |
| V.call(this); | |
| /** @type {!Object} */ | |
| this.D = item; | |
| /** @type {string} */ | |
| this.g = group; | |
| item = ni(this.D); | |
| this.b = data ? data : item.length; | |
| ji(this.D); | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| data = 0; | |
| for (; data < this.b; ++data) { | |
| item = new Rp(""); | |
| item.Ba(16, true); | |
| U(item, p, this.m, false, this); | |
| item.aa(this.D); | |
| zn(item.c, item, 0 == data ? 2 : 3); | |
| this.a.push(item); | |
| } | |
| if (this.c = c ? c : false) { | |
| item = new Rp(""); | |
| item.Ba(16, true); | |
| U(item, p, this.m, false, this); | |
| item.aa(this.D); | |
| zn(item.c, item, 3); | |
| this.a.push(item); | |
| } | |
| }; | |
| C(rB, V); | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| rB.prototype.j = function(key) { | |
| var s = key.selected; | |
| key = key.data.slice(0, this.b); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < key.length; ++i) { | |
| this.a[i].Vd(key[i]); | |
| var container = this.g(key[i]); | |
| this.a[i].g(container); | |
| this.a[i].setVisible(true); | |
| this.a[i].ma(key[i] == s); | |
| } | |
| for (; i < this.b; ++i) { | |
| this.a[i].setVisible(false); | |
| } | |
| if (this.c) { | |
| key = this.a[this.b]; | |
| key.Vd(Qa); | |
| key.g(detect_language); | |
| key.setVisible(true); | |
| key.ma(Qa == s); | |
| } | |
| S(this.D, true); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| rB.prototype.m = function(name) { | |
| name.a.ma(true); | |
| this.dispatchEvent({ | |
| type : r, | |
| data : name.a.T() | |
| }); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| rB.prototype.o = function(key) { | |
| if (this.c) { | |
| var c = this.a[this.a.length - 1]; | |
| if ("" == key.data) { | |
| c.g(detect_language); | |
| } else { | |
| key = source_language_detected.replace(/%\d\$s/g, this.g(key.data)); | |
| c.g(key); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var sB = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {null} */ | |
| this.c = this.m = this.B = this.o = this.j = this.g = null; | |
| this.b = Wp.M(); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| var vB = function(o, f) { | |
| if (f.dh) { | |
| o.g = f.dh; | |
| tB(o, o.g, o.G); | |
| uB(o, o.a, Ld, o.F); | |
| uB(o, o.a, lb, o.w); | |
| } | |
| if (f.kh) { | |
| o.j = f.kh; | |
| tB(o, o.j, o.H); | |
| uB(o, o.a, Wd, o.O); | |
| } | |
| if (f.eh) { | |
| o.o = f.eh; | |
| uB(o, o.o, r, o.A); | |
| var b = o.o; | |
| U(o.a, Od, b.j, false, b); | |
| b = o.o; | |
| U(o.a, lb, b.o, false, b); | |
| } | |
| if (f.lh) { | |
| o.B = f.lh; | |
| uB(o, o.B, r, o.Ca); | |
| b = o.B; | |
| U(o.a, Pd, b.j, false, b); | |
| } | |
| if (f.hh) { | |
| o.m = f.hh; | |
| uB(o, o.m, p, o.K); | |
| } | |
| if (f.mh) { | |
| o.c = f.mh; | |
| uB(o, new Gn(o.c.l()), Hc, o.C); | |
| uB(o, new Vs(o.c.l()), hd, o.C); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Object} M | |
| * @param {string} x | |
| * @param {!Function} y | |
| * @return {undefined} | |
| */ | |
| var uB = function(obj, M, x, y) { | |
| if (M) { | |
| U(M, x, y, false, obj); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| sB.prototype.G = function() { | |
| wB(this, this.g, this.a.m, zt(this.a.O), "slc"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| sB.prototype.H = function() { | |
| wB(this, this.j, this.a.o, zt(this.a.I.a), "tlc", true); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {string} value | |
| * @param {!Function} ctx | |
| * @param {string} val | |
| * @param {string} o | |
| * @param {boolean} reAppend | |
| * @return {undefined} | |
| */ | |
| var wB = function(e, value, ctx, val, o, reAppend) { | |
| var y = xB(value); | |
| var node = yB(e, y); | |
| var params = zB(e, reAppend); | |
| ctx.call(e.a, y, 4); | |
| if (value.Fa) { | |
| node.ct = value.Fa; | |
| } | |
| if ("" != val) { | |
| /** @type {string} */ | |
| node.emphlang = val; | |
| } | |
| value = zt(e.a.C.a); | |
| if (!(reAppend || "" == value)) { | |
| /** @type {string} */ | |
| node.bslang = value; | |
| } | |
| if ("" != params) { | |
| node.sugglang = params; | |
| } | |
| e.b.log(o, node); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sB.prototype.F = function(name) { | |
| if (xB(this.g) != name.data) { | |
| var c = this.g; | |
| var m = name.data; | |
| if (c.tagName == ya) { | |
| c.value = m; | |
| } else { | |
| Uu(c, m); | |
| } | |
| } | |
| AB(this); | |
| if (name.Zf) { | |
| name = yB(this); | |
| this.b.log("slauto", name); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| sB.prototype.w = function() { | |
| AB(this); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sB.prototype.O = function(name) { | |
| if (xB(this.j) != name.data) { | |
| var a = this.j; | |
| var m = name.data; | |
| if (a.tagName == ya) { | |
| a.value = m; | |
| } else { | |
| Uu(a, m); | |
| } | |
| } | |
| AB(this); | |
| if (name.Zf) { | |
| name = yB(this); | |
| this.b.log("tlauto", name); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} prop | |
| * @return {?} | |
| */ | |
| var xB = function(prop) { | |
| return prop.tagName == ya ? prop.value : prop.T(); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} input | |
| * @param {!Function} n | |
| * @return {undefined} | |
| */ | |
| var tB = function(o, input, n) { | |
| if (input.tagName == ya) { | |
| uB(o, input, Ya, n); | |
| } else { | |
| uB(o, input, p, n); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sB.prototype.A = function(name) { | |
| if (name.data != this.a.a) { | |
| var mask = this.a.m; | |
| var ssm_ConfirmMassDelete = zB(this); | |
| var b = yB(this, name.data); | |
| mask.call(this.a, name.data, 3); | |
| b.sugglang = ssm_ConfirmMassDelete; | |
| this.b.log("ssuggclick", b); | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sB.prototype.Ca = function(name) { | |
| if (name.data != this.a.b) { | |
| var p = this.a.o; | |
| var ssm_ConfirmMassDelete = zB(this, true); | |
| var b = yB(this, name.data); | |
| p.call(this.a, name.data, 3); | |
| b.sugglang = ssm_ConfirmMassDelete; | |
| this.b.log("tsuggclick", b); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| sB.prototype.K = function() { | |
| var b = yB(this); | |
| var a0 = this.a.a; | |
| var foo = this.a.b; | |
| var j = a0; | |
| if (a0 == Qa && (j = this.a.j, !j)) { | |
| return; | |
| } | |
| this.b.log("swapclick", b); | |
| b = this.a; | |
| b.m(foo, 5); | |
| b.o(j, 5); | |
| b.dispatchEvent(Nc); | |
| cq(this.b, "swap", 1, Ha); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| sB.prototype.C = function(name) { | |
| if (name.type == hd || 2 > We(this.c.T()).length) { | |
| /** @type {boolean} */ | |
| this.a.G = false; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} temp | |
| * @return {?} | |
| */ | |
| var yB = function(obj, temp) { | |
| var data = {}; | |
| data.sl = obj.a.a; | |
| data.tl = obj.a.b; | |
| if (temp) { | |
| /** @type {string} */ | |
| data.val = temp; | |
| } | |
| var selector = obj.a.j; | |
| if (selector) { | |
| data.dsl = selector; | |
| } | |
| if (obj.c) { | |
| data.ql = We(obj.c.T()).length; | |
| } | |
| return data; | |
| }; | |
| /** | |
| * @param {!Object} r | |
| * @return {undefined} | |
| */ | |
| var BB = function(r) { | |
| cq(r.b, "ssel", r.a.H); | |
| cq(r.b, "tsel", r.a.L); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {boolean} reAppend | |
| * @return {?} | |
| */ | |
| var zB = function(o, reAppend) { | |
| return reAppend ? zt(o.a.F.a) : zt(o.a.w.a); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {undefined} | |
| */ | |
| var AB = function(node) { | |
| if (node.m) { | |
| var b = node.a.a; | |
| if (b == Qa) { | |
| b = node.a.j; | |
| } | |
| if (b == pe && node.a.B == qe) { | |
| b = qe; | |
| } | |
| if ("" == b || b == node.a.b) { | |
| node.m.ba(false); | |
| } else { | |
| node.m.ba(true); | |
| } | |
| } | |
| }; | |
| var kn = ue(); | |
| C(kn, hn); | |
| Be(kn); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| kn.prototype.Pa = function(a) { | |
| var all = a.a.b(za, nn(this, a).join(" ")); | |
| CB(this, all, a.o); | |
| return all; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| kn.prototype.R = function(a, b) { | |
| b = kn.v.R.call(this, a, b); | |
| var $words = Ah(b); | |
| /** @type {boolean} */ | |
| var content = false; | |
| if (Ef($words, DB(this, null))) { | |
| /** @type {null} */ | |
| content = null; | |
| } else { | |
| if (Ef($words, DB(this, true))) { | |
| /** @type {boolean} */ | |
| content = true; | |
| } else { | |
| if (Ef($words, DB(this, false))) { | |
| /** @type {boolean} */ | |
| content = false; | |
| } | |
| } | |
| } | |
| /** @type {boolean} */ | |
| a.o = content; | |
| dn(b, $a, null == content ? "mixed" : 1 == content ? ie : "false"); | |
| return b; | |
| }; | |
| kn.prototype.Rb = x("checkbox"); | |
| /** | |
| * @param {!Object} name | |
| * @param {(Object|string)} err | |
| * @param {number} res | |
| * @return {undefined} | |
| */ | |
| var CB = function(name, err, res) { | |
| if (err) { | |
| var d = DB(name, res); | |
| if (!Bh(err, d)) { | |
| Nf(EB, function(zoom) { | |
| zoom = DB(this, zoom); | |
| Eh(err, zoom, zoom == d); | |
| }, name); | |
| dn(err, $a, null == res ? "mixed" : 1 == res ? ie : "false"); | |
| } | |
| } | |
| }; | |
| kn.prototype.S = x("goog-checkbox"); | |
| /** | |
| * @param {!Object} options | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| var DB = function(options, name) { | |
| var un = options.S(); | |
| if (1 == name) { | |
| return un + "-checked"; | |
| } | |
| if (0 == name) { | |
| return un + "-unchecked"; | |
| } | |
| if (null == name) { | |
| return un + "-undetermined"; | |
| } | |
| throw Error("Invalid checkbox state: " + name); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {?} addr | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var FB = function(s, addr, cb) { | |
| cb = cb || kn.M(); | |
| Qn.call(this, null, cb, addr); | |
| this.o = xe(s) ? s : false; | |
| }; | |
| C(FB, Qn); | |
| var EB = { | |
| a : true, | |
| b : false, | |
| c : null | |
| }; | |
| y = FB.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Ea = function() { | |
| return 1 == this.o; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| y.ma = function(a) { | |
| if (a != this.o) { | |
| /** @type {string} */ | |
| this.o = a; | |
| CB(this.c, this.l(), this.o); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.yg = function() { | |
| this.ma(this.o ? false : true); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| FB.v.V.call(this); | |
| if (this.ie) { | |
| X(this).a(this.l(), r, this.Fg); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| y.ba = function(a) { | |
| FB.v.ba.call(this, a); | |
| if (a = this.l()) { | |
| /** @type {number} */ | |
| a.tabIndex = this.isEnabled() ? 0 : -1; | |
| } | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| y.Fg = function(event) { | |
| event.stopPropagation(); | |
| /** @type {string} */ | |
| var head = this.o ? "uncheck" : "check"; | |
| if (this.isEnabled() && !event.target.href && this.dispatchEvent(head)) { | |
| event.preventDefault(); | |
| this.yg(); | |
| this.dispatchEvent(Ya); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} key | |
| * @return {?} | |
| */ | |
| y.tc = function(key) { | |
| if (32 == key.keyCode) { | |
| this.Wb(key); | |
| this.Fg(key); | |
| } | |
| return false; | |
| }; | |
| On("goog-checkbox", function() { | |
| return new FB; | |
| }); | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var GB = function(data) { | |
| data = data || {}; | |
| return mp('<span class="jfk-checkbox goog-inline-block' + (data.sh ? " jfk-checkbox-undetermined" : data.checked ? " jfk-checkbox-checked" : " jfk-checkbox-unchecked") + (data.disabled ? " jfk-checkbox-disabled" : "") + (data.Ue ? " " + tp(data.Ue) : "") + '" role="checkbox" aria-checked="' + (data.sh ? "mixed" : data.checked ? ie : "false") + '"' + (data.Gh ? 'aria-labelledby="' + tp(data.Gh) + '"' : data.Fh ? 'aria-label="' + tp(data.Fh) + '"' : "") + (data.id ? 'id="' + tp(data.id) + '"' : "") + | |
| (data.disabled ? 'aria-disabled="true" tabindex="-1"' : 'tabindex="' + (data.Of ? tp(data.Of) : "0") + '"') + (data.attributes ? " " + xp(data.attributes) : "") + 'dir="ltr"><div class="jfk-checkbox-checkmark" role="presentation"></div></span>'); | |
| }; | |
| /** | |
| * @param {?} data | |
| * @param {?} callback | |
| * @return {undefined} | |
| */ | |
| var HB = function(data, callback) { | |
| var a = ln(); | |
| FB.call(this, data, callback, a); | |
| this.Ba(4, true); | |
| }; | |
| C(HB, FB); | |
| /** | |
| * @return {undefined} | |
| */ | |
| HB.prototype.ra = function() { | |
| this.D = jp(GB, { | |
| checked : this.Ea(), | |
| disabled : !this.isEnabled(), | |
| sh : null == this.o | |
| }, void 0, this.a); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| HB.prototype.Y = function(s) { | |
| HB.v.Y.call(this, s); | |
| J(s, Gb); | |
| this.l().dir = Qc; | |
| if (!Hl(this, Fc)) { | |
| s = this.a.b(qb, Fc); | |
| this.l().appendChild(s); | |
| } | |
| s = Hl(this, Fc); | |
| cn(s, "presentation"); | |
| }; | |
| /** | |
| * @param {boolean} c | |
| * @return {undefined} | |
| */ | |
| HB.prototype.hc = function(c) { | |
| HB.v.hc.call(this, c); | |
| IB(this, false); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| HB.prototype.Za = function(name) { | |
| HB.v.Za.call(this, name); | |
| if (this.isEnabled()) { | |
| IB(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} repeats | |
| * @return {undefined} | |
| */ | |
| var IB = function(a, repeats) { | |
| if (a.l()) { | |
| Eh(a.l(), "jfk-checkbox-clearOutline", repeats); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var JB = function(a, b) { | |
| HB.call(this, a, b); | |
| }; | |
| C(JB, HB); | |
| /** | |
| * @return {undefined} | |
| */ | |
| JB.prototype.yg = function() { | |
| this.ma(0 == this.o ? true : false); | |
| }; | |
| /** | |
| * @param {(Object|string)} a | |
| * @param {string} b | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var KB = function(a, b, c) { | |
| V.call(this); | |
| /** @type {(Object|string)} */ | |
| this.o = a; | |
| /** @type {string} */ | |
| this.B = b; | |
| /** @type {number} */ | |
| this.c = c; | |
| /** @type {number} */ | |
| this.G = 1E4; | |
| /** @type {null} */ | |
| this.a = null; | |
| this.m = this.g = Ja; | |
| /** @type {string} */ | |
| this.C = "0"; | |
| /** @type {string} */ | |
| this.b = ""; | |
| /** @type {!Array} */ | |
| this.F = []; | |
| /** @type {boolean} */ | |
| this.w = false; | |
| /** @type {string} */ | |
| this.A = ""; | |
| }; | |
| C(KB, V); | |
| /** | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| var LB = function(t) { | |
| /** @type {boolean} */ | |
| t.w = false; | |
| if ("" != t.b) { | |
| var p = t.o; | |
| var a = A(t.K, t); | |
| var e = { | |
| cm : "s" | |
| }; | |
| e.q = t.b; | |
| if ("" != p.a) { | |
| e.tk = p.a; | |
| /** @type {string} */ | |
| p.a = ""; | |
| } | |
| qz(p, ia + sq(e), a, "GET"); | |
| } else { | |
| p = t.o; | |
| a = A(t.K, t); | |
| e = t.g; | |
| var m = t.m; | |
| t = t.C; | |
| var data = { | |
| cm : "g" | |
| }; | |
| if (null != e && e != Ja) { | |
| data.sl = e; | |
| } | |
| if (null != m && m != Ja) { | |
| data.tl = m; | |
| } | |
| if (null != t && "0" != t) { | |
| /** @type {!Object} */ | |
| data.od = t; | |
| } | |
| if ("" != p.a) { | |
| data.tk = p.a; | |
| /** @type {string} */ | |
| p.a = ""; | |
| } | |
| qz(p, ia + sq(data), a, "GET"); | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| KB.prototype.O = function(key, name) { | |
| var value = mz(name); | |
| if (null != value && "" != value) { | |
| this.dispatchEvent(id); | |
| } else { | |
| if (Gf(this.F, name.F()), null != name.a[6] && (value = Number(nz(name)), null == value || isNaN(value) || (this.G = value)), null == this.a || this.w || "0" != this.C) { | |
| LB(this); | |
| } else { | |
| value = new hz; | |
| var param = value.a; | |
| var ret = key ? key.b() : null; | |
| if (param !== ret) { | |
| /** @type {number} */ | |
| param.length = 0; | |
| if (ret) { | |
| param.length = ret.length; | |
| Rl(param, ret); | |
| } | |
| } | |
| param = name.F(); | |
| value.a[0] = param; | |
| this.a.push(value); | |
| this.dispatchEvent(id); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} callback | |
| * @return {?} | |
| */ | |
| var MB = function(callback) { | |
| var b = Jf(callback.F); | |
| /** @type {!Array} */ | |
| callback.F = []; | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {?} url | |
| * @return {undefined} | |
| */ | |
| var NB = function(m, url) { | |
| if (0 != url.length) { | |
| var index = m.o; | |
| var w = { | |
| cm : "d" | |
| }; | |
| /** @type {string} */ | |
| w.count = url.length + ""; | |
| var i = {}; | |
| i.id = url; | |
| qz(index, ia + sq(w), Ae, wa, sq(i)); | |
| /** @type {number} */ | |
| index = m.a.length - 1; | |
| for (; 0 <= index; --index) { | |
| if (Ef(url, m.a[index].Zb())) { | |
| Array.prototype.splice.call(m.a, index, 1); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| KB.prototype.K = function(value) { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| var sc = 0; | |
| for (; sc < Y(value.a, 2); ++sc) { | |
| this.a.push(oz(value, sc)); | |
| } | |
| this.A = pf(mz(value)); | |
| this.dispatchEvent(id); | |
| if (null != value.a[6]) { | |
| /** @type {number} */ | |
| value = Number(nz(value)); | |
| if (!(null == value || isNaN(value))) { | |
| /** @type {string} */ | |
| this.G = value; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var OB = function(a) { | |
| if (a.match(/[",\t\n]/)) { | |
| /** @type {string} */ | |
| a = '"' + a.replace(/"/g, '""') + '"'; | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {number} type | |
| * @param {?} id | |
| * @return {?} | |
| */ | |
| KB.prototype.j = function(name, type, id) { | |
| if (null == this.a) { | |
| return []; | |
| } | |
| /** @type {!Array} */ | |
| var c = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| var value = this.a[i]; | |
| var allKeys = lz(value); | |
| if (jz(value) == type && kz(value) == id && 0 == allKeys.lastIndexOf(name, 0) && allKeys.length >= name.length) { | |
| c.push(value); | |
| } | |
| } | |
| name = {}; | |
| /** @type {number} */ | |
| id = type = 0; | |
| for (; id < c.length;) { | |
| value = i = c[id++]; | |
| /** @type {string} */ | |
| value = Ie(value) ? "o" + Le(value) : (typeof value).charAt(0) + value; | |
| if (!Object.prototype.hasOwnProperty.call(name, value)) { | |
| /** @type {boolean} */ | |
| name[value] = true; | |
| c[type++] = i; | |
| } | |
| } | |
| /** @type {number} */ | |
| c.length = type; | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var PB = function(a) { | |
| V.call(this); | |
| this.a = a || window; | |
| this.b = U(this.a, od, this.g, false, this); | |
| this.c = Xh(this.a || window); | |
| }; | |
| C(PB, V); | |
| /** | |
| * @return {undefined} | |
| */ | |
| PB.prototype.J = function() { | |
| PB.v.J.call(this); | |
| if (this.b) { | |
| ik(this.b); | |
| /** @type {null} */ | |
| this.b = null; | |
| } | |
| /** @type {null} */ | |
| this.c = this.a = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| PB.prototype.g = function() { | |
| var c = Xh(this.a || window); | |
| if (!Hh(c, this.c)) { | |
| this.c = c; | |
| this.dispatchEvent(od); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {undefined} b | |
| * @param {string} delta | |
| * @return {undefined} | |
| */ | |
| var QB = function(a, b, delta) { | |
| V.call(this); | |
| /** @type {!Object} */ | |
| this.target = a; | |
| this.B = b || a; | |
| this.m = delta || new Oi(NaN, NaN, NaN, NaN); | |
| this.j = Ph(a); | |
| this.a = new nk(this); | |
| Cj(this, this.a); | |
| /** @type {number} */ | |
| this.g = this.c = this.G = this.F = this.screenY = this.screenX = this.clientY = this.clientX = 0; | |
| /** @type {boolean} */ | |
| this.o = true; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {number} */ | |
| this.C = 0; | |
| U(this.B, [ae, Vc], this.Mf, false, this); | |
| }; | |
| C(QB, V); | |
| /** @type {boolean} */ | |
| var RB = z.document && z.document.documentElement && !!z.document.documentElement.setCapture; | |
| y = QB.prototype; | |
| y.ba = ve("o"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| QB.v.J.call(this); | |
| hk(this.B, [ae, Vc], this.Mf, false, this); | |
| pk(this.a); | |
| if (RB) { | |
| this.j.releaseCapture(); | |
| } | |
| /** @type {null} */ | |
| this.B = this.target = null; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| y.Mf = function(e) { | |
| /** @type {boolean} */ | |
| var a = e.type == Vc; | |
| if (!this.o || this.b || a && !Kj(e)) { | |
| this.dispatchEvent(sb); | |
| } else { | |
| if (0 == this.C) { | |
| if (this.dispatchEvent(new SB(Nd, this, e.clientX, e.clientY, e))) { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| if (a) { | |
| e.preventDefault(); | |
| } | |
| } else { | |
| return; | |
| } | |
| } else { | |
| if (a) { | |
| e.preventDefault(); | |
| } | |
| } | |
| a = this.j; | |
| var d = a.documentElement; | |
| /** @type {boolean} */ | |
| var data = !RB; | |
| this.a.a(a, [$d, Wc], this.xi, data); | |
| this.a.a(a, [Zd, Zc], this.Kd, data); | |
| if (RB) { | |
| d.setCapture(false); | |
| this.a.a(d, "losecapture", this.Kd); | |
| } else { | |
| this.a.a($h(a), Va, this.Kd); | |
| } | |
| if (this.K) { | |
| this.a.a(this.K, td, this.A, data); | |
| } | |
| this.clientX = this.F = e.clientX; | |
| this.clientY = this.G = e.clientY; | |
| this.screenX = e.screenX; | |
| this.screenY = e.screenY; | |
| this.c = this.target.offsetLeft; | |
| this.g = this.target.offsetTop; | |
| this.w = Zh(Qh(this.j).a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| y.Kd = function(e) { | |
| pk(this.a); | |
| if (RB) { | |
| this.j.releaseCapture(); | |
| } | |
| if (this.b) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| this.dispatchEvent(new SB(ub, this, e.clientX, e.clientY, e, TB(this, this.c), UB(this, this.g))); | |
| } else { | |
| this.dispatchEvent(sb); | |
| } | |
| }; | |
| /** | |
| * @param {string} e | |
| * @return {undefined} | |
| */ | |
| y.xi = function(e) { | |
| if (this.o) { | |
| /** @type {number} */ | |
| var x = 1 * (e.clientX - this.clientX); | |
| /** @type {number} */ | |
| var y = e.clientY - this.clientY; | |
| this.clientX = e.clientX; | |
| this.clientY = e.clientY; | |
| this.screenX = e.screenX; | |
| this.screenY = e.screenY; | |
| if (!this.b) { | |
| /** @type {number} */ | |
| var diffX = this.F - this.clientX; | |
| /** @type {number} */ | |
| var diffY = this.G - this.clientY; | |
| if (diffX * diffX + diffY * diffY > this.C) { | |
| if (this.dispatchEvent(new SB(Nd, this, e.clientX, e.clientY, e))) { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| } else { | |
| if (!this.Ca) { | |
| this.Kd(e); | |
| } | |
| return; | |
| } | |
| } | |
| } | |
| y = VB(this, x, y); | |
| x = y.x; | |
| y = y.y; | |
| if (this.b && this.dispatchEvent(new SB("beforedrag", this, e.clientX, e.clientY, e, x, y))) { | |
| WB(this, e, x, y); | |
| e.preventDefault(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {number} offset | |
| * @param {number} start | |
| * @return {?} | |
| */ | |
| var VB = function(m, offset, start) { | |
| var a = Zh(Qh(m.j).a); | |
| offset = offset + (a.x - m.w.x); | |
| start = start + (a.y - m.w.y); | |
| m.w = a; | |
| m.c += offset; | |
| m.g += start; | |
| return new L(TB(m, m.c), UB(m, m.g)); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| QB.prototype.A = function(name) { | |
| var b = VB(this, 0, 0); | |
| name.clientX = this.clientX; | |
| name.clientY = this.clientY; | |
| WB(this, name, b.x, b.y); | |
| }; | |
| /** | |
| * @param {string} element | |
| * @param {string} props | |
| * @param {number} id | |
| * @param {number} name | |
| * @return {undefined} | |
| */ | |
| var WB = function(element, props, id, name) { | |
| element.target.style.left = id + md; | |
| element.target.style.top = name + md; | |
| element.dispatchEvent(new SB("drag", element, props.clientX, props.clientY, props, id, name)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var TB = function(a, b) { | |
| var m = a.m; | |
| var min = isNaN(m.left) ? null : m.left; | |
| m = isNaN(m.width) ? 0 : m.width; | |
| return Math.min(null != min ? min + m : Infinity, Math.max(null != min ? min : -Infinity, b)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var UB = function(a, b) { | |
| var m = a.m; | |
| var min = isNaN(m.top) ? null : m.top; | |
| m = isNaN(m.height) ? 0 : m.height; | |
| return Math.min(null != min ? min + m : Infinity, Math.max(null != min ? min : -Infinity, b)); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {!Object} b | |
| * @param {number} opt_clientX | |
| * @param {number} opt_clientY | |
| * @param {number} canvas | |
| * @param {undefined} left | |
| * @param {undefined} top | |
| * @return {undefined} | |
| */ | |
| var SB = function(a, b, opt_clientX, opt_clientY, canvas, left, top) { | |
| T.call(this, a); | |
| /** @type {number} */ | |
| this.clientX = opt_clientX; | |
| /** @type {number} */ | |
| this.clientY = opt_clientY; | |
| /** @type {number} */ | |
| this.c = canvas; | |
| this.left = xe(left) ? left : b.c; | |
| this.top = xe(top) ? top : b.g; | |
| }; | |
| C(SB, T); | |
| /** @type {string} */ | |
| var XB = E ? 'javascript:""' : "about:blank"; | |
| /** | |
| * @param {?} object | |
| * @param {number} prop | |
| * @return {undefined} | |
| */ | |
| var YB = function(object, prop) { | |
| this.D = object; | |
| /** @type {number} */ | |
| this.b = prop; | |
| }; | |
| /** | |
| * @param {?} optionalSource | |
| * @param {?} delay | |
| * @return {undefined} | |
| */ | |
| var ZB = function(optionalSource, delay) { | |
| W.call(this, delay); | |
| /** @type {boolean} */ | |
| this.L = !!optionalSource; | |
| /** @type {null} */ | |
| this.g = null; | |
| }; | |
| C(ZB, W); | |
| y = ZB.prototype; | |
| /** @type {null} */ | |
| y.cf = null; | |
| /** @type {boolean} */ | |
| y.fe = false; | |
| /** @type {null} */ | |
| y.cb = null; | |
| /** @type {null} */ | |
| y.Sa = null; | |
| /** @type {null} */ | |
| y.Bb = null; | |
| /** @type {boolean} */ | |
| y.Se = false; | |
| y.S = x("goog-modalpopup"); | |
| y.Ld = w("cb"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| ZB.v.ra.call(this); | |
| var e = this.l(); | |
| var f = We(this.S()).split(" "); | |
| Ch(e, f); | |
| Bi(e, true); | |
| S(e, false); | |
| $B(this); | |
| aC(this); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var $B = function(self) { | |
| if (self.L && !self.Sa) { | |
| var audio; | |
| audio = self.a.b("iframe", { | |
| frameborder : 0, | |
| style : "border:0;vertical-align:bottom;", | |
| src : XB | |
| }); | |
| self.Sa = audio; | |
| self.Sa.className = self.S() + "-bg"; | |
| S(self.Sa, false); | |
| jj(self.Sa, 0); | |
| } | |
| if (!self.cb) { | |
| self.cb = self.a.b(k, self.S() + "-bg"); | |
| S(self.cb, false); | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} self | |
| * @return {undefined} | |
| */ | |
| var aC = function(self) { | |
| if (!self.Bb) { | |
| self.Bb = Ji(self.a, za); | |
| S(self.Bb, false); | |
| Bi(self.Bb, true); | |
| self.Bb.style.position = Ga; | |
| } | |
| }; | |
| y = ZB.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.$g = function() { | |
| /** @type {boolean} */ | |
| this.Se = false; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| y.Wd = function(obj) { | |
| return !!obj && obj.tagName == k; | |
| }; | |
| /** | |
| * @param {?} y | |
| * @return {undefined} | |
| */ | |
| y.Y = function(y) { | |
| ZB.v.Y.call(this, y); | |
| y = We(this.S()).split(" "); | |
| Ch(this.l(), y); | |
| $B(this); | |
| aC(this); | |
| Bi(this.l(), true); | |
| S(this.l(), false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| if (this.Sa) { | |
| ki(this.Sa, this.l()); | |
| } | |
| ki(this.cb, this.l()); | |
| ZB.v.V.call(this); | |
| li(this.Bb, this.l()); | |
| this.cf = new Cx(this.a.a); | |
| X(this).a(this.cf, xb, this.Wi); | |
| bC(this, false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ya = function() { | |
| if (this.isVisible()) { | |
| this.setVisible(false); | |
| } | |
| Bj(this.cf); | |
| ZB.v.Ya.call(this); | |
| mi(this.Sa); | |
| mi(this.cb); | |
| mi(this.Bb); | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(b) { | |
| if (b != this.fe) { | |
| if (this.m && this.m.Eb(), this.w && this.w.Eb(), this.j && this.j.Eb(), this.o && this.o.Eb(), this.sa && bC(this, b), b) { | |
| if (this.dispatchEvent(Ta)) { | |
| try { | |
| this.g = this.a.a.activeElement; | |
| } catch (e) { | |
| } | |
| this.Ff(); | |
| var target = $h(this.a.a) || window; | |
| if ("fixed" == Ui(this.l(), ld)) { | |
| /** @type {number} */ | |
| var a = b = 0; | |
| } else { | |
| a = Zh(this.a.a); | |
| b = a.x; | |
| a = a.y; | |
| } | |
| var body = hj(this.l()); | |
| target = Xh(target || window); | |
| /** @type {number} */ | |
| b = Math.max(b + target.width / 2 - body.width / 2, 0); | |
| /** @type {number} */ | |
| a = Math.max(a + target.height / 2 - body.height / 2, 0); | |
| Wi(this.l(), b, a); | |
| Wi(this.Bb, b, a); | |
| X(this).a(Ki(this.a), od, this.Ff); | |
| cC(this, true); | |
| this.ng(); | |
| /** @type {boolean} */ | |
| this.fe = true; | |
| if (this.m && this.w) { | |
| gk(this.m, ub, this.ee, false, this); | |
| this.w.play(); | |
| this.m.play(); | |
| } else { | |
| this.ee(); | |
| } | |
| } | |
| } else { | |
| if (this.dispatchEvent(Sa)) { | |
| X(this).b(Ki(this.a), od, this.Ff); | |
| /** @type {boolean} */ | |
| this.fe = false; | |
| if (this.j && this.o) { | |
| gk(this.j, ub, this.ce, false, this); | |
| this.o.play(); | |
| this.j.play(); | |
| } else { | |
| this.ce(); | |
| } | |
| a: { | |
| try { | |
| a = this.a; | |
| body = a.a.body; | |
| target = a.a.activeElement || body; | |
| if (!this.g || this.g == body) { | |
| /** @type {null} */ | |
| this.g = null; | |
| break a; | |
| } | |
| if (target == body || a.contains(this.l(), target)) { | |
| this.g.focus(); | |
| } | |
| } catch (e) { | |
| } | |
| /** @type {null} */ | |
| this.g = null; | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} self | |
| * @param {string} byte | |
| * @return {undefined} | |
| */ | |
| var bC = function(self, byte) { | |
| if (!self.A) { | |
| self.A = new YB(self.D, self.a); | |
| } | |
| var a = self.A; | |
| if (byte) { | |
| if (!a.a) { | |
| /** @type {!Array} */ | |
| a.a = []; | |
| } | |
| var so = a.b.sg(a.b.a.body); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < so.length; i++) { | |
| var size = so[i]; | |
| if (!(size == a.D || en(size, oc))) { | |
| dn(size, oc, true); | |
| a.a.push(size); | |
| } | |
| } | |
| } else { | |
| if (a.a) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < a.a.length; i++) { | |
| a.a[i].removeAttribute("aria-hidden"); | |
| } | |
| /** @type {null} */ | |
| a.a = null; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {boolean} i | |
| * @return {undefined} | |
| */ | |
| var cC = function(item, i) { | |
| if (item.Sa) { | |
| S(item.Sa, i); | |
| } | |
| if (item.cb) { | |
| S(item.cb, i); | |
| } | |
| S(item.l(), i); | |
| S(item.Bb, i); | |
| }; | |
| y = ZB.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ee = function() { | |
| this.dispatchEvent(Ad); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ce = function() { | |
| cC(this, false); | |
| this.dispatchEvent(pc); | |
| }; | |
| y.isVisible = w("fe"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ff = function() { | |
| if (this.Sa) { | |
| S(this.Sa, false); | |
| } | |
| if (this.cb) { | |
| S(this.cb, false); | |
| } | |
| var doc = this.a.a; | |
| var newMinimals = Xh($h(doc) || window || window); | |
| /** @type {number} */ | |
| var valueProgess = Math.max(newMinimals.width, Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth)); | |
| /** @type {number} */ | |
| doc = Math.max(newMinimals.height, Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight)); | |
| if (this.Sa) { | |
| S(this.Sa, true); | |
| fj(this.Sa, valueProgess, doc); | |
| } | |
| if (this.cb) { | |
| S(this.cb, true); | |
| fj(this.cb, valueProgess, doc); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} mutationEvent | |
| * @return {undefined} | |
| */ | |
| y.Wi = function(mutationEvent) { | |
| if (this.Se) { | |
| this.$g(); | |
| } else { | |
| if (mutationEvent.target == this.Bb) { | |
| cl(this.ng, 0, this); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ng = function() { | |
| try { | |
| if (E) { | |
| this.a.a.body.focus(); | |
| } | |
| this.l().focus(); | |
| } catch (a) { | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| Bj(this.m); | |
| /** @type {null} */ | |
| this.m = null; | |
| Bj(this.j); | |
| /** @type {null} */ | |
| this.j = null; | |
| Bj(this.w); | |
| /** @type {null} */ | |
| this.w = null; | |
| Bj(this.o); | |
| /** @type {null} */ | |
| this.o = null; | |
| ZB.v.J.call(this); | |
| }; | |
| /** | |
| * @param {string} frustum2DWidth | |
| * @param {?} mode | |
| * @param {?} connectionProvider | |
| * @return {undefined} | |
| */ | |
| var hC = function(frustum2DWidth, mode, connectionProvider) { | |
| ZB.call(this, mode, connectionProvider); | |
| this.c = frustum2DWidth || "modal-dialog"; | |
| this.b = dC(dC(new eC, fC, true), gC, false, true); | |
| }; | |
| C(hC, ZB); | |
| y = hC.prototype; | |
| /** @type {boolean} */ | |
| y.Vg = true; | |
| /** @type {number} */ | |
| y.Dd = .5; | |
| /** @type {string} */ | |
| y.nh = ""; | |
| /** @type {null} */ | |
| y.uc = null; | |
| /** @type {null} */ | |
| y.cc = null; | |
| /** @type {boolean} */ | |
| y.Bg = false; | |
| /** @type {null} */ | |
| y.$a = null; | |
| /** @type {null} */ | |
| y.jb = null; | |
| /** @type {null} */ | |
| y.xe = null; | |
| /** @type {null} */ | |
| y.ab = null; | |
| /** @type {null} */ | |
| y.Ab = null; | |
| /** @type {null} */ | |
| y.Oa = null; | |
| y.S = w("c"); | |
| /** | |
| * @return {?} | |
| */ | |
| y.Aa = function() { | |
| return null != this.uc ? Gg(this.uc) : ""; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.yb = function() { | |
| if (!this.l()) { | |
| this.aa(); | |
| } | |
| return this.Ab; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Ld = function() { | |
| if (!this.l()) { | |
| this.aa(); | |
| } | |
| return hC.v.Ld.call(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Array} b | |
| * @return {undefined} | |
| */ | |
| var iC = function(a, b) { | |
| /** @type {!Array} */ | |
| a.Dd = b; | |
| if (a.l()) { | |
| var valueProgess = a.Ld(); | |
| if (valueProgess) { | |
| jj(valueProgess, a.Dd); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @param {boolean} err | |
| * @return {undefined} | |
| */ | |
| var jC = function(res, err) { | |
| var f = We(res.c + "-title-draggable").split(" "); | |
| if (res.l()) { | |
| if (err) { | |
| Ch(res.$a, f); | |
| } else { | |
| Dh(res.$a, f); | |
| } | |
| } | |
| if (err && !res.cc) { | |
| res.cc = new QB(res.l(), res.$a); | |
| Ch(res.$a, f); | |
| U(res.cc, Nd, res.oj, false, res); | |
| } else { | |
| if (!err && res.cc) { | |
| res.cc.za(); | |
| /** @type {null} */ | |
| res.cc = null; | |
| } | |
| } | |
| }; | |
| y = hC.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ra = function() { | |
| hC.v.ra.call(this); | |
| var f = this.l(); | |
| var lang = this.a; | |
| this.$a = lang.b(k, this.c + "-title", this.jb = lang.b(za, { | |
| className : this.c + "-title-text", | |
| id : this.F() | |
| }, this.nh), this.ab = lang.b(za, this.c + "-title-close")); | |
| ii(f, this.$a, this.Ab = lang.b(k, this.c + ca), this.Oa = lang.b(k, this.c + "-buttons")); | |
| cn(this.jb, "heading"); | |
| cn(this.ab, Xa); | |
| Bi(this.ab, true); | |
| dn(this.ab, Lc, "Close"); | |
| this.xe = this.jb.id; | |
| cn(f, "dialog"); | |
| dn(f, Mc, this.xe || ""); | |
| if (this.uc) { | |
| Nh(this.Ab, this.uc); | |
| } | |
| S(this.ab, true); | |
| if (this.b) { | |
| f = this.b; | |
| f.D = this.Oa; | |
| kC(f); | |
| } | |
| S(this.Oa, !!this.b); | |
| iC(this, this.Dd); | |
| }; | |
| /** | |
| * @param {!Object} input | |
| * @return {undefined} | |
| */ | |
| y.Y = function(input) { | |
| hC.v.Y.call(this, input); | |
| input = this.l(); | |
| var end = this.c + ca; | |
| this.Ab = Sh(null, end, input)[0]; | |
| if (!this.Ab) { | |
| this.Ab = this.a.b(k, end); | |
| if (this.uc) { | |
| Nh(this.Ab, this.uc); | |
| } | |
| input.appendChild(this.Ab); | |
| } | |
| /** @type {string} */ | |
| end = this.c + "-title"; | |
| /** @type {string} */ | |
| var c = this.c + "-title-text"; | |
| /** @type {string} */ | |
| var b = this.c + "-title-close"; | |
| if (this.$a = Sh(null, end, input)[0]) { | |
| this.jb = Sh(null, c, this.$a)[0]; | |
| this.ab = Sh(null, b, this.$a)[0]; | |
| } else { | |
| this.$a = this.a.b(k, end); | |
| input.insertBefore(this.$a, this.Ab); | |
| } | |
| if (this.jb) { | |
| this.nh = Fi(this.jb); | |
| if (!this.jb.id) { | |
| this.jb.id = this.F(); | |
| } | |
| } else { | |
| this.jb = P(za, { | |
| className : c, | |
| id : this.F() | |
| }); | |
| this.$a.appendChild(this.jb); | |
| } | |
| this.xe = this.jb.id; | |
| dn(input, Mc, this.xe || ""); | |
| if (!this.ab) { | |
| this.ab = this.a.b(za, b); | |
| this.$a.appendChild(this.ab); | |
| } | |
| S(this.ab, true); | |
| /** @type {string} */ | |
| end = this.c + "-buttons"; | |
| if (this.Oa = Sh(null, end, input)[0]) { | |
| this.b = new eC(this.a); | |
| this.b.R(this.Oa); | |
| } else { | |
| this.Oa = this.a.b(k, end); | |
| input.appendChild(this.Oa); | |
| if (this.b) { | |
| input = this.b; | |
| input.D = this.Oa; | |
| kC(input); | |
| } | |
| S(this.Oa, !!this.b); | |
| } | |
| iC(this, this.Dd); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.V = function() { | |
| hC.v.V.call(this); | |
| X(this).a(this.l(), Ic, this.H).a(this.l(), Jc, this.H); | |
| X(this).a(this.Oa, r, this.I); | |
| jC(this, true); | |
| X(this).a(this.ab, r, this.aj); | |
| var b = this.l(); | |
| cn(b, "dialog"); | |
| if ("" !== this.jb.id) { | |
| dn(b, Mc, this.jb.id); | |
| } | |
| if (!this.Vg) { | |
| /** @type {boolean} */ | |
| this.Vg = false; | |
| if (this.sa) { | |
| b = this.a; | |
| var a = this.Ld(); | |
| b.wg(this.Sa); | |
| b.wg(a); | |
| } | |
| if (this.isVisible()) { | |
| bC(this, false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ya = function() { | |
| if (this.isVisible()) { | |
| this.setVisible(false); | |
| } | |
| jC(this, false); | |
| hC.v.Ya.call(this); | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| y.setVisible = function(id) { | |
| if (id != this.isVisible()) { | |
| if (!this.sa) { | |
| this.aa(); | |
| } | |
| hC.v.setVisible.call(this, id); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ee = function() { | |
| hC.v.ee.call(this); | |
| this.dispatchEvent("aftershow"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.ce = function() { | |
| hC.v.ce.call(this); | |
| this.dispatchEvent("afterhide"); | |
| if (this.Bg) { | |
| this.za(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.oj = function() { | |
| var t = this.a.a; | |
| var b = Xh($h(t) || window || window); | |
| /** @type {number} */ | |
| var width = Math.max(t.body.scrollWidth, b.width); | |
| /** @type {number} */ | |
| t = Math.max(t.body.scrollHeight, b.height); | |
| var a = hj(this.l()); | |
| if ("fixed" == Ui(this.l(), ld)) { | |
| this.cc.m = new Oi(0, 0, Math.max(0, b.width - a.width), Math.max(0, b.height - a.height)); | |
| } else { | |
| this.cc.m = new Oi(0, 0, width - a.width, t - a.height); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.aj = function() { | |
| lC(this); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var lC = function(self) { | |
| var c = self.b; | |
| var e = c && c.m; | |
| if (e) { | |
| c = c.get(e); | |
| if (self.dispatchEvent(new mC(e, c))) { | |
| self.setVisible(false); | |
| } | |
| } else { | |
| self.setVisible(false); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hC.prototype.J = function() { | |
| /** @type {null} */ | |
| this.Oa = this.ab = null; | |
| hC.v.J.call(this); | |
| }; | |
| /** | |
| * @param {?} key | |
| * @return {undefined} | |
| */ | |
| hC.prototype.I = function(key) { | |
| a: { | |
| key = key.target; | |
| for (; null != key && key != this.Oa;) { | |
| if (key.tagName == oa) { | |
| break a; | |
| } | |
| key = key.parentNode; | |
| } | |
| /** @type {null} */ | |
| key = null; | |
| } | |
| if (key && !key.disabled) { | |
| key = key.name; | |
| var content = this.b.get(key); | |
| if (this.dispatchEvent(new mC(key, content))) { | |
| this.setVisible(false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| hC.prototype.H = function(key) { | |
| /** @type {boolean} */ | |
| var msg = false; | |
| /** @type {boolean} */ | |
| var id = false; | |
| var f = this.b; | |
| var node = key.target; | |
| if (key.type == Ic) { | |
| if (27 == key.keyCode) { | |
| var n = f && f.m; | |
| /** @type {boolean} */ | |
| node = node.tagName == ya && !node.disabled; | |
| if (n && !node) { | |
| /** @type {boolean} */ | |
| id = true; | |
| msg = f.get(n); | |
| msg = this.dispatchEvent(new mC(n, msg)); | |
| } else { | |
| if (!node) { | |
| /** @type {boolean} */ | |
| msg = true; | |
| } | |
| } | |
| } else { | |
| if (9 == key.keyCode && key.shiftKey && node == this.l()) { | |
| /** @type {boolean} */ | |
| this.Se = true; | |
| try { | |
| this.Bb.focus(); | |
| } catch (q) { | |
| } | |
| cl(this.$g, 0, this); | |
| } | |
| } | |
| } else { | |
| if (13 == key.keyCode) { | |
| if (node.tagName == oa && !node.disabled) { | |
| n = node.name; | |
| } else { | |
| if (node == this.ab) { | |
| lC(this); | |
| } else { | |
| if (f) { | |
| var j = f.j; | |
| var c; | |
| if (c = j) { | |
| a: { | |
| c = f.D.getElementsByTagName(oa); | |
| /** @type {number} */ | |
| var i = 0; | |
| var e; | |
| for (; e = c[i]; i++) { | |
| if (e.name == j || e.id == j) { | |
| c = e; | |
| break a; | |
| } | |
| } | |
| /** @type {null} */ | |
| c = null; | |
| } | |
| } | |
| /** @type {boolean} */ | |
| node = (node.tagName == Da || node.tagName == ya || "A" == node.tagName) && !node.disabled; | |
| if (!(!c || c.disabled || node)) { | |
| n = j; | |
| } | |
| } | |
| } | |
| } | |
| if (n && f) { | |
| /** @type {boolean} */ | |
| id = true; | |
| msg = this.dispatchEvent(new mC(n, String(f.get(n)))); | |
| } | |
| } else { | |
| if (node == this.ab && 32 == key.keyCode) { | |
| lC(this); | |
| } | |
| } | |
| } | |
| if (msg || id) { | |
| key.stopPropagation(); | |
| key.preventDefault(); | |
| } | |
| if (msg) { | |
| this.setVisible(false); | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {(Element|string)} b | |
| * @return {undefined} | |
| */ | |
| var mC = function(a, b) { | |
| /** @type {string} */ | |
| this.type = "dialogselect"; | |
| /** @type {string} */ | |
| this.key = a; | |
| /** @type {(Element|string)} */ | |
| this.caption = b; | |
| }; | |
| C(mC, T); | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| var eC = function(a) { | |
| if (!a) { | |
| Qh(); | |
| } | |
| Wg.call(this); | |
| }; | |
| C(eC, Wg); | |
| /** @type {null} */ | |
| eC.prototype.j = null; | |
| /** @type {null} */ | |
| eC.prototype.D = null; | |
| /** @type {null} */ | |
| eC.prototype.m = null; | |
| /** | |
| * @param {number} name | |
| * @param {!Object} obj | |
| * @param {boolean} text | |
| * @param {boolean} color | |
| * @return {?} | |
| */ | |
| eC.prototype.set = function(name, obj, text, color) { | |
| Wg.prototype.set.call(this, name, obj); | |
| if (text) { | |
| /** @type {number} */ | |
| this.j = name; | |
| } | |
| if (color) { | |
| /** @type {number} */ | |
| this.m = name; | |
| } | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Object} options | |
| * @param {boolean} prev | |
| * @param {boolean} a | |
| * @return {?} | |
| */ | |
| var dC = function(obj, options, prev, a) { | |
| return obj.set(options.key, options.caption, prev, a); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var kC = function(data) { | |
| if (data.D) { | |
| Nh(data.D, Qg); | |
| var self = Qh(data.D); | |
| data.forEach(function(w, newPrinter) { | |
| var body = self.b(oa, { | |
| name : newPrinter | |
| }, w); | |
| if (newPrinter == this.j) { | |
| body.className = Cb; | |
| } | |
| this.D.appendChild(body); | |
| }, data); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| eC.prototype.R = function(a) { | |
| if (a && 1 == a.nodeType) { | |
| /** @type {!Object} */ | |
| this.D = a; | |
| a = this.D.getElementsByTagName(oa); | |
| /** @type {number} */ | |
| var prop = 0; | |
| var val; | |
| var i; | |
| var d; | |
| for (; val = a[prop]; prop++) { | |
| if (i = val.name || val.id, d = Fi(val) || val.value, i) { | |
| /** @type {boolean} */ | |
| var deepExpose = 0 == prop; | |
| this.set(i, d, deepExpose, "cancel" == val.name); | |
| if (deepExpose) { | |
| J(val, Cb); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| eC.prototype.l = w("D"); | |
| var fC = { | |
| key : "ok", | |
| caption : "OK" | |
| }; | |
| var gC = { | |
| key : "cancel", | |
| caption : "Cancel" | |
| }; | |
| var nC = { | |
| key : "yes", | |
| caption : "Yes" | |
| }; | |
| var oC = { | |
| key : "no", | |
| caption : "No" | |
| }; | |
| var pC = { | |
| key : "save", | |
| caption : "Save" | |
| }; | |
| var qC = { | |
| key : "continue", | |
| caption : "Continue" | |
| }; | |
| if ("undefined" != typeof document) { | |
| dC(new eC, fC, true, true); | |
| dC(dC(new eC, fC, true), gC, false, true); | |
| dC(dC(new eC, nC, true), oC, false, true); | |
| dC(dC(dC(new eC, nC), oC, true), gC, false, true); | |
| dC(dC(dC(new eC, qC), pC), gC, true, true); | |
| } | |
| var rC = ue(); | |
| C(rC, mu); | |
| Be(rC); | |
| rC.prototype.S = x("goog-toolbar-menu-button"); | |
| /** | |
| * @param {number} n | |
| * @param {number} b | |
| * @param {?} variableNames | |
| * @return {undefined} | |
| */ | |
| var sC = function(n, b, variableNames) { | |
| W.call(this); | |
| /** @type {number} */ | |
| this.b = b; | |
| /** @type {number} */ | |
| this.w = n; | |
| /** @type {boolean} */ | |
| this.j = !!variableNames; | |
| Wp.M(); | |
| }; | |
| C(sC, W); | |
| /** | |
| * @return {undefined} | |
| */ | |
| sC.prototype.ra = function() { | |
| sC.v.ra.call(this); | |
| var row = di(k); | |
| var val; | |
| val = this.j ? "" : this.w.wa(jz(this.b)); | |
| var first = this.j ? "" : this.w.Wa(kz(this.b)); | |
| var pY = Zo(hf(lz(this.b))); | |
| var falseySection = Zo(hf(this.b.Ta())); | |
| /** @type {string} */ | |
| val = "<tr" + ("" == val ? ' class="nolabel"' : "") + '><td class="pb-cb"></td><td class="pb-slis-td"></td><td class="pb-src-td">' + ("" != val ? ma + Z(val) + la : "") + '<div class="gt-pb-stc">' + yp(pY) + '</div></td><td class="pb-tlis-td"></td><td class="pb-tgt-td">' + ("" != val ? ma + Z(first) + la : "") + '<div class="gt-pb-ttc">' + yp(falseySection) + "</div></td><tr>"; | |
| /** @type {string} */ | |
| row.innerHTML = "<table><tbody>" + val + "</tbody></table>"; | |
| this.Y(row.firstChild.rows[0]); | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {undefined} | |
| */ | |
| sC.prototype.Y = function(v) { | |
| sC.v.Y.call(this, v); | |
| v = this.l(); | |
| this.c = O("pb-src-td", v); | |
| if (ag(jz(this.b))) { | |
| this.c.dir = sd; | |
| } else { | |
| this.c.dir = Qc; | |
| } | |
| this.g = O("pb-tgt-td", v); | |
| if (ag(kz(this.b))) { | |
| this.g.dir = sd; | |
| } else { | |
| this.g.dir = Qc; | |
| } | |
| O("gt-pb-ttc", v); | |
| var x = O("pb-cb", v); | |
| var a = new HB; | |
| this.Ia(a); | |
| a.aa(x); | |
| X(this).a(a, "check", A(this.pf, this, true)); | |
| X(this).a(a, "uncheck", A(this.pf, this, false)); | |
| this.o = a; | |
| this.A = tC(this, O("pb-slis-td", v)); | |
| v = O("pb-tlis-td", v); | |
| this.m = tC(this, v); | |
| v = jz(this.b); | |
| x = lz(this.b); | |
| a = new xs(this.A, "&client=t&prev=pbsrc"); | |
| Cj(this, a); | |
| a.update(x, v); | |
| v = kz(this.b); | |
| x = this.b.Ta(); | |
| a = new xs(this.m, "&client=t&prev=pbtgt"); | |
| Cj(this, a); | |
| a.update(x, v); | |
| this.m.isVisible(); | |
| X(this).a(this.c, r, this.Ig); | |
| X(this).a(this.g, r, this.Ig); | |
| }; | |
| /** | |
| * @param {?} s | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var tC = function(s, v) { | |
| var m = new So(MSG_LISTEN, void 0, new Vo(be)); | |
| s.Ia(m); | |
| m.aa(v); | |
| m.setVisible(false); | |
| return m; | |
| }; | |
| y = sC.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.J = function() { | |
| sC.v.J.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Ea = function() { | |
| return this.o.Ea(); | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {undefined} | |
| */ | |
| y.ma = function(v) { | |
| this.o.ma(v); | |
| this.pf(v); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| y.Zb = function() { | |
| return this.b.Zb(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ig = function() { | |
| this.dispatchEvent("pbclick"); | |
| }; | |
| /** | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| y.pf = function(s) { | |
| if (s) { | |
| J(this.l(), $a); | |
| } else { | |
| K(this.l(), $a); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var uC = function() { | |
| V.call(this); | |
| /** @type {number} */ | |
| this.X = 0; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {!Array} */ | |
| this.o = []; | |
| this.K = {}; | |
| this.a = new nk(this); | |
| /** @type {boolean} */ | |
| this.$ = this.wa = false; | |
| /** @type {boolean} */ | |
| this.F = true; | |
| }; | |
| C(uC, V); | |
| /** | |
| * @param {!Object} type | |
| * @param {string} name | |
| * @param {!Function} a | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| uC.prototype.G = function(type, name, a, i) { | |
| /** @type {string} */ | |
| type.c = name; | |
| /** @type {string} */ | |
| type.a = i; | |
| this.g.push(type); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| uC.prototype.Ha = function(a) { | |
| this.w = Lf(arguments, 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uC.prototype.J = function() { | |
| this.a.za(); | |
| /** @type {number} */ | |
| var key = 0; | |
| var itl = this.g.length; | |
| for (; key < itl; key++) { | |
| var super$0 = this.g[key]; | |
| super$0.c = void 0; | |
| super$0.a = void 0; | |
| } | |
| /** @type {number} */ | |
| this.g.length = 0; | |
| /** @type {number} */ | |
| this.o.length = 0; | |
| /** @type {null} */ | |
| this.K = null; | |
| vC(this); | |
| uC.v.J.call(this); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {?} opener | |
| * @return {undefined} | |
| */ | |
| var wC = function(options, opener) { | |
| /** @type {number} */ | |
| var n = 0; | |
| var d = options.g.length; | |
| for (; n < d; n++) { | |
| var i = options.g[n]; | |
| i.Ic = ij(i); | |
| } | |
| /** @type {number} */ | |
| n = 0; | |
| d = options.o.length; | |
| for (; n < d; n++) { | |
| i = options.o[n]; | |
| if (i != opener) { | |
| i.Ic = ij(i); | |
| } | |
| } | |
| }; | |
| y = uC.prototype; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| y.Bi = function(value) { | |
| var b = Le(value.a); | |
| this.b = this.K[b]; | |
| a: { | |
| b = this.b; | |
| var f = b.cloneNode(true); | |
| var in_tokens = b.getElementsByTagName(Da); | |
| var currentFacets = f.getElementsByTagName(Da); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < in_tokens.length; i++) { | |
| currentFacets[i].value = in_tokens[i].value; | |
| } | |
| switch(b.tagName) { | |
| case "TR": | |
| b = P("TABLE", null, P("TBODY", null, f)); | |
| break a; | |
| case "TD": | |
| case "TH": | |
| b = P("TABLE", null, P("TBODY", null, P("TR", null, f))); | |
| break a; | |
| case Da: | |
| f.value = b.value; | |
| default: | |
| b = f; | |
| } | |
| } | |
| this.c = b; | |
| if (this.P) { | |
| Ch(this.c, this.P || []); | |
| } | |
| /** @type {string} */ | |
| this.c.style.margin = "0"; | |
| this.c.style.position = Ga; | |
| this.c.style.visibility = oc; | |
| Ph(this.b).body.appendChild(this.c); | |
| b = $i(this.b); | |
| ej(this.c, b); | |
| this.m = new QB(this.c); | |
| /** @type {number} */ | |
| this.m.C = Math.pow(this.X, 2); | |
| U(this.m, Nd, this.ki, false, this); | |
| U(this.m, ub, this.ii, false, this); | |
| U(this.m, sb, this.Ve, false, this); | |
| this.m.Mf(value); | |
| }; | |
| /** | |
| * @param {!Object} M | |
| * @return {undefined} | |
| */ | |
| y.ki = function(M) { | |
| if (this.dispatchEvent(new xC(Ra, 0, M.c))) { | |
| this.C = this.b.parentNode; | |
| this.j = this.O = qi(this.b); | |
| this.A = this.C; | |
| if (this.w) { | |
| Ch(this.b, this.w || []); | |
| } else { | |
| this.b.style.visibility = oc; | |
| } | |
| var c = hj(this.c); | |
| /** @type {number} */ | |
| this.c.m = c.width / 2; | |
| /** @type {number} */ | |
| this.c.g = c.height / 2; | |
| /** @type {string} */ | |
| this.c.style.visibility = ""; | |
| if (this.F) { | |
| this.b.style.display = ad; | |
| } | |
| wC(this, this.b); | |
| /** @type {string} */ | |
| this.b.style.display = ""; | |
| U(this.m, "drag", this.ji, false, this); | |
| this.dispatchEvent(new xC(rb, 0, M.c)); | |
| } else { | |
| M.preventDefault(); | |
| this.Ve(); | |
| } | |
| }; | |
| /** | |
| * @param {number} dragEvent | |
| * @return {?} | |
| */ | |
| y.ji = function(dragEvent) { | |
| var v = $i(this.c); | |
| v = new L(v.x + this.c.m, v.y + this.c.g); | |
| var item; | |
| a: { | |
| /** @type {null} */ | |
| item = null; | |
| if (this.b.style.display != ad) { | |
| item = this.b.parentNode; | |
| var key = ij(item); | |
| if (yC(v, key)) { | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| key = 0; | |
| var end = this.g.length; | |
| for (; key < end; key++) { | |
| var text = this.g[key]; | |
| if (text != item && yC(v, text.Ic)) { | |
| item = text; | |
| break a; | |
| } | |
| } | |
| /** @type {null} */ | |
| item = null; | |
| } | |
| var t; | |
| if (item) { | |
| if (null == item) { | |
| throw Error("getHoverNextItem_ called with null hoverList."); | |
| } | |
| var a; | |
| var callback; | |
| /** @type {boolean} */ | |
| key = false; | |
| end = void 0; | |
| switch(item.c) { | |
| case 0: | |
| t = v.y; | |
| /** @type {function(!Object): ?} */ | |
| a = zC; | |
| /** @type {function(!Object, !Object): ?} */ | |
| callback = AC; | |
| break; | |
| case 4: | |
| /** @type {boolean} */ | |
| key = true; | |
| case 2: | |
| t = v.x; | |
| /** @type {function(!Object): ?} */ | |
| a = BC; | |
| /** @type {function(!Object, !Object): ?} */ | |
| callback = AC; | |
| break; | |
| case 5: | |
| /** @type {boolean} */ | |
| key = true; | |
| case 3: | |
| t = v.x; | |
| /** @type {function(!Object): ?} */ | |
| a = CC; | |
| /** @type {function(!Object, !Object): ?} */ | |
| callback = DC; | |
| } | |
| /** @type {null} */ | |
| text = null; | |
| var child; | |
| var values = ni(item); | |
| /** @type {number} */ | |
| var i = 0; | |
| var l = values.length; | |
| for (; i < l; i++) { | |
| var b = values[i]; | |
| if (b != this.b) { | |
| var parent = a(b.Ic); | |
| if (key) { | |
| var e = EC(b, v); | |
| if (!xe(end)) { | |
| end = e; | |
| } | |
| if (callback(t, parent) && (void 0 == child || e < end || e == end && (callback(parent, child) || parent == child))) { | |
| text = b; | |
| child = parent; | |
| } | |
| if (e < end) { | |
| end = e; | |
| } | |
| } else { | |
| if (callback(t, parent) && (void 0 == child || callback(parent, child))) { | |
| text = b; | |
| child = parent; | |
| } | |
| } | |
| } | |
| } | |
| t = null !== text && EC(text, v) > end ? null : text; | |
| } else { | |
| /** @type {null} */ | |
| t = null; | |
| } | |
| if (!this.dispatchEvent(new xC("beforedragmove", 0, dragEvent))) { | |
| return false; | |
| } | |
| if (item) { | |
| if (this.F) { | |
| if (!(this.b.parentNode == item && qi(this.b) == t)) { | |
| item.insertBefore(this.b, t); | |
| } | |
| } else { | |
| this.H(t, v); | |
| } | |
| /** @type {string} */ | |
| this.b.style.display = ""; | |
| if (item.a) { | |
| J(item, item.a); | |
| } | |
| } else { | |
| if (!this.$) { | |
| this.b.style.display = ad; | |
| } | |
| /** @type {number} */ | |
| v = 0; | |
| t = this.g.length; | |
| for (; v < t; v++) { | |
| a = this.g[v]; | |
| if (a.a) { | |
| K(a, a.a); | |
| } | |
| } | |
| } | |
| if (item != this.A) { | |
| this.A = item; | |
| wC(this, this.b); | |
| } | |
| this.dispatchEvent(new xC("dragmove", 0, dragEvent)); | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ve = function() { | |
| vC(this); | |
| /** @type {null} */ | |
| this.m = this.c = this.O = this.C = this.A = this.b = null; | |
| /** @type {number} */ | |
| var i = 0; | |
| var el = this.g.length; | |
| for (; i < el; i++) { | |
| /** @type {null} */ | |
| this.g[i].Ic = null; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| el = this.o.length; | |
| for (; i < el; i++) { | |
| /** @type {null} */ | |
| this.o[i].Ic = null; | |
| } | |
| }; | |
| /** | |
| * @param {number} dragEvent | |
| * @return {?} | |
| */ | |
| y.ii = function(dragEvent) { | |
| if (!this.dispatchEvent(new xC("beforedragend", 0, dragEvent))) { | |
| return false; | |
| } | |
| if (!this.F) { | |
| this.Z(); | |
| } | |
| vC(this); | |
| this.dispatchEvent(new xC("dragend", 0, dragEvent)); | |
| this.Ve(); | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var vC = function(options) { | |
| Bj(options.m); | |
| if (options.c) { | |
| mi(options.c); | |
| } | |
| if (options.b && options.b.style.display == ad) { | |
| options.C.insertBefore(options.b, options.O); | |
| /** @type {string} */ | |
| options.b.style.display = ""; | |
| } | |
| if (options.w && options.b) { | |
| Dh(options.b, options.w || []); | |
| } else { | |
| if (options.b) { | |
| /** @type {string} */ | |
| options.b.style.visibility = ""; | |
| } | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| var patchLen = options.g.length; | |
| for (; i < patchLen; i++) { | |
| var val = options.g[i]; | |
| if (val.a) { | |
| K(val, val.a); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| uC.prototype.Fa = function(key) { | |
| Ch(key.a, this.N || []); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| uC.prototype.Da = function(key) { | |
| Dh(key.a, this.N || []); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| uC.prototype.va = function(key) { | |
| Ch(key.a, this.L || []); | |
| }; | |
| /** | |
| * @param {(number|string)} defaultTagAttributes | |
| * @return {undefined} | |
| */ | |
| uC.prototype.Ma = function(defaultTagAttributes) { | |
| Dh(defaultTagAttributes.a, this.L || []); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var yC = function(a, b) { | |
| return a.x > b.left && a.x < b.left + b.width && a.y > b.top && a.y < b.top + b.height; | |
| }; | |
| /** | |
| * @param {number} name | |
| * @return {undefined} | |
| */ | |
| uC.prototype.H = function(name) { | |
| if (name) { | |
| /** @type {number} */ | |
| this.j = name; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uC.prototype.Z = function() { | |
| this.C.insertBefore(this.b, this.j); | |
| }; | |
| /** | |
| * @param {?} obj | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var EC = function(obj, options) { | |
| var c = obj.Ic; | |
| return Math.abs(options.y - (c.top + (c.height - 1) / 2)); | |
| }; | |
| /** | |
| * @param {!Object} bou_Pos | |
| * @return {?} | |
| */ | |
| var zC = function(bou_Pos) { | |
| return bou_Pos.top + bou_Pos.height - 1; | |
| }; | |
| /** | |
| * @param {!Object} bou_Pos | |
| * @return {?} | |
| */ | |
| var BC = function(bou_Pos) { | |
| return bou_Pos.left + bou_Pos.width - 1; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var CC = function(value) { | |
| return value.left || 0; | |
| }; | |
| /** | |
| * @param {!Object} width | |
| * @param {!Object} height | |
| * @return {?} | |
| */ | |
| var AC = function(width, height) { | |
| return width < height; | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var DC = function(n, a) { | |
| return n > a; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var xC = function(a, b, c) { | |
| T.call(this, a); | |
| /** @type {number} */ | |
| this.c = c; | |
| }; | |
| C(xC, T); | |
| /** | |
| * @param {string} city | |
| * @param {string} result | |
| * @return {undefined} | |
| */ | |
| var FC = function(city, result) { | |
| uC.call(this); | |
| this.W = null != city ? city : ""; | |
| this.U = null != result ? result : ""; | |
| /** @type {boolean} */ | |
| this.F = false; | |
| /** @type {null} */ | |
| this.B = null; | |
| this.I = new nk(this); | |
| }; | |
| C(FC, uC); | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {!Function} input | |
| * @param {string} args | |
| * @return {undefined} | |
| */ | |
| FC.prototype.G = function(name, type, input, args) { | |
| FC.v.G.call(this, name, type, input, args); | |
| this.I.a(this, Ra, this.qa); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| FC.prototype.qa = function(e) { | |
| var scrollOffset = Zh(document); | |
| this.m.c = e.c.clientX + scrollOffset.x; | |
| this.m.g = e.c.clientY + scrollOffset.y; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| FC.prototype.Z = function() { | |
| if (this.B) { | |
| if (1 == this.B) { | |
| li(this.b, this.j); | |
| } else { | |
| ki(this.b, this.j); | |
| } | |
| } | |
| GC(this, false); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| FC.prototype.H = function(name, type) { | |
| GC(this, false); | |
| FC.v.H.call(this, name, type); | |
| GC(this, true, type); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {number} a | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var GC = function(self, a, c) { | |
| if (null != self.j) { | |
| if (a && c) { | |
| a = ij(self.j); | |
| c = Fh(new L(a.left + a.width / 2, a.top + a.height / 2), c); | |
| /** @type {boolean} */ | |
| a = 0 == self.C.c; | |
| /** @type {number} */ | |
| self.B = 0 > c.y && a || 0 > c.x && !a ? 1 : 2; | |
| if (1 == self.B) { | |
| J(self.j, self.U); | |
| } else { | |
| J(self.j, self.W); | |
| } | |
| } else { | |
| K(self.j, self.U); | |
| K(self.j, self.W); | |
| /** @type {null} */ | |
| self.B = null; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| FC.prototype.J = function() { | |
| this.I.za(); | |
| FC.v.J.call(this); | |
| }; | |
| /** | |
| * @param {number} s | |
| * @param {number} i | |
| * @param {?} forceOptional | |
| * @return {undefined} | |
| */ | |
| var HC = function(s, i, forceOptional) { | |
| Aj.call(this); | |
| /** @type {number} */ | |
| this.b = s; | |
| this.c = new Zk(50); | |
| this.a = new nk(this); | |
| this.j = new L; | |
| this.m = ij(s); | |
| this.ue = i || 0; | |
| if (i) { | |
| if (s = this.m.clone(), i = this.ue) { | |
| /** @type {number} */ | |
| var d = Math.min(i, .25 * s.height); | |
| s.top += d; | |
| s.height -= 2 * d; | |
| /** @type {number} */ | |
| i = Math.min(i, .25 * s.width); | |
| s.left += i; | |
| s.width -= 2 * i; | |
| } | |
| } else { | |
| s = this.m; | |
| } | |
| /** @type {number} */ | |
| this.g = s; | |
| if (!forceOptional) { | |
| this.a.a(Ph(this.b), Wc, this.B); | |
| } | |
| this.a.a(this.c, "tick", this.o); | |
| }; | |
| C(HC, Aj); | |
| /** | |
| * @return {undefined} | |
| */ | |
| HC.prototype.o = function() { | |
| this.b.scrollTop += this.j.y; | |
| this.b.scrollLeft += this.j.x; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| HC.prototype.B = function(name) { | |
| var href = IC(name.clientX, this.g.left, this.g.width); | |
| name = IC(name.clientY, this.g.top, this.g.height); | |
| this.j.x = href; | |
| /** @type {string} */ | |
| this.j.y = name; | |
| if (!(href = !href && !name)) { | |
| /** @type {boolean} */ | |
| href = false; | |
| } | |
| if (href) { | |
| $k(this.c); | |
| } else { | |
| if (!this.c.b) { | |
| al(this.c); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} c | |
| * @param {string} g | |
| * @return {?} | |
| */ | |
| var IC = function(a, c, g) { | |
| /** @type {number} */ | |
| var d = 0; | |
| if (a < c) { | |
| /** @type {number} */ | |
| d = -8; | |
| } else { | |
| if (a > c + g) { | |
| /** @type {number} */ | |
| d = 8; | |
| } | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| HC.prototype.J = function() { | |
| HC.v.J.call(this); | |
| this.a.za(); | |
| this.c.za(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var JC = function() { | |
| W.call(this); | |
| /** @type {null} */ | |
| this.c = this.b = null; | |
| }; | |
| C(JC, W); | |
| /** @type {!Array} */ | |
| var KC = [255, 255, 204]; | |
| /** @type {!Array} */ | |
| var LC = [255, 255, 255]; | |
| /** | |
| * @return {undefined} | |
| */ | |
| JC.prototype.ra = function() { | |
| JC.v.ra.call(this); | |
| var p = P("TBODY"); | |
| this.Y(p); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} i | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| JC.prototype.update = function(data, i, val) { | |
| Ql(this); | |
| /** @type {number} */ | |
| var map = data.length - 1; | |
| for (; 0 <= map; map--) { | |
| var c = new sC(i, data[map], val); | |
| this.Ia(c, true); | |
| } | |
| if (this.b) { | |
| hk(this.b, rb, this.j, false, this); | |
| hk(this.b, "dragend", this.g, false, this); | |
| Bj(this.b); | |
| } | |
| if (rr && (this.b = new FC("pb-drag-before", "pb-drag-after"), this.b.P = We("pb-drag-flt").split(" "), this.b.Ha("pb-drag-cur"), this.b.$ = true, this.b.G(this.l(), 0), this.b.X = 5, U(this.b, rb, this.j, false, this), U(this.b, "dragend", this.g, false, this), data = this.b, !data.wa)) { | |
| /** @type {number} */ | |
| i = 0; | |
| val = data.g.length; | |
| for (; i < val; i++) { | |
| map = ni(data.g[i]); | |
| /** @type {number} */ | |
| c = 0; | |
| var cl = map.length; | |
| for (; c < cl; ++c) { | |
| /** @type {!Object} */ | |
| var o = data; | |
| var type = map[c]; | |
| var i = Le(type); | |
| o.K[i] = type; | |
| if (o.N) { | |
| o.a.a(type, Yc, o.Fa); | |
| o.a.a(type, Xc, o.Da); | |
| } | |
| if (o.L) { | |
| o.a.a(type, Yc, o.va); | |
| o.a.a(type, Xc, o.Ma); | |
| } | |
| o.o.push(type); | |
| o.a.a(type, [Vc, ae], o.Bi); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| data.wa = true; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| JC.prototype.j = function() { | |
| this.c = new HC(M("pb-tb-c")); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| JC.prototype.g = function() { | |
| Bj(this.c); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Array} view | |
| * @return {undefined} | |
| */ | |
| var MC = function(b, view) { | |
| /** @type {!Array} */ | |
| var a = []; | |
| Ll(b, function(idx) { | |
| if (Ef(view, idx.Zb())) { | |
| a.push(idx); | |
| } | |
| }, b); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; ++i) { | |
| b.removeChild(a[i], true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var NC = function(b) { | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| /** @type {!Array} */ | |
| var tabs = []; | |
| Ll(b, function(a) { | |
| if (a.Ea()) { | |
| newNodeLists.push(a.Zb()); | |
| tabs.push(a); | |
| } | |
| }, b); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < tabs.length; ++i) { | |
| b.removeChild(tabs[i], true); | |
| } | |
| return newNodeLists; | |
| }; | |
| /** | |
| * @param {!Object} level | |
| * @return {?} | |
| */ | |
| var OC = function(level) { | |
| var url = Ml(level); | |
| /** @type {number} */ | |
| var lastImageUrl = 0; | |
| /** @type {number} */ | |
| var title = 0; | |
| for (; title < url; title++) { | |
| if (Nl(level, title).Ea()) { | |
| lastImageUrl++; | |
| } | |
| } | |
| return 0 == lastImageUrl ? false : lastImageUrl == url ? true : null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| JC.prototype.ma = function(a) { | |
| var G = Ml(this); | |
| /** @type {number} */ | |
| var g = 0; | |
| for (; g < G; g++) { | |
| Nl(this, g).ma(a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Array} m | |
| * @return {undefined} | |
| */ | |
| var PC = function(b, m) { | |
| /** @type {!Array} */ | |
| var result = []; | |
| Ll(b, function(a) { | |
| if (Ef(m, a.Zb())) { | |
| result.push(a); | |
| } | |
| }, b); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < result.length; ++i) { | |
| (new Dy(result[i].l(), KC, LC, 1E3)).play(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} m | |
| * @param {!Object} g | |
| * @param {string} name | |
| * @param {string} fc | |
| * @param {?} disposition | |
| * @param {?} index | |
| * @param {number} prop | |
| * @return {undefined} | |
| */ | |
| var TC = function(b, m, g, name, fc, disposition, index, prop) { | |
| /** @type {!Object} */ | |
| this.G = g; | |
| /** @type {!Object} */ | |
| this.I = m; | |
| /** @type {string} */ | |
| this.gc = name; | |
| /** @type {string} */ | |
| this.fc = fc; | |
| this.Ca = disposition; | |
| this.ob = index; | |
| /** @type {boolean} */ | |
| this.F = this.Ra = false; | |
| this.a = new KB(b, m, g); | |
| this.Da = MSG_PB_SIGNIN; | |
| this.va = MSG_SAVE; | |
| this.P = MSG_MY_PB; | |
| b = M("gt-pb-star"); | |
| if (null != b) { | |
| m = new eo(MSG_SAVE_PB, new Vo("trans-pb-button")); | |
| m.setVisible(false); | |
| m.aa(b); | |
| if (this.Ca) { | |
| U(m, p, this.Fb, false, this); | |
| } else { | |
| U(m, p, A(this.Qa, this, "st"), false, this); | |
| } | |
| QC(this, m); | |
| /** @type {!Object} */ | |
| b = m; | |
| } else { | |
| /** @type {null} */ | |
| b = null; | |
| } | |
| /** @type {!Object} */ | |
| this.m = b; | |
| this.w = RC(this); | |
| b = M("gt-apb-main"); | |
| m = P(k, { | |
| id : "gt-pb-sw1" | |
| }); | |
| b.appendChild(m); | |
| this.N = SC(this, m, MSG_SHOW_PB); | |
| b = this.N.l(); | |
| m = P(k, { | |
| id : "gt-pb-id" | |
| }); | |
| b.appendChild(m); | |
| S(m, false); | |
| /** @type {!Object} */ | |
| this.wa = m; | |
| /** @type {number} */ | |
| this.C = 0; | |
| this.g = Wp.M(); | |
| /** @type {boolean} */ | |
| this.Ma = true; | |
| /** @type {string} */ | |
| this.B = ""; | |
| /** @type {number} */ | |
| this.b = prop; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.Fb = function() { | |
| if ("" == this.B) { | |
| UC(this); | |
| this.g.log("pbsavs", 1); | |
| } else { | |
| /** @type {!Array} */ | |
| var a = [this.B]; | |
| MC(this.j, a); | |
| if (0 != a.length) { | |
| NB(this.a, a); | |
| } | |
| VC(this); | |
| this.O(); | |
| if (!this.F) { | |
| WC(this, -1); | |
| } | |
| this.g.log("pbsavs", 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| var QC = function(obj, f) { | |
| if (obj.Ca) { | |
| var node = obj.a; | |
| if (null != node.a && node.a.length >= node.G) { | |
| f.ba("" != obj.B); | |
| f.g("" != obj.B ? MSG_SAVED : MSG_PB_FULL); | |
| } else { | |
| f.ba(true); | |
| f.g("" != obj.B ? MSG_SAVED : MSG_SAVE_PB); | |
| } | |
| } else { | |
| f.ba(true); | |
| f.g(MSG_SAVE_PB); | |
| } | |
| }; | |
| /** | |
| * @param {string} now | |
| * @return {undefined} | |
| */ | |
| TC.prototype.Qa = function(now) { | |
| this.g.log("pbsi", now); | |
| window.open("//accounts.google.com/Login?hl=" + this.b + "&continue=" + (window.location.protocol + "//" + window.location.hostname + (window.location.port ? ":" + window.location.port : "") + "/"), "_top"); | |
| }; | |
| /** | |
| * @param {!Object} buffer | |
| * @return {?} | |
| */ | |
| var RC = function(buffer) { | |
| var table = M("gt-pb-save"); | |
| if (null == table) { | |
| return null; | |
| } | |
| var m = new Rp(buffer.va); | |
| m.aa(table); | |
| m.setVisible(false); | |
| if (!buffer.Ca) { | |
| m.ba(false); | |
| Go(m.l(), buffer.Da); | |
| } | |
| U(m, p, function() { | |
| UC(this); | |
| this.g.log("pbsavb"); | |
| }, false, buffer); | |
| return m; | |
| }; | |
| /** | |
| * @param {!Object} string | |
| * @param {!Object} pos | |
| * @param {string} settings | |
| * @return {?} | |
| */ | |
| var SC = function(string, pos, settings) { | |
| var args = new eo(null, new Uo); | |
| args.aa(pos); | |
| J(args.l(), "pb-sw"); | |
| if (string.Ca) { | |
| Go(args.l(), settings); | |
| U(args, p, string.Vb, false, string); | |
| } else { | |
| Go(args.l(), string.Da); | |
| U(args, p, A(string.Qa, string, "sw"), false, string); | |
| } | |
| return args; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var YC = function(obj) { | |
| var table = M("pb-back-c"); | |
| var x = new eo(MSG_BACK_TO_ALL, new Vo("pbback-button")); | |
| x.aa(table); | |
| R(x.l(), le, oc); | |
| U(x, p, function() { | |
| XC(this); | |
| LB(this.a); | |
| }, false, obj); | |
| return x; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.pb = function() { | |
| this.o.ma(OC(this.j)); | |
| VC(this); | |
| this.g.log("pbco"); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {boolean} attributeViewModelBindings | |
| * @return {undefined} | |
| */ | |
| var XC = function(node, attributeViewModelBindings) { | |
| var a = node.a; | |
| if ("" != a.b) { | |
| /** @type {boolean} */ | |
| a.w = true; | |
| /** @type {string} */ | |
| a.b = ""; | |
| } | |
| /** @type {string} */ | |
| node.H.value = ""; | |
| /** @type {string} */ | |
| node.W = ""; | |
| if (!attributeViewModelBindings) { | |
| a = node.a; | |
| if (a.g != Ja || a.m != Ja) { | |
| /** @type {boolean} */ | |
| a.w = true; | |
| a.g = Ja; | |
| a.m = Ja; | |
| } | |
| Uu(node.c, Ka); | |
| } | |
| S(node.U, false); | |
| S(node.qa, true); | |
| VC(node); | |
| S(node.A, true); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {number} count | |
| * @return {undefined} | |
| */ | |
| var WC = function(item, count) { | |
| item.C += count; | |
| if (0 > item.C) { | |
| /** @type {number} */ | |
| item.C = 0; | |
| } | |
| Q(item.wa, 9 >= item.C ? item.C + "" : "9+"); | |
| S(item.wa, 0 < item.C); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var UC = function(item) { | |
| if (300 < $A(item.I, true).length || 300 < cz(item.I.c, void 0).length) { | |
| var v = ZA(item.G); | |
| var result = YA(item.G); | |
| var a = $A(item.I, true).length; | |
| var c = cz(item.I.c, void 0).length; | |
| var options = new hC; | |
| var y = Jg(MSG_PB_TL); | |
| options.uc = y; | |
| if (options.Ab) { | |
| Nh(options.Ab, y); | |
| } | |
| y = dC(new eC, fC, true, true); | |
| options.b = y; | |
| if (options.Oa) { | |
| if (options.b) { | |
| y = options.b; | |
| y.D = options.Oa; | |
| kC(y); | |
| } else { | |
| Nh(options.Oa, Qg); | |
| } | |
| S(options.Oa, !!options.b); | |
| } | |
| /** @type {boolean} */ | |
| options.Bg = true; | |
| options.aa(); | |
| options.setVisible(true); | |
| item.g.log("pbtl", { | |
| sl : v, | |
| tl : result, | |
| slen : a, | |
| tlen : c | |
| }); | |
| } else { | |
| if (null != item.m) { | |
| item.m.ba(false); | |
| item.m.g(MSG_SAVING); | |
| J(item.m.l(), ce); | |
| } | |
| if (null != item.w) { | |
| item.w.ba(false); | |
| item.w.g(MSG_SAVING); | |
| } | |
| if (!item.Ra) { | |
| ZC(item); | |
| } | |
| /** @type {boolean} */ | |
| v = item.c.T() != Ka && item.c.T() != ZA(item.G) + "|" + YA(item.G); | |
| XC(item, !v); | |
| c = item.a; | |
| v = new hz; | |
| result = ZA(c.c); | |
| v.a[1] = result; | |
| result = YA(c.c); | |
| v.a[2] = result; | |
| result = $A(c.B, true); | |
| v.a[3] = result; | |
| result = cz(c.B.c, true); | |
| v.a[4] = result; | |
| result = c.o; | |
| a = A(c.O, c, v); | |
| var obj = c.B.c; | |
| y = kz(v); | |
| c = lz(v); | |
| options = v.Ta(); | |
| var m = null != obj.j && kj(obj.j.a); | |
| obj = { | |
| cm : "a" | |
| }; | |
| obj.sl = jz(v); | |
| obj.tl = y; | |
| /** @type {string} */ | |
| obj.ql = c.length + ""; | |
| if (m) { | |
| /** @type {string} */ | |
| obj.edit = "1"; | |
| } | |
| v = {}; | |
| v.q = c; | |
| v.utrans = options; | |
| qz(result, ia + sq(obj), a, wa, sq(v)); | |
| S(item.A, true); | |
| if (!item.F) { | |
| WC(item, 1); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var VC = function(self) { | |
| /** @type {boolean} */ | |
| var id = 0 != self.o.o; | |
| self.Z.setVisible(id); | |
| S(self.$, id); | |
| if ("" == self.a.b) { | |
| R(self.bb.l(), le, oc); | |
| } else { | |
| R(self.bb.l(), le, ""); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var $C = function(a, b) { | |
| if (null != a.m) { | |
| a.m.setVisible(b); | |
| } | |
| if (null != a.w) { | |
| a.w.setVisible(b); | |
| } | |
| }; | |
| y = TC.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Sh = function() { | |
| VC(this); | |
| var a = this.a; | |
| var m = this.c.T(); | |
| var g = m.split("|")[0]; | |
| m = m.split("|")[1]; | |
| if (g != a.g || m != a.m) { | |
| a.g = g; | |
| a.m = m; | |
| LB(a); | |
| } | |
| S(this.A, true); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Hh = function() { | |
| var data = this.a; | |
| var c = this.Xb.T(); | |
| if (c != data.C) { | |
| data.C = c; | |
| LB(data); | |
| } | |
| S(this.A, true); | |
| }; | |
| /** | |
| * @param {string} e | |
| * @return {undefined} | |
| */ | |
| y.hg = function(e) { | |
| e.stopPropagation(); | |
| e.preventDefault(); | |
| e = this.H.value; | |
| if (e != this.W) { | |
| if (this.W = e, "" == e) { | |
| XC(this); | |
| LB(this.a); | |
| } else { | |
| e = this.a; | |
| var i = this.H.value; | |
| if (i != e.b) { | |
| e.b = i; | |
| LB(e); | |
| } | |
| VC(this); | |
| S(this.A, true); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ph = function() { | |
| var a = NC(this.j); | |
| this.o.ma(false); | |
| if (0 != a.length) { | |
| NB(this.a, a); | |
| } | |
| VC(this); | |
| this.O(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Ih = function() { | |
| if (0 == this.a.a.length) { | |
| this.o.ma(false); | |
| } else { | |
| this.j.ma(this.o.Ea()); | |
| VC(this); | |
| this.g.log("pbca", this.o.Ea()); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| y.Lj = function(data) { | |
| var b = data.target.b; | |
| data = this.a.o; | |
| var c = jz(b); | |
| var l = kz(b); | |
| var tmp = lz(b); | |
| var DOTA_Slider_Box = b.Ta(); | |
| var res = { | |
| cm : "e" | |
| }; | |
| res.id = b.Zb(); | |
| res.sl = c; | |
| res.tl = l; | |
| b = {}; | |
| b.q = tmp; | |
| b.utrans = DOTA_Slider_Box; | |
| qz(data, ia + sq(res), Ae, wa, sq(b)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| y.$h = function(a) { | |
| a = a.target; | |
| var b = a.b; | |
| tl(this.gc, jz(b), kz(b), lz(b), "pb"); | |
| az(this.fc, b.Ta()); | |
| b = this.j; | |
| var originalB = Ml(b); | |
| /** @type {number} */ | |
| var arr = 0; | |
| for (; arr < originalB; arr++) { | |
| Nl(b, arr).ma(Nl(b, arr) == a); | |
| } | |
| this.o.ma(OC(this.j)); | |
| VC(this); | |
| this.O(); | |
| this.g.log("pbcl"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Rh = function() { | |
| var o = {}; | |
| var a = (new Sq(window.location.href, true)).a.get(Pa); | |
| o.authuser = a ? a : "0"; | |
| a = this.a; | |
| /** @type {!Array} */ | |
| var result = []; | |
| /** @type {boolean} */ | |
| var value = false; | |
| if (a.g != Ja && a.m != Ja) { | |
| /** @type {boolean} */ | |
| value = true; | |
| } | |
| /** @type {number} */ | |
| var key = a.a.length - 1; | |
| for (; 0 <= key; --key) { | |
| /** @type {!Array} */ | |
| var drilldownLevelLabels = []; | |
| var r = a.a[key]; | |
| drilldownLevelLabels.push(a.c.wa(jz(r))); | |
| drilldownLevelLabels.push(a.c.Wa(kz(r))); | |
| drilldownLevelLabels.push(OB(lz(r))); | |
| drilldownLevelLabels.push(OB(r.Ta())); | |
| result.push(drilldownLevelLabels.join(",")); | |
| } | |
| /** @type {string} */ | |
| key = ""; | |
| if (value) { | |
| key = " - " + a.c.wa(a.g) + " - " + a.c.Wa(a.m); | |
| } else { | |
| if ("" != a.b) { | |
| /** @type {string} */ | |
| key = " - " + a.b; | |
| } | |
| } | |
| /** @type {!Array} */ | |
| a = [result.join("\n"), key]; | |
| this.g.log("pbexp", "" == a[1] ? 1 : 2); | |
| result = a[0]; | |
| value = this.P + a[1]; | |
| o = o || {}; | |
| a = o.target; | |
| key = o.trixPath || (o.useCorp ? "https://docs.google.com/a/google.com/spreadsheets/" : void 0); | |
| delete o.target; | |
| delete o.useCorp; | |
| delete o.trixPath; | |
| Wf(o, { | |
| content : result, | |
| title : value | |
| }); | |
| value = o.authuser; | |
| result = tq(key || "https://docs.google.com/spreadsheets/", "import"); | |
| result = tq(result, "inline"); | |
| if (value) { | |
| /** @type {!Array} */ | |
| result = [result, "&", Pa]; | |
| if (null != value) { | |
| result.push("=", Xe(value)); | |
| } | |
| if (result[1]) { | |
| value = result[0]; | |
| key = value.indexOf("#"); | |
| if (0 <= key) { | |
| result.push(value.substr(key)); | |
| result[0] = value = value.substr(0, key); | |
| } | |
| key = value.indexOf("?"); | |
| if (0 > key) { | |
| /** @type {string} */ | |
| result[1] = "?"; | |
| } else { | |
| if (key == value.length - 1) { | |
| result[1] = void 0; | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| result = result.join(""); | |
| } | |
| cB(new aB, o, result, a); | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @return {undefined} | |
| */ | |
| var ZC = function(params) { | |
| /** @type {boolean} */ | |
| params.Ra = true; | |
| M("gt-apb-c").appendChild(jp(Ap, { | |
| Df : params.P | |
| })); | |
| SC(params, M("gt-pb-sw2"), MSG_HIDE_PB); | |
| M("gt-main").appendChild(jp(Bp, { | |
| Df : params.P | |
| })); | |
| params.qa = M("pb-dd"); | |
| params.U = M("pb-sh"); | |
| params.o = new JB; | |
| params.o.aa(M("pb-cb-a")); | |
| params.$ = M("pb-sp-del"); | |
| var d = M("pb-del-c"); | |
| var item = new eo(MSG_DELETE, new Vo("pbdel-button")); | |
| item.aa(d); | |
| item.setVisible(false); | |
| U(item, p, params.Ph, false, params); | |
| params.Z = item; | |
| params.bb = YC(params); | |
| d = new Wu(M("pb-ls"), [MSG_ALL, "-"], 11, [Ka, xd], void 0, "", rC.M()); | |
| U(d, Ya, params.Sh, false, params); | |
| params.c = d; | |
| d = new Wu(M("pb-st"), [MSG_NEWEST, MSG_SOURCE], 10, ["0", "2"], void 0, MSG_SORT_BY + " ", rC.M(), void 0, true); | |
| U(d, Ya, params.Hh, false, params); | |
| params.Xb = d; | |
| params.L = M("pb-empty"); | |
| d = M("gt-pb-tb"); | |
| item = new JC; | |
| item.aa(d); | |
| U(item, Ya, params.pb, false, params); | |
| U(item, "pbedit", params.Lj, false, params); | |
| U(item, "pbclick", params.$h, false, params); | |
| params.j = item; | |
| params.H = M("gt-pb-sb"); | |
| /** @type {string} */ | |
| params.W = ""; | |
| params.Gb = M("gt-pb-sbt"); | |
| params.A = M("gt-pb-spin"); | |
| params.Fa = M("gt-apb-pb"); | |
| params.Ha = M("gt-pb-c"); | |
| params.K = M("pb-tb-c"); | |
| params.Wa = M("pb-tool"); | |
| d = M("pb-tool-r"); | |
| item = new eo(MSG_PB_EXP, new Vo("pbexp-button")); | |
| item.aa(d); | |
| U(item, p, params.Rh, false, params); | |
| d = new PB; | |
| U(d, od, params.X, false, params); | |
| aD(params); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| var bD = function(options, data) { | |
| var doc; | |
| if (null != data) { | |
| /** @type {string} */ | |
| doc = data; | |
| } else { | |
| doc = MSG_NP; | |
| var mainDoc = MSG_NPM; | |
| doc = options.c.T() == Ka ? doc : mainDoc; | |
| } | |
| Q(options.L, doc); | |
| S(options.L, true); | |
| S(options.j.l(), false); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {undefined} b | |
| * @return {undefined} | |
| */ | |
| var cD = function(o, b) { | |
| o.j.update(b, o.G, true); | |
| S(o.L, false); | |
| S(o.j.l(), true); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.lc = function() { | |
| this.o.ma(false); | |
| this.Z.setVisible(false); | |
| S(this.$, false); | |
| S(this.A, false); | |
| var a = this.a.a; | |
| if (this.c.T() == Ka) { | |
| var result = {}; | |
| this.c.T(); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; i++) { | |
| var c1 = a[i]; | |
| var column2Row0 = this.G.wa(jz(c1)) + (document.body.dir == sd ? " < " : " > ") + this.G.Wa(kz(c1)); | |
| result[jz(c1) + "|" + kz(c1)] = column2Row0; | |
| } | |
| var p; | |
| for (p in result) { | |
| /** @type {boolean} */ | |
| c1 = false; | |
| /** @type {number} */ | |
| i = 2; | |
| for (; i < su(this.c); i++) { | |
| if (Vu(this.c, i) == p) { | |
| /** @type {boolean} */ | |
| c1 = true; | |
| break; | |
| } | |
| } | |
| if (!c1) { | |
| i = new yu(result[p], p); | |
| this.c.ae(i); | |
| } | |
| } | |
| /** @type {number} */ | |
| i = su(this.c) - 1; | |
| for (; 1 < i; i--) { | |
| if (!(null != result[Vu(this.c, i)])) { | |
| this.c.vc(i); | |
| } | |
| } | |
| ru(this.c, 1).setVisible(2 < su(this.c)); | |
| } | |
| if ("" != this.a.b) { | |
| result = MSG_PB_SR.replace(aa, a.length); | |
| Q(this.U, result); | |
| S(this.U, true); | |
| S(this.qa, false); | |
| } | |
| if (0 == a.length) { | |
| result = this.a.A; | |
| if ("" != result) { | |
| bD(this, result); | |
| this.g.log("pberr"); | |
| } else { | |
| if ("" == this.a.b) { | |
| bD(this); | |
| } else { | |
| cD(this, a); | |
| } | |
| } | |
| } else { | |
| cD(this, a); | |
| if (this.F) { | |
| PC(this.j, MB(this.a)); | |
| } | |
| } | |
| this.O(); | |
| if (this.Ma) { | |
| /** @type {!Array} */ | |
| result = []; | |
| /** @type {number} */ | |
| p = 0; | |
| for (; p < a.length; p++) { | |
| Gf(result, jz(a[p]) + "/" + kz(a[p])); | |
| } | |
| p = {}; | |
| p.count = a.length; | |
| /** @type {number} */ | |
| p.pairs = result.length; | |
| this.g.log("pbfo", p); | |
| /** @type {boolean} */ | |
| this.Ma = false; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.Vb = function() { | |
| S(this.wa, false); | |
| /** @type {number} */ | |
| this.C = 0; | |
| if (this.F) { | |
| Go(this.N.l(), MSG_SHOW_PB); | |
| K(document.body, "pbv"); | |
| var explosionSprite = new By(this.Fa, 400); | |
| var previewPlayer = new By(this.Ha, 400); | |
| explosionSprite.play(); | |
| previewPlayer.play(); | |
| /** @type {boolean} */ | |
| this.F = false; | |
| } else { | |
| Go(this.N.l(), MSG_HIDE_PB); | |
| /** @type {boolean} */ | |
| this.F = true; | |
| if (!this.Ra) { | |
| ZC(this); | |
| LB(this.a); | |
| S(this.A, true); | |
| } | |
| J(document.body, "pbv"); | |
| explosionSprite = new Cy(this.Fa, 400); | |
| previewPlayer = new Cy(this.Ha, 400); | |
| explosionSprite.play(); | |
| previewPlayer.play(); | |
| this.X(); | |
| PC(this.j, MB(this.a)); | |
| } | |
| this.g.log("pbsw", this.F); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var aD = function(o) { | |
| U(o.o, Ya, o.Ih, false, o); | |
| U(o.Gb, r, o.hg, false, o); | |
| U(new Gn(o.H), Hc, function(e) { | |
| if (13 == e.keyCode) { | |
| this.hg(e); | |
| } | |
| }, false, o); | |
| U(o.a, id, o.lc, false, o); | |
| U(o.ob, he, o.O, false, o); | |
| U(window, td, o.X, false, o); | |
| U(o.K, td, o.kc, false, o); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.X = function() { | |
| /** @type {number} */ | |
| var h = document.documentElement.clientHeight; | |
| S(this.K, false); | |
| if (document.body.scrollHeight > h) { | |
| /** @type {number} */ | |
| h = document.body.scrollHeight; | |
| } | |
| S(this.K, true); | |
| var offy = $i(this.K).y; | |
| this.K.style.height = Vi(h - offy - 29, true); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.O = function() { | |
| var b; | |
| a: { | |
| b = this.a; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.a.length; ++i) { | |
| var r = b.a[i]; | |
| if (ZA(b.c) == jz(r) && YA(b.c) == kz(r) && $A(b.B) == lz(r) && cz(b.B.c, true) == r.Ta()) { | |
| b = r.Zb(); | |
| break a; | |
| } | |
| } | |
| /** @type {string} */ | |
| b = ""; | |
| } | |
| this.B = b; | |
| if (null != this.m) { | |
| if ("" != this.B) { | |
| J(this.m.l(), ce); | |
| } else { | |
| K(this.m.l(), ce); | |
| } | |
| QC(this, this.m); | |
| } | |
| if (null != this.w) { | |
| this.w.ba("" == this.B); | |
| this.w.g("" != this.B ? MSG_SAVED : this.va); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| TC.prototype.kc = function() { | |
| if (0 < this.K.scrollTop) { | |
| J(this.Wa, "pb-shadow"); | |
| } else { | |
| K(this.Wa, "pb-shadow"); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var dD = function(a, b) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {number} */ | |
| this.b = b; | |
| }; | |
| var eD = { | |
| af : "af-ZA", | |
| bg : "bg-BG", | |
| ca : "ca-ES", | |
| cs : "cs-CZ", | |
| da : "da-DK", | |
| de : "de-DE", | |
| el : "el-GR", | |
| eu : "eu-ES", | |
| fa : "fa-IR", | |
| fi : "fi-FI", | |
| tl : "fil-PH", | |
| fr : "fr-FR", | |
| gl : "gl-ES", | |
| hi : "hi-IN", | |
| hr : "hr-HR", | |
| hu : "hu-HU", | |
| iw : "he-IL", | |
| id : "id-ID", | |
| is : "is-IS", | |
| it : "it-IT", | |
| ja : "ja-JP", | |
| ko : "ko-KR", | |
| lt : "lt-LT", | |
| ms : "ms-MY", | |
| no : "nb-NO", | |
| nl : "nl-NL", | |
| pl : "pl-PL", | |
| ro : "ro-RO", | |
| ru : "ru-RU", | |
| sk : "sk-SK", | |
| sl : "sl-SI", | |
| sr : "sr-RS", | |
| sv : "sv-SE", | |
| th : "th-TH", | |
| tr : "tr-TR", | |
| uk : "uk-UA", | |
| vi : "vi-VN", | |
| zu : "zu-ZA", | |
| "ar::ae" : "ar-AE", | |
| "ar::bh" : "ar-BH", | |
| "ar::dz" : "ar-DZ", | |
| "ar::eg" : "ar-EG", | |
| "ar::il" : "ar-IL", | |
| "ar::jo" : "ar-JO", | |
| "ar::kw" : "ar-KW", | |
| "ar::lb" : "ar-LB", | |
| "ar::ma" : "ar-MA", | |
| "ar::om" : "ar-OM", | |
| "ar::ps" : "ar-PS", | |
| "ar::qa" : "ar-QA", | |
| "ar::sa" : "ar-SA", | |
| "ar::tn" : "ar-TN", | |
| ar : "ar-EG", | |
| "en::au" : "en-AU", | |
| "en::ca" : "en-CA", | |
| "en::uk" : "en-GB", | |
| "en::ie" : "en-IE", | |
| "en::in" : "en-IN", | |
| "en::nz" : "en-NZ", | |
| "en::com" : "en-US", | |
| "en::za" : "en-ZA", | |
| en : "en-001", | |
| "es::ar" : "es-AR", | |
| "es::bo" : "es-BO", | |
| "es::cl" : "es-CL", | |
| "es::co" : "es-CO", | |
| "es::cr" : "es-CR", | |
| "es::do" : "es-DO", | |
| "es::ec" : "es-EC", | |
| "es::es" : "es-ES", | |
| "es::gt" : "es-GT", | |
| "es::hn" : "es-HN", | |
| "es::mx" : "es-MX", | |
| "es::ni" : "es-NI", | |
| "es::pa" : "es-PA", | |
| "es::pe" : "es-PE", | |
| "es::pr" : "es-PR", | |
| "es::py" : "es-PY", | |
| "es::sv" : "es-SV", | |
| "es::com" : "es-US", | |
| "es::uy" : "es-UY", | |
| "es::ve" : "es-VE", | |
| es : "es-ES", | |
| "pt::pt" : "pt-PT", | |
| pt : "pt-BR", | |
| "zh-CN:zh-TW:hk" : "yue-Hant-HK", | |
| "zh-CN:zh-CN:hk" : "cmn-Hans-HK", | |
| "zh-CN:zh-TW" : "cmn-Hant-TW", | |
| "zh-CN" : "cmn-Hans-CN" | |
| }; | |
| /** | |
| * @param {string} num | |
| * @return {?} | |
| */ | |
| dD.prototype.get = function(num) { | |
| return eD[num + ":" + this.b + ":" + this.a] || eD[num + "::" + this.a] || eD[num + ":" + this.b] || eD[num] || null; | |
| }; | |
| /** | |
| * @param {number} fn | |
| * @param {?} disposer | |
| * @return {undefined} | |
| */ | |
| var fD = function(fn, disposer) { | |
| Xz.call(this, disposer); | |
| /** @type {number} */ | |
| this.o = 0; | |
| /** @type {boolean} */ | |
| this.c.oe = true; | |
| this.setAutoHide(false); | |
| /** @type {number} */ | |
| this.c.b = fn; | |
| $z(this); | |
| uo(this.c, 1, 2, void 0); | |
| /** @type {boolean} */ | |
| this.g = false; | |
| Zz(this, jp(Lp, { | |
| label : MSG_SPEAK_NOW | |
| })); | |
| }; | |
| C(fD, Xz); | |
| /** | |
| * @return {undefined} | |
| */ | |
| fD.prototype.V = function() { | |
| fD.v.V.call(this); | |
| this.m = O("gt-speech-l3", this.l()); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var gD = function(d) { | |
| if (0 == d.o++) { | |
| J(d.m, "trigger"); | |
| } | |
| cl(d.A, 600, d); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| fD.prototype.A = function() { | |
| if (0 == --this.o) { | |
| K(this.m, "trigger"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} recognition | |
| * @param {?} b | |
| * @param {boolean} variableNames | |
| * @return {undefined} | |
| */ | |
| var hD = function(recognition, b, variableNames) { | |
| /** @type {!Object} */ | |
| this.B = recognition; | |
| /** @type {null} */ | |
| this.a = null; | |
| if (sr && "webkitSpeechRecognition" in window) { | |
| recognition = new webkitSpeechRecognition; | |
| /** @type {boolean} */ | |
| recognition.continuous = true; | |
| /** @type {boolean} */ | |
| recognition.interimResults = true; | |
| /** @type {!Object} */ | |
| this.a = recognition; | |
| } | |
| this.H = new dD(b, variableNames); | |
| /** @type {string} */ | |
| this.g = ""; | |
| /** @type {boolean} */ | |
| this.j = false; | |
| /** @type {null} */ | |
| this.b = null; | |
| this.m = vc; | |
| this.o = Wp.M(); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var iD = function(item) { | |
| if (null != item.a) { | |
| item.b = new So(MSG_SPEECH_INPUT_TURN_ON, MSG_SPEECH_INPUT_TURN_OFF, new Vo("speech-button")); | |
| item.b.R(P(k, { | |
| id : "gt-speech", | |
| tabindex : "0" | |
| })); | |
| var table = M(jc); | |
| table.insertBefore(item.b.l(), table.childNodes[1] || null); | |
| item.c = new fD(item.b.l()); | |
| item.c.aa(item.b.l()); | |
| item.a.onresult = A(item.G, item); | |
| item.a.onstart = A(item.O, item); | |
| item.a.onspeechstart = A(item.K, item); | |
| item.a.onend = A(item.w, item); | |
| item.a.onspeechend = A(item.A, item); | |
| item.a.onerror = A(item.Ca, item); | |
| item.a.onnomatch = A(item.F, item); | |
| U(item.b, p, item.C, false, item); | |
| } | |
| }; | |
| /** @type {!Array<string>} */ | |
| var jD = "init:buttonOn end:buttonOn buttonOn:start start:speechStart speechStart:result result:result result:buttonOff buttonOff:speechEnd speechEnd:end".split(" "); | |
| /** | |
| * @param {!Object} message | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var kD = function(message, value) { | |
| if (!(0 <= jD.indexOf(message.m + ":" + value))) { | |
| var p = {}; | |
| p.from = message.m; | |
| /** @type {number} */ | |
| p.to = value; | |
| message.o.log("speech", p); | |
| } | |
| /** @type {number} */ | |
| message.m = value; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.C = function() { | |
| if (this.b.Ea()) { | |
| /** @type {string} */ | |
| this.g = ""; | |
| this.a.start(); | |
| kD(this, "buttonOn"); | |
| } else { | |
| this.a.stop(); | |
| this.c.setVisible(false); | |
| kD(this, "buttonOff"); | |
| } | |
| this.B.l().focus(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.clear = function() { | |
| /** @type {string} */ | |
| this.g = ""; | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var lD = function(self, url) { | |
| if (null != self.a) { | |
| if (self.j) { | |
| self.a.stop(); | |
| } | |
| var city = self.H.get(url); | |
| self.a.lang = null != city ? city : ""; | |
| self.b.setVisible(null != city); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.O = function() { | |
| /** @type {boolean} */ | |
| this.j = true; | |
| this.c.setVisible(true); | |
| kD(this, Nd); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.K = function() { | |
| gD(this.c); | |
| kD(this, "speechStart"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.w = function() { | |
| mD(this); | |
| kD(this, ub); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.A = function() { | |
| gD(this.c); | |
| kD(this, "speechEnd"); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var mD = function(options) { | |
| /** @type {boolean} */ | |
| options.j = false; | |
| options.c.setVisible(false); | |
| options.b.ma(false); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| hD.prototype.G = function(value) { | |
| gD(this.c); | |
| /** @type {string} */ | |
| var delta = ""; | |
| var i = value.resultIndex; | |
| for (; i < value.results.length; ++i) { | |
| if (value.results[i].isFinal) { | |
| this.g += value.results[i][0].transcript; | |
| } else { | |
| /** @type {string} */ | |
| delta = delta + value.results[i][0].transcript; | |
| } | |
| } | |
| /** @type {string} */ | |
| value = this.g + delta; | |
| cq(this.o, xc, 3); | |
| this.B.b(value); | |
| kD(this, "result"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.Ca = function() { | |
| mD(this); | |
| kD(this, "error"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.F = function() { | |
| mD(this); | |
| kD(this, "noMatch"); | |
| }; | |
| /** | |
| * @param {?} pip_offset_base | |
| * @param {!Array} p | |
| * @param {number} w | |
| * @param {string} i | |
| * @param {string} X | |
| * @return {undefined} | |
| */ | |
| var nD = function(pip_offset_base, p, w, i, X) { | |
| W.call(this); | |
| this.I = pip_offset_base; | |
| /** @type {!Array} */ | |
| this.P = p; | |
| /** @type {number} */ | |
| this.W = w; | |
| this.U = i || ""; | |
| this.X = X || ""; | |
| /** @type {string} */ | |
| this.g = this.c = this.m = ""; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {boolean} */ | |
| this.o = true; | |
| /** @type {!Array} */ | |
| this.A = []; | |
| /** @type {string} */ | |
| this.w = ""; | |
| /** @type {boolean} */ | |
| this.L = false; | |
| this.H = new io(this.N, 1E3, this); | |
| this.j = Wp.M(); | |
| }; | |
| C(nD, W); | |
| /** | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| nD.prototype.setVisible = function(id) { | |
| if (!id) { | |
| /** @type {boolean} */ | |
| this.L = this.b = false; | |
| jo(this.H); | |
| } | |
| S(this.l(), id); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| nD.prototype.isVisible = function() { | |
| return kj(this.l()); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var oD = function(node, options) { | |
| if ("" == options.Hd) { | |
| node.setVisible(false); | |
| } else { | |
| if (options.Nf) { | |
| if (node.L) { | |
| return; | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| node.L = true; | |
| } | |
| node.w = options.Nf || ""; | |
| node.m = options.Zg; | |
| node.c = options.gh; | |
| node.g = options.Hd; | |
| var s = options.Nh || hf(options.Hd); | |
| var value; | |
| value = options.Nf ? node.P : options.eg && node.o ? node.U : node.W; | |
| node.b = options.eg && node.o; | |
| if (node.b && Ef(options.Xe, 6)) { | |
| if (node.setVisible(false), Q(M(Jd), node.g), options.result) { | |
| /** @type {number} */ | |
| var val = 0; | |
| for (; val < Nm(options.result); val++) { | |
| Om(options.result, val).kb[3] = 0 == val ? node.g : ""; | |
| } | |
| } | |
| } else { | |
| if (node.b) { | |
| val = node.l(); | |
| K(val, gc); | |
| J(val, ac); | |
| } else { | |
| val = node.l(); | |
| K(val, ac); | |
| J(val, gc); | |
| } | |
| node.setVisible(true); | |
| } | |
| Q(node.l(), value + " "); | |
| node.A = options.Xe; | |
| value = P("a", { | |
| tabindex : 0, | |
| href : yc | |
| }); | |
| R(value, { | |
| direction : ag(node.c) ? sd : Qc | |
| }); | |
| R(value, { | |
| "text-decoration" : ad | |
| }); | |
| value.innerHTML = s; | |
| U(value, r, node.Z, false, node); | |
| node.l().appendChild(value); | |
| if (node.b && !Ef(options.Xe, 6)) { | |
| s = P(qb); | |
| Q(s, node.X + " "); | |
| value = P("a", { | |
| tabindex : 1, | |
| href : yc | |
| }); | |
| U(value, r, node.$, false, node); | |
| Q(value, node.m); | |
| s.appendChild(value); | |
| node.l().appendChild(s); | |
| J(s, "gt-revert-correct-message"); | |
| } | |
| ko(node.H); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nD.prototype.N = function() { | |
| var data = {}; | |
| data.orig = this.m; | |
| data.sl = this.c; | |
| if (this.b) { | |
| data.autocorrect = this.b; | |
| } | |
| if (this.w) { | |
| data.corrlang = this.w; | |
| this.j.log("langidshow", data); | |
| } else { | |
| data.corr = this.g; | |
| data.corrtype = this.A; | |
| this.j.log("spell", data); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nD.prototype.Z = function() { | |
| var value = this.m; | |
| if (64 < value.length) { | |
| value = value.substr(0, 64); | |
| } | |
| cq(this.j, "orig", value); | |
| if (this.w) { | |
| cq(this.j, "psl", this.c); | |
| tl(this.I, this.w, "", this.m, "tws_lsugg"); | |
| } else { | |
| cq(this.j, "corrtype", this.A); | |
| if (this.b) { | |
| tl(this.I, "", "", this.g, "tws_confirm"); | |
| } else { | |
| tl(this.I, "", "", this.g, "tws_spell"); | |
| } | |
| } | |
| value = this.H; | |
| if (0 != value.Ga) { | |
| jo(value); | |
| value.b(); | |
| } | |
| this.setVisible(false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nD.prototype.$ = function() { | |
| var value = this.g; | |
| if (64 < value.length) { | |
| value = value.substr(0, 64); | |
| } | |
| cq(this.j, "corr", value); | |
| cq(this.j, "corrtype", this.A); | |
| /** @type {boolean} */ | |
| this.o = false; | |
| tl(this.I, "", "", this.m, "tws_revert"); | |
| value = this.H; | |
| if (0 != value.Ga) { | |
| jo(value); | |
| value.b(); | |
| } | |
| this.setVisible(false); | |
| }; | |
| /** | |
| * @param {number} s | |
| * @param {?} t | |
| * @param {?} i | |
| * @return {undefined} | |
| */ | |
| var pD = function(s, t, i) { | |
| W.call(this); | |
| /** @type {number} */ | |
| this.b = s; | |
| this.H = t; | |
| this.N = i; | |
| this.c = HATS_TP; | |
| /** @type {null} */ | |
| this.g = this.w = this.j = this.o = null; | |
| /** @type {number} */ | |
| this.m = -1; | |
| this.I = Wp.M(); | |
| }; | |
| C(pD, W); | |
| /** | |
| * @return {undefined} | |
| */ | |
| pD.prototype.ra = function() { | |
| pD.v.ra.call(this); | |
| this.Y(di(k)); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| pD.prototype.Y = function(data) { | |
| pD.v.Y.call(this, data); | |
| J(data, "gt-hats"); | |
| data.appendChild(ip(Ep)); | |
| this.o = O("gt-hats-tt", data); | |
| this.j = O("gt-hats-c", data); | |
| this.w = O("gt-hats-x", data); | |
| Q(this.o, MSG_HATS_TITLE); | |
| this.g = new gu; | |
| this.Ia(this.g, true); | |
| /** @type {!Array} */ | |
| data = [[MSG_HATS_O1, 0], [MSG_HATS_O2, 1], [MSG_HATS_O3, 2], [MSG_HATS_O4, 3], [MSG_HATS_O5, 4]]; | |
| if (2 == this.c || 4 == this.c || 6 == this.c) { | |
| /** @type {function(): number} */ | |
| var r = Math.random; | |
| /** @type {number} */ | |
| var a = data.length - 1; | |
| for (; 0 < a; a--) { | |
| /** @type {number} */ | |
| var name = Math.floor(r() * (a + 1)); | |
| var i = data[a]; | |
| data[a] = data[name]; | |
| data[name] = i; | |
| } | |
| } | |
| /** @type {number} */ | |
| r = 0; | |
| for (; r < data.length; ++r) { | |
| if (data[r][0]) { | |
| a = data[r][0]; | |
| name = data[r][1]; | |
| i = P(za); | |
| if (1 == this.c) { | |
| var s = P(za, { | |
| "class" : "goog-inline-block gt-hats-icon" | |
| }); | |
| J(s, "gt-hats-icon" + Ml(this.g)); | |
| i.appendChild(s); | |
| } | |
| s = P(za, { | |
| "class" : "gt-hats-option" | |
| }); | |
| Q(s, a); | |
| i.appendChild(s); | |
| a = new yu(i, name); | |
| this.g.Ia(a, true); | |
| } | |
| } | |
| }; | |
| pD.prototype.yb = w("j"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| pD.prototype.V = function() { | |
| pD.v.V.call(this); | |
| X(this).a(this.g, p, this.L); | |
| X(this).a(this.w, r, A(this.A, this, 0)); | |
| qD(this, Ad); | |
| }; | |
| /** | |
| * @param {!Object} query | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var qD = function(query, type) { | |
| var data = {}; | |
| data.sl = ZA(query.H); | |
| data.tl = YA(query.H); | |
| data.hl = query.b; | |
| /** @type {string} */ | |
| data.e = type; | |
| query.I.log(1 == query.c ? "survey" : "survey" + query.c, data); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| pD.prototype.L = function(key) { | |
| this.m = key.target.T(); | |
| qD(this, ud + this.m); | |
| fj(this.l(), hj(this.l())); | |
| this.g.za(); | |
| Q(this.o, MSG_HATS_THANKS); | |
| this.j.appendChild(ip(Fp, { | |
| Eh : MSG_HATS_AF, | |
| qd : MSG_HATS_MF | |
| })); | |
| key = O("gt-hats-link", this.j); | |
| X(this).a(key, r, function() { | |
| this.N.c(); | |
| qD(this, "feedback"); | |
| }); | |
| this.A(1E4); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| pD.prototype.A = function(name) { | |
| $p(this.I, "/translate/uc?ua=dismiss&uav=survey"); | |
| cl(this.P, name, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| pD.prototype.P = function() { | |
| (new By(this.l(), 300)).play(); | |
| cl(A(this.za, this), 300); | |
| }; | |
| /** | |
| * @param {!Object} ch | |
| * @param {string} i | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| function rD(ch, i, c) { | |
| i = P(wc, { | |
| type : oc, | |
| name : i, | |
| value : c | |
| }); | |
| ch.appendChild(i); | |
| } | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var DD = function(options) { | |
| V.call(this); | |
| this.m = Wp.M(); | |
| var c = new fv(this); | |
| if (options.m) { | |
| options = HA(options); | |
| } | |
| this.submit = M("gt-submit"); | |
| this.form = this.submit.form; | |
| this.b = M("hl").value; | |
| this.Da = new Ar("t"); | |
| /** @type {boolean} */ | |
| this.zc = true; | |
| this.L = options.A; | |
| /** @type {number} */ | |
| this.lg = (new Date).getTime(); | |
| this.A = new dv("gt-sl"); | |
| this.N = new dv("gt-tl"); | |
| ev(this.A); | |
| /** @type {number} */ | |
| this.A.Ha = 0; | |
| ev(this.N); | |
| /** @type {number} */ | |
| this.N.Ha = 0; | |
| /** @type {null} */ | |
| this.Be = null; | |
| this.Fb = Bv.M(); | |
| this.Ng = M("gt-swap"); | |
| this.Je = new eo(null, new Uo("trans-swap-button")); | |
| if (this.Ng) { | |
| this.Je.R(this.Ng); | |
| } | |
| var x = M(Fd); | |
| this.j = new ht(x.value); | |
| bt(this.j); | |
| this.j.R(x); | |
| at(this.j); | |
| J(sD(this), yd); | |
| /** @type {number} */ | |
| this.Ee = this.Me = 0; | |
| this.a = new qt; | |
| gv(c, this.a, this.A, this.N); | |
| x = "" == options.c ? null : new rB(tD(options.c), A(this.wa, this), void 0, true); | |
| var _this = "" == options.g ? null : new rB(tD(options.g), A(this.Wa, this)); | |
| yt(this.a); | |
| /** @type {boolean} */ | |
| this.Lg = true; | |
| this.Cc = new sB(this.a); | |
| vB(this.Cc, { | |
| dh : this.A, | |
| kh : this.N, | |
| eh : x, | |
| lh : _this, | |
| hh : this.Je, | |
| mh : this.j | |
| }); | |
| if (null != FEATURE_STICKINESS) { | |
| uD(this); | |
| } | |
| vD(this); | |
| wD(this.j, ZA(this)); | |
| U(this.a, Md, this.Rj, false, this); | |
| U(this.a, Ld, this.Tj, false, this); | |
| U(this.a, lb, this.Qi, false, this); | |
| U(this.a, Wd, this.wh, false, this); | |
| this.g = tD(options.K); | |
| this.F = new Xs(""); | |
| this.F.R(M("contribute-target")); | |
| bt(this.F); | |
| at(this.F); | |
| wD(this.F, YA(this)); | |
| U(this.submit, r, this.Ki, false, this); | |
| U(this.a, Nc, A(this.Ad, this, false), false, this); | |
| U(this.j, Ya, this.nj, false, this); | |
| U(this, he, this.yj, false, this); | |
| this.w = new Bs(this.b, this.Da, this); | |
| this.w.R(M("gt-lc")); | |
| x = new Ms(this.b); | |
| this.w.b.Ia(x, true); | |
| this.ze = new Pr(this.b, [common_translation_tooltip, uncommon_translation_tooltip, rare_translation_tooltip, MSG_N_MORE_TRANSLATIONS_LABEL], true); | |
| this.w.w.Ia(this.ze, true); | |
| /** @type {null} */ | |
| this.Ec = this.Ac = this.xd = this.Xc = null; | |
| this.Xc = new Hs(this.b); | |
| this.w.b.Ia(this.Xc, true); | |
| this.xd = new Sz(this.b); | |
| this.w.b.Ia(this.xd, true); | |
| this.Ac = new SA(this.b); | |
| this.w.b.Ia(this.Ac, true); | |
| this.Ec = new rz(this.b); | |
| this.w.b.Ia(this.Ec, true); | |
| if (x = tD(options.H)) { | |
| this.o = new nD(this, MSG_LANGUAGE_CORRECTION, MSG_SPELLING_CORRECTION, MSG_SPELLING_AUTO_CORRECTION, MSG_SPELLING_REVERT_CORRECTION); | |
| this.o.R(x); | |
| } | |
| this.Ke = options.Ra; | |
| this.Bh = options.U; | |
| this.K = M(nd); | |
| this.I = M(Jd); | |
| this.Wc = M("backend-stats-stt-total"); | |
| this.fc = M("backend-stats-community"); | |
| this.kc = M("backend-stats-dictionary"); | |
| this.lc = M("backend-stats-other"); | |
| this.gc = M("backend-stats-decoder"); | |
| this.yh = options.Ca; | |
| this.jg = tD(options.C); | |
| this.Vb = tD(options.w); | |
| /** @type {null} */ | |
| this.Z = null; | |
| if (null != options.a) { | |
| this.Z = new Lv(options.a, sD(this), M("gt-src-c"), this.b, this); | |
| } | |
| /** @type {null} */ | |
| this.Qa = null; | |
| if (null != this.F && null != options.o) { | |
| this.Qa = new Lv(options.o, this.F.l(), M("gt-res-c"), this.b, void 0); | |
| S(options.o, false); | |
| } | |
| this.Yc = M(vd); | |
| this.$f = new KA(this); | |
| xD(this); | |
| this.Ge = options.I; | |
| this.He = options.P; | |
| this.B = options.L; | |
| this.C = options.wa; | |
| if (this.O = options.O) { | |
| yD(this.O, ZA(this)); | |
| li(this.O.l(), sD(this)); | |
| U(this.O, p, this.Kh, false, this); | |
| } | |
| this.bb = options.X; | |
| if (null != this.F && null != this.bb) { | |
| yD(this.bb, YA(this)); | |
| li(this.bb.l(), this.F.l()); | |
| } | |
| if (this.B) { | |
| U(this.B, p, this.kj, false, this); | |
| } | |
| if (this.C) { | |
| U(this.C, p, this.vj, false, this); | |
| } | |
| this.$ = options.N; | |
| /** @type {null} */ | |
| this.pb = null; | |
| if (this.$) { | |
| this.pb = zD(this.$.l()); | |
| U(this.$, p, this.mj, false, this); | |
| } | |
| /** @type {null} */ | |
| this.Ha = null; | |
| if (ENABLE_COMMUNITY_SERVED_PROMO) { | |
| this.Ha = new aA("t-served-community", MSG_COMMUNITY_PROMO_SERVED_DESCRIPTION, MSG_COMMUNITY_PROMO_SERVED_LINK, MSG_COMMUNITY_PROMO_SERVED_DISMISS, MSG_COMMUNITY_PROMO_SERVED_URL, COMMUNITY_PROMO_SERVED_DISMISSED); | |
| this.Ha.R(M(ec)); | |
| } | |
| this.qa = {}; | |
| this.qa.edit = ENABLE_COMMUNITY_USER_EDIT_PROMO ? new Gs(MSG_COMMUNITY_PROMO_EDIT_LINK, MSG_COMMUNITY_PROMO_EDIT_SUBTEXT, MSG_COMMUNITY_PROMO_EDIT_TITLE, "", MSG_COMMUNITY_PROMO_EDIT_URL, "t-user-edit") : null; | |
| if ("new" === COMMUNITY_PROMO_TYPE) { | |
| this.qa[kb] = new Gs(MSG_COMMUNITY_PROMO_NEW_USER_LINK, "", MSG_COMMUNITY_PROMO_NEW_USER_TITLE, MSG_COMMUNITY_PROMO_NEW_USER_SUBTEXT, MSG_COMMUNITY_PROMO_NEW_USER_URL, "t-new-user"); | |
| } else { | |
| if ("return" === COMMUNITY_PROMO_TYPE) { | |
| this.qa[kb] = new Gs(MSG_COMMUNITY_PROMO_RETURN_USER_LINK, "", MSG_COMMUNITY_PROMO_RETURN_USER_TITLE, MSG_COMMUNITY_PROMO_RETURN_USER_SUBTEXT, MSG_COMMUNITY_PROMO_RETURN_USER_URL, "t-return-user"); | |
| } | |
| } | |
| x = M("gt-promo-lr"); | |
| _this = this.qa[kb]; | |
| if (null != _this) { | |
| _this.R(x); | |
| } | |
| Qy = MSG_UNDO_EDITS; | |
| this.W = new Ry(options.b); | |
| if (this.W.b) { | |
| if (null != M(bc)) { | |
| this.ye = new Tx(M(bc), MSG_COPIED, null, 2); | |
| } | |
| U(this.W.b, p, this.lj, false, this); | |
| } | |
| c.b(this.Je, this.B, this.C, this.Ge, this.He); | |
| if (c = Ly()) { | |
| /** @type {string} */ | |
| c = "&" + c; | |
| } | |
| /** @type {null} */ | |
| this.ob = null; | |
| if (null != this.Ge) { | |
| this.ob = new xs(this.Ge, "&client=t" + c, ur); | |
| } | |
| /** @type {null} */ | |
| this.X = null; | |
| if (null != this.He) { | |
| this.X = new xs(this.He, "&client=t&prev=input" + c, ur); | |
| } | |
| NA(true); | |
| /** @type {boolean} */ | |
| this.Bc = false; | |
| dy = MSG_ALT_PHRASE_TITLE; | |
| ey = MSG_EDIT_TRANSLATION; | |
| oy = MSG_USE_ALTERNATIVE; | |
| py = Ac; | |
| x = di(k); | |
| S(x, false); | |
| ki(x, this.K); | |
| c = new Ey(MSG_SUBMIT_TRANSLATION, MSG_CANCEL_EDITS, MSG_SUGGEST_A_TRANSLATION, this.qa.edit); | |
| c.R(x); | |
| x = new Oy(this.F, M("gt-edit"), M("gt-res-content"), M("gt-res-wrap"), this.K, this.bb); | |
| this.H = new Ps(this, MSG_FORMAL, MSG_INFORMAL, false, ENABLE_FORMALITY, IS_STICKY_FORMALITY, DEFAULT_FORMALITY); | |
| this.c = new Ty(void 0, true, void 0, options.F, options.G, c, x, this.W, this.H); | |
| this.c.R(this.g); | |
| this.yd = new jx(sD(this)); | |
| Uy(this.c, this.yd); | |
| J(this.yd.a, yd); | |
| this.c.g.j = new Tx(void 0, MSG_ALT_PHRASE_TITLE, void 0, 2); | |
| /** @type {number} */ | |
| this.c.g.j.L = 700; | |
| if (tr) { | |
| c = new sz([this.j.l()], [this.g]); | |
| U(c, ud, this.w.Ci, false, this.w); | |
| U(this.c, r, function(input) { | |
| if (1 < input.Ti) { | |
| this.w.Eg(input); | |
| } | |
| }, false, this); | |
| U(this.c, "usealt", this.w.Eg, false, this.w); | |
| } | |
| if (this.K) { | |
| S(this.K, false); | |
| if (this.K.firstChild && this.B) { | |
| this.B.setVisible(true); | |
| } | |
| } | |
| if (this.I) { | |
| S(this.I, false); | |
| if (this.I.firstChild && this.C) { | |
| this.C.setVisible(true); | |
| } | |
| } | |
| OA(this); | |
| if (null != this.Qa) { | |
| Ov(this.Qa, YA(this)); | |
| } | |
| if (this.o) { | |
| U(this.o, p, this.Uj, false, this); | |
| } | |
| this.Fc = new hD(this.j, tld.substr(tld.lastIndexOf(".") + 1), this.b); | |
| iD(this.Fc); | |
| lD(this.Fc, XA(this)); | |
| U(this.c, p, this.hj, false, this); | |
| /** @type {!Array} */ | |
| c = [this.g]; | |
| if (x = M("gt-res-tools")) { | |
| c.push(x); | |
| } | |
| new Tz(this.g, c); | |
| if ((c = M("gt-swap")) && c.title) { | |
| Ho(c); | |
| } | |
| var doc = M("gt-src-wrap"); | |
| J(doc, wb); | |
| U(sD(this), wb, function() { | |
| J(doc, wb); | |
| }); | |
| U(sD(this), Va, function() { | |
| K(doc, wb); | |
| }); | |
| K(document.body, "nj"); | |
| c = M("gt-sl-gms"); | |
| x = M("gt-tl-gms"); | |
| if (null != c) { | |
| /** @type {null} */ | |
| c.onclick = null; | |
| } | |
| if (null != x) { | |
| /** @type {null} */ | |
| x.onclick = null; | |
| } | |
| this.Pg = new UA(M("gt-feedback"), this, this.b); | |
| WA(this.Pg); | |
| this.Vf = new IA(this.b); | |
| this.Vf.aa(M("gt-bbar")); | |
| JA(this.Vf); | |
| /** @type {null} */ | |
| this.P = null; | |
| if (options.B) { | |
| this.P = new rA; | |
| tA(this.P, this.b); | |
| uA(this.P, XA(this)); | |
| vA(this.P, YA(this)); | |
| } | |
| new qB(sD(this), this); | |
| this.Gb = AD(this); | |
| if (ENABLE_FORMALITY) { | |
| this.H.R(M(dc)); | |
| Qs(this.H); | |
| } | |
| if (qr) { | |
| this.Dc = new TC(new pz(this.b), this, this, this, this.c, SIGNED_IN, this, this.b); | |
| } | |
| this.Ah = new Qz; | |
| this.Ie = new Rz; | |
| this.Ie.R(M("gt-src-is")); | |
| this.Ie.setVisible(false); | |
| this.Xb = new Xs(""); | |
| c = M("source-is"); | |
| this.Xb.R(c); | |
| J(c, yd); | |
| wD(this.Xb, ZA(this)); | |
| this.zd = new Ww("t", this.Ah, this.Ie, this.j, this.Xb, this.Z, this.a, this.b, new Oz("t", INPUT_SUGGESTION_SERVER_URL), new Ar("t"), false, false, 4, false, MSG_FLAG_SUGGESTION, this.zc, false); | |
| this.Nj = new hx(this.j, this.zc, M("gt-otf-switch"), this.zd, A(this.Ad, this, true, void 0), A(this.Da.o, this.Da)); | |
| U(this, Gd, this.c.Cj, false, this.c); | |
| /** @type {null} */ | |
| this.Ma = null; | |
| if (mr) { | |
| x = di(k); | |
| S(x, false); | |
| li(x, M(nd)); | |
| this.Ma = new eB(this, this, this.b); | |
| this.Ma.R(x); | |
| } | |
| /** @type {null} */ | |
| this.wd = null; | |
| cl(this.Sj, 6E4, this); | |
| /** @type {string} */ | |
| this.G = ""; | |
| /** @type {null} */ | |
| this.Fa = null; | |
| if (options.j) { | |
| this.Fa = options.j; | |
| this.Fa.Rf = this; | |
| if (window.location.hash.substr(1)) { | |
| sl(this.Fa, window.location.hash.substr(1)); | |
| } | |
| this.Fa.me.ba(true); | |
| } | |
| /** @type {!Array} */ | |
| this.U = []; | |
| this.U.push(new fB(sD(this), "ilogorig")); | |
| this.U.push(new fB(this.g, "ilogtrans")); | |
| this.U.push(new fB(this.ze.l(), "ilog" + this.ze.Ua())); | |
| this.U.push(new fB(this.Xc.l(), "ilog" + this.Xc.Ua())); | |
| this.U.push(new fB(this.xd.l(), "ilog" + this.xd.Ua())); | |
| this.U.push(new fB(this.Ac.l(), "ilog" + this.Ac.Ua())); | |
| this.U.push(new fB(this.Ec.l(), "ilog" + this.Ec.Ua())); | |
| U(window, Ua, A(this.De, this, Ua)); | |
| U(window, "unload", A(this.De, this, "unload")); | |
| /** @type {boolean} */ | |
| JS_LOADED = true; | |
| if (window.jstiming && window.jstiming.load) { | |
| window.jstiming.load.tick("je"); | |
| _csi("t", XA(this), YA(this), this.j.l()); | |
| } | |
| BD(this); | |
| CD(this); | |
| }; | |
| C(DD, V); | |
| /** | |
| * @param {string} options | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Rj = function(options) { | |
| if (!this.Bc && options && options.data && 0 < options.data.length) { | |
| options = options.data[0]; | |
| var minifyOptionsForStylesheet = this.wa(options); | |
| if (minifyOptionsForStylesheet) { | |
| oD(this.o, { | |
| Hd : minifyOptionsForStylesheet, | |
| Nf : options, | |
| Zg : $A(this), | |
| gh : XA(this) | |
| }); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {undefined} path | |
| * @return {?} | |
| */ | |
| var tD = function(path) { | |
| return xe(path) ? M(path) : null; | |
| }; | |
| y = DD.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.Kh = function() { | |
| ED(this, ""); | |
| var option = this.c; | |
| /** @type {null} */ | |
| option.o = null; | |
| /** @type {null} */ | |
| option.I = null; | |
| bz(this.c); | |
| FD(this); | |
| this.Fc.clear(); | |
| cq(this.m, "clearbtn", 1, Ha); | |
| this.va(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.kj = function() { | |
| var paths = this.B.Ea(); | |
| var currentChr = XA(this); | |
| var bName = YA(this); | |
| var pb = this.b; | |
| this.Fb.b[bName] = paths; | |
| Iv("rom", paths, currentChr, bName, pb); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.vj = function() { | |
| var a = this.C.Ea(); | |
| var i = XA(this); | |
| var dataElementsCount = YA(this); | |
| var pb = this.b; | |
| this.Fb.c[i] = a; | |
| Iv("srcrom", a, i, dataElementsCount, pb); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.lj = function() { | |
| var fields = ay(M(pd)); | |
| var query = yB(this.Cc); | |
| query.hl = this.b; | |
| query.ql = $A(this).length; | |
| /** @type {string} */ | |
| var status = ""; | |
| if (null != M(bc)) { | |
| try { | |
| if (document.execCommand("copy")) { | |
| /** @type {string} */ | |
| status = "success"; | |
| Lo(true); | |
| var e = this.ye; | |
| var m = M(bc); | |
| Fx(e, m); | |
| e.b = m; | |
| Mx(e, m, void 0); | |
| } else { | |
| /** @type {string} */ | |
| status = "failure"; | |
| } | |
| } catch (f) { | |
| /** @type {string} */ | |
| status = "error"; | |
| } finally { | |
| aq(this.m, "t", "copy", status, query); | |
| } | |
| } else { | |
| query.selected = fields; | |
| this.m.log("selectall", query); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| y.mj = function() { | |
| if (rx(this.pb.b)) { | |
| this.pb.setVisible(false); | |
| } else { | |
| /** @type {string} */ | |
| var b = "https://translate.google.com/#" + XA(this) + "/" + YA(this) + "/" + Xe($A(this)); | |
| b = op(Op, { | |
| ph : cz(this.c, void 0), | |
| sj : MSG_SHARE_MODULE_TITLE, | |
| rj : MSG_SHARE_MODULE_EMAIL, | |
| url : Xe(b) | |
| }); | |
| Zz(this.pb, b); | |
| this.pb.setVisible(true); | |
| var a = this.m; | |
| aq(a, "t", "share", "share", { | |
| sl : XA(this), | |
| tl : YA(this), | |
| hl : this.b, | |
| ql : $A(this).length | |
| }); | |
| b = O("share-panel"); | |
| b = Sh("a", "", b); | |
| xf(b, function(m) { | |
| U(m, r, function() { | |
| aq(a, "t", "share", m.className.split(" ")[0], { | |
| sl : XA(this), | |
| tl : YA(this), | |
| hl : this.b, | |
| ql : $A(this).length | |
| }); | |
| }, false, this); | |
| }, this); | |
| } | |
| }; | |
| /** | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var zD = function(b) { | |
| var m = new Xz; | |
| /** @type {number} */ | |
| m.c.b = b; | |
| $z(m); | |
| uo(m.c, 1, 0, void 0); | |
| /** @type {boolean} */ | |
| m.g = true; | |
| m.aa(); | |
| return m; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.va = function() { | |
| if (!(jh || wl || xl || yl)) { | |
| sD(this).focus(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Uj = function() { | |
| this.va(); | |
| }; | |
| /** | |
| * @param {!Object} z | |
| * @param {undefined} x | |
| * @return {undefined} | |
| */ | |
| var wD = function(z, x) { | |
| if (z) { | |
| var d = z.l(); | |
| if (ag(x)) { | |
| d.dir = sd; | |
| R(d, fd, "20px"); | |
| R(d, gd, ""); | |
| } else { | |
| d.dir = Qc; | |
| R(d, gd, "20px"); | |
| R(d, fd, ""); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} z | |
| * @param {undefined} x | |
| * @return {undefined} | |
| */ | |
| var yD = function(z, x) { | |
| if (z) { | |
| var xe = z.l(); | |
| if (ag(x)) { | |
| R(xe, qd, ""); | |
| R(xe, Pc, "0"); | |
| } else { | |
| R(xe, Pc, ""); | |
| R(xe, qd, "0"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Function} o | |
| * @return {undefined} | |
| */ | |
| var vD = function(o) { | |
| var prop = ZA(o); | |
| if (XA(o) == Qa && prop != Qa) { | |
| prop = source_language_detected.replace(/%\d\$s/g, o.wa(prop)); | |
| Zu(o.A, prop); | |
| } else { | |
| Zu(o.A, detect_language); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Tj = function() { | |
| lD(this.Fc, XA(this)); | |
| OA(this); | |
| CD(this); | |
| if (null != this.P) { | |
| uA(this.P, XA(this)); | |
| } | |
| wD(this.j, ZA(this)); | |
| wD(this.Xb, ZA(this)); | |
| yD(this.O, ZA(this)); | |
| var data = $A(this, true); | |
| var x = XA(this); | |
| if (this.X) { | |
| this.X.update(data, x); | |
| } | |
| GD(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Qi = function() { | |
| vD(this); | |
| CD(this); | |
| wD(this.j, ZA(this)); | |
| wD(this.Xb, ZA(this)); | |
| yD(this.O, ZA(this)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.wh = function() { | |
| if (null != this.Qa) { | |
| Ov(this.Qa, YA(this)); | |
| } | |
| CD(this); | |
| if (null != this.P) { | |
| vA(this.P, YA(this)); | |
| } | |
| wD(this.F, YA(this)); | |
| yD(this.bb, YA(this)); | |
| GD(this); | |
| }; | |
| /** | |
| * @param {!Object} row | |
| * @return {undefined} | |
| */ | |
| var GD = function(row) { | |
| /** @type {boolean} */ | |
| var value = true; | |
| if (0 == cz(row.c, void 0).length) { | |
| /** @type {boolean} */ | |
| value = false; | |
| } | |
| row.Gb.setVisible(value); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| DD.prototype.nj = function(o) { | |
| if (this.O) { | |
| this.O.setVisible($A(this) ? true : false); | |
| } | |
| if (o.j == hd) { | |
| if (HD(this, $A(this))) { | |
| this.Me++; | |
| } else { | |
| this.Ee++; | |
| } | |
| } | |
| this.dispatchEvent(new RA(o.text)); | |
| }; | |
| /** | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| var CD = function(value) { | |
| var glgeObject = value.qa[kb]; | |
| if (null != glgeObject) { | |
| /** @type {boolean} */ | |
| value = !$A(value); | |
| glgeObject.setVisible(value); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.yj = function() { | |
| if (this.ye) { | |
| Jx(this.ye, M(bc)); | |
| Lo(false); | |
| } | |
| if (ZA(this) != Qa) { | |
| var data = $A(this, true); | |
| var x = ZA(this); | |
| if (this.X) { | |
| this.X.update(data, x); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var ID = function(options) { | |
| if ("u" == sD(options).name) { | |
| options.form.action = options.Ke; | |
| options.form.enctype = options.form.encoding = Ma; | |
| /** @type {string} */ | |
| options.form.method = "get"; | |
| } else { | |
| if (null != options.jg && kj(options.jg)) { | |
| options.form.action = options.yh; | |
| /** @type {string} */ | |
| options.form.enctype = options.form.encoding = "multipart/form-data"; | |
| /** @type {string} */ | |
| options.form.method = "post"; | |
| } else { | |
| options.form.action = options.Bh; | |
| options.form.enctype = options.form.encoding = Ma; | |
| if (2E3 < $A(options).length) { | |
| /** @type {string} */ | |
| options.form.method = "post"; | |
| } else { | |
| /** @type {string} */ | |
| options.form.method = "get"; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} apexdist | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Uf = function(apexdist) { | |
| ED(this, $A(this)); | |
| if (null != this.Vb) { | |
| mi(this.Vb); | |
| /** @type {null} */ | |
| this.Vb = null; | |
| } | |
| /** @type {string} */ | |
| sD(this).name = "u"; | |
| ID(this); | |
| if (apexdist) { | |
| rD(this.form, "act", "url"); | |
| } | |
| if (apexdist = (new Sq(window.location, true)).a.get(Pa)) { | |
| rD(this.form, Pa, apexdist); | |
| } | |
| this.form.submit(); | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Ki = function(event) { | |
| event.preventDefault(); | |
| if (-1 != this.form.action.indexOf("/translate_f")) { | |
| if (!(this.Vb && Te(pf(this.Vb.value)))) { | |
| this.form.submit(); | |
| } | |
| } else { | |
| if ("" != this.Ke && Ky($A(this))) { | |
| this.Uf(); | |
| } else { | |
| cq(this.m, Fd, "btn"); | |
| this.Ad(false); | |
| if (this.Yj) { | |
| this.zd.clear(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var JD = function(a) { | |
| if (0 != a.g.innerHTML.length) { | |
| a.g.innerHTML += "..."; | |
| } else { | |
| cl(function() { | |
| if (this.Da.b && 0 == this.g.innerHTML.length) { | |
| this.g.innerHTML = tr_in; | |
| } | |
| }, 1500, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var FD = function(self) { | |
| ji(self.g); | |
| /** @type {string} */ | |
| self.g.lang = ""; | |
| self.w.setVisible(false); | |
| if (self.a) { | |
| rt(self.a, null); | |
| } | |
| if (self.K) { | |
| ji(self.K); | |
| } | |
| if (self.I) { | |
| ji(self.I); | |
| } | |
| if (self.Wc) { | |
| Q(self.Wc, "0"); | |
| } | |
| if (self.fc) { | |
| Q(self.fc, "0"); | |
| } | |
| if (self.kc) { | |
| Q(self.kc, "0"); | |
| } | |
| if (self.lc) { | |
| Q(self.lc, "0"); | |
| } | |
| if (self.gc) { | |
| Q(self.gc, "0"); | |
| } | |
| if (self.B) { | |
| self.B.setVisible(false); | |
| } | |
| if (self.C) { | |
| self.C.setVisible(false); | |
| } | |
| if (self.W.b) { | |
| self.W.b.setVisible(false); | |
| } | |
| if (self.$) { | |
| self.$.setVisible(false); | |
| } | |
| if (null != self.Ha) { | |
| self.Ha.setVisible(false); | |
| } | |
| if (self.ob) { | |
| zs(self.ob, false); | |
| } | |
| if (self.X) { | |
| zs(self.X, false); | |
| } | |
| vD(self); | |
| if (self.O) { | |
| self.O.setVisible(false); | |
| } | |
| if (self.Ma) { | |
| self.Ma.setVisible(false); | |
| } | |
| if (null != self.Dc) { | |
| $C(self.Dc, false); | |
| } | |
| if (self.Gb) { | |
| self.Gb.setVisible(false); | |
| } | |
| if (ENABLE_FORMALITY && self.H) { | |
| self.H.setVisible(false); | |
| Ss(self.H); | |
| } | |
| if (self.o) { | |
| self.o.setVisible(false); | |
| } | |
| if (self.Yc) { | |
| S(self.Yc, true); | |
| } | |
| CD(self); | |
| self.dispatchEvent(new QA); | |
| }; | |
| /** | |
| * @param {string} results | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Ad = function(results) { | |
| this.Nj.reset(results); | |
| var inp = XA(this); | |
| var x = YA(this); | |
| KD(this); | |
| if (this.B && this.B.Ea()) { | |
| cq(this.m, "rom", this.B.isVisible()); | |
| } | |
| if (this.C && this.C.Ea()) { | |
| cq(this.m, "srcrom", this.C.isVisible()); | |
| } | |
| BB(this.Cc); | |
| if (0 == $A(this).length) { | |
| FD(this); | |
| } else { | |
| if (this.Fa) { | |
| ul(this.Fa, XA(this), YA(this), $A(this), results); | |
| } | |
| var currentEvent = new window.jstiming.Timer; | |
| /** @type {string} */ | |
| currentEvent.name = "at"; | |
| JD(this); | |
| var v = new Xq; | |
| v.g(new Xq(gq(this.m))); | |
| v.g(new Xq(Ly())); | |
| fr(v, "kc", jt(this.j)); | |
| if (null != this.H.g && inp == t && "de" == x) { | |
| fr(v, "tco", this.H.g); | |
| } | |
| results = $A(this); | |
| var falseySection = null != this.o && this.o.o; | |
| Gr(this.Da, inp, x, this.b, results, A(this.Ch, this, results, currentEvent), falseySection, ENCODING, v); | |
| /** @type {boolean} */ | |
| currentEvent = false; | |
| if (HD(this, results)) { | |
| this.De(); | |
| /** @type {boolean} */ | |
| currentEvent = true; | |
| } else { | |
| if (results.length >= this.G.length) { | |
| /** @type {boolean} */ | |
| currentEvent = true; | |
| } | |
| } | |
| if (currentEvent) { | |
| /** @type {string} */ | |
| this.G = results; | |
| this.Ui = inp; | |
| this.bj = x; | |
| } | |
| if (lr) { | |
| var s = M("prod-trans"); | |
| if (!s) { | |
| s = P(k, { | |
| id : "prod-trans" | |
| }); | |
| li(s, M(nd)); | |
| } | |
| v = v.clone(); | |
| fr(v, "internal", 1); | |
| Gr(new Ar("t", "https://translate.google.com"), inp, x, this.b, results, function(threshold) { | |
| ji(s); | |
| S(s, !!threshold); | |
| if (threshold) { | |
| /** @type {!Array} */ | |
| var outChance = []; | |
| /** @type {number} */ | |
| var cellValue = 0; | |
| for (; cellValue < Nm(threshold); cellValue++) { | |
| outChance.push(Om(threshold, cellValue).Ta()); | |
| } | |
| Q(s, outChance.join("")); | |
| R(s, nb, ag(x) ? sd : Qc); | |
| } | |
| }, falseySection, ENCODING, v); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Window} query | |
| * @param {string} results | |
| * @return {?} | |
| */ | |
| var HD = function(query, results) { | |
| return "" != query.G && results[0] != query.G[0] && results[results.length - 1] != query.G[query.G.length - 1]; | |
| }; | |
| /** | |
| * @param {?} _name | |
| * @return {undefined} | |
| */ | |
| DD.prototype.De = function(_name) { | |
| if ("" != this.G) { | |
| var result = { | |
| sl : this.Ui, | |
| tl : this.bj, | |
| ql : this.G.length | |
| }; | |
| if (64 < this.G.length) { | |
| this.G = this.G.substr(0, 64); | |
| } | |
| result.q = this.G; | |
| if (_name) { | |
| /** @type {number} */ | |
| result[_name] = 1; | |
| } | |
| result.pc = this.Ee; | |
| this.Ee = this.Me; | |
| /** @type {number} */ | |
| this.Me = 0; | |
| this.m.log("fq", result); | |
| /** @type {string} */ | |
| this.G = ""; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} pos | |
| * @param {!Object} node | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Ch = function(pos, node, x) { | |
| if (this.o) { | |
| this.o.setVisible(false); | |
| } | |
| if (null != x) { | |
| try { | |
| this.Bc = Ky(pos); | |
| if (XA(this) == Qa && null != x.a[2]) { | |
| if (this.Bc || null != x.a[3]) { | |
| tt(this.a, ""); | |
| } else { | |
| tt(this.a, Gm(x)); | |
| } | |
| } | |
| var y; | |
| if (null != x.a[8]) { | |
| var value = x.a[8]; | |
| y = value ? new nm(value) : Jm; | |
| } else { | |
| /** @type {null} */ | |
| y = null; | |
| } | |
| LD(this, y); | |
| var c = YA(this); | |
| if (null != x.a[9]) { | |
| node.tick("_start", void 0, 1); | |
| var params = x.a[9]; | |
| node.tick("st", "_start", (null != params ? params : 0) + 1); | |
| } | |
| /** @type {string} */ | |
| this.g.parentNode.parentNode.style.display = ""; | |
| eq(this.m, "trans"); | |
| xt(this.a); | |
| /** @type {!Array} */ | |
| params = []; | |
| /** @type {!Array} */ | |
| var DEFAULT_REVERSE_FORMATTER_REGEXS = []; | |
| /** @type {!Array} */ | |
| y = []; | |
| this.g.lang = c; | |
| ji(this.g); | |
| var h = Gm(x); | |
| /** @type {boolean} */ | |
| value = false; | |
| if (0 < Nm(x)) { | |
| /** @type {boolean} */ | |
| value = true; | |
| /** @type {number} */ | |
| var y = 0; | |
| for (; y < Nm(x); y++) { | |
| var b = Om(x, y); | |
| /** @type {number} */ | |
| value = value & (null == b.kb[4] || 1 == Dm(b)); | |
| if (null != b.kb[2]) { | |
| var v = b.kb[2]; | |
| params.push(null != v ? v : ""); | |
| } | |
| if (null != b.kb[3]) { | |
| DEFAULT_REVERSE_FORMATTER_REGEXS.push(Cm(b)); | |
| } | |
| if (null != b.kb[0] && b.Ta()) { | |
| y.push(Dm(b)); | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| v = ""; | |
| if (bz(this.c, x.b(), "qab" == XA(this) ? "qab" : h, c, this.b)) { | |
| v = cz(this.c); | |
| } else { | |
| ji(this.g); | |
| /** @type {number} */ | |
| y = 0; | |
| for (; y < Nm(x); y++) { | |
| b = Om(x, y); | |
| var r = P(Hd, { | |
| title : Bm(b) | |
| }); | |
| r.innerHTML = Ze(hf(b.Ta())); | |
| this.g.appendChild(r); | |
| /** @type {string} */ | |
| v = v + Fi(r); | |
| } | |
| } | |
| if (null != this.Gb) { | |
| this.Gb.setVisible(true); | |
| } | |
| if (ENABLE_FORMALITY && null != this.H) { | |
| this.H.update(h, c, this.b, $A(this), v); | |
| } | |
| this.og(c, params.join(" ")); | |
| if (this.I && this.C) { | |
| var a = Ze(hf(pf(DEFAULT_REVERSE_FORMATTER_REGEXS.join(" ")))); | |
| if (Te(a)) { | |
| ji(this.I); | |
| this.C.setVisible(false); | |
| } else { | |
| var iy = ag(h) ? qd : Pc; | |
| this.I.innerHTML = a; | |
| this.I.style.textAlign = iy; | |
| if (h != this.vh) { | |
| var N; | |
| var defaults = this.Fb; | |
| N = xe(defaults.c[h]) ? !!defaults.c[h] : Ev(h, this.b); | |
| this.C.ma(N); | |
| this.vh = h; | |
| } | |
| this.C.setVisible(true); | |
| } | |
| } | |
| if (null != x.a[7]) { | |
| var city = Im(x).a[0]; | |
| var v = Im(x).a[1]; | |
| var mb = Im(x).a[5]; | |
| oD(this.o, { | |
| Nh : null != city ? city : "", | |
| Hd : null != v ? v : "", | |
| eg : null != mb ? mb : false, | |
| Zg : $A(this), | |
| Xe : Tl(Im(x).a, 2), | |
| gh : XA(this) | |
| }); | |
| /** @type {boolean} */ | |
| this.o.o = true; | |
| } | |
| this.dispatchEvent(new QA); | |
| if (this.Wc && this.fc && this.kc && this.gc && this.lc) { | |
| /** @type {number} */ | |
| iy = a = r = b = y = 0; | |
| for (; iy < y.length; iy++) { | |
| if (0 == y[iy]) { | |
| y++; | |
| } else { | |
| if (1 == y[iy]) { | |
| b++; | |
| } else { | |
| if (2 == y[iy]) { | |
| r++; | |
| } else { | |
| if (10 == y[iy]) { | |
| a++; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| this.Wc.innerHTML = (b + r).toString(); | |
| /** @type {string} */ | |
| this.fc.innerHTML = b.toString(); | |
| /** @type {string} */ | |
| this.kc.innerHTML = r.toString(); | |
| /** @type {string} */ | |
| this.lc.innerHTML = a.toString(); | |
| /** @type {string} */ | |
| this.gc.innerHTML = y.toString(); | |
| } | |
| var s = We(v); | |
| if ("" != this.Ke && this.Bc && (null != this.Ae && this.Ae.Th(), this.g.innerHTML = '<a href="javascript:ctr._submitUrl(true);" title="' + url_hyperlink_tooltip + '">' + hf(pos) + "</a>", 0 != s.length && s != pos)) { | |
| var a = P(Hd, { | |
| title : pos | |
| }); | |
| a.innerHTML = Ze(hf(" (" + s + ")")); | |
| this.g.appendChild(a); | |
| } | |
| var vLen = v.length; | |
| if (this.Yc) { | |
| S(this.Yc, false); | |
| } | |
| this.g.parentNode.dir = ag(c) ? sd : Qc; | |
| if (50 >= vLen) { | |
| J(this.g, yd); | |
| J(sD(this), yd); | |
| J(this.yd.a, yd); | |
| if (null != this.F) { | |
| J(this.F.l(), yd); | |
| } | |
| } else { | |
| K(this.g, yd); | |
| K(sD(this), yd); | |
| K(this.yd.a, yd); | |
| if (null != this.F) { | |
| K(this.F.l(), yd); | |
| } | |
| } | |
| CD(this); | |
| node.tick("prt"); | |
| if (null != this.L) { | |
| this.m.log("ftrans", { | |
| ttl : this.lg - this.L, | |
| ttt : (new Date).getTime() - this.L | |
| }); | |
| /** @type {null} */ | |
| this.L = null; | |
| } | |
| var w = this.w; | |
| w.c.reset(); | |
| w.c.push(pos, h, c, x); | |
| if (null != this.Dc) { | |
| $C(this.Dc, null == x.a[3]); | |
| } | |
| if (this.W.b) { | |
| this.W.b.setVisible(null == x.a[3]); | |
| } | |
| if (this.$) { | |
| this.$.setVisible(null == x.a[3]); | |
| } | |
| var b = cz(this.c, void 0); | |
| var childSymbol = YA(this); | |
| if (this.ob) { | |
| this.ob.update(b, childSymbol, x); | |
| } | |
| if (this.Ma) { | |
| this.Ma.setVisible(true); | |
| } | |
| if (null != this.Ha) { | |
| this.Ha.setVisible(value); | |
| } | |
| var val = { | |
| sl : h, | |
| tl : c, | |
| otext : pos, | |
| ttext : v, | |
| ql : pos.length | |
| }; | |
| var i; | |
| for (i in val) { | |
| if (Fe(val[i]) && 64 < val[i].length) { | |
| /** @type {number} */ | |
| val.tr = 1; | |
| val[i] = val[i].substr(0, 64); | |
| } | |
| } | |
| this.m.c("trans", 5E3, val); | |
| var len = Xe(pos).length; | |
| pos = {}; | |
| pos.sl = h; | |
| pos.tl = c; | |
| pos.size = len; | |
| pos.e = EXPERIMENT_IDS.join(","); | |
| node.tick("ol"); | |
| window.jstiming.sn = ge; | |
| window.jstiming.report(node, pos); | |
| } catch (options) { | |
| throw null.Qj("Ajax translation failed.", options), node = {}, options.name && (node.name = options.name), options.message && (node.message = options.message), options.stack && (node.stack = options.stack.substr(0, 2E3)), this.m.log("transerr", node), options; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| DD.prototype.hj = function(c) { | |
| var b = cz(c.target); | |
| var show = c.target.na; | |
| c = this.Da; | |
| var B = A(this.og, this, show); | |
| var self = new Xq; | |
| var d = new Xq; | |
| self.set(ab, c.c); | |
| self.set("sl", show); | |
| show = c.a + ka; | |
| self.set("dt", "rm"); | |
| d.set("q", b); | |
| Dr(c, show, self, d, A(c.m, c, B)); | |
| this.dispatchEvent(new QA); | |
| }; | |
| /** | |
| * @param {boolean} x | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| DD.prototype.og = function(x, key) { | |
| if (this.K && this.B) { | |
| var c = Ze(hf(pf(key))); | |
| if (Te(c)) { | |
| ji(this.K); | |
| this.B.setVisible(false); | |
| } else { | |
| var value = ag(x) ? qd : Pc; | |
| this.K.innerHTML = c; | |
| this.K.style.textAlign = value; | |
| if (x != this.Pj) { | |
| c = this.Fb; | |
| c = xe(c.b[x]) ? !!c.b[x] : Ev(x, this.b); | |
| this.B.ma(c); | |
| /** @type {boolean} */ | |
| this.Pj = x; | |
| } | |
| this.B.setVisible(true); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var BD = function(c) { | |
| var b = c.Cc; | |
| var data = yB(b); | |
| /** @type {!Array} */ | |
| var d = []; | |
| /** @type {!Array} */ | |
| var e = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.a.c.length; ++i) { | |
| d.push(b.a.c[i]); | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < b.a.g.length; ++i) { | |
| e.push(b.a.g[i]); | |
| } | |
| /** @type {string} */ | |
| data.slh = d.join("|"); | |
| /** @type {string} */ | |
| data.tlh = e.join("|"); | |
| b = b.a; | |
| /** @type {!Array} */ | |
| d = []; | |
| /** @type {!Array} */ | |
| e = []; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < b.c.length; ++i) { | |
| var g = b.c[i]; | |
| if (-1 == wf(d, g)) { | |
| d.push(g); | |
| e.push(g); | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < b.g.length; ++i) { | |
| g = b.g[i]; | |
| if (-1 == wf(e, g)) { | |
| e.push(g); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| data.soph = 2 < d.length && 3 < e.length; | |
| data.hl = c.b; | |
| if (null != c.L) { | |
| /** @type {number} */ | |
| c.Le = (new Date).getTime() - c.L; | |
| /** @type {number} */ | |
| data.ttnc = c.Le; | |
| } | |
| data.uetrans = c.c.$; | |
| data.eotf = c.zc; | |
| c.m.log("hready", data); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var uD = function(item) { | |
| var val = FEATURE_STICKINESS; | |
| item.Be = val; | |
| val = new xA(val); | |
| if (null != val.a[2]) { | |
| var v = val.a[2]; | |
| var result = item.Fb; | |
| v = v ? new tv(v) : CA; | |
| result.a = {}; | |
| result.a[$b] = new Av; | |
| var s; | |
| /** @type {number} */ | |
| var n = 0; | |
| for (; n < Y(v.a, 3); ++n) { | |
| if (s = n, s = new rv(Tl(v.a, 3)[s]), 0 == !!vv(s)) { | |
| var i; | |
| for (i in result.a) { | |
| result.a[i].update(uv(s), false, ""); | |
| } | |
| } | |
| } | |
| result.c = {}; | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < Y(v.a, 1); ++n) { | |
| /** @type {number} */ | |
| i = n; | |
| s = new rv(Tl(v.a, 1)[i]); | |
| /** @type {boolean} */ | |
| result.c[uv(s)] = !!vv(s); | |
| } | |
| result.b = {}; | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < Y(v.a, 2); ++n) { | |
| /** @type {number} */ | |
| i = n; | |
| s = new rv(Tl(v.a, 2)[i]); | |
| /** @type {boolean} */ | |
| result.b[uv(s)] = !!vv(s); | |
| } | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < Y(v.a, 9); ++n) { | |
| /** @type {number} */ | |
| i = n; | |
| i = new sv(Tl(v.a, 9)[i]); | |
| (null != i.a[3] ? Hv(result, zv(i), true) : Hv(result, $b, true)).update(wv(i), xv(i), yv(i)); | |
| } | |
| } | |
| result = val.a[1]; | |
| item.zc = null != result ? result : false; | |
| v = BA(val); | |
| /** @type {!Array} */ | |
| n = []; | |
| /** @type {!Array} */ | |
| result = []; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < Y(v.rb, 0); ++i) { | |
| s = yA(v, i); | |
| n.push(s); | |
| } | |
| i = item.a; | |
| /** @type {number} */ | |
| s = 0; | |
| for (; s < n.length; ++s) { | |
| i.c.push(n[s]); | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < Y(v.rb, 1); ++i) { | |
| s = zA(v, i); | |
| result.push(s); | |
| } | |
| v = item.a; | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < result.length; ++n) { | |
| v.g.push(result[n]); | |
| } | |
| if (item.Lg) { | |
| val = BA(val); | |
| /** @type {!Array} */ | |
| result = []; | |
| /** @type {!Array} */ | |
| v = []; | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < Y(val.rb, 0); ++n) { | |
| result.push(yA(val, n)); | |
| } | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < Y(val.rb, 1); ++n) { | |
| v.push(zA(val, n)); | |
| } | |
| if (null != val.rb[4]) { | |
| result = val.rb[4]; | |
| /** @type {!Array} */ | |
| result = [null != result ? result : ""]; | |
| } | |
| if (null != val.rb[5]) { | |
| v = val.rb[5]; | |
| /** @type {!Array} */ | |
| v = [null != v ? v : ""]; | |
| } | |
| if (!(2E3 < $A(item).length || window.location.href.match(/^[^#]+(\?|&)sl=([A-Za-z-]+)/))) { | |
| if (window.location.href.match(/^[^#]+(\?|&)tl=([A-Za-z-]+)/)) { | |
| Uu(item.A, Qa); | |
| } else { | |
| val = val.rb[3]; | |
| if (null != val && val) { | |
| Uu(item.A, Qa); | |
| } else { | |
| Uu(item.A, result[0]); | |
| } | |
| Uu(item.N, v[0]); | |
| } | |
| } | |
| item.a.m(XA(item)); | |
| item.a.o(YA(item)); | |
| } | |
| LD(item, null); | |
| xt(item.a); | |
| val = item.a; | |
| st(val.A, val.c, val.w, val.a); | |
| item = item.a; | |
| st(item.K, item.g, item.F, item.b); | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| var LD = function(res, name) { | |
| if (res.a) { | |
| if (name) { | |
| /** @type {!Array} */ | |
| var item = []; | |
| /** @type {number} */ | |
| var b = 0; | |
| for (; b < Y(name.Sf, 0); ++b) { | |
| var a; | |
| /** @type {number} */ | |
| a = b; | |
| a = Tl(name.Sf, 0)[a]; | |
| item.push(a); | |
| } | |
| rt(res.a, item); | |
| } else { | |
| rt(res.a, null); | |
| } | |
| item = res.a; | |
| b = item.a == Qa ? "" : item.a; | |
| a = At(item.c, b); | |
| a.push(item.a); | |
| item.O = Jf(a); | |
| a = a.concat(At(item.C.a, b)); | |
| item.N.update(a); | |
| item = res.a; | |
| b = At(item.g, item.b); | |
| b.push(item.b); | |
| item.I.update(b); | |
| } | |
| }; | |
| /** | |
| * @param {!Function} object | |
| * @return {undefined} | |
| */ | |
| var OA = function(object) { | |
| if (null != object.Z) { | |
| S(object.Z.m, true); | |
| Ov(object.Z, XA(object)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var KD = function(d) { | |
| if (null != d.Z) { | |
| d = d.Z; | |
| if (Pv(d)) { | |
| cq(d.j, "trs"); | |
| cq(d.j, xc, 1); | |
| } | |
| if (d.isEnabled() && 0 <= d.c.indexOf("-k0-")) { | |
| cq(d.j, "vkb"); | |
| cq(d.j, xc, 2); | |
| } | |
| if (d.isEnabled() && ov(d.c)) { | |
| cq(d.j, "hwt"); | |
| cq(d.j, xc, 5); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var xD = function(a) { | |
| var C = Sh("A", null, M(vd)); | |
| if (C && 1 == C.length) { | |
| C = C[0]; | |
| U(C, r, function(M) { | |
| M.preventDefault(); | |
| M = this.$f; | |
| PA(M, false); | |
| MA(M, true); | |
| LA("gt-res-data", false, true); | |
| LA(vd, false, false); | |
| ID(M.a); | |
| }, false, a); | |
| } | |
| if ((C = Sh("A", null, M("select_text"))) && 1 == C.length) { | |
| C = C[0]; | |
| U(C, r, function(M) { | |
| M.preventDefault(); | |
| M = this.$f; | |
| MA(M, false); | |
| PA(M, true); | |
| LA("gt-res-data", true, true); | |
| LA(vd, true, false); | |
| ID(M.a); | |
| }, false, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @param {string} date | |
| * @param {string} i | |
| * @param {string} array | |
| * @param {string} num | |
| * @return {undefined} | |
| */ | |
| var tl = function(params, date, i, array, num) { | |
| /** @type {boolean} */ | |
| params.Lg = false; | |
| if (date) { | |
| var hash = void 0; | |
| if ("tws_lsugg" == num) { | |
| /** @type {number} */ | |
| hash = 3; | |
| } | |
| params.a.m(date, hash); | |
| } | |
| if (i) { | |
| params.a.o(i); | |
| } | |
| if ($A(params) != array) { | |
| ED(params, array); | |
| } | |
| if (num) { | |
| cq(params.m, Fd, num); | |
| } | |
| params.Ad(false); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| DD.prototype.wa = function(name) { | |
| return null != name ? Yu(this.A, name) : Yu(this.A); | |
| }; | |
| /** | |
| * @param {!Object} markup_start | |
| * @return {?} | |
| */ | |
| DD.prototype.Wa = function(markup_start) { | |
| return null != markup_start ? Yu(this.N, markup_start) : Yu(this.N); | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| var ZA = function(obj) { | |
| var callback_impl = obj.A.T(); | |
| obj = obj.a.j; | |
| if (callback_impl == Qa && "" != obj) { | |
| /** @type {string} */ | |
| callback_impl = obj; | |
| } | |
| return callback_impl; | |
| }; | |
| /** | |
| * @param {!Function} obj | |
| * @return {?} | |
| */ | |
| var XA = function(obj) { | |
| return obj.A.T(); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var YA = function(obj) { | |
| return obj.N.T(); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var sD = function(options) { | |
| return options.j.l(); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {boolean} node | |
| * @return {?} | |
| */ | |
| var $A = function(obj, node) { | |
| return node && obj.o && obj.o.b ? We(obj.o.g) : We(obj.j.T()); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} t | |
| * @return {undefined} | |
| */ | |
| var ED = function(a, t) { | |
| a.j.b(t); | |
| if (a.zd) { | |
| var d = a.zd; | |
| var temp = a.a.a; | |
| var b = a.a.b; | |
| d.j = Zw(t); | |
| d.c = temp; | |
| d.na = b; | |
| d.clear(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} origin | |
| * @return {?} | |
| */ | |
| var AD = function(origin) { | |
| var b = P(k, { | |
| id : cc, | |
| style : pb | |
| }); | |
| ki(b, M(fc)); | |
| var exports = new eo(MSG_EDIT_POPUP, new Vo("trans-edit-button")); | |
| exports.R(b); | |
| ii(b, MSG_SUGGEST_AN_EDIT); | |
| exports.setVisible(false); | |
| U(exports, p, origin.ij, false, origin); | |
| return exports; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.ij = function() { | |
| if ($A(this)) { | |
| fz(this.c); | |
| this.m.log("editclk"); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| DD.prototype.Sj = function() { | |
| if (pr) { | |
| this.wd = new pD(this.b, this, this.Pg); | |
| this.wd.aa(document.body); | |
| } | |
| }; | |
| /** @type {function(string): undefined} */ | |
| DD.prototype._submitUrl = DD.prototype.Uf; | |
| /** | |
| * @param {string} target | |
| * @param {string} action | |
| * @param {!NodeList} after | |
| * @param {!Object} elem | |
| * @return {undefined} | |
| */ | |
| function _csi(target, action, after, elem) { | |
| var pos = {}; | |
| if (0 < elem.value.length) { | |
| if (0 < action.length) { | |
| /** @type {string} */ | |
| pos.sl = action; | |
| } | |
| if (0 < after.length) { | |
| /** @type {!NodeList} */ | |
| pos.tl = after; | |
| } | |
| pos.size = elem.value.length; | |
| } | |
| action = window.jstiming.load; | |
| /** @type {string} */ | |
| action.name = target; | |
| window.jstiming.sn = ge; | |
| window.jstiming.report(action, pos); | |
| try { | |
| if (window[MD.a] && window[MD.a].resT) { | |
| window[MD.a].resT(); | |
| } | |
| } catch (artistTrack) { | |
| null.hk("No CSI (window.external.resT) found.", artistTrack); | |
| } | |
| } | |
| ye("_csi", _csi); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var MD = function() { | |
| var o = new yj; | |
| o = A(o.a, o); | |
| if (window.gbar && window.gbar.elc) { | |
| window.gbar.elc(o); | |
| if (window.gbar.elr) { | |
| o(window.gbar.elr()); | |
| } | |
| } | |
| z.h = new rl; | |
| o = new zj; | |
| o.j = z.h; | |
| o.K = pd; | |
| o.Ra = WEB_TRANSLATION_PATH; | |
| o.U = TEXT_TRANSLATION_PATH; | |
| o.Ca = FILE_TRANSLATION_PATH; | |
| o.W = null != window.INPUT_SUGGESTION_SERVER_URL ? window.INPUT_SUGGESTION_SERVER_URL : ""; | |
| o.H = Id; | |
| /** @type {string} */ | |
| o.c = "gt-sl-sugg"; | |
| /** @type {string} */ | |
| o.g = "gt-tl-sugg"; | |
| /** @type {string} */ | |
| o.C = "file_div"; | |
| /** @type {string} */ | |
| o.w = "file"; | |
| /** @type {number} */ | |
| o.A = (new Date).getTime(); | |
| o.G = MAX_ALTERNATIVES_ROUNDTRIP_RESULTS; | |
| /** @type {boolean} */ | |
| o.m = true; | |
| o.F = LOW_CONFIDENCE_THRESHOLD; | |
| z.ctr = new DD(o); | |
| }; | |
| /** @type {string} */ | |
| MD.a = "external"; | |
| ye("Init", MD); | |
| if (window.jstiming) { | |
| window.jstiming.$c = {}; | |
| /** @type {number} */ | |
| window.jstiming.Ef = 1; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} i | |
| * @param {number} match | |
| * @return {?} | |
| */ | |
| var ND = function(a, i, match) { | |
| var value = a.t[i]; | |
| var start = a.t.start; | |
| if (value && (start || match)) { | |
| return value = a.t[i][0], void 0 != match ? start = match : start = start[0], Math.round(value - start); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {string} b | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var OD = function(v, b, c) { | |
| /** @type {string} */ | |
| var advancedFormHTML = ""; | |
| if (window.jstiming.srt) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&srt=" + window.jstiming.srt); | |
| delete window.jstiming.srt; | |
| } | |
| if (window.jstiming.pt) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&tbsrt=" + window.jstiming.pt); | |
| delete window.jstiming.pt; | |
| } | |
| try { | |
| if (window.external && window.external.tran) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&tran=" + window.external.tran); | |
| } else { | |
| if (window.gtbExternal && window.gtbExternal.tran) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&tran=" + window.gtbExternal.tran()); | |
| } else { | |
| if (window.chrome && window.chrome.csi) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&tran=" + window.chrome.csi().tran); | |
| } | |
| } | |
| } | |
| } catch (u) { | |
| } | |
| var on = window.chrome; | |
| if (on && (on = on.loadTimes)) { | |
| if (on().wasFetchedViaSpdy) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + "&p=s"; | |
| } | |
| if (on().wasNpnNegotiated) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + "&npn=1"; | |
| var f = on().npnNegotiatedProtocol; | |
| if (f) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&npnv=" + (encodeURIComponent || escape)(f)); | |
| } | |
| } | |
| if (on().wasAlternateProtocolAvailable) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + "&apa=1"; | |
| } | |
| } | |
| var y = v.t; | |
| var p = y.start; | |
| /** @type {!Array} */ | |
| on = []; | |
| /** @type {!Array} */ | |
| f = []; | |
| var k; | |
| for (k in y) { | |
| if (k != Nd && 0 != k.indexOf("_")) { | |
| var p = y[k][1]; | |
| if (p) { | |
| if (y[p]) { | |
| f.push(k + "." + ND(v, k, y[p][0])); | |
| } | |
| } else { | |
| if (p) { | |
| on.push(k + "." + ND(v, k)); | |
| } | |
| } | |
| } | |
| } | |
| delete y.start; | |
| if (b) { | |
| var prop; | |
| for (prop in b) { | |
| /** @type {string} */ | |
| advancedFormHTML = advancedFormHTML + ("&" + prop + "=" + b[prop]); | |
| } | |
| } | |
| if (!(b = c)) { | |
| /** @type {string} */ | |
| b = "https:" == document.location.protocol ? "https://csi.gstatic.com/csi" : "http://csi.gstatic.com/csi"; | |
| } | |
| return [b, "?v=3", "&s=" + (window.jstiming.sn || ge) + "&action=", v.name, f.length ? "&it=" + f.join(",") : "", advancedFormHTML, "&rt=", on.join(",")].join(""); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {!Object} b | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var QD = function(a, b, c) { | |
| a = OD(a, b, c); | |
| if (!a) { | |
| return ""; | |
| } | |
| /** @type {!Image} */ | |
| b = new Image; | |
| /** @type {number} */ | |
| var aPos = window.jstiming.Ef++; | |
| /** @type {!Object} */ | |
| window.jstiming.$c[aPos] = b; | |
| /** @type {function(): undefined} */ | |
| b.onload = b.onerror = function() { | |
| if (window.jstiming) { | |
| delete window.jstiming.$c[aPos]; | |
| } | |
| }; | |
| /** @type {string} */ | |
| b.src = a; | |
| /** @type {null} */ | |
| b = null; | |
| return a; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {!Object} b | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| window.jstiming.report = function(a, b, c) { | |
| if ("prerender" == document.webkitVisibilityState) { | |
| /** @type {boolean} */ | |
| var d = false; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var c = function() { | |
| if (!d) { | |
| if (b) { | |
| /** @type {string} */ | |
| b.prerender = "1"; | |
| } else { | |
| b = { | |
| prerender : "1" | |
| }; | |
| } | |
| var f; | |
| if ("prerender" == document.webkitVisibilityState) { | |
| /** @type {boolean} */ | |
| f = false; | |
| } else { | |
| QD(a, b, c); | |
| /** @type {boolean} */ | |
| f = true; | |
| } | |
| if (f) { | |
| /** @type {boolean} */ | |
| d = true; | |
| document.removeEventListener(ne, c, false); | |
| } | |
| } | |
| }; | |
| document.addEventListener(ne, c, false); | |
| return ""; | |
| } | |
| return QD(a, b, c); | |
| }; | |
| } | |
| window.jstiming.load.tick("jl"); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment