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